54 files changed, 4 insertions, 22202 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index d496c95d..51263449 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -7,19 +7,8 @@ zzuftests = testzzuf
 endif
 endif
 endif
-if ENABLE_SPDY
-if HAVE_OPENSSL
-microspdy = microspdy
-if HAVE_CURL
-microspdy += spdy2http
-endif
-#if HAVE_SPDYLAY
-microspdy += testspdy
-#endif
-endif
-endif
 
-SUBDIRS = include platform microhttpd $(microspdy) $(curltests) $(zzuftests) .
+SUBDIRS = include platform microhttpd $(curltests) $(zzuftests) .
 
 if BUILD_EXAMPLES
 SUBDIRS += examples
@@ -27,5 +16,4 @@ endif
 
 EXTRA_DIST = \
  datadir/cert-and-key.pem \
- datadir/cert-and-key-for-wireshark.pem \
- datadir/spdy-draft.txt
+ datadir/cert-and-key-for-wireshark.pem 
diff --git a/src/datadir/spdy-draft.txt b/src/datadir/spdy-draft.txt
deleted file mode 100644
index c31648cc..00000000
--- a/src/datadir/spdy-draft.txt
+++ /dev/null
@@ -1,2856 +0,0 @@
-
-
-
-Network Working Group                                          M. Belshe
-Internet-Draft                                                     Twist
-Expires: August 4, 2012                                          R. Peon
-                                                             Google, Inc
-                                                                Feb 2012
-
-
-                             SPDY Protocol
-                     draft-mbelshe-httpbis-spdy-00
-
-Abstract
-
-   This document describes SPDY, a protocol designed for low-latency
-   transport of content over the World Wide Web. SPDY introduces two
-   layers of protocol.  The lower layer is a general purpose framing
-   layer which can be used atop a reliable transport (likely TCP) for
-   multiplexed, prioritized, and compressed data communication of many
-   concurrent streams.  The upper layer of the protocol provides HTTP-
-   like RFC2616 [RFC2616] semantics for compatibility with existing HTTP
-   application servers.
-
-Status of this Memo
-
-   This Internet-Draft is submitted in full conformance with the
-   provisions of BCP 78 and BCP 79.
-
-   Internet-Drafts are working documents of the Internet Engineering
-   Task Force (IETF).  Note that other groups may also distribute
-   working documents as Internet-Drafts.  The list of current Internet-
-   Drafts is at http://datatracker.ietf.org/drafts/current/.
-
-   Internet-Drafts are draft documents valid for a maximum of six months
-   and may be updated, replaced, or obsoleted by other documents at any
-   time.  It is inappropriate to use Internet-Drafts as reference
-   material or to cite them other than as "work in progress."
-
-   This Internet-Draft will expire on August 4, 2012.
-
-Copyright Notice
-
-   Copyright (c) 2012 IETF Trust and the persons identified as the
-   document authors.  All rights reserved.
-
-   This document is subject to BCP 78 and the IETF Trust's Legal
-   Provisions Relating to IETF Documents
-   (http://trustee.ietf.org/license-info) in effect on the date of
-   publication of this document.  Please review these documents
-   carefully, as they describe your rights and restrictions with respect
-
-
-
-Belshe & Peon            Expires August 4, 2012                 [Page 1]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   to this document.  Code Components extracted from this document must
-   include Simplified BSD License text as described in Section 4.e of
-   the Trust Legal Provisions and are provided without warranty as
-   described in the Simplified BSD License.
-
-
-Table of Contents
-
-   1.  Overview . . . . . . . . . . . . . . . . . . . . . . . . . . .  4
-     1.1.  Document Organization  . . . . . . . . . . . . . . . . . .  4
-     1.2.  Definitions  . . . . . . . . . . . . . . . . . . . . . . .  5
-   2.  SPDY Framing Layer . . . . . . . . . . . . . . . . . . . . . .  6
-     2.1.  Session (Connections)  . . . . . . . . . . . . . . . . . .  6
-     2.2.  Framing  . . . . . . . . . . . . . . . . . . . . . . . . .  6
-       2.2.1.  Control frames . . . . . . . . . . . . . . . . . . . .  6
-       2.2.2.  Data frames  . . . . . . . . . . . . . . . . . . . . .  7
-     2.3.  Streams  . . . . . . . . . . . . . . . . . . . . . . . . .  8
-       2.3.1.  Stream frames  . . . . . . . . . . . . . . . . . . . .  9
-       2.3.2.  Stream creation  . . . . . . . . . . . . . . . . . . .  9
-       2.3.3.  Stream priority  . . . . . . . . . . . . . . . . . . . 10
-       2.3.4.  Stream headers . . . . . . . . . . . . . . . . . . . . 10
-       2.3.5.  Stream data exchange . . . . . . . . . . . . . . . . . 10
-       2.3.6.  Stream half-close  . . . . . . . . . . . . . . . . . . 10
-       2.3.7.  Stream close . . . . . . . . . . . . . . . . . . . . . 11
-     2.4.  Error Handling . . . . . . . . . . . . . . . . . . . . . . 11
-       2.4.1.  Session Error Handling . . . . . . . . . . . . . . . . 11
-       2.4.2.  Stream Error Handling  . . . . . . . . . . . . . . . . 12
-     2.5.  Data flow  . . . . . . . . . . . . . . . . . . . . . . . . 12
-     2.6.  Control frame types  . . . . . . . . . . . . . . . . . . . 12
-       2.6.1.  SYN_STREAM . . . . . . . . . . . . . . . . . . . . . . 12
-       2.6.2.  SYN_REPLY  . . . . . . . . . . . . . . . . . . . . . . 14
-       2.6.3.  RST_STREAM . . . . . . . . . . . . . . . . . . . . . . 15
-       2.6.4.  SETTINGS . . . . . . . . . . . . . . . . . . . . . . . 16
-       2.6.5.  PING . . . . . . . . . . . . . . . . . . . . . . . . . 19
-       2.6.6.  GOAWAY . . . . . . . . . . . . . . . . . . . . . . . . 20
-       2.6.7.  HEADERS  . . . . . . . . . . . . . . . . . . . . . . . 21
-       2.6.8.  WINDOW_UPDATE  . . . . . . . . . . . . . . . . . . . . 22
-       2.6.9.  CREDENTIAL . . . . . . . . . . . . . . . . . . . . . . 24
-       2.6.10. Name/Value Header Block  . . . . . . . . . . . . . . . 26
-   3.  HTTP Layering over SPDY  . . . . . . . . . . . . . . . . . . . 33
-     3.1.  Connection Management  . . . . . . . . . . . . . . . . . . 33
-       3.1.1.  Use of GOAWAY  . . . . . . . . . . . . . . . . . . . . 33
-     3.2.  HTTP Request/Response  . . . . . . . . . . . . . . . . . . 34
-       3.2.1.  Request  . . . . . . . . . . . . . . . . . . . . . . . 34
-       3.2.2.  Response . . . . . . . . . . . . . . . . . . . . . . . 35
-       3.2.3.  Authentication . . . . . . . . . . . . . . . . . . . . 36
-     3.3.  Server Push Transactions . . . . . . . . . . . . . . . . . 37
-       3.3.1.  Server implementation  . . . . . . . . . . . . . . . . 38
-
-
-
-Belshe & Peon            Expires August 4, 2012                 [Page 2]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-       3.3.2.  Client implementation  . . . . . . . . . . . . . . . . 39
-   4.  Design Rationale and Notes . . . . . . . . . . . . . . . . . . 40
-     4.1.  Separation of Framing Layer and Application Layer  . . . . 40
-     4.2.  Error handling - Framing Layer . . . . . . . . . . . . . . 40
-     4.3.  One Connection Per Domain  . . . . . . . . . . . . . . . . 40
-     4.4.  Fixed vs Variable Length Fields  . . . . . . . . . . . . . 41
-     4.5.  Compression Context(s) . . . . . . . . . . . . . . . . . . 41
-     4.6.  Unidirectional streams . . . . . . . . . . . . . . . . . . 42
-     4.7.  Data Compression . . . . . . . . . . . . . . . . . . . . . 42
-     4.8.  Server Push  . . . . . . . . . . . . . . . . . . . . . . . 42
-   5.  Security Considerations  . . . . . . . . . . . . . . . . . . . 43
-     5.1.  Use of Same-origin constraints . . . . . . . . . . . . . . 43
-     5.2.  HTTP Headers and SPDY Headers  . . . . . . . . . . . . . . 43
-     5.3.  Cross-Protocol Attacks . . . . . . . . . . . . . . . . . . 43
-     5.4.  Server Push Implicit Headers . . . . . . . . . . . . . . . 43
-   6.  Privacy Considerations . . . . . . . . . . . . . . . . . . . . 44
-     6.1.  Long Lived Connections . . . . . . . . . . . . . . . . . . 44
-     6.2.  SETTINGS frame . . . . . . . . . . . . . . . . . . . . . . 44
-   7.  Incompatibilities with SPDY draft #2 . . . . . . . . . . . . . 45
-   8.  Requirements Notation  . . . . . . . . . . . . . . . . . . . . 46
-   9.  Acknowledgements . . . . . . . . . . . . . . . . . . . . . . . 47
-   10. Normative References . . . . . . . . . . . . . . . . . . . . . 48
-   Appendix A.  Changes . . . . . . . . . . . . . . . . . . . . . . . 50
-   Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . . 51
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                 [Page 3]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-1.  Overview
-
-   One of the bottlenecks of HTTP implementations is that HTTP relies on
-   multiple connections for concurrency.  This causes several problems,
-   including additional round trips for connection setup, slow-start
-   delays, and connection rationing by the client, where it tries to
-   avoid opening too many connections to any single server.  HTTP
-   pipelining helps some, but only achieves partial multiplexing.  In
-   addition, pipelining has proven non-deployable in existing browsers
-   due to intermediary interference.
-
-   SPDY adds a framing layer for multiplexing multiple, concurrent
-   streams across a single TCP connection (or any reliable transport
-   stream).  The framing layer is optimized for HTTP-like request-
-   response streams, such that applications which run over HTTP today
-   can work over SPDY with little or no change on behalf of the web
-   application writer.
-
-   The SPDY session offers four improvements over HTTP:
-
-      Multiplexed requests: There is no limit to the number of requests
-      that can be issued concurrently over a single SPDY connection.
-
-      Prioritized requests: Clients can request certain resources to be
-      delivered first.  This avoids the problem of congesting the
-      network channel with non-critical resources when a high-priority
-      request is pending.
-
-      Compressed headers: Clients today send a significant amount of
-      redundant data in the form of HTTP headers.  Because a single web
-      page may require 50 or 100 subrequests, this data is significant.
-
-      Server pushed streams: Server Push enables content to be pushed
-      from servers to clients without a request.
-
-   SPDY attempts to preserve the existing semantics of HTTP.  All
-   features such as cookies, ETags, Vary headers, Content-Encoding
-   negotiations, etc work as they do with HTTP; SPDY only replaces the
-   way the data is written to the network.
-
-1.1.  Document Organization
-
-   The SPDY Specification is split into two parts: a framing layer
-   (Section 2), which multiplexes a TCP connection into independent,
-   length-prefixed frames, and an HTTP layer (Section 3), which
-   specifies the mechanism for overlaying HTTP request/response pairs on
-   top of the framing layer.  While some of the framing layer concepts
-   are isolated from the HTTP layer, building a generic framing layer
-
-
-
-Belshe & Peon            Expires August 4, 2012                 [Page 4]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   has not been a goal.  The framing layer is tailored to the needs of
-   the HTTP protocol and server push.
-
-1.2.  Definitions
-
-      client: The endpoint initiating the SPDY session.
-
-      connection: A transport-level connection between two endpoints.
-
-      endpoint: Either the client or server of a connection.
-
-      frame: A header-prefixed sequence of bytes sent over a SPDY
-      session.
-
-      server: The endpoint which did not initiate the SPDY session.
-
-      session: A synonym for a connection.
-
-      session error: An error on the SPDY session.
-
-      stream: A bi-directional flow of bytes across a virtual channel
-      within a SPDY session.
-
-      stream error: An error on an individual SPDY stream.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                 [Page 5]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-2.  SPDY Framing Layer
-
-2.1.  Session (Connections)
-
-   The SPDY framing layer (or "session") runs atop a reliable transport
-   layer such as TCP [RFC0793].  The client is the TCP connection
-   initiator.  SPDY connections are persistent connections.
-
-   For best performance, it is expected that clients will not close open
-   connections until the user navigates away from all web pages
-   referencing a connection, or until the server closes the connection.
-   Servers are encouraged to leave connections open for as long as
-   possible, but can terminate idle connections if necessary.  When
-   either endpoint closes the transport-level connection, it MUST first
-   send a GOAWAY (Section 2.6.6) frame so that the endpoints can
-   reliably determine if requests finished before the close.
-
-2.2.  Framing
-
-   Once the connection is established, clients and servers exchange
-   framed messages.  There are two types of frames: control frames
-   (Section 2.2.1) and data frames (Section 2.2.2).  Frames always have
-   a common header which is 8 bytes in length.
-
-   The first bit is a control bit indicating whether a frame is a
-   control frame or data frame.  Control frames carry a version number,
-   a frame type, flags, and a length.  Data frames contain the stream
-   ID, flags, and the length for the payload carried after the common
-   header.  The simple header is designed to make reading and writing of
-   frames easy.
-
-   All integer values, including length, version, and type, are in
-   network byte order.  SPDY does not enforce alignment of types in
-   dynamically sized frames.
-
-2.2.1.  Control frames
-
-   +----------------------------------+
-   |C| Version(15bits) | Type(16bits) |
-   +----------------------------------+
-   | Flags (8)  |  Length (24 bits)   |
-   +----------------------------------+
-   |               Data               |
-   +----------------------------------+
-
-   Control bit: The 'C' bit is a single bit indicating if this is a
-   control message.  For control frames this value is always 1.
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                 [Page 6]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   Version: The version number of the SPDY protocol.  This document
-   describes SPDY version 3.
-
-   Type: The type of control frame.  See Control Frames for the complete
-   list of control frames.
-
-   Flags: Flags related to this frame.  Flags for control frames and
-   data frames are different.
-
-   Length: An unsigned 24-bit value representing the number of bytes
-   after the length field.
-
-   Data: data associated with this control frame.  The format and length
-   of this data is controlled by the control frame type.
-
-   Control frame processing requirements:
-
-      Note that full length control frames (16MB) can be large for
-      implementations running on resource-limited hardware.  In such
-      cases, implementations MAY limit the maximum length frame
-      supported.  However, all implementations MUST be able to receive
-      control frames of at least 8192 octets in length.
-
-2.2.2.  Data frames
-
-   +----------------------------------+
-   |C|       Stream-ID (31bits)       |
-   +----------------------------------+
-   | Flags (8)  |  Length (24 bits)   |
-   +----------------------------------+
-   |               Data               |
-   +----------------------------------+
-
-   Control bit: For data frames this value is always 0.
-
-   Stream-ID: A 31-bit value identifying the stream.
-
-   Flags: Flags related to this frame.  Valid flags are:
-
-      0x01 = FLAG_FIN - signifies that this frame represents the last
-      frame to be transmitted on this stream.  See Stream Close
-      (Section 2.3.7) below.
-
-      0x02 = FLAG_COMPRESS - indicates that the data in this frame has
-      been compressed.
-
-   Length: An unsigned 24-bit value representing the number of bytes
-   after the length field.  The total size of a data frame is 8 bytes +
-
-
-
-Belshe & Peon            Expires August 4, 2012                 [Page 7]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   length.  It is valid to have a zero-length data frame.
-
-   Data: The variable-length data payload; the length was defined in the
-   length field.
-
-   Data frame processing requirements:
-
-      If an endpoint receives a data frame for a stream-id which is not
-      open and the endpoint has not sent a GOAWAY (Section 2.6.6) frame,
-      it MUST send issue a stream error (Section 2.4.2) with the error
-      code INVALID_STREAM for the stream-id.
-
-      If the endpoint which created the stream receives a data frame
-      before receiving a SYN_REPLY on that stream, it is a protocol
-      error, and the recipient MUST issue a stream error (Section 2.4.2)
-      with the status code PROTOCOL_ERROR for the stream-id.
-
-      Implementors note: If an endpoint receives multiple data frames
-      for invalid stream-ids, it MAY close the session.
-
-      All SPDY endpoints MUST accept compressed data frames.
-      Compression of data frames is always done using zlib compression.
-      Each stream initializes and uses its own compression context
-      dedicated to use within that stream.  Endpoints are encouraged to
-      use application level compression rather than SPDY stream level
-      compression.
-
-      Each SPDY stream sending compressed frames creates its own zlib
-      context for that stream, and these compression contexts MUST be
-      distinct from the compression contexts used with SYN_STREAM/
-      SYN_REPLY/HEADER compression.  (Thus, if both endpoints of a
-      stream are compressing data on the stream, there will be two zlib
-      contexts, one for sending and one for receiving).
-
-2.3.  Streams
-
-   Streams are independent sequences of bi-directional data divided into
-   frames with several properties:
-
-      Streams may be created by either the client or server.
-
-      Streams optionally carry a set of name/value header pairs.
-
-      Streams can concurrently send data interleaved with other streams.
-
-      Streams may be cancelled.
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                 [Page 8]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-2.3.1.  Stream frames
-
-   SPDY defines 3 control frames to manage the lifecycle of a stream:
-
-      SYN_STREAM - Open a new stream
-
-      SYN_REPLY - Remote acknowledgement of a new, open stream
-
-      RST_STREAM - Close a stream
-
-2.3.2.  Stream creation
-
-   A stream is created by sending a control frame with the type set to
-   SYN_STREAM (Section 2.6.1).  If the server is initiating the stream,
-   the Stream-ID must be even.  If the client is initiating the stream,
-   the Stream-ID must be odd. 0 is not a valid Stream-ID.  Stream-IDs
-   from each side of the connection must increase monotonically as new
-   streams are created.  E.g.  Stream 2 may be created after stream 3,
-   but stream 7 must not be created after stream 9.  Stream IDs do not
-   wrap: when a client or server cannot create a new stream id without
-   exceeding a 31 bit value, it MUST NOT create a new stream.
-
-   The stream-id MUST increase with each new stream.  If an endpoint
-   receives a SYN_STREAM with a stream id which is less than any
-   previously received SYN_STREAM, it MUST issue a session error
-   (Section 2.4.1) with the status PROTOCOL_ERROR.
-
-   It is a protocol error to send two SYN_STREAMs with the same
-   stream-id.  If a recipient receives a second SYN_STREAM for the same
-   stream, it MUST issue a stream error (Section 2.4.2) with the status
-   code PROTOCOL_ERROR.
-
-   Upon receipt of a SYN_STREAM, the recipient can reject the stream by
-   sending a stream error (Section 2.4.2) with the error code
-   REFUSED_STREAM.  Note, however, that the creating endpoint may have
-   already sent additional frames for that stream which cannot be
-   immediately stopped.
-
-   Once the stream is created, the creator may immediately send HEADERS
-   or DATA frames for that stream, without needing to wait for the
-   recipient to acknowledge.
-
-2.3.2.1.  Unidirectional streams
-
-   When an endpoint creates a stream with the FLAG_UNIDIRECTIONAL flag
-   set, it creates a unidirectional stream which the creating endpoint
-   can use to send frames, but the receiving endpoint cannot.  The
-   receiving endpoint is implicitly already in the half-closed
-
-
-
-Belshe & Peon            Expires August 4, 2012                 [Page 9]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   (Section 2.3.6) state.
-
-2.3.2.2.  Bidirectional streams
-
-   SYN_STREAM frames which do not use the FLAG_UNIDIRECTIONAL flag are
-   bidirectional streams.  Both endpoints can send data on a bi-
-   directional stream.
-
-2.3.3.  Stream priority
-
-   The creator of a stream assigns a priority for that stream.  Priority
-   is represented as an integer from 0 to 7. 0 represents the highest
-   priority and 7 represents the lowest priority.
-
-   The sender and recipient SHOULD use best-effort to process streams in
-   the order of highest priority to lowest priority.
-
-2.3.4.  Stream headers
-
-   Streams carry optional sets of name/value pair headers which carry
-   metadata about the stream.  After the stream has been created, and as
-   long as the sender is not closed (Section 2.3.7) or half-closed
-   (Section 2.3.6), each side may send HEADERS frame(s) containing the
-   header data.  Header data can be sent in multiple HEADERS frames, and
-   HEADERS frames may be interleaved with data frames.
-
-2.3.5.  Stream data exchange
-
-   Once a stream is created, it can be used to send arbitrary amounts of
-   data.  Generally this means that a series of data frames will be sent
-   on the stream until a frame containing the FLAG_FIN flag is set.  The
-   FLAG_FIN can be set on a SYN_STREAM (Section 2.6.1), SYN_REPLY
-   (Section 2.6.2), HEADERS (Section 2.6.7) or a DATA (Section 2.2.2)
-   frame.  Once the FLAG_FIN has been sent, the stream is considered to
-   be half-closed.
-
-2.3.6.  Stream half-close
-
-   When one side of the stream sends a frame with the FLAG_FIN flag set,
-   the stream is half-closed from that endpoint.  The sender of the
-   FLAG_FIN MUST NOT send further frames on that stream.  When both
-   sides have half-closed, the stream is closed.
-
-   If an endpoint receives a data frame after the stream is half-closed
-   from the sender (e.g. the endpoint has already received a prior frame
-   for the stream with the FIN flag set), it MUST send a RST_STREAM to
-   the sender with the status STREAM_ALREADY_CLOSED.
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 10]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-2.3.7.  Stream close
-
-   There are 3 ways that streams can be terminated:
-
-      Normal termination: Normal stream termination occurs when both
-      sender and recipient have half-closed the stream by sending a
-      FLAG_FIN.
-
-      Abrupt termination: Either the client or server can send a
-      RST_STREAM control frame at any time.  A RST_STREAM contains an
-      error code to indicate the reason for failure.  When a RST_STREAM
-      is sent from the stream originator, it indicates a failure to
-      complete the stream and that no further data will be sent on the
-      stream.  When a RST_STREAM is sent from the stream recipient, the
-      sender, upon receipt, should stop sending any data on the stream.
-      The stream recipient should be aware that there is a race between
-      data already in transit from the sender and the time the
-      RST_STREAM is received.  See Stream Error Handling (Section 2.4.2)
-
-      TCP connection teardown: If the TCP connection is torn down while
-      un-closed streams exist, then the endpoint must assume that the
-      stream was abnormally interrupted and may be incomplete.
-
-   If an endpoint receives a data frame after the stream is closed, it
-   must send a RST_STREAM to the sender with the status PROTOCOL_ERROR.
-
-2.4.  Error Handling
-
-   The SPDY framing layer has only two types of errors, and they are
-   always handled consistently.  Any reference in this specification to
-   "issue a session error" refers to Section 2.4.1.  Any reference to
-   "issue a stream error" refers to Section 2.4.2.
-
-2.4.1.  Session Error Handling
-
-   A session error is any error which prevents further processing of the
-   framing layer or which corrupts the session compression state.  When
-   a session error occurs, the endpoint encountering the error MUST
-   first send a GOAWAY (Section 2.6.6) frame with the stream id of most
-   recently received stream from the remote endpoint, and the error code
-   for why the session is terminating.  After sending the GOAWAY frame,
-   the endpoint MUST close the TCP connection.
-
-   Note that the session compression state is dependent upon both
-   endpoints always processing all compressed data.  If an endpoint
-   partially processes a frame containing compressed data without
-   updating compression state properly, future control frames which use
-   compression will be always be errored.  Implementations SHOULD always
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 11]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   try to process compressed data so that errors which could be handled
-   as stream errors do not become session errors.
-
-   Note that because this GOAWAY is sent during a session error case, it
-   is possible that the GOAWAY will not be reliably received by the
-   receiving endpoint.  It is a best-effort attempt to communicate with
-   the remote about why the session is going down.
-
-2.4.2.  Stream Error Handling
-
-   A stream error is an error related to a specific stream-id which does
-   not affect processing of other streams at the framing layer.  Upon a
-   stream error, the endpoint MUST send a RST_STREAM (Section 2.6.3)
-   frame which contains the stream id of the stream where the error
-   occurred and the error status which caused the error.  After sending
-   the RST_STREAM, the stream is closed to the sending endpoint.  After
-   sending the RST_STREAM, if the sender receives any frames other than
-   a RST_STREAM for that stream id, it will result in sending additional
-   RST_STREAM frames.  An endpoint MUST NOT send a RST_STREAM in
-   response to an RST_STREAM, as doing so would lead to RST_STREAM
-   loops.  Sending a RST_STREAM does not cause the SPDY session to be
-   closed.
-
-   If an endpoint has multiple RST_STREAM frames to send in succession
-   for the same stream-id and the same error code, it MAY coalesce them
-   into a single RST_STREAM frame.  (This can happen if a stream is
-   closed, but the remote sends multiple data frames.  There is no
-   reason to send a RST_STREAM for each frame in succession).
-
-2.5.  Data flow
-
-   Because TCP provides a single stream of data on which SPDY
-   multiplexes multiple logical streams, clients and servers must
-   intelligently interleave data messages for concurrent sessions.
-
-2.6.  Control frame types
-
-2.6.1.  SYN_STREAM
-
-   The SYN_STREAM control frame allows the sender to asynchronously
-   create a stream between the endpoints.  See Stream Creation
-   (Section 2.3.2)
-
-
-
-
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 12]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-+------------------------------------+
-|1|    version    |         1        |
-+------------------------------------+
-|  Flags (8)  |  Length (24 bits)    |
-+------------------------------------+
-|X|           Stream-ID (31bits)     |
-+------------------------------------+
-|X| Associated-To-Stream-ID (31bits) |
-+------------------------------------+
-| Pri|Unused | Slot |                |
-+-------------------+                |
-| Number of Name/Value pairs (int32) |   <+
-+------------------------------------+    |
-|     Length of name (int32)         |    | This section is the "Name/Value
-+------------------------------------+    | Header Block", and is compressed.
-|           Name (string)            |    |
-+------------------------------------+    |
-|     Length of value  (int32)       |    |
-+------------------------------------+    |
-|          Value   (string)          |    |
-+------------------------------------+    |
-|           (repeats)                |   <+
-
-   Flags: Flags related to this frame.  Valid flags are:
-
-      0x01 = FLAG_FIN - marks this frame as the last frame to be
-      transmitted on this stream and puts the sender in the half-closed
-      (Section 2.3.6) state.
-
-      0x02 = FLAG_UNIDIRECTIONAL - a stream created with this flag puts
-      the recipient in the half-closed (Section 2.3.6) state.
-
-   Length: The length is the number of bytes which follow the length
-   field in the frame.  For SYN_STREAM frames, this is 10 bytes plus the
-   length of the compressed Name/Value block.
-
-   Stream-ID: The 31-bit identifier for this stream.  This stream-id
-   will be used in frames which are part of this stream.
-
-   Associated-To-Stream-ID: The 31-bit identifier for a stream which
-   this stream is associated to.  If this stream is independent of all
-   other streams, it should be 0.
-
-   Priority: A 3-bit priority (Section 2.3.3) field.
-
-   Unused: 5 bits of unused space, reserved for future use.
-
-   Slot: An 8 bit unsigned integer specifying the index in the server's
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 13]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   CREDENTIAL vector of the client certificate to be used for this
-   request. see CREDENTIAL frame (Section 2.6.9).  The value 0 means no
-   client certificate should be associated with this stream.
-
-   Name/Value Header Block: A set of name/value pairs carried as part of
-   the SYN_STREAM. see Name/Value Header Block (Section 2.6.10).
-
-   If an endpoint receives a SYN_STREAM which is larger than the
-   implementation supports, it MAY send a RST_STREAM with error code
-   FRAME_TOO_LARGE.  All implementations MUST support the minimum size
-   limits defined in the Control Frames section (Section 2.2.1).
-
-2.6.2.  SYN_REPLY
-
-   SYN_REPLY indicates the acceptance of a stream creation by the
-   recipient of a SYN_STREAM frame.
-
-+------------------------------------+
-|1|    version    |         2        |
-+------------------------------------+
-|  Flags (8)  |  Length (24 bits)    |
-+------------------------------------+
-|X|           Stream-ID (31bits)     |
-+------------------------------------+
-| Number of Name/Value pairs (int32) |   <+
-+------------------------------------+    |
-|     Length of name (int32)         |    | This section is the "Name/Value
-+------------------------------------+    | Header Block", and is compressed.
-|           Name (string)            |    |
-+------------------------------------+    |
-|     Length of value  (int32)       |    |
-+------------------------------------+    |
-|          Value   (string)          |    |
-+------------------------------------+    |
-|           (repeats)                |   <+
-
-   Flags: Flags related to this frame.  Valid flags are:
-
-      0x01 = FLAG_FIN - marks this frame as the last frame to be
-      transmitted on this stream and puts the sender in the half-closed
-      (Section 2.3.6) state.
-
-   Length: The length is the number of bytes which follow the length
-   field in the frame.  For SYN_REPLY frames, this is 4 bytes plus the
-   length of the compressed Name/Value block.
-
-   Stream-ID: The 31-bit identifier for this stream.
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 14]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   If an endpoint receives multiple SYN_REPLY frames for the same active
-   stream ID, it MUST issue a stream error (Section 2.4.2) with the
-   error code STREAM_IN_USE.
-
-   Name/Value Header Block: A set of name/value pairs carried as part of
-   the SYN_STREAM. see Name/Value Header Block (Section 2.6.10).
-
-   If an endpoint receives a SYN_REPLY which is larger than the
-   implementation supports, it MAY send a RST_STREAM with error code
-   FRAME_TOO_LARGE.  All implementations MUST support the minimum size
-   limits defined in the Control Frames section (Section 2.2.1).
-
-2.6.3.  RST_STREAM
-
-   The RST_STREAM frame allows for abnormal termination of a stream.
-   When sent by the creator of a stream, it indicates the creator wishes
-   to cancel the stream.  When sent by the recipient of a stream, it
-   indicates an error or that the recipient did not want to accept the
-   stream, so the stream should be closed.
-
-   +----------------------------------+
-   |1|   version    |         3       |
-   +----------------------------------+
-   | Flags (8)  |         8           |
-   +----------------------------------+
-   |X|          Stream-ID (31bits)    |
-   +----------------------------------+
-   |          Status code             |
-   +----------------------------------+
-
-   Flags: Flags related to this frame.  RST_STREAM does not define any
-   flags.  This value must be 0.
-
-   Length: An unsigned 24-bit value representing the number of bytes
-   after the length field.  For RST_STREAM control frames, this value is
-   always 8.
-
-   Stream-ID: The 31-bit identifier for this stream.
-
-   Status code: (32 bits) An indicator for why the stream is being
-   terminated.The following status codes are defined:
-
-      1 - PROTOCOL_ERROR.  This is a generic error, and should only be
-      used if a more specific error is not available.
-
-      2 - INVALID_STREAM.  This is returned when a frame is received for
-      a stream which is not active.
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 15]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-      3 - REFUSED_STREAM.  Indicates that the stream was refused before
-      any processing has been done on the stream.
-
-      4 - UNSUPPORTED_VERSION.  Indicates that the recipient of a stream
-      does not support the SPDY version requested.
-
-      5 - CANCEL.  Used by the creator of a stream to indicate that the
-      stream is no longer needed.
-
-      6 - INTERNAL_ERROR.  This is a generic error which can be used
-      when the implementation has internally failed, not due to anything
-      in the protocol.
-
-      7 - FLOW_CONTROL_ERROR.  The endpoint detected that its peer
-      violated the flow control protocol.
-
-      8 - STREAM_IN_USE.  The endpoint received a SYN_REPLY for a stream
-      already open.
-
-      9 - STREAM_ALREADY_CLOSED.  The endpoint received a data or
-      SYN_REPLY frame for a stream which is half closed.
-
-      10 - INVALID_CREDENTIALS.  The server received a request for a
-      resource whose origin does not have valid credentials in the
-      client certificate vector.
-
-      11 - FRAME_TOO_LARGE.  The endpoint received a frame which this
-      implementation could not support.  If FRAME_TOO_LARGE is sent for
-      a SYN_STREAM, HEADERS, or SYN_REPLY frame without fully processing
-      the compressed portion of those frames, then the compression state
-      will be out-of-sync with the other endpoint.  In this case,
-      senders of FRAME_TOO_LARGE MUST close the session.
-
-      Note: 0 is not a valid status code for a RST_STREAM.
-
-   After receiving a RST_STREAM on a stream, the recipient must not send
-   additional frames for that stream, and the stream moves into the
-   closed state.
-
-2.6.4.  SETTINGS
-
-   A SETTINGS frame contains a set of id/value pairs for communicating
-   configuration data about how the two endpoints may communicate.
-   SETTINGS frames can be sent at any time by either endpoint, are
-   optionally sent, and are fully asynchronous.  When the server is the
-   sender, the sender can request that configuration data be persisted
-   by the client across SPDY sessions and returned to the server in
-   future communications.
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 16]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   Persistence of SETTINGS ID/Value pairs is done on a per origin/IP
-   pair (the "origin" is the set of scheme, host, and port from the URI.
-   See [RFC6454]).  That is, when a client connects to a server, and the
-   server persists settings within the client, the client SHOULD return
-   the persisted settings on future connections to the same origin AND
-   IP address and TCP port.  Clients MUST NOT request servers to use the
-   persistence features of the SETTINGS frames, and servers MUST ignore
-   persistence related flags sent by a client.
-
-   +----------------------------------+
-   |1|   version    |         4       |
-   +----------------------------------+
-   | Flags (8)  |  Length (24 bits)   |
-   +----------------------------------+
-   |         Number of entries        |
-   +----------------------------------+
-   |          ID/Value Pairs          |
-   |             ...                  |
-
-   Control bit: The control bit is always 1 for this message.
-
-   Version: The SPDY version number.
-
-   Type: The message type for a SETTINGS message is 4.
-
-   Flags: FLAG_SETTINGS_CLEAR_SETTINGS (0x1): When set, the client
-   should clear any previously persisted SETTINGS ID/Value pairs.  If
-   this frame contains ID/Value pairs with the
-   FLAG_SETTINGS_PERSIST_VALUE set, then the client will first clear its
-   existing, persisted settings, and then persist the values with the
-   flag set which are contained within this frame.  Because persistence
-   is only implemented on the client, this flag can only be used when
-   the sender is the server.
-
-   Length: An unsigned 24-bit value representing the number of bytes
-   after the length field.  The total size of a SETTINGS frame is 8
-   bytes + length.
-
-   Number of entries: A 32-bit value representing the number of ID/value
-   pairs in this message.
-
-   ID: A 32-bit ID number, comprised of 8 bits of flags and 24 bits of
-   unique ID.
-
-      ID.flags:
-
-         FLAG_SETTINGS_PERSIST_VALUE (0x1): When set, the sender of this
-         SETTINGS frame is requesting that the recipient persist the ID/
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 17]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-         Value and return it in future SETTINGS frames sent from the
-         sender to this recipient.  Because persistence is only
-         implemented on the client, this flag is only sent by the
-         server.
-
-         FLAG_SETTINGS_PERSISTED (0x2): When set, the sender is
-         notifying the recipient that this ID/Value pair was previously
-         sent to the sender by the recipient with the
-         FLAG_SETTINGS_PERSIST_VALUE, and the sender is returning it.
-         Because persistence is only implemented on the client, this
-         flag is only sent by the client.
-
-      Defined IDs:
-
-         1 - SETTINGS_UPLOAD_BANDWIDTH allows the sender to send its
-         expected upload bandwidth on this channel.  This number is an
-         estimate.  The value should be the integral number of kilobytes
-         per second that the sender predicts as an expected maximum
-         upload channel capacity.
-
-         2 - SETTINGS_DOWNLOAD_BANDWIDTH allows the sender to send its
-         expected download bandwidth on this channel.  This number is an
-         estimate.  The value should be the integral number of kilobytes
-         per second that the sender predicts as an expected maximum
-         download channel capacity.
-
-         3 - SETTINGS_ROUND_TRIP_TIME allows the sender to send its
-         expected round-trip-time on this channel.  The round trip time
-         is defined as the minimum amount of time to send a control
-         frame from this client to the remote and receive a response.
-         The value is represented in milliseconds.
-
-         4 - SETTINGS_MAX_CONCURRENT_STREAMS allows the sender to inform
-         the remote endpoint the maximum number of concurrent streams
-         which it will allow.  By default there is no limit.  For
-         implementors it is recommended that this value be no smaller
-         than 100.
-
-         5 - SETTINGS_CURRENT_CWND allows the sender to inform the
-         remote endpoint of the current TCP CWND value.
-
-         6 - SETTINGS_DOWNLOAD_RETRANS_RATE allows the sender to inform
-         the remote endpoint the retransmission rate (bytes
-         retransmitted / total bytes transmitted).
-
-         7 - SETTINGS_INITIAL_WINDOW_SIZE allows the sender to inform
-         the remote endpoint the initial window size (in bytes) for new
-         streams.
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 18]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-         8 - SETTINGS_CLIENT_CERTIFICATE_VECTOR_SIZE allows the server
-         to inform the client if the new size of the client certificate
-         vector.
-
-   Value: A 32-bit value.
-
-   The message is intentionally extensible for future information which
-   may improve client-server communications.  The sender does not need
-   to send every type of ID/value.  It must only send those for which it
-   has accurate values to convey.  When multiple ID/value pairs are
-   sent, they should be sent in order of lowest id to highest id.  A
-   single SETTINGS frame MUST not contain multiple values for the same
-   ID.  If the recipient of a SETTINGS frame discovers multiple values
-   for the same ID, it MUST ignore all values except the first one.
-
-   A server may send multiple SETTINGS frames containing different ID/
-   Value pairs.  When the same ID/Value is sent twice, the most recent
-   value overrides any previously sent values.  If the server sends IDs
-   1, 2, and 3 with the FLAG_SETTINGS_PERSIST_VALUE in a first SETTINGS
-   frame, and then sends IDs 4 and 5 with the
-   FLAG_SETTINGS_PERSIST_VALUE, when the client returns the persisted
-   state on its next SETTINGS frame, it SHOULD send all 5 settings (1,
-   2, 3, 4, and 5 in this example) to the server.
-
-2.6.5.  PING
-
-   The PING control frame is a mechanism for measuring a minimal round-
-   trip time from the sender.  It can be sent from the client or the
-   server.  Recipients of a PING frame should send an identical frame to
-   the sender as soon as possible (if there is other pending data
-   waiting to be sent, PING should take highest priority).  Each ping
-   sent by a sender should use a unique ID.
-
-   +----------------------------------+
-   |1|   version    |         6       |
-   +----------------------------------+
-   | 0 (flags) |     4 (length)       |
-   +----------------------------------|
-   |            32-bit ID             |
-   +----------------------------------+
-
-   Control bit: The control bit is always 1 for this message.
-
-   Version: The SPDY version number.
-
-   Type: The message type for a PING message is 6.
-
-   Length: This frame is always 4 bytes long.
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 19]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   ID: A unique ID for this ping, represented as an unsigned 32 bit
-   value.  When the client initiates a ping, it must use an odd numbered
-   ID.  When the server initiates a ping, it must use an even numbered
-   ping.  Use of odd/even IDs is required in order to avoid accidental
-   looping on PINGs (where each side initiates an identical PING at the
-   same time).
-
-   Note: If a sender uses all possible PING ids (e.g. has sent all 2^31
-   possible IDs), it can wrap and start re-using IDs.
-
-   If a server receives an even numbered PING which it did not initiate,
-   it must ignore the PING.  If a client receives an odd numbered PING
-   which it did not initiate, it must ignore the PING.
-
-2.6.6.  GOAWAY
-
-   The GOAWAY control frame is a mechanism to tell the remote side of
-   the connection to stop creating streams on this session.  It can be
-   sent from the client or the server.  Once sent, the sender will not
-   respond to any new SYN_STREAMs on this session.  Recipients of a
-   GOAWAY frame must not send additional streams on this session,
-   although a new session can be established for new streams.  The
-   purpose of this message is to allow an endpoint to gracefully stop
-   accepting new streams (perhaps for a reboot or maintenance), while
-   still finishing processing of previously established streams.
-
-   There is an inherent race condition between an endpoint sending
-   SYN_STREAMs and the remote sending a GOAWAY message.  To deal with
-   this case, the GOAWAY contains a last-stream-id indicating the
-   stream-id of the last stream which was created on the sending
-   endpoint in this session.  If the receiver of the GOAWAY sent new
-   SYN_STREAMs for sessions after this last-stream-id, they were not
-   processed by the server and the receiver may treat the stream as
-   though it had never been created at all (hence the receiver may want
-   to re-create the stream later on a new session).
-
-   Endpoints should always send a GOAWAY message before closing a
-   connection so that the remote can know whether a stream has been
-   partially processed or not.  (For example, if an HTTP client sends a
-   POST at the same time that a server closes a connection, the client
-   cannot know if the server started to process that POST request if the
-   server does not send a GOAWAY frame to indicate where it stopped
-   working).
-
-   After sending a GOAWAY message, the sender must ignore all SYN_STREAM
-   frames for new streams.
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 20]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   +----------------------------------+
-   |1|   version    |         7       |
-   +----------------------------------+
-   | 0 (flags) |     8 (length)       |
-   +----------------------------------|
-   |X|  Last-good-stream-ID (31 bits) |
-   +----------------------------------+
-   |          Status code             |
-   +----------------------------------+
-
-   Control bit: The control bit is always 1 for this message.
-
-   Version: The SPDY version number.
-
-   Type: The message type for a GOAWAY message is 7.
-
-   Length: This frame is always 8 bytes long.
-
-   Last-good-stream-Id: The last stream id which was replied to (with
-   either a SYN_REPLY or RST_STREAM) by the sender of the GOAWAY
-   message.  If no streams were replied to, this value MUST be 0.
-
-   Status: The reason for closing the session.
-
-      0 - OK.  This is a normal session teardown.
-
-      1 - PROTOCOL_ERROR.  This is a generic error, and should only be
-      used if a more specific error is not available.
-
-      11 - INTERNAL_ERROR.  This is a generic error which can be used
-      when the implementation has internally failed, not due to anything
-      in the protocol.
-
-2.6.7.  HEADERS
-
-   The HEADERS frame augments a stream with additional headers.  It may
-   be optionally sent on an existing stream at any time.  Specific
-   application of the headers in this frame is application-dependent.
-   The name/value header block within this frame is compressed.
-
-
-
-
-
-
-
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 21]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-+------------------------------------+
-|1|   version     |          8       |
-+------------------------------------+
-| Flags (8)  |   Length (24 bits)    |
-+------------------------------------+
-|X|          Stream-ID (31bits)      |
-+------------------------------------+
-| Number of Name/Value pairs (int32) |   <+
-+------------------------------------+    |
-|     Length of name (int32)         |    | This section is the "Name/Value
-+------------------------------------+    | Header Block", and is compressed.
-|           Name (string)            |    |
-+------------------------------------+    |
-|     Length of value  (int32)       |    |
-+------------------------------------+    |
-|          Value   (string)          |    |
-+------------------------------------+    |
-|           (repeats)                |   <+
-
-   Flags: Flags related to this frame.  Valid flags are:
-
-      0x01 = FLAG_FIN - marks this frame as the last frame to be
-      transmitted on this stream and puts the sender in the half-closed
-      (Section 2.3.6) state.
-
-   Length: An unsigned 24 bit value representing the number of bytes
-   after the length field.  The minimum length of the length field is 4
-   (when the number of name value pairs is 0).
-
-   Stream-ID: The stream this HEADERS block is associated with.
-
-   Name/Value Header Block: A set of name/value pairs carried as part of
-   the SYN_STREAM. see Name/Value Header Block (Section 2.6.10).
-
-2.6.8.  WINDOW_UPDATE
-
-   The WINDOW_UPDATE control frame is used to implement per stream flow
-   control in SPDY.  Flow control in SPDY is per hop, that is, only
-   between the two endpoints of a SPDY connection.  If there are one or
-   more intermediaries between the client and the origin server, flow
-   control signals are not explicitly forwarded by the intermediaries.
-   (However, throttling of data transfer by any recipient may have the
-   effect of indirectly propagating flow control information upstream
-   back to the original sender.)  Flow control only applies to the data
-   portion of data frames.  Recipients must buffer all control frames.
-   If a recipient fails to buffer an entire control frame, it MUST issue
-   a stream error (Section 2.4.2) with the status code
-   FLOW_CONTROL_ERROR for the stream.
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 22]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   Flow control in SPDY is implemented by a data transfer window kept by
-   the sender of each stream.  The data transfer window is a simple
-   uint32 that indicates how many bytes of data the sender can transmit.
-   After a stream is created, but before any data frames have been
-   transmitted, the sender begins with the initial window size.  This
-   window size is a measure of the buffering capability of the
-   recipient.  The sender must not send a data frame with data length
-   greater than the transfer window size.  After sending each data
-   frame, the sender decrements its transfer window size by the amount
-   of data transmitted.  When the window size becomes less than or equal
-   to 0, the sender must pause transmitting data frames.  At the other
-   end of the stream, the recipient sends a WINDOW_UPDATE control back
-   to notify the sender that it has consumed some data and freed up
-   buffer space to receive more data.
-
-   +----------------------------------+
-   |1|   version    |         9       |
-   +----------------------------------+
-   | 0 (flags) |     8 (length)       |
-   +----------------------------------+
-   |X|     Stream-ID (31-bits)        |
-   +----------------------------------+
-   |X|  Delta-Window-Size (31-bits)   |
-   +----------------------------------+
-
-   Control bit: The control bit is always 1 for this message.
-
-   Version: The SPDY version number.
-
-   Type: The message type for a WINDOW_UPDATE message is 9.
-
-   Length: The length field is always 8 for this frame (there are 8
-   bytes after the length field).
-
-   Stream-ID: The stream ID that this WINDOW_UPDATE control frame is
-   for.
-
-   Delta-Window-Size: The additional number of bytes that the sender can
-   transmit in addition to existing remaining window size.  The legal
-   range for this field is 1 to 2^31 - 1 (0x7fffffff) bytes.
-
-   The window size as kept by the sender must never exceed 2^31
-   (although it can become negative in one special case).  If a sender
-   receives a WINDOW_UPDATE that causes the its window size to exceed
-   this limit, it must send RST_STREAM with status code
-   FLOW_CONTROL_ERROR to terminate the stream.
-
-   When a SPDY connection is first established, the default initial
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 23]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   window size for all streams is 64KB.  An endpoint can use the
-   SETTINGS control frame to adjust the initial window size for the
-   connection.  That is, its peer can start out using the 64KB default
-   initial window size when sending data frames before receiving the
-   SETTINGS.  Because SETTINGS is asynchronous, there may be a race
-   condition if the recipient wants to decrease the initial window size,
-   but its peer immediately sends 64KB on the creation of a new
-   connection, before waiting for the SETTINGS to arrive.  This is one
-   case where the window size kept by the sender will become negative.
-   Once the sender detects this condition, it must stop sending data
-   frames and wait for the recipient to catch up.  The recipient has two
-   choices:
-
-      immediately send RST_STREAM with FLOW_CONTROL_ERROR status code.
-
-      allow the head of line blocking (as there is only one stream for
-      the session and the amount of data in flight is bounded by the
-      default initial window size), and send WINDOW_UPDATE as it
-      consumes data.
-
-   In the case of option 2, both sides must compute the window size
-   based on the initial window size in the SETTINGS.  For example, if
-   the recipient sets the initial window size to be 16KB, and the sender
-   sends 64KB immediately on connection establishment, the sender will
-   discover its window size is -48KB on receipt of the SETTINGS.  As the
-   recipient consumes the first 16KB, it must send a WINDOW_UPDATE of
-   16KB back to the sender.  This interaction continues until the
-   sender's window size becomes positive again, and it can resume
-   transmitting data frames.
-
-   After the recipient reads in a data frame with FLAG_FIN that marks
-   the end of the data stream, it should not send WINDOW_UPDATE frames
-   as it consumes the last data frame.  A sender should ignore all the
-   WINDOW_UPDATE frames associated with the stream after it send the
-   last frame for the stream.
-
-   The data frames from the sender and the WINDOW_UPDATE frames from the
-   recipient are completely asynchronous with respect to each other.
-   This property allows a recipient to aggressively update the window
-   size kept by the sender to prevent the stream from stalling.
-
-2.6.9.  CREDENTIAL
-
-   The CREDENTIAL control frame is used by the client to send additional
-   client certificates to the server.  A SPDY client may decide to send
-   requests for resources from different origins on the same SPDY
-   session if it decides that that server handles both origins.  For
-   example if the IP address associated with both hostnames matches and
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 24]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   the SSL server certificate presented in the initial handshake is
-   valid for both hostnames.  However, because the SSL connection can
-   contain at most one client certificate, the client needs a mechanism
-   to send additional client certificates to the server.
-
-   The server is required to maintain a vector of client certificates
-   associated with a SPDY session.  When the client needs to send a
-   client certificate to the server, it will send a CREDENTIAL frame
-   that specifies the index of the slot in which to store the
-   certificate as well as proof that the client posesses the
-   corresponding private key.  The initial size of this vector must be
-   8.  If the client provides a client certificate during the first TLS
-   handshake, the contents of this certificate must be copied into the
-   first slot (index 1) in the CREDENTIAL vector, though it may be
-   overwritten by subsequent CREDENTIAL frames.  The server must
-   exclusively use the CREDNETIAL vector when evaluating the client
-   certificates associated with an origin.  The server may change the
-   size of this vector by sending a SETTINGS frame with the setting
-   SETTINGS_CLIENT_CERTIFICATE_VECTOR_SIZE value specified.  In the
-   event that the new size is smaller than the current size, truncation
-   occurs preserving lower-index slots as possible.
-
-   TLS renegotiation with client authentication is incompatible with
-   SPDY given the multiplexed nature of SPDY.  Specifically, imagine
-   that the client has 2 requests outstanding to the server for two
-   different pages (in different tabs).  When the renegotiation + client
-   certificate request comes in, the browser is unable to determine
-   which resource triggered the client certificate request, in order to
-   prompt the user accordingly.
-
-   +----------------------------------+
-   |1|000000000000001|0000000000001011|
-   +----------------------------------+
-   | flags (8)  |  Length (24 bits)   |
-   +----------------------------------+
-   |  Slot (16 bits) |                |
-   +-----------------+                |
-   |      Proof Length (32 bits)      |
-   +----------------------------------+
-   |               Proof              |
-   +----------------------------------+ <+
-   |   Certificate Length (32 bits)   |  |
-   +----------------------------------+  | Repeated until end of frame
-   |            Certificate           |  |
-   +----------------------------------+ <+
-
-   Slot: The index in the server's client certificate vector where this
-   certificate should be stored.  If there is already a certificate
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 25]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   stored at this index, it will be overwritten.  The index is one
-   based, not zero based; zero is an invalid slot index.
-
-   Proof: Cryptographic proof that the client has possession of the
-   private key associated with the certificate.  The format is a TLS
-   digitally-signed element
-   (http://tools.ietf.org/html/rfc5246#section-4.7).  The signature
-   algorithm must be the same as that used in the CertificateVerify
-   message.  However, since the MD5+SHA1 signature type used in TLS 1.0
-   connections can not be correctly encoded in a digitally-signed
-   element, SHA1 must be used when MD5+SHA1 was used in the SSL
-   connection.  The signature is calculated over a 32 byte TLS extractor
-   value (http://tools.ietf.org/html/rfc5705) with a label of "EXPORTER
-   SPDY certificate proof" using the empty string as context.  ForRSA
-   certificates the signature would be a PKCS#1 v1.5 signature.  For
-   ECDSA, it would be an ECDSA-Sig-Value
-   (http://tools.ietf.org/html/rfc5480#appendix-A).  For a 1024-bit RSA
-   key, the CREDENTIAL message would be ~500 bytes.
-
-   Certificate: The certificate chain, starting with the leaf
-   certificate.  Each certificate must be encoded as a 32 bit length,
-   followed by a DER encoded certificate.  The certificate must be of
-   the same type (RSA, ECDSA, etc) as the client certificate associated
-   with the SSL connection.
-
-   If the server receives a request for a resource with unacceptable
-   credential (either missing or invalid), it must reply with a
-   RST_STREAM frame with the status code INVALID_CREDENTIALS.  Upon
-   receipt of a RST_STREAM frame with INVALID_CREDENTIALS, the client
-   should initiate a new stream directly to the requested origin and
-   resend the request.  Note, SPDY does not allow the server to request
-   different client authentication for different resources in the same
-   origin.
-
-   If the server receives an invalid CREDENTIAL frame, it MUST respond
-   with a GOAWAY frame and shutdown the session.
-
-2.6.10.  Name/Value Header Block
-
-   The Name/Value Header Block is found in the SYN_STREAM, SYN_REPLY and
-   HEADERS control frames, and shares a common format:
-
-
-
-
-
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 26]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   +------------------------------------+
-   | Number of Name/Value pairs (int32) |
-   +------------------------------------+
-   |     Length of name (int32)         |
-   +------------------------------------+
-   |           Name (string)            |
-   +------------------------------------+
-   |     Length of value  (int32)       |
-   +------------------------------------+
-   |          Value   (string)          |
-   +------------------------------------+
-   |           (repeats)                |
-
-   Number of Name/Value pairs: The number of repeating name/value pairs
-   following this field.
-
-   List of Name/Value pairs:
-
-      Length of Name: a 32-bit value containing the number of octets in
-      the name field.  Note that in practice, this length must not
-      exceed 2^24, as that is the maximum size of a SPDY frame.
-
-      Name: 0 or more octets, 8-bit sequences of data, excluding 0.
-
-      Length of Value: a 32-bit value containing the number of octets in
-      the value field.  Note that in practice, this length must not
-      exceed 2^24, as that is the maximum size of a SPDY frame.
-
-      Value: 0 or more octets, 8-bit sequences of data, excluding 0.
-
-   Each header name must have at least one value.  Header names are
-   encoded using the US-ASCII character set [ASCII] and must be all
-   lower case.  The length of each name must be greater than zero.  A
-   recipient of a zero-length name MUST issue a stream error
-   (Section 2.4.2) with the status code PROTOCOL_ERROR for the
-   stream-id.
-
-   Duplicate header names are not allowed.  To send two identically
-   named headers, send a header with two values, where the values are
-   separated by a single NUL (0) byte.  A header value can either be
-   empty (e.g. the length is zero) or it can contain multiple, NUL-
-   separated values, each with length greater than zero.  The value
-   never starts nor ends with a NUL character.  Recipients of illegal
-   value fields MUST issue a stream error (Section 2.4.2) with the
-   status code PROTOCOL_ERROR for the stream-id.
-
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 27]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-2.6.10.1.  Compression
-
-   The Name/Value Header Block is a section of the SYN_STREAM,
-   SYN_REPLY, and HEADERS frames used to carry header meta-data.  This
-   block is always compressed using zlib compression.  Within this
-   specification, any reference to 'zlib' is referring to the ZLIB
-   Compressed Data Format Specification Version 3.3 as part of RFC1950.
-   [RFC1950]
-
-   For each HEADERS compression instance, the initial state is
-   initialized using the following dictionary [UDELCOMPRESSION]:
-
-   const unsigned char SPDY_dictionary_txt[] = {
-           0x00, 0x00, 0x00, 0x07, 0x6f, 0x70, 0x74, 0x69,   \\ - - - - o p t i
-           0x6f, 0x6e, 0x73, 0x00, 0x00, 0x00, 0x04, 0x68,   \\ o n s - - - - h
-           0x65, 0x61, 0x64, 0x00, 0x00, 0x00, 0x04, 0x70,   \\ e a d - - - - p
-           0x6f, 0x73, 0x74, 0x00, 0x00, 0x00, 0x03, 0x70,   \\ o s t - - - - p
-           0x75, 0x74, 0x00, 0x00, 0x00, 0x06, 0x64, 0x65,   \\ u t - - - - d e
-           0x6c, 0x65, 0x74, 0x65, 0x00, 0x00, 0x00, 0x05,   \\ l e t e - - - -
-           0x74, 0x72, 0x61, 0x63, 0x65, 0x00, 0x00, 0x00,   \\ t r a c e - - -
-           0x06, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x00,   \\ - a c c e p t -
-           0x00, 0x00, 0x0e, 0x61, 0x63, 0x63, 0x65, 0x70,   \\ - - - a c c e p
-           0x74, 0x2d, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65,   \\ t - c h a r s e
-           0x74, 0x00, 0x00, 0x00, 0x0f, 0x61, 0x63, 0x63,   \\ t - - - - a c c
-           0x65, 0x70, 0x74, 0x2d, 0x65, 0x6e, 0x63, 0x6f,   \\ e p t - e n c o
-           0x64, 0x69, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x0f,   \\ d i n g - - - -
-           0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2d, 0x6c,   \\ a c c e p t - l
-           0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x00,   \\ a n g u a g e -
-           0x00, 0x00, 0x0d, 0x61, 0x63, 0x63, 0x65, 0x70,   \\ - - - a c c e p
-           0x74, 0x2d, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73,   \\ t - r a n g e s
-           0x00, 0x00, 0x00, 0x03, 0x61, 0x67, 0x65, 0x00,   \\ - - - - a g e -
-           0x00, 0x00, 0x05, 0x61, 0x6c, 0x6c, 0x6f, 0x77,   \\ - - - a l l o w
-           0x00, 0x00, 0x00, 0x0d, 0x61, 0x75, 0x74, 0x68,   \\ - - - - a u t h
-           0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f,   \\ o r i z a t i o
-           0x6e, 0x00, 0x00, 0x00, 0x0d, 0x63, 0x61, 0x63,   \\ n - - - - c a c
-           0x68, 0x65, 0x2d, 0x63, 0x6f, 0x6e, 0x74, 0x72,   \\ h e - c o n t r
-           0x6f, 0x6c, 0x00, 0x00, 0x00, 0x0a, 0x63, 0x6f,   \\ o l - - - - c o
-           0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,   \\ n n e c t i o n
-           0x00, 0x00, 0x00, 0x0c, 0x63, 0x6f, 0x6e, 0x74,   \\ - - - - c o n t
-           0x65, 0x6e, 0x74, 0x2d, 0x62, 0x61, 0x73, 0x65,   \\ e n t - b a s e
-           0x00, 0x00, 0x00, 0x10, 0x63, 0x6f, 0x6e, 0x74,   \\ - - - - c o n t
-           0x65, 0x6e, 0x74, 0x2d, 0x65, 0x6e, 0x63, 0x6f,   \\ e n t - e n c o
-           0x64, 0x69, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x10,   \\ d i n g - - - -
-           0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d,   \\ c o n t e n t -
-           0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65,   \\ l a n g u a g e
-           0x00, 0x00, 0x00, 0x0e, 0x63, 0x6f, 0x6e, 0x74,   \\ - - - - c o n t
-           0x65, 0x6e, 0x74, 0x2d, 0x6c, 0x65, 0x6e, 0x67,   \\ e n t - l e n g
-           0x74, 0x68, 0x00, 0x00, 0x00, 0x10, 0x63, 0x6f,   \\ t h - - - - c o
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 28]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-           0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x6c, 0x6f,   \\ n t e n t - l o
-           0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00,   \\ c a t i o n - -
-           0x00, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e,   \\ - - c o n t e n
-           0x74, 0x2d, 0x6d, 0x64, 0x35, 0x00, 0x00, 0x00,   \\ t - m d 5 - - -
-           0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74,   \\ - c o n t e n t
-           0x2d, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x00,   \\ - r a n g e - -
-           0x00, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e,   \\ - - c o n t e n
-           0x74, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x00, 0x00,   \\ t - t y p e - -
-           0x00, 0x04, 0x64, 0x61, 0x74, 0x65, 0x00, 0x00,   \\ - - d a t e - -
-           0x00, 0x04, 0x65, 0x74, 0x61, 0x67, 0x00, 0x00,   \\ - - e t a g - -
-           0x00, 0x06, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74,   \\ - - e x p e c t
-           0x00, 0x00, 0x00, 0x07, 0x65, 0x78, 0x70, 0x69,   \\ - - - - e x p i
-           0x72, 0x65, 0x73, 0x00, 0x00, 0x00, 0x04, 0x66,   \\ r e s - - - - f
-           0x72, 0x6f, 0x6d, 0x00, 0x00, 0x00, 0x04, 0x68,   \\ r o m - - - - h
-           0x6f, 0x73, 0x74, 0x00, 0x00, 0x00, 0x08, 0x69,   \\ o s t - - - - i
-           0x66, 0x2d, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x00,   \\ f - m a t c h -
-           0x00, 0x00, 0x11, 0x69, 0x66, 0x2d, 0x6d, 0x6f,   \\ - - - i f - m o
-           0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2d, 0x73,   \\ d i f i e d - s
-           0x69, 0x6e, 0x63, 0x65, 0x00, 0x00, 0x00, 0x0d,   \\ i n c e - - - -
-           0x69, 0x66, 0x2d, 0x6e, 0x6f, 0x6e, 0x65, 0x2d,   \\ i f - n o n e -
-           0x6d, 0x61, 0x74, 0x63, 0x68, 0x00, 0x00, 0x00,   \\ m a t c h - - -
-           0x08, 0x69, 0x66, 0x2d, 0x72, 0x61, 0x6e, 0x67,   \\ - i f - r a n g
-           0x65, 0x00, 0x00, 0x00, 0x13, 0x69, 0x66, 0x2d,   \\ e - - - - i f -
-           0x75, 0x6e, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69,   \\ u n m o d i f i
-           0x65, 0x64, 0x2d, 0x73, 0x69, 0x6e, 0x63, 0x65,   \\ e d - s i n c e
-           0x00, 0x00, 0x00, 0x0d, 0x6c, 0x61, 0x73, 0x74,   \\ - - - - l a s t
-           0x2d, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65,   \\ - m o d i f i e
-           0x64, 0x00, 0x00, 0x00, 0x08, 0x6c, 0x6f, 0x63,   \\ d - - - - l o c
-           0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00,   \\ a t i o n - - -
-           0x0c, 0x6d, 0x61, 0x78, 0x2d, 0x66, 0x6f, 0x72,   \\ - m a x - f o r
-           0x77, 0x61, 0x72, 0x64, 0x73, 0x00, 0x00, 0x00,   \\ w a r d s - - -
-           0x06, 0x70, 0x72, 0x61, 0x67, 0x6d, 0x61, 0x00,   \\ - p r a g m a -
-           0x00, 0x00, 0x12, 0x70, 0x72, 0x6f, 0x78, 0x79,   \\ - - - p r o x y
-           0x2d, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74,   \\ - a u t h e n t
-           0x69, 0x63, 0x61, 0x74, 0x65, 0x00, 0x00, 0x00,   \\ i c a t e - - -
-           0x13, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2d, 0x61,   \\ - p r o x y - a
-           0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61,   \\ u t h o r i z a
-           0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x05,   \\ t i o n - - - -
-           0x72, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x00, 0x00,   \\ r a n g e - - -
-           0x07, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x72,   \\ - r e f e r e r
-           0x00, 0x00, 0x00, 0x0b, 0x72, 0x65, 0x74, 0x72,   \\ - - - - r e t r
-           0x79, 0x2d, 0x61, 0x66, 0x74, 0x65, 0x72, 0x00,   \\ y - a f t e r -
-           0x00, 0x00, 0x06, 0x73, 0x65, 0x72, 0x76, 0x65,   \\ - - - s e r v e
-           0x72, 0x00, 0x00, 0x00, 0x02, 0x74, 0x65, 0x00,   \\ r - - - - t e -
-           0x00, 0x00, 0x07, 0x74, 0x72, 0x61, 0x69, 0x6c,   \\ - - - t r a i l
-           0x65, 0x72, 0x00, 0x00, 0x00, 0x11, 0x74, 0x72,   \\ e r - - - - t r
-           0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2d, 0x65,   \\ a n s f e r - e
-           0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x00,   \\ n c o d i n g -
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 29]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-           0x00, 0x00, 0x07, 0x75, 0x70, 0x67, 0x72, 0x61,   \\ - - - u p g r a
-           0x64, 0x65, 0x00, 0x00, 0x00, 0x0a, 0x75, 0x73,   \\ d e - - - - u s
-           0x65, 0x72, 0x2d, 0x61, 0x67, 0x65, 0x6e, 0x74,   \\ e r - a g e n t
-           0x00, 0x00, 0x00, 0x04, 0x76, 0x61, 0x72, 0x79,   \\ - - - - v a r y
-           0x00, 0x00, 0x00, 0x03, 0x76, 0x69, 0x61, 0x00,   \\ - - - - v i a -
-           0x00, 0x00, 0x07, 0x77, 0x61, 0x72, 0x6e, 0x69,   \\ - - - w a r n i
-           0x6e, 0x67, 0x00, 0x00, 0x00, 0x10, 0x77, 0x77,   \\ n g - - - - w w
-           0x77, 0x2d, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e,   \\ w - a u t h e n
-           0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x00, 0x00,   \\ t i c a t e - -
-           0x00, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64,   \\ - - m e t h o d
-           0x00, 0x00, 0x00, 0x03, 0x67, 0x65, 0x74, 0x00,   \\ - - - - g e t -
-           0x00, 0x00, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75,   \\ - - - s t a t u
-           0x73, 0x00, 0x00, 0x00, 0x06, 0x32, 0x30, 0x30,   \\ s - - - - 2 0 0
-           0x20, 0x4f, 0x4b, 0x00, 0x00, 0x00, 0x07, 0x76,   \\ - O K - - - - v
-           0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x00, 0x00,   \\ e r s i o n - -
-           0x00, 0x08, 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31,   \\ - - H T T P - 1
-           0x2e, 0x31, 0x00, 0x00, 0x00, 0x03, 0x75, 0x72,   \\ - 1 - - - - u r
-           0x6c, 0x00, 0x00, 0x00, 0x06, 0x70, 0x75, 0x62,   \\ l - - - - p u b
-           0x6c, 0x69, 0x63, 0x00, 0x00, 0x00, 0x0a, 0x73,   \\ l i c - - - - s
-           0x65, 0x74, 0x2d, 0x63, 0x6f, 0x6f, 0x6b, 0x69,   \\ e t - c o o k i
-           0x65, 0x00, 0x00, 0x00, 0x0a, 0x6b, 0x65, 0x65,   \\ e - - - - k e e
-           0x70, 0x2d, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x00,   \\ p - a l i v e -
-           0x00, 0x00, 0x06, 0x6f, 0x72, 0x69, 0x67, 0x69,   \\ - - - o r i g i
-           0x6e, 0x31, 0x30, 0x30, 0x31, 0x30, 0x31, 0x32,   \\ n 1 0 0 1 0 1 2
-           0x30, 0x31, 0x32, 0x30, 0x32, 0x32, 0x30, 0x35,   \\ 0 1 2 0 2 2 0 5
-           0x32, 0x30, 0x36, 0x33, 0x30, 0x30, 0x33, 0x30,   \\ 2 0 6 3 0 0 3 0
-           0x32, 0x33, 0x30, 0x33, 0x33, 0x30, 0x34, 0x33,   \\ 2 3 0 3 3 0 4 3
-           0x30, 0x35, 0x33, 0x30, 0x36, 0x33, 0x30, 0x37,   \\ 0 5 3 0 6 3 0 7
-           0x34, 0x30, 0x32, 0x34, 0x30, 0x35, 0x34, 0x30,   \\ 4 0 2 4 0 5 4 0
-           0x36, 0x34, 0x30, 0x37, 0x34, 0x30, 0x38, 0x34,   \\ 6 4 0 7 4 0 8 4
-           0x30, 0x39, 0x34, 0x31, 0x30, 0x34, 0x31, 0x31,   \\ 0 9 4 1 0 4 1 1
-           0x34, 0x31, 0x32, 0x34, 0x31, 0x33, 0x34, 0x31,   \\ 4 1 2 4 1 3 4 1
-           0x34, 0x34, 0x31, 0x35, 0x34, 0x31, 0x36, 0x34,   \\ 4 4 1 5 4 1 6 4
-           0x31, 0x37, 0x35, 0x30, 0x32, 0x35, 0x30, 0x34,   \\ 1 7 5 0 2 5 0 4
-           0x35, 0x30, 0x35, 0x32, 0x30, 0x33, 0x20, 0x4e,   \\ 5 0 5 2 0 3 - N
-           0x6f, 0x6e, 0x2d, 0x41, 0x75, 0x74, 0x68, 0x6f,   \\ o n - A u t h o
-           0x72, 0x69, 0x74, 0x61, 0x74, 0x69, 0x76, 0x65,   \\ r i t a t i v e
-           0x20, 0x49, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61,   \\ - I n f o r m a
-           0x74, 0x69, 0x6f, 0x6e, 0x32, 0x30, 0x34, 0x20,   \\ t i o n 2 0 4 -
-           0x4e, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x65,   \\ N o - C o n t e
-           0x6e, 0x74, 0x33, 0x30, 0x31, 0x20, 0x4d, 0x6f,   \\ n t 3 0 1 - M o
-           0x76, 0x65, 0x64, 0x20, 0x50, 0x65, 0x72, 0x6d,   \\ v e d - P e r m
-           0x61, 0x6e, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x34,   \\ a n e n t l y 4
-           0x30, 0x30, 0x20, 0x42, 0x61, 0x64, 0x20, 0x52,   \\ 0 0 - B a d - R
-           0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x34, 0x30,   \\ e q u e s t 4 0
-           0x31, 0x20, 0x55, 0x6e, 0x61, 0x75, 0x74, 0x68,   \\ 1 - U n a u t h
-           0x6f, 0x72, 0x69, 0x7a, 0x65, 0x64, 0x34, 0x30,   \\ o r i z e d 4 0
-           0x33, 0x20, 0x46, 0x6f, 0x72, 0x62, 0x69, 0x64,   \\ 3 - F o r b i d
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 30]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-           0x64, 0x65, 0x6e, 0x34, 0x30, 0x34, 0x20, 0x4e,   \\ d e n 4 0 4 - N
-           0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64,   \\ o t - F o u n d
-           0x35, 0x30, 0x30, 0x20, 0x49, 0x6e, 0x74, 0x65,   \\ 5 0 0 - I n t e
-           0x72, 0x6e, 0x61, 0x6c, 0x20, 0x53, 0x65, 0x72,   \\ r n a l - S e r
-           0x76, 0x65, 0x72, 0x20, 0x45, 0x72, 0x72, 0x6f,   \\ v e r - E r r o
-           0x72, 0x35, 0x30, 0x31, 0x20, 0x4e, 0x6f, 0x74,   \\ r 5 0 1 - N o t
-           0x20, 0x49, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65,   \\ - I m p l e m e
-           0x6e, 0x74, 0x65, 0x64, 0x35, 0x30, 0x33, 0x20,   \\ n t e d 5 0 3 -
-           0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20,   \\ S e r v i c e -
-           0x55, 0x6e, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61,   \\ U n a v a i l a
-           0x62, 0x6c, 0x65, 0x4a, 0x61, 0x6e, 0x20, 0x46,   \\ b l e J a n - F
-           0x65, 0x62, 0x20, 0x4d, 0x61, 0x72, 0x20, 0x41,   \\ e b - M a r - A
-           0x70, 0x72, 0x20, 0x4d, 0x61, 0x79, 0x20, 0x4a,   \\ p r - M a y - J
-           0x75, 0x6e, 0x20, 0x4a, 0x75, 0x6c, 0x20, 0x41,   \\ u n - J u l - A
-           0x75, 0x67, 0x20, 0x53, 0x65, 0x70, 0x74, 0x20,   \\ u g - S e p t -
-           0x4f, 0x63, 0x74, 0x20, 0x4e, 0x6f, 0x76, 0x20,   \\ O c t - N o v -
-           0x44, 0x65, 0x63, 0x20, 0x30, 0x30, 0x3a, 0x30,   \\ D e c - 0 0 - 0
-           0x30, 0x3a, 0x30, 0x30, 0x20, 0x4d, 0x6f, 0x6e,   \\ 0 - 0 0 - M o n
-           0x2c, 0x20, 0x54, 0x75, 0x65, 0x2c, 0x20, 0x57,   \\ - - T u e - - W
-           0x65, 0x64, 0x2c, 0x20, 0x54, 0x68, 0x75, 0x2c,   \\ e d - - T h u -
-           0x20, 0x46, 0x72, 0x69, 0x2c, 0x20, 0x53, 0x61,   \\ - F r i - - S a
-           0x74, 0x2c, 0x20, 0x53, 0x75, 0x6e, 0x2c, 0x20,   \\ t - - S u n - -
-           0x47, 0x4d, 0x54, 0x63, 0x68, 0x75, 0x6e, 0x6b,   \\ G M T c h u n k
-           0x65, 0x64, 0x2c, 0x74, 0x65, 0x78, 0x74, 0x2f,   \\ e d - t e x t -
-           0x68, 0x74, 0x6d, 0x6c, 0x2c, 0x69, 0x6d, 0x61,   \\ h t m l - i m a
-           0x67, 0x65, 0x2f, 0x70, 0x6e, 0x67, 0x2c, 0x69,   \\ g e - p n g - i
-           0x6d, 0x61, 0x67, 0x65, 0x2f, 0x6a, 0x70, 0x67,   \\ m a g e - j p g
-           0x2c, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x67,   \\ - i m a g e - g
-           0x69, 0x66, 0x2c, 0x61, 0x70, 0x70, 0x6c, 0x69,   \\ i f - a p p l i
-           0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x78,   \\ c a t i o n - x
-           0x6d, 0x6c, 0x2c, 0x61, 0x70, 0x70, 0x6c, 0x69,   \\ m l - a p p l i
-           0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x78,   \\ c a t i o n - x
-           0x68, 0x74, 0x6d, 0x6c, 0x2b, 0x78, 0x6d, 0x6c,   \\ h t m l - x m l
-           0x2c, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x70, 0x6c,   \\ - t e x t - p l
-           0x61, 0x69, 0x6e, 0x2c, 0x74, 0x65, 0x78, 0x74,   \\ a i n - t e x t
-           0x2f, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72,   \\ - j a v a s c r
-           0x69, 0x70, 0x74, 0x2c, 0x70, 0x75, 0x62, 0x6c,   \\ i p t - p u b l
-           0x69, 0x63, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74,   \\ i c p r i v a t
-           0x65, 0x6d, 0x61, 0x78, 0x2d, 0x61, 0x67, 0x65,   \\ e m a x - a g e
-           0x3d, 0x67, 0x7a, 0x69, 0x70, 0x2c, 0x64, 0x65,   \\ - g z i p - d e
-           0x66, 0x6c, 0x61, 0x74, 0x65, 0x2c, 0x73, 0x64,   \\ f l a t e - s d
-           0x63, 0x68, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65,   \\ c h c h a r s e
-           0x74, 0x3d, 0x75, 0x74, 0x66, 0x2d, 0x38, 0x63,   \\ t - u t f - 8 c
-           0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x3d, 0x69,   \\ h a r s e t - i
-           0x73, 0x6f, 0x2d, 0x38, 0x38, 0x35, 0x39, 0x2d,   \\ s o - 8 8 5 9 -
-           0x31, 0x2c, 0x75, 0x74, 0x66, 0x2d, 0x2c, 0x2a,   \\ 1 - u t f - - -
-           0x2c, 0x65, 0x6e, 0x71, 0x3d, 0x30, 0x2e          \\ - e n q - 0 -
-   };
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 31]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   The entire contents of the name/value header block is compressed
-   using zlib.  There is a single zlib stream for all name value pairs
-   in one direction on a connection.  SPDY uses a SYNC_FLUSH between
-   each compressed frame.
-
-   Implementation notes: the compression engine can be tuned to favor
-   speed or size.  Optimizing for size increases memory use and CPU
-   consumption.  Because header blocks are generally small, implementors
-   may want to reduce the window-size of the compression engine from the
-   default 15bits (a 32KB window) to more like 11bits (a 2KB window).
-   The exact setting is chosen by the compressor, the decompressor will
-   work with any setting.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 32]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-3.  HTTP Layering over SPDY
-
-   SPDY is intended to be as compatible as possible with current web-
-   based applications.  This means that, from the perspective of the
-   server business logic or application API, the features of HTTP are
-   unchanged.  To achieve this, all of the application request and
-   response header semantics are preserved, although the syntax of
-   conveying those semantics has changed.  Thus, the rules from the
-   HTTP/1.1 specification in RFC2616 [RFC2616] apply with the changes in
-   the sections below.
-
-3.1.  Connection Management
-
-   Clients SHOULD NOT open more than one SPDY session to a given origin
-   [RFC6454] concurrently.
-
-   Note that it is possible for one SPDY session to be finishing (e.g. a
-   GOAWAY message has been sent, but not all streams have finished),
-   while another SPDY session is starting.
-
-3.1.1.  Use of GOAWAY
-
-   SPDY provides a GOAWAY message which can be used when closing a
-   connection from either the client or server.  Without a server GOAWAY
-   message, HTTP has a race condition where the client sends a request
-   (a new SYN_STREAM) just as the server is closing the connection, and
-   the client cannot know if the server received the stream or not.  By
-   using the last-stream-id in the GOAWAY, servers can indicate to the
-   client if a request was processed or not.
-
-   Note that some servers will choose to send the GOAWAY and immediately
-   terminate the connection without waiting for active streams to
-   finish.  The client will be able to determine this because SPDY
-   streams are determinstically closed.  This abrupt termination will
-   force the client to heuristically decide whether to retry the pending
-   requests.  Clients always need to be capable of dealing with this
-   case because they must deal with accidental connection termination
-   cases, which are the same as the server never having sent a GOAWAY.
-
-   More sophisticated servers will use GOAWAY to implement a graceful
-   teardown.  They will send the GOAWAY and provide some time for the
-   active streams to finish before terminating the connection.
-
-   If a SPDY client closes the connection, it should also send a GOAWAY
-   message.  This allows the server to know if any server-push streams
-   were received by the client.
-
-   If the endpoint closing the connection has not received any
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 33]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   SYN_STREAMs from the remote, the GOAWAY will contain a last-stream-id
-   of 0.
-
-3.2.  HTTP Request/Response
-
-3.2.1.  Request
-
-   The client initiates a request by sending a SYN_STREAM frame.  For
-   requests which do not contain a body, the SYN_STREAM frame MUST set
-   the FLAG_FIN, indicating that the client intends to send no further
-   data on this stream.  For requests which do contain a body, the
-   SYN_STREAM will not contain the FLAG_FIN, and the body will follow
-   the SYN_STREAM in a series of DATA frames.  The last DATA frame will
-   set the FLAG_FIN to indicate the end of the body.
-
-   The SYN_STREAM Name/Value section will contain all of the HTTP
-   headers which are associated with an HTTP request.  The header block
-   in SPDY is mostly unchanged from today's HTTP header block, with the
-   following differences:
-
-      The first line of the request is unfolded into name/value pairs
-      like other HTTP headers and MUST be present:
-
-         ":method" - the HTTP method for this request (e.g.  "GET",
-         "POST", "HEAD", etc)
-
-         ":path" - the url-path for this url with "/" prefixed.  (See
-         RFC1738 [RFC1738]).  For example, for
-         "http://www.google.com/search?q=dogs" the path would be
-         "/search?q=dogs".
-
-         ":version" - the HTTP version of this request (e.g.
-         "HTTP/1.1")
-
-      In addition, the following two name/value pairs must also be
-      present in every request:
-
-         ":host" - the hostport (See RFC1738 [RFC1738]) portion of the
-         URL for this request (e.g. "www.google.com:1234").  This header
-         is the same as the HTTP 'Host' header.
-
-         ":scheme" - the scheme portion of the URL for this request
-         (e.g. "https"))
-
-      Header names are all lowercase.
-
-      The Connection, Host, Keep-Alive, Proxy-Connection, and Transfer-
-      Encoding headers are not valid and MUST not be sent.
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 34]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-      User-agents MUST support gzip compression.  Regardless of the
-      Accept-Encoding sent by the user-agent, the server may always send
-      content encoded with gzip or deflate encoding.
-
-      If a server receives a request where the sum of the data frame
-      payload lengths does not equal the size of the Content-Length
-      header, the server MUST return a 400 (Bad Request) error.
-
-      POST-specific changes:
-
-         Although POSTs are inherently chunked, POST requests SHOULD
-         also be accompanied by a Content-Length header.  There are two
-         reasons for this: First, it assists with upload progress meters
-         for an improved user experience.  But second, we know from
-         early versions of SPDY that failure to send a content length
-         header is incompatible with many existing HTTP server
-         implementations.  Existing user-agents do not omit the Content-
-         Length header, and server implementations have come to depend
-         upon this.
-
-   The user-agent is free to prioritize requests as it sees fit.  If the
-   user-agent cannot make progress without receiving a resource, it
-   should attempt to raise the priority of that resource.  Resources
-   such as images, SHOULD generally use the lowest priority.
-
-   If a client sends a SYN_STREAM without all of the method, host, path,
-   scheme, and version headers, the server MUST reply with a HTTP 400
-   Bad Request reply.
-
-3.2.2.  Response
-
-   The server responds to a client request with a SYN_REPLY frame.
-   Symmetric to the client's upload stream, server will send data after
-   the SYN_REPLY frame via a series of DATA frames, and the last data
-   frame will contain the FLAG_FIN to indicate successful end-of-stream.
-   If a response (like a 202 or 204 response) contains no body, the
-   SYN_REPLY frame may contain the FLAG_FIN flag to indicate no further
-   data will be sent on the stream.
-
-      The response status line is unfolded into name/value pairs like
-      other HTTP headers and must be present:
-
-         ":status" - The HTTP response status code (e.g. "200" or "200
-         OK")
-
-         ":version" - The HTTP response version (e.g.  "HTTP/1.1")
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 35]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-      All header names must be lowercase.
-
-      The Connection, Keep-Alive, Proxy-Connection, and Transfer-
-      Encoding headers are not valid and MUST not be sent.
-
-      Responses MAY be accompanied by a Content-Length header for
-      advisory purposes. (e.g. for UI progress meters)
-
-      If a client receives a response where the sum of the data frame
-      payload lengths does not equal the size of the Content-Length
-      header, the client MUST ignore the content length header.
-
-   If a client receives a SYN_REPLY without a status or without a
-   version header, the client must reply with a RST_STREAM frame
-   indicating a PROTOCOL ERROR.
-
-3.2.3.  Authentication
-
-   When a client sends a request to an origin server that requires
-   authentication, the server can reply with a "401 Unauthorized"
-   response, and include a WWW-Authenticate challenge header that
-   defines the authentication scheme to be used.  The client then
-   retries the request with an Authorization header appropriate to the
-   specified authentication scheme.
-
-   There are four options for proxy authentication, Basic, Digest, NTLM
-   and Negotiate (SPNEGO).  The first two options were defined in
-   RFC2617 [RFC2617], and are stateless.  The second two options were
-   developed by Microsoft and specified in RFC4559 [RFC4559], and are
-   stateful; otherwise known as multi-round authentication, or
-   connection authentication.
-
-3.2.3.1.  Stateless Authentication
-
-   Stateless Authentication over SPDY is identical to how it is
-   performed over HTTP.  If multiple SPDY streams are concurrently sent
-   to a single server, each will authenticate independently, similar to
-   how two HTTP connections would independently authenticate to a proxy
-   server.
-
-3.2.3.2.  Stateful Authentication
-
-   Unfortunately, the stateful authentication mechanisms were
-   implemented and defined in a such a way that directly violates
-   RFC2617 - they do not include a "realm" as part of the request.  This
-   is problematic in SPDY because it makes it impossible for a client to
-   disambiguate two concurrent server authentication challenges.
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 36]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   To deal with this case, SPDY servers using Stateful Authentication
-   MUST implement one of two changes:
-
-      Servers can add a "realm=<desired realm>" header so that the two
-      authentication requests can be disambiguated and run concurrently.
-      Unfortunately, given how these mechanisms work, this is probably
-      not practical.
-
-      Upon sending the first stateful challenge response, the server
-      MUST buffer and defer all further frames which are not part of
-      completing the challenge until the challenge has completed.
-      Completing the authentication challenge may take multiple round
-      trips.  Once the client receives a "401 Authenticate" response for
-      a stateful authentication type, it MUST stop sending new requests
-      to the server until the authentication has completed by receiving
-      a non-401 response on at least one stream.
-
-3.3.  Server Push Transactions
-
-   SPDY enables a server to send multiple replies to a client for a
-   single request.  The rationale for this feature is that sometimes a
-   server knows that it will need to send multiple resources in response
-   to a single request.  Without server push features, the client must
-   first download the primary resource, then discover the secondary
-   resource(s), and request them.  Pushing of resources avoids the
-   round-trip delay, but also creates a potential race where a server
-   can be pushing content which a user-agent is in the process of
-   requesting.  The following mechanics attempt to prevent the race
-   condition while enabling the performance benefit.
-
-   Browsers receiving a pushed response MUST validate that the server is
-   authorized to push the URL using the browser same-origin [RFC6454]
-   policy.  For example, a SPDY connection to www.foo.com is generally
-   not permitted to push a response for www.evil.com.
-
-   If the browser accepts a pushed response (e.g. it does not send a
-   RST_STREAM), the browser MUST attempt to cache the pushed response in
-   same way that it would cache any other response.  This means
-   validating the response headers and inserting into the disk cache.
-
-   Because pushed responses have no request, they have no request
-   headers associated with them.  At the framing layer, SPDY pushed
-   streams contain an "associated-stream-id" which indicates the
-   requested stream for which the pushed stream is related.  The pushed
-   stream inherits all of the headers from the associated-stream-id with
-   the exception of ":host", ":scheme", and ":path", which are provided
-   as part of the pushed response stream headers.  The browser MUST
-   store these inherited and implied request headers with the cached
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 37]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   resource.
-
-   Implementation note: With server push, it is theoretically possible
-   for servers to push unreasonable amounts of content or resources to
-   the user-agent.  Browsers MUST implement throttles to protect against
-   unreasonable push attacks.
-
-3.3.1.  Server implementation
-
-   When the server intends to push a resource to the user-agent, it
-   opens a new stream by sending a unidirectional SYN_STREAM.  The
-   SYN_STREAM MUST include an Associated-To-Stream-ID, and MUST set the
-   FLAG_UNIDIRECTIONAL flag.  The SYN_STREAM MUST include headers for
-   ":scheme", ":host", ":path", which represent the URL for the resource
-   being pushed.  Subsequent headers may follow in HEADERS frames.  The
-   purpose of the association is so that the user-agent can
-   differentiate which request induced the pushed stream; without it, if
-   the user-agent had two tabs open to the same page, each pushing
-   unique content under a fixed URL, the user-agent would not be able to
-   differentiate the requests.
-
-   The Associated-To-Stream-ID must be the ID of an existing, open
-   stream.  The reason for this restriction is to have a clear endpoint
-   for pushed content.  If the user-agent requested a resource on stream
-   11, the server replies on stream 11.  It can push any number of
-   additional streams to the client before sending a FLAG_FIN on stream
-   11.  However, once the originating stream is closed no further push
-   streams may be associated with it.  The pushed streams do not need to
-   be closed (FIN set) before the originating stream is closed, they
-   only need to be created before the originating stream closes.
-
-   It is illegal for a server to push a resource with the Associated-To-
-   Stream-ID of 0.
-
-   To minimize race conditions with the client, the SYN_STREAM for the
-   pushed resources MUST be sent prior to sending any content which
-   could allow the client to discover the pushed resource and request
-   it.
-
-   The server MUST only push resources which would have been returned
-   from a GET request.
-
-   Note: If the server does not have all of the Name/Value Response
-   headers available at the time it issues the HEADERS frame for the
-   pushed resource, it may later use an additional HEADERS frame to
-   augment the name/value pairs to be associated with the pushed stream.
-   The subsequent HEADERS frame(s) must not contain a header for
-   ':host', ':scheme', or ':path' (e.g. the server can't change the
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 38]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   identity of the resource to be pushed).  The HEADERS frame must not
-   contain duplicate headers with a previously sent HEADERS frame.  The
-   server must send a HEADERS frame including the scheme/host/port
-   headers before sending any data frames on the stream.
-
-3.3.2.  Client implementation
-
-   When fetching a resource the client has 3 possibilities:
-
-      the resource is not being pushed
-
-      the resource is being pushed, but the data has not yet arrived
-
-      the resource is being pushed, and the data has started to arrive
-
-   When a SYN_STREAM and HEADERS frame which contains an Associated-To-
-   Stream-ID is received, the client must not issue GET requests for the
-   resource in the pushed stream, and instead wait for the pushed stream
-   to arrive.
-
-   If a client receives a server push stream with stream-id 0, it MUST
-   issue a session error (Section 2.4.1) with the status code
-   PROTOCOL_ERROR.
-
-   When a client receives a SYN_STREAM from the server without a the
-   ':host', ':scheme', and ':path' headers in the Name/Value section, it
-   MUST reply with a RST_STREAM with error code HTTP_PROTOCOL_ERROR.
-
-   To cancel individual server push streams, the client can issue a
-   stream error (Section 2.4.2) with error code CANCEL.  Upon receipt,
-   the server MUST stop sending on this stream immediately (this is an
-   Abrupt termination).
-
-   To cancel all server push streams related to a request, the client
-   may issue a stream error (Section 2.4.2) with error code CANCEL on
-   the associated-stream-id.  By cancelling that stream, the server MUST
-   immediately stop sending frames for any streams with
-   in-association-to for the original stream.
-
-   If the server sends a HEADER frame containing duplicate headers with
-   a previous HEADERS frame for the same stream, the client must issue a
-   stream error (Section 2.4.2) with error code PROTOCOL ERROR.
-
-   If the server sends a HEADERS frame after sending a data frame for
-   the same stream, the client MAY ignore the HEADERS frame.  Ignoring
-   the HEADERS frame after a data frame prevents handling of HTTP's
-   trailing headers
-   (http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.40).
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 39]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-4.  Design Rationale and Notes
-
-   Authors' notes: The notes in this section have no bearing on the SPDY
-   protocol as specified within this document, and none of these notes
-   should be considered authoritative about how the protocol works.
-   However, these notes may prove useful in future debates about how to
-   resolve protocol ambiguities or how to evolve the protocol going
-   forward.  They may be removed before the final draft.
-
-4.1.  Separation of Framing Layer and Application Layer
-
-   Readers may note that this specification sometimes blends the framing
-   layer (Section 2) with requirements of a specific application - HTTP
-   (Section 3).  This is reflected in the request/response nature of the
-   streams, the definition of the HEADERS and compression contexts which
-   are very similar to HTTP, and other areas as well.
-
-   This blending is intentional - the primary goal of this protocol is
-   to create a low-latency protocol for use with HTTP.  Isolating the
-   two layers is convenient for description of the protocol and how it
-   relates to existing HTTP implementations.  However, the ability to
-   reuse the SPDY framing layer is a non goal.
-
-4.2.  Error handling - Framing Layer
-
-   Error handling at the SPDY layer splits errors into two groups: Those
-   that affect an individual SPDY stream, and those that do not.
-
-   When an error is confined to a single stream, but general framing is
-   in tact, SPDY attempts to use the RST_STREAM as a mechanism to
-   invalidate the stream but move forward without aborting the
-   connection altogether.
-
-   For errors occuring outside of a single stream context, SPDY assumes
-   the entire session is hosed.  In this case, the endpoint detecting
-   the error should initiate a connection close.
-
-4.3.  One Connection Per Domain
-
-   SPDY attempts to use fewer connections than other protocols have
-   traditionally used.  The rationale for this behavior is because it is
-   very difficult to provide a consistent level of service (e.g.  TCP
-   slow-start), prioritization, or optimal compression when the client
-   is connecting to the server through multiple channels.
-
-   Through lab measurements, we have seen consistent latency benefits by
-   using fewer connections from the client.  The overall number of
-   packets sent by SPDY can be as much as 40% less than HTTP.  Handling
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 40]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   large numbers of concurrent connections on the server also does
-   become a scalability problem, and SPDY reduces this load.
-
-   The use of multiple connections is not without benefit, however.
-   Because SPDY multiplexes multiple, independent streams onto a single
-   stream, it creates a potential for head-of-line blocking problems at
-   the transport level.  In tests so far, the negative effects of head-
-   of-line blocking (especially in the presence of packet loss) is
-   outweighed by the benefits of compression and prioritization.
-
-4.4.  Fixed vs Variable Length Fields
-
-   SPDY favors use of fixed length 32bit fields in cases where smaller,
-   variable length encodings could have been used.  To some, this seems
-   like a tragic waste of bandwidth.  SPDY choses the simple encoding
-   for speed and simplicity.
-
-   The goal of SPDY is to reduce latency on the network.  The overhead
-   of SPDY frames is generally quite low.  Each data frame is only an 8
-   byte overhead for a 1452 byte payload (~0.6%).  At the time of this
-   writing, bandwidth is already plentiful, and there is a strong trend
-   indicating that bandwidth will continue to increase.  With an average
-   worldwide bandwidth of 1Mbps, and assuming that a variable length
-   encoding could reduce the overhead by 50%, the latency saved by using
-   a variable length encoding would be less than 100 nanoseconds.  More
-   interesting are the effects when the larger encodings force a packet
-   boundary, in which case a round-trip could be induced.  However, by
-   addressing other aspects of SPDY and TCP interactions, we believe
-   this is completely mitigated.
-
-4.5.  Compression Context(s)
-
-   When isolating the compression contexts used for communicating with
-   multiple origins, we had a few choices to make.  We could have
-   maintained a map (or list) of compression contexts usable for each
-   origin.  The basic case is easy - each HEADERS frame would need to
-   identify the context to use for that frame.  However, compression
-   contexts are not cheap, so the lifecycle of each context would need
-   to be bounded.  For proxy servers, where we could churn through many
-   contexts, this would be a concern.  We considered using a static set
-   of contexts, say 16 of them, which would bound the memory use.  We
-   also considered dynamic contexts, which could be created on the fly,
-   and would need to be subsequently destroyed.  All of these are
-   complicated, and ultimately we decided that such a mechanism creates
-   too many problems to solve.
-
-   Alternatively, we've chosen the simple approach, which is to simply
-   provide a flag for resetting the compression context.  For the common
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 41]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   case (no proxy), this fine because most requests are to the same
-   origin and we never need to reset the context.  For cases where we
-   are using two different origins over a single SPDY session, we simply
-   reset the compression state between each transition.
-
-4.6.  Unidirectional streams
-
-   Many readers notice that unidirectional streams are both a bit
-   confusing in concept and also somewhat redundant.  If the recipient
-   of a stream doesn't wish to send data on a stream, it could simply
-   send a SYN_REPLY with the FLAG_FIN bit set.  The FLAG_UNIDIRECTIONAL
-   is, therefore, not necessary.
-
-   It is true that we don't need the UNIDIRECTIONAL markings.  It is
-   added because it avoids the recipient of pushed streams from needing
-   to send a set of empty frames (e.g. the SYN_STREAM w/ FLAG_FIN) which
-   otherwise serve no purpose.
-
-4.7.  Data Compression
-
-   Generic compression of data portion of the streams (as opposed to
-   compression of the headers) without knowing the content of the stream
-   is redundant.  There is no value in compressing a stream which is
-   already compressed.  Because of this, SPDY does allow data
-   compression to be optional.  We included it because study of existing
-   websites shows that many sites are not using compression as they
-   should, and users suffer because of it.  We wanted a mechanism where,
-   at the SPDY layer, site administrators could simply force compression
-   - it is better to compress twice than to not compress.
-
-   Overall, however, with this feature being optional and sometimes
-   redundant, it is unclear if it is useful at all.  We will likely
-   remove it from the specification.
-
-4.8.  Server Push
-
-   A subtle but important point is that server push streams must be
-   declared before the associated stream is closed.  The reason for this
-   is so that proxies have a lifetime for which they can discard
-   information about previous streams.  If a pushed stream could
-   associate itself with an already-closed stream, then endpoints would
-   not have a specific lifecycle for when they could disavow knowledge
-   of the streams which went before.
-
-
-
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 42]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-5.  Security Considerations
-
-5.1.  Use of Same-origin constraints
-
-   This specification uses the same-origin policy [RFC6454] in all cases
-   where verification of content is required.
-
-5.2.  HTTP Headers and SPDY Headers
-
-   At the application level, HTTP uses name/value pairs in its headers.
-   Because SPDY merges the existing HTTP headers with SPDY headers,
-   there is a possibility that some HTTP applications already use a
-   particular header name.  To avoid any conflicts, all headers
-   introduced for layering HTTP over SPDY are prefixed with ":". ":" is
-   not a valid sequence in HTTP header naming, preventing any possible
-   conflict.
-
-5.3.  Cross-Protocol Attacks
-
-   By utilizing TLS, we believe that SPDY introduces no new cross-
-   protocol attacks.  TLS encrypts the contents of all transmission
-   (except the handshake itself), making it difficult for attackers to
-   control the data which could be used in a cross-protocol attack.
-
-5.4.  Server Push Implicit Headers
-
-   Pushed resources do not have an associated request.  In order for
-   existing HTTP cache control validations (such as the Vary header) to
-   work, however, all cached resources must have a set of request
-   headers.  For this reason, browsers MUST be careful to inherit
-   request headers from the associated stream for the push.  This
-   includes the 'Cookie' header.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 43]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-6.  Privacy Considerations
-
-6.1.  Long Lived Connections
-
-   SPDY aims to keep connections open longer between clients and servers
-   in order to reduce the latency when a user makes a request.  The
-   maintenance of these connections over time could be used to expose
-   private information.  For example, a user using a browser hours after
-   the previous user stopped using that browser may be able to learn
-   about what the previous user was doing.  This is a problem with HTTP
-   in its current form as well, however the short lived connections make
-   it less of a risk.
-
-6.2.  SETTINGS frame
-
-   The SPDY SETTINGS frame allows servers to store out-of-band
-   transmitted information about the communication between client and
-   server on the client.  Although this is intended only to be used to
-   reduce latency, renegade servers could use it as a mechanism to store
-   identifying information about the client in future requests.
-
-   Clients implementing privacy modes, such as Google Chrome's
-   "incognito mode", may wish to disable client-persisted SETTINGS
-   storage.
-
-   Clients MUST clear persisted SETTINGS information when clearing the
-   cookies.
-
-   TODO: Put range maximums on each type of setting to limit
-   inappropriate uses.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 44]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-7.  Incompatibilities with SPDY draft #2
-
-   Here is a list of the major changes between this draft and draft #2.
-
-      Addition of flow control
-
-      Increased 16 bit length fields in SYN_STREAM and SYN_REPLY to 32
-      bits.
-
-      Changed definition of compression for DATA frames
-
-      Updated compression dictionary
-
-      Fixed off-by-one on the compression dictionary for headers
-
-      Increased priority field from 2bits to 3bits.
-
-      Removed NOOP frame
-
-      Split the request "url" into "scheme", "host", and "path"
-
-      Added the requirement that POSTs contain content-length.
-
-      Removed wasted 16bits of unused space from the end of the
-      SYN_REPLY and HEADERS frames.
-
-      Fixed bug: Priorities were described backward (0 was lowest
-      instead of highest).
-
-      Fixed bug: Name/Value header counts were duplicated in both the
-      Name Value header block and also the containing frame.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 45]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-8.  Requirements Notation
-
-   The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
-   "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
-   document are to be interpreted as described in RFC 2119 [RFC2119].
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 46]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-9.  Acknowledgements
-
-   Many individuals have contributed to the design and evolution of
-   SPDY: Adam Langley, Wan-Teh Chang, Jim Morrison, Mark Nottingham,
-   Alyssa Wilk, Costin Manolache, William Chan, Vitaliy Lvin, Joe Chan,
-   Adam Barth, Ryan Hamilton, Gavin Peters, Kent Alstad, Kevin Lindsay,
-   Paul Amer, Fan Yang, Jonathan Leighton
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 47]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-10.  Normative References
-
-   [RFC0793]  Postel, J., "Transmission Control Protocol", STD 7,
-              RFC 793, September 1981.
-
-   [RFC1738]  Berners-Lee, T., Masinter, L., and M. McCahill, "Uniform
-              Resource Locators (URL)", RFC 1738, December 1994.
-
-   [RFC1950]  Deutsch, L. and J-L. Gailly, "ZLIB Compressed Data Format
-              Specification version 3.3", RFC 1950, May 1996.
-
-   [RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
-              Requirement Levels", BCP 14, RFC 2119, March 1997.
-
-   [RFC2285]  Mandeville, R., "Benchmarking Terminology for LAN
-              Switching Devices", RFC 2285, February 1998.
-
-   [RFC2616]  Fielding, R., Gettys, J., Mogul, J., Frystyk, H.,
-              Masinter, L., Leach, P., and T. Berners-Lee, "Hypertext
-              Transfer Protocol -- HTTP/1.1", RFC 2616, June 1999.
-
-   [RFC2617]  Franks, J., Hallam-Baker, P., Hostetler, J., Lawrence, S.,
-              Leach, P., Luotonen, A., and L. Stewart, "HTTP
-              Authentication: Basic and Digest Access Authentication",
-              RFC 2617, June 1999.
-
-   [RFC4559]  Jaganathan, K., Zhu, L., and J. Brezak, "SPNEGO-based
-              Kerberos and NTLM HTTP Authentication in Microsoft
-              Windows", RFC 4559, June 2006.
-
-   [RFC4366]  Blake-Wilson, S., Nystrom, M., Hopwood, D., Mikkelsen, J.,
-              and T. Wright, "Transport Layer Security (TLS)
-              Extensions", RFC 4366, April 2006.
-
-   [RFC5246]  Dierks, T. and E. Rescorla, "The Transport Layer Security
-              (TLS) Protocol Version 1.2", RFC 5246, August 2008.
-
-   [RFC6454]  Barth, A., "The Web Origin Concept", RFC 6454,
-              December 2011.
-
-   [TLSNPN]   Langley, A., "TLS Next Protocol Negotiation",
-              <http://tools.ietf.org/html/
-              draft-agl-tls-nextprotoneg-01>.
-
-   [ASCII]    "US-ASCII. Coded Character Set - 7-Bit American Standard
-              Code for Information Interchange. Standard ANSI X3.4-1986,
-              ANSI, 1986.".
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 48]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-   [UDELCOMPRESSION]
-              Yang, F., Amer, P., and J. Leighton, "A Methodology to
-              Derive SPDY's Initial Dictionary for Zlib Compression",
-              <http://www.eecis.udel.edu/~amer/PEL/poc/pdf/
-              SPDY-Fan.pdf>.
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 49]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-Appendix A.  Changes
-
-   To be removed by RFC Editor before publication
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 50]
-
-Internet-Draft                    SPDY                          Feb 2012
-
-
-Authors' Addresses
-
-   Mike Belshe
-   Twist
-
-   Email: mbelshe@chromium.org
-
-
-   Roberto Peon
-   Google, Inc
-
-   Email: fenix@google.com
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Belshe & Peon            Expires August 4, 2012                [Page 51]
-
diff --git a/src/examples/Makefile.am b/src/examples/Makefile.am
index edc80dc1..c3330e6f 100644
--- a/src/examples/Makefile.am
+++ b/src/examples/Makefile.am
@@ -13,17 +13,6 @@ if USE_COVERAGE
   AM_CFLAGS += --coverage
 endif
 
-if ENABLE_SPDY
-spdyex = \
-  spdy_event_loop \
-  spdy_fileserver \
-  spdy_response_with_callback
-
-if HAVE_SPDYLAY
-spdyex += mhd2spdy
-endif
-endif
-
 
 # example programs
 noinst_PROGRAMS = \
@@ -37,8 +26,7 @@ noinst_PROGRAMS = \
  fileserver_example \
  fileserver_example_dirs \
  fileserver_example_external_select \
- refuse_post_example \
- $(spdyex)
+ refuse_post_example 
 
 
 if ENABLE_HTTPS
@@ -98,15 +86,6 @@ demo_https_LDADD = \
  $(top_builddir)/src/microhttpd/libmicrohttpd.la  \
  $(PTHREAD_LIBS) -lmagic
 
-mhd2spdy_SOURCES = \
- mhd2spdy.c \
- mhd2spdy_spdy.c mhd2spdy_spdy.h \
- mhd2spdy_http.c mhd2spdy_http.h \
- mhd2spdy_structures.c mhd2spdy_structures.h
-mhd2spdy_LDADD = \
- $(top_builddir)/src/microhttpd/libmicrohttpd.la  \
- -lssl -lcrypto -lspdylay
-
 benchmark_SOURCES = \
  benchmark.c
 benchmark_CPPFLAGS = \
@@ -179,20 +158,3 @@ https_fileserver_example_LDADD = \
  $(top_builddir)/src/microhttpd/libmicrohttpd.la
 
 
-spdy_event_loop_SOURCES = \
- spdy_event_loop.c
-spdy_event_loop_LDADD = \
-  $(top_builddir)/src/microspdy/libmicrospdy.la \
- -lz
-
-spdy_fileserver_SOURCES = \
- spdy_fileserver.c
-spdy_fileserver_LDADD = \
-  $(top_builddir)/src/microspdy/libmicrospdy.la \
- -lz
-
-spdy_response_with_callback_SOURCES = \
- spdy_response_with_callback.c
-spdy_response_with_callback_LDADD = \
-  $(top_builddir)/src/microspdy/libmicrospdy.la \
- -lz
diff --git a/src/examples/mhd2spdy.c b/src/examples/mhd2spdy.c
deleted file mode 100644
index a2275087..00000000
--- a/src/examples/mhd2spdy.c
+++ /dev/null
@@ -1,322 +0,0 @@
-/*
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file mhd2spdy.c
- * @brief  The main file of the HTTP-to-SPDY proxy with the 'main' function
- *         and event loop. No threads are used.
- *         Currently only GET is supported.
- *         TODOs:
- *         - non blocking SSL connect
- *         - check certificate
- *         - on closing spdy session, close sockets for all requests
- * @author Andrey Uzunov
- */
- 
- 
-#include "mhd2spdy_structures.h"
-#include "mhd2spdy_spdy.h"
-#include "mhd2spdy_http.h"
-
-
-static int run = 1;
-//static int spdy_close = 0;
-
-
-static void
-catch_signal(int signal)
-{
-  (void)signal;
-  //spdy_close = 1;
-  run = 0;
-}
-
-
-void
-print_stat()
-{
-  if(!glob_opt.statistics)
-    return;
-  
-  printf("--------------------------\n");
-  printf("Statistics (TLS overhead is ignored when used):\n");
-  //printf("HTTP bytes received: %lld\n", glob_stat.http_bytes_received);
-  //printf("HTTP bytes sent: %lld\n", glob_stat.http_bytes_sent);
-  printf("SPDY bytes sent: %lld\n", glob_stat.spdy_bytes_sent);
-  printf("SPDY bytes received: %lld\n", glob_stat.spdy_bytes_received);
-  printf("SPDY bytes received and dropped: %lld\n", glob_stat.spdy_bytes_received_and_dropped);
-}
-
-
-int
-run_everything ()
-{       
-  unsigned long long timeoutlong=0;
-  struct timeval timeout;
-  int ret;
-  fd_set rs;
-  fd_set ws;
-  fd_set es;
-  int maxfd = -1;
-  int maxfd_s = -1;
-  struct MHD_Daemon *daemon;
-  nfds_t spdy_npollfds = 1;
-  struct URI * spdy2http_uri = NULL;
-  struct SPDY_Connection *connection;
-  struct SPDY_Connection *connections[MAX_SPDY_CONNECTIONS];
-  struct SPDY_Connection *connection_for_delete;
-
-  if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
-    PRINT_INFO("signal failed");
-    
-  if (signal(SIGINT, catch_signal) == SIG_ERR)
-    PRINT_INFO("signal failed");
-
-  glob_opt.streams_opened = 0;
-  glob_opt.responses_pending = 0;
-  //glob_opt.global_memory = 0;
-
-  srand(time(NULL));
-  
-  if(init_parse_uri(&glob_opt.uri_preg))
-    DIE("Regexp compilation failed");
-    
-  if(NULL != glob_opt.spdy2http_str)
-  {
-    ret = parse_uri(&glob_opt.uri_preg, glob_opt.spdy2http_str, &spdy2http_uri);
-    if(ret != 0)
-      DIE("spdy_parse_uri failed");
-  }
-
-  SSL_load_error_strings();
-  SSL_library_init();
-  glob_opt.ssl_ctx = SSL_CTX_new(SSLv23_client_method());
-  if(glob_opt.ssl_ctx == NULL) {
-    PRINT_INFO2("SSL_CTX_new %s", ERR_error_string(ERR_get_error(), NULL));
-    abort();
-  }
-  spdy_ssl_init_ssl_ctx(glob_opt.ssl_ctx, &glob_opt.spdy_proto_version);
-
-  daemon = MHD_start_daemon ( 
-          MHD_SUPPRESS_DATE_NO_CLOCK,
-          glob_opt.listen_port,
-          NULL, NULL, &http_cb_request, NULL,
-          MHD_OPTION_URI_LOG_CALLBACK, &http_cb_log, NULL,
-          MHD_OPTION_NOTIFY_COMPLETED, &http_cb_request_completed, NULL,
-          MHD_OPTION_END);
-  if(NULL==daemon)
-    DIE("MHD_start_daemon failed");
-
-  do
-  {
-    timeout.tv_sec = 0;
-    timeout.tv_usec = 0;
-  
-    if(NULL == glob_opt.spdy_connection && NULL != glob_opt.spdy2http_str)
-    {
-      glob_opt.spdy_connection = spdy_connect(spdy2http_uri, spdy2http_uri->port, strcmp("https", spdy2http_uri->scheme)==0);
-      if(NULL == glob_opt.spdy_connection && glob_opt.only_proxy)
-        PRINT_INFO("cannot connect to the proxy");
-    }
-
-    FD_ZERO(&rs);
-    FD_ZERO(&ws);
-    FD_ZERO(&es);
-
-    ret = MHD_get_timeout(daemon, &timeoutlong);
-    if(MHD_NO == ret || timeoutlong > 5000)
-      timeout.tv_sec = 5;
-    else
-    {
-      timeout.tv_sec = timeoutlong / 1000;
-      timeout.tv_usec = (timeoutlong % 1000) * 1000;
-    }
-    
-    if(MHD_NO == MHD_get_fdset (daemon,
-                                  &rs,
-                                  &ws, 
-                                  &es,
-                                  &maxfd))
-    {
-      PRINT_INFO("MHD_get_fdset error");
-    }
-    assert(-1 != maxfd);
-    
-    maxfd_s = spdy_get_selectfdset(
-                                  &rs,
-                                  &ws, 
-                                  &es,
-                                  connections, MAX_SPDY_CONNECTIONS, &spdy_npollfds);
-    if(maxfd_s > maxfd) 
-      maxfd = maxfd_s;
- 
-    PRINT_INFO2("MHD timeout %lld %lld", (unsigned long long)timeout.tv_sec, (unsigned long long)timeout.tv_usec);
-
-    glob_opt.spdy_data_received = false;
-      
-    ret = select(maxfd+1, &rs, &ws, &es, &timeout);
-    PRINT_INFO2("timeout now %lld %lld ret is %i", (unsigned long long)timeout.tv_sec, (unsigned long long)timeout.tv_usec, ret);
-
-    switch(ret)
-    {
-      case -1:
-        PRINT_INFO2("select error: %i", errno);
-        break;
-      case 0:
-        //break;
-      default:
-      PRINT_INFO("run");
-        //MHD_run_from_select(daemon,&rs, &ws, &es); //not closing FDs at some time in past
-        MHD_run(daemon);
-        spdy_run_select(&rs, &ws, &es, connections, spdy_npollfds);
-        if(glob_opt.spdy_data_received)
-        {
-          PRINT_INFO("MHD run again");
-          //MHD_run_from_select(daemon,&rs, &ws, &es); //not closing FDs at some time in past
-          MHD_run(daemon);
-        }
-        break;
-    }
-  }
-  while(run);
-
-  MHD_stop_daemon (daemon);
-  
-  //TODO SSL_free brakes
-  spdy_free_connection(glob_opt.spdy_connection);
-  
-  connection = glob_opt.spdy_connections_head;
-  while(NULL != connection)
-  {    
-    connection_for_delete = connection;
-    connection = connection_for_delete->next;
-    glob_opt.streams_opened -= connection_for_delete->streams_opened;
-    DLL_remove(glob_opt.spdy_connections_head, glob_opt.spdy_connections_tail, connection_for_delete);
-    spdy_free_connection(connection_for_delete);
-  }
-  
-  free_uri(spdy2http_uri);
-  
-  deinit_parse_uri(&glob_opt.uri_preg);
-  
-  SSL_CTX_free(glob_opt.ssl_ctx);
-  ERR_free_strings();
-  EVP_cleanup();
-    
-  PRINT_INFO2("spdy streams: %i; http requests: %i", glob_opt.streams_opened, glob_opt.responses_pending);
-  //PRINT_INFO2("memory allocated %zu bytes", glob_opt.global_memory);
-  
-  print_stat();
-
-  return 0;
-}
-
-
-void
-display_usage()
-{
-  printf(
-    "Usage: mhd2spdy [-ovs] [-b <SPDY2HTTP-PROXY>] -p <PORT>\n\n"
-    "OPTIONS:\n"
-    "    -p, --port            Listening port.\n"
-    "    -b, --backend-proxy   If set, he proxy will send requests to\n"
-    "                          that SPDY server or proxy. Set the address\n"
-    "                          in the form 'http://host:port'. Use 'https'\n"
-    "                          for SPDY over TLS, or 'http' for plain SPDY\n"
-    "                          communication with the backend.\n"
-    "    -o, --only-proxy      If set, the proxy will always forward the\n"
-    "                          requests to the backend proxy. If not set,\n"
-    "                          the proxy will first try to establsh SPDY\n"
-    "                          connection to the requested server. If the\n"
-    "                          server does not support SPDY and TLS, the\n"
-    "                          backend proxy will be used for the request.\n"
-    "    -v, --verbose         Print debug information.\n"
-    "    -s, --statistics      Print simple statistics on exit.\n\n"
-
-  );
-}
-
-
-int
-main (int argc,
-      char *const *argv)
-{   
-  int getopt_ret;
-  int option_index;
-  struct option long_options[] = {
-    {"port",  required_argument, 0, 'p'},
-    {"backend-proxy",  required_argument, 0, 'b'},
-    {"verbose",  no_argument, 0, 'v'},
-    {"only-proxy",  no_argument, 0, 'o'},
-    {"statistics",  no_argument, 0, 's'},
-    {0, 0, 0, 0}
-  };
-  
-  while (1)
-  {
-    getopt_ret = getopt_long( argc, argv, "p:b:vos", long_options, &option_index);
-    if (getopt_ret == -1)
-      break;
-
-    switch(getopt_ret)
-    {
-      case 'p':
-        glob_opt.listen_port = atoi(optarg);
-        break;
-        
-      case 'b':
-        glob_opt.spdy2http_str = strdup(optarg);
-        if(NULL == glob_opt.spdy2http_str)
-          return 1;
-        break;
-        
-      case 'v':
-        glob_opt.verbose = true;
-        break;
-        
-      case 'o':
-        glob_opt.only_proxy = true;
-        break;
-        
-      case 's':
-        glob_opt.statistics = true;
-        break;
-        
-      case 0:
-        PRINT_INFO("0 from getopt");
-        break;
-        
-      case '?':
-        display_usage();
-        return 1;
-        
-      default:
-        DIE("default from getopt");
-    }
-  }
-  
-  if(
-    0 == glob_opt.listen_port
-    || (glob_opt.only_proxy && NULL == glob_opt.spdy2http_str)
-    )
-  {
-    display_usage();
-    return 1;
-  }
-    
-  return run_everything();
-}
diff --git a/src/examples/mhd2spdy_http.c b/src/examples/mhd2spdy_http.c
deleted file mode 100644
index 895f07fa..00000000
--- a/src/examples/mhd2spdy_http.c
+++ /dev/null
@@ -1,422 +0,0 @@
-/*
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file mhd2spdy_http.c
- * @brief  HTTP part of the proxy. libmicrohttpd is used for the server side.
- * @author Andrey Uzunov
- */
- 
-#include "mhd2spdy_structures.h"
-#include "mhd2spdy_http.h"
-#include "mhd2spdy_spdy.h"
-
-
-void *
-http_cb_log(void * cls,
-const char * uri)
-{
-  (void)cls;
-  
-  struct HTTP_URI * http_uri;
-  
-  PRINT_INFO2("log uri '%s'\n", uri);
-  
-  //TODO not freed once in a while
-  if(NULL == (http_uri = au_malloc(sizeof(struct HTTP_URI ))))
-    return NULL;
-  http_uri->uri = strdup(uri);
-  return http_uri;
-}
-
-
-static int
-http_cb_iterate(void *cls,
-                 enum MHD_ValueKind kind,
-                 const char *name,
-                 const char *value)
-{
-  (void)kind;
-  
-  static char * const forbidden[] = {"Transfer-Encoding",
-    "Proxy-Connection",
-    "Keep-Alive",
-    "Connection"};
-  static int forbidden_size = 4;
-  int i;
-        struct SPDY_Headers *spdy_headers = (struct SPDY_Headers *)cls;
-        
-        if(0 == strcasecmp(name, "Host"))
-    spdy_headers->nv[9] = (char *)value;
-  else
-  {
-    for(i=0; i<forbidden_size; ++i)
-      if(0 == strcasecmp(forbidden[i], name))
-        return MHD_YES;
-    spdy_headers->nv[spdy_headers->cnt++] = (char *)name;
-    spdy_headers->nv[spdy_headers->cnt++] = (char *)value;
-  }
-        
-        return MHD_YES;
-}
-
-
-static ssize_t
-http_cb_response (void *cls,
-                        uint64_t pos,
-                        char *buffer,
-                        size_t max)
-{
-  (void)pos;
-  
-        int ret;
-        struct Proxy *proxy = (struct Proxy *)cls;
-        void *newbody;
-  const union MHD_ConnectionInfo *info;
-  int val = 1;
-  
-  PRINT_INFO2("http_cb_response for %s", proxy->url);
-  
-  if(proxy->spdy_error)
-    return MHD_CONTENT_READER_END_WITH_ERROR;
-  
-        if(0 == proxy->http_body_size && (proxy->done || !proxy->spdy_active))
-  {
-    PRINT_INFO("sent end of stream");
-    return MHD_CONTENT_READER_END_OF_STREAM;
-  }
-        
-        if(!proxy->http_body_size)//nothing to write now
-  {
-    //flush data
-    info = MHD_get_connection_info (proxy->http_connection,
-         MHD_CONNECTION_INFO_CONNECTION_FD);
-    ret = setsockopt(info->connect_fd, IPPROTO_TCP, TCP_NODELAY, &val, (socklen_t)sizeof(val));
-    if(ret == -1) {
-      DIE("setsockopt");
-    }
-    
-    PRINT_INFO("FLUSH data");
-                return 0;
-  }
-        
-        if(max >= proxy->http_body_size)
-        {
-                ret = proxy->http_body_size;
-                newbody = NULL;
-        }
-        else
-        {
-                ret = max;
-                if(NULL == (newbody = au_malloc(proxy->http_body_size - max)))
-                {
-                        PRINT_INFO("no memory");
-                        return MHD_CONTENT_READER_END_WITH_ERROR;
-                }
-                memcpy(newbody, proxy->http_body + max, proxy->http_body_size - max);
-        }
-        memcpy(buffer, proxy->http_body, ret);
-        free(proxy->http_body);
-        proxy->http_body = newbody;
-        proxy->http_body_size -= ret;
-        
-        if(proxy->length >= 0)
-        {
-                proxy->length -= ret;
-        }
-        
-        PRINT_INFO2("response_callback, size: %i",ret);
-        
-        return ret;
-}
-
-
-static void
-http_cb_response_done(void *cls)
-{
-  (void)cls;
-  //TODO remove
-}
-
-int
-http_cb_request (void *cls,
-                struct MHD_Connection *connection,
-                const char *url,
-                const char *method,
-                const char *version,
-                const char *upload_data,
-                size_t *upload_data_size,
-                void **ptr)
-{
-  (void)cls;
-  (void)url;
-  (void)upload_data;
-  (void)upload_data_size;
-  
-  int ret;
-  struct Proxy *proxy;
-  struct SPDY_Headers spdy_headers;
-  bool with_body = false;
-  struct HTTP_URI *http_uri;
-  const char *header_value;
-
-  if (NULL == ptr || NULL == *ptr)
-    return MHD_NO;
-    
-  http_uri = (struct HTTP_URI *)*ptr;
-    
-  if(NULL == http_uri->proxy)
-  {
-    //first call for this request
-    if (0 != strcmp (method, MHD_HTTP_METHOD_GET) && 0 != strcmp (method, MHD_HTTP_METHOD_POST))
-    {
-      free(http_uri->uri);
-      free(http_uri);
-      PRINT_INFO2("unexpected method %s", method);
-      return MHD_NO;
-    }
-    
-    if(NULL == (proxy = au_malloc(sizeof(struct Proxy))))
-    {
-      free(http_uri->uri);
-      free(http_uri);
-      PRINT_INFO("No memory");
-      return MHD_NO; 
-    }
-    
-    ++glob_opt.responses_pending;
-    proxy->id = rand();
-    proxy->http_active = true;
-    proxy->http_connection = connection;
-    http_uri->proxy = proxy;
-    return MHD_YES;
-  }
-  
-  proxy = http_uri->proxy;
-  
-  if(proxy->spdy_error || proxy->http_error)
-    return MHD_NO; // handled at different place TODO? leaks?
-
-  if(proxy->spdy_active)
-  {
-    if(0 == strcmp (method, MHD_HTTP_METHOD_POST))
-    {
-      PRINT_INFO("POST processing");
-        
-      int rc= spdylay_session_resume_data(proxy->spdy_connection->session, proxy->stream_id);
-      PRINT_INFO2("rc is %i stream is %i", rc, proxy->stream_id);
-      proxy->spdy_connection->want_io |= WANT_WRITE;
-      
-      if(0 == *upload_data_size)
-      {
-      PRINT_INFO("POST http EOF");
-        proxy->receiving_done = true;
-        return MHD_YES;
-      }
-      
-      if(!copy_buffer(upload_data, *upload_data_size, &proxy->received_body, &proxy->received_body_size))
-      {
-        //TODO handle it better?
-        PRINT_INFO("not enough memory (malloc/realloc returned NULL)");
-        return MHD_NO;
-      }
-      
-      *upload_data_size = 0;
-                               
-      return MHD_YES;
-    }
-  
-    //already handled
-    PRINT_INFO("unnecessary call to http_cb_request");
-    return MHD_YES;
-  }
-  
-  //second call for this request
-
-  PRINT_INFO2("received request for '%s %s %s'", method, http_uri->uri, version);
-
-  proxy->url = http_uri->uri;
-  
-  header_value = MHD_lookup_connection_value(connection,
-    MHD_HEADER_KIND, MHD_HTTP_HEADER_CONTENT_LENGTH);
-  
-  with_body = 0 == strcmp (method, MHD_HTTP_METHOD_POST)
-    && (NULL == header_value || 0 != strcmp ("0", header_value));
-    
-  PRINT_INFO2("body will be sent %i", with_body);
-    
-  ret = parse_uri(&glob_opt.uri_preg, proxy->url, &proxy->uri);
-  if(ret != 0)
-    DIE("parse_uri failed");
-  proxy->http_uri = http_uri;
-
-  spdy_headers.num = MHD_get_connection_values (connection,
-                       MHD_HEADER_KIND,
-                       NULL,
-                       NULL);
-  if(NULL == (spdy_headers.nv = au_malloc(((spdy_headers.num + 5) * 2 + 1) * sizeof(char *))))
-    DIE("no memory");
-  spdy_headers.nv[0] = ":method";     spdy_headers.nv[1] = method;
-  spdy_headers.nv[2] = ":path";       spdy_headers.nv[3] = proxy->uri->path_and_more;
-  spdy_headers.nv[4] = ":version";    spdy_headers.nv[5] = (char *)version;
-  spdy_headers.nv[6] = ":scheme";     spdy_headers.nv[7] = proxy->uri->scheme;
-  spdy_headers.nv[8] = ":host";       spdy_headers.nv[9] = NULL;
-  //nv[14] = NULL;
-  spdy_headers.cnt = 10;
-  MHD_get_connection_values (connection,
-                       MHD_HEADER_KIND,
-                       &http_cb_iterate,
-                       &spdy_headers);
-                       
-  spdy_headers.nv[spdy_headers.cnt] = NULL;
-  if(NULL == spdy_headers.nv[9])
-    spdy_headers.nv[9] = proxy->uri->host_and_port;
-
-  if(0 != spdy_request(spdy_headers.nv, proxy, with_body))
-  {
-    free(spdy_headers.nv);
-    //free_proxy(proxy);
-    
-    return MHD_NO;
-  }
-  free(spdy_headers.nv);
-  
-  proxy->http_response = MHD_create_response_from_callback (MHD_SIZE_UNKNOWN,
-                         4096,
-                         &http_cb_response,
-                         proxy,
-                         &http_cb_response_done);
-
-  if (NULL == proxy->http_response)
-    DIE("no response");
-  
-  if(MHD_NO == MHD_add_response_header (proxy->http_response,
-                 "Proxy-Connection", "keep-alive"))
-    PRINT_INFO("SPDY_name_value_add failed: ");
-  if(MHD_NO == MHD_add_response_header (proxy->http_response,
-                 "Connection", "Keep-Alive"))
-    PRINT_INFO("SPDY_name_value_add failed: ");
-  if(MHD_NO == MHD_add_response_header (proxy->http_response,
-                 "Keep-Alive", "timeout=5, max=100"))
-    PRINT_INFO("SPDY_name_value_add failed: ");
-    
-  proxy->spdy_active = true;
-  
-  return MHD_YES;
-}
-
-
-void
-http_create_response(struct Proxy* proxy,
-                     char **nv)
-{
-  size_t i;
-  
-  if(!proxy->http_active)
-    return;
-  
-  for(i = 0; nv[i]; i += 2) {
-    if(0 == strcmp(":status", nv[i]))
-    {
-      char tmp[4];
-      memcpy(&tmp,nv[i+1],3);
-      tmp[3]=0;
-      proxy->status = atoi(tmp);
-      continue;
-    }
-    else if(0 == strcmp(":version", nv[i]))
-    {
-      proxy->version = nv[i+1];
-      continue;
-    }
-    else if(0 == strcmp("content-length", nv[i]))
-    {
-      continue;
-    }
-
-    char *header = *(nv+i);
-    if(MHD_NO == MHD_add_response_header (proxy->http_response,
-                   header, nv[i+1]))
-    {
-      PRINT_INFO2("SPDY_name_value_add failed: '%s' '%s'", header, nv[i+1]);
-    }
-    PRINT_INFO2("adding '%s: %s'",header, nv[i+1]);
-  }
-  
-  if(MHD_NO == MHD_queue_response (proxy->http_connection, proxy->status, proxy->http_response)){
-    PRINT_INFO("No queue");
-    //TODO
-    //abort();
-    proxy->http_error = true;
-  }
-  
-  MHD_destroy_response (proxy->http_response);
-  proxy->http_response = NULL;
-}
-
-void
-http_cb_request_completed (void *cls,
-                                   struct MHD_Connection *connection,
-                                   void **con_cls,
-                                   enum MHD_RequestTerminationCode toe)
-{
-  (void)cls;
-  (void)connection;
-  struct HTTP_URI *http_uri;
-  struct Proxy *proxy;
-  
-  http_uri = (struct HTTP_URI *)*con_cls;
-  if(NULL == http_uri)
-    return;
-  proxy = (struct Proxy *)http_uri->proxy;
-  assert(NULL != proxy);
-  
-  PRINT_INFO2("http_cb_request_completed %i for %s; id %i",toe, http_uri->uri, proxy->id);
-  
-  if(NULL != proxy->http_response)
-  {
-    MHD_destroy_response (proxy->http_response);
-    proxy->http_response = NULL;
-  }
-  
-  if(proxy->spdy_active)
-  {
-    proxy->http_active = false;
-    if(MHD_REQUEST_TERMINATED_COMPLETED_OK != toe)
-    {
-      proxy->http_error = true;
-      if(proxy->stream_id > 0 /*&& NULL != proxy->spdy_connection->session*/)
-      {
-        //send RST_STREAM_STATUS_CANCEL
-        PRINT_INFO2("send rst_stream %i %i",proxy->spdy_active, proxy->stream_id );
-        spdylay_submit_rst_stream(proxy->spdy_connection->session, proxy->stream_id, 5);
-      }
-      /*else
-      {
-        DLL_remove(proxy->spdy_connection->proxies_head, proxy->spdy_connection->proxies_tail, proxy); 
-        free_proxy(proxy);
-      }*/
-    }
-  }
-  else
-  {
-    PRINT_INFO2("proxy free http id %i ", proxy->id);
-    free_proxy(proxy);
-  }
-    
-  --glob_opt.responses_pending;
-}
diff --git a/src/examples/mhd2spdy_http.h b/src/examples/mhd2spdy_http.h
deleted file mode 100644
index 89d38897..00000000
--- a/src/examples/mhd2spdy_http.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file mhd2spdy_http.h
- * @brief  HTTP part of the proxy. libmicrohttpd is used for the server side.
- * @author Andrey Uzunov
- */
- 
-#ifndef HTTP_H
-#define HTTP_H
-
-#include "mhd2spdy_structures.h"
-
-
-int
-http_cb_request (void *cls,
-                struct MHD_Connection *connection,
-                const char *url,
-                const char *method,
-                const char *version,
-                const char *upload_data,
-                size_t *upload_data_size,
-                void **ptr);
-
-
-void * http_cb_log(void * cls, const char * uri);
-
-
-void
-http_create_response(struct Proxy* proxy, char **nv);
-
-
-void
-http_cb_request_completed (void *cls,
-                                   struct MHD_Connection *connection,
-                                   void **con_cls,
-                                   enum MHD_RequestTerminationCode toe);
-
-#endif
diff --git a/src/examples/mhd2spdy_spdy.c b/src/examples/mhd2spdy_spdy.c
deleted file mode 100644
index 9092da11..00000000
--- a/src/examples/mhd2spdy_spdy.c
+++ /dev/null
@@ -1,1150 +0,0 @@
-/*
- *
- * Copyright (c) 2012 Tatsuhiro Tsujikawa
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-/**
- * @file mhd2spdy_spdy.c
- * @brief  SPDY part of the proxy. libspdylay is used for the client side.
- *         The example spdycli.c from spdylay was used as basis;
- *         however, multiple changes were made.
- * @author Tatsuhiro Tsujikawa
- * @author Andrey Uzunov
- */
-
-#include "mhd2spdy_structures.h"
-#include "mhd2spdy_spdy.h"
-#include "mhd2spdy_http.h"
-
-
-/*
- * Prints error containing the function name |func| and message |msg|
- * and exit.
- */
-static void
-spdy_dief(const char *func,
-          const char *msg)
-{
-  fprintf(stderr, "FATAL: %s: %s\n", func, msg);
-  exit(EXIT_FAILURE);
-}
-
-
-/*
- * Prints error containing the function name |func| and error code
- * |error_code| and exit.
- */
-void
-spdy_diec(const char *func,
-          int error_code)
-{
-  fprintf(stderr, "FATAL: %s: error_code=%d, msg=%s\n", func, error_code,
-          spdylay_strerror(error_code));
-  exit(EXIT_FAILURE);
-}
-
-
-static ssize_t
-spdy_cb_data_source_read(spdylay_session *session, int32_t stream_id, uint8_t *buf, size_t length, int *eof, spdylay_data_source *source, void *user_data)
-{
-  (void)session;
-  (void)stream_id;
-  (void)user_data;
-
-  ssize_t ret;
-  assert(NULL != source);
-  assert(NULL != source->ptr);
-        struct Proxy *proxy = (struct Proxy *)(source->ptr);
-        void *newbody;
-
-
-  if(length < 1)
-  {
-    PRINT_INFO("spdy_cb_data_source_read: length is 0");
-    return 0;
-        }
-
-        if(!proxy->received_body_size)//nothing to write now
-  {
-    if(proxy->receiving_done)
-    {
-      PRINT_INFO("POST spdy EOF");
-      *eof = 1;
-    }
-      PRINT_INFO("POST SPDYLAY_ERR_DEFERRED");
-                return SPDYLAY_ERR_DEFERRED;//TODO SPDYLAY_ERR_DEFERRED should be used
-  }
-
-        if(length >= proxy->received_body_size)
-        {
-                ret = proxy->received_body_size;
-                newbody = NULL;
-        }
-        else
-        {
-                ret = length;
-                if(NULL == (newbody = malloc(proxy->received_body_size - length)))
-                {
-                        PRINT_INFO("no memory");
-                        return SPDYLAY_ERR_TEMPORAL_CALLBACK_FAILURE;
-                }
-                memcpy(newbody, proxy->received_body + length, proxy->received_body_size - length);
-        }
-        memcpy(buf, proxy->received_body, ret);
-        free(proxy->received_body);
-        proxy->received_body = newbody;
-        proxy->received_body_size -= ret;
-
-  if(0 == proxy->received_body_size && proxy->receiving_done)
-    {
-      PRINT_INFO("POST spdy EOF");
-    *eof = 1;
-  }
-
-  PRINT_INFO2("given POST bytes to spdylay: %zd", ret);
-
-  return ret;
-}
-
-
-/*
- * The implementation of spdylay_send_callback type. Here we write
- * |data| with size |length| to the network and return the number of
- * bytes actually written. See the documentation of
- * spdylay_send_callback for the details.
- */
-static ssize_t
-spdy_cb_send(spdylay_session *session,
-             const uint8_t *data,
-             size_t length,
-             int flags,
-             void *user_data)
-{
-  (void)session;
-  (void)flags;
-
-  //PRINT_INFO("spdy_cb_send called");
-  struct SPDY_Connection *connection;
-  ssize_t rv;
-  connection = (struct SPDY_Connection*)user_data;
-  connection->want_io = IO_NONE;
-
-  if(glob_opt.ignore_rst_stream
-    && 16 == length
-    && 0x80 == data[0]
-    && 0x00 == data[2]
-    && 0x03 == data[3]
-    )
-  {
-    PRINT_INFO2("ignoring RST_STREAM for stream_id %i %i %i %i", data[8], data[9], data[10], data[11]);
-    glob_opt.ignore_rst_stream = false;
-    return 16;
-  }
-  glob_opt.ignore_rst_stream = false;
-
-  if(connection->is_tls)
-  {
-    ERR_clear_error();
-    rv = SSL_write(connection->ssl, data, length);
-    if(rv < 0) {
-      int err = SSL_get_error(connection->ssl, rv);
-      if(err == SSL_ERROR_WANT_WRITE || err == SSL_ERROR_WANT_READ) {
-        connection->want_io |= (err == SSL_ERROR_WANT_READ ?
-                               WANT_READ : WANT_WRITE);
-        rv = SPDYLAY_ERR_WOULDBLOCK;
-      } else {
-        rv = SPDYLAY_ERR_CALLBACK_FAILURE;
-      }
-    }
-  }
-  else
-  {
-    rv = write(connection->fd,
-            data,
-            length);
-
-    if (rv < 0)
-    {
-      switch(errno)
-      {
-        case EAGAIN:
-  #if EAGAIN != EWOULDBLOCK
-        case EWOULDBLOCK:
-  #endif
-          connection->want_io |= WANT_WRITE;
-          rv = SPDYLAY_ERR_WOULDBLOCK;
-          break;
-
-        default:
-          rv = SPDYLAY_ERR_CALLBACK_FAILURE;
-      }
-    }
-  }
-
-  PRINT_INFO2("%zd bytes written by spdy", rv);
-
-  if(rv > 0)
-    UPDATE_STAT(glob_stat.spdy_bytes_sent, rv);
-
-  return rv;
-}
-
-
-/*
- * The implementation of spdylay_recv_callback type. Here we read data
- * from the network and write them in |buf|. The capacity of |buf| is
- * |length| bytes. Returns the number of bytes stored in |buf|. See
- * the documentation of spdylay_recv_callback for the details.
- */
-static ssize_t
-spdy_cb_recv(spdylay_session *session,
-             uint8_t *buf,
-             size_t length,
-             int flags,
-             void *user_data)
-{
-  (void)session;
-  (void)flags;
-
-  struct SPDY_Connection *connection;
-  ssize_t rv;
-
-  connection = (struct SPDY_Connection*)user_data;
-  //prevent monopolizing everything
-  if(!(++connection->counter % 10)) return SPDYLAY_ERR_WOULDBLOCK;
-  connection->want_io = IO_NONE;
-  if(connection->is_tls)
-  {
-    ERR_clear_error();
-    rv = SSL_read(connection->ssl, buf, length);
-    if(rv < 0) {
-      int err = SSL_get_error(connection->ssl, rv);
-      if(err == SSL_ERROR_WANT_WRITE || err == SSL_ERROR_WANT_READ) {
-        connection->want_io |= (err == SSL_ERROR_WANT_READ ?
-                               WANT_READ : WANT_WRITE);
-        rv = SPDYLAY_ERR_WOULDBLOCK;
-      } else {
-        rv = SPDYLAY_ERR_CALLBACK_FAILURE;
-      }
-    } else if(rv == 0) {
-      rv = SPDYLAY_ERR_EOF;
-    }
-  }
-  else
-  {
-    rv = read(connection->fd,
-            buf,
-            length);
-
-    if (rv < 0)
-    {
-      switch(errno)
-      {
-        case EAGAIN:
-  #if EAGAIN != EWOULDBLOCK
-        case EWOULDBLOCK:
-  #endif
-          connection->want_io |= WANT_READ;
-          rv = SPDYLAY_ERR_WOULDBLOCK;
-          break;
-
-        default:
-          rv = SPDYLAY_ERR_CALLBACK_FAILURE;
-      }
-    }
-    else if(rv == 0)
-      rv = SPDYLAY_ERR_EOF;
-  }
-
-  if(rv > 0)
-    UPDATE_STAT(glob_stat.spdy_bytes_received, rv);
-
-  return rv;
-}
-
-
-static void
-spdy_cb_before_ctrl_send(spdylay_session *session,
-                    spdylay_frame_type type,
-                    spdylay_frame *frame,
-                    void *user_data)
-{
-  (void)user_data;
-
-  int32_t stream_id;
-  struct Proxy *proxy;
-
-  switch(type) {
-    case SPDYLAY_SYN_STREAM:
-      stream_id = frame->syn_stream.stream_id;
-      proxy = spdylay_session_get_stream_user_data(session, stream_id);
-      proxy->stream_id = stream_id;
-      ++glob_opt.streams_opened;
-      ++proxy->spdy_connection->streams_opened;
-      PRINT_INFO2("opening stream: str open %i; %s", glob_opt.streams_opened, proxy->url);
-      break;
-    case SPDYLAY_RST_STREAM:
-      //try to ignore duplicate RST_STREAMs
-      //TODO this will ignore RST_STREAMs also for bogus data
-      glob_opt.ignore_rst_stream = NULL==spdylay_session_get_stream_user_data(session, frame->rst_stream.stream_id);
-      PRINT_INFO2("sending RST_STREAM for %i; ignore %i; status %i",
-        frame->rst_stream.stream_id,
-        glob_opt.ignore_rst_stream,
-        frame->rst_stream.status_code);
-    break;
-    default:
-      break;
-  }
-}
-
-
-void
-spdy_cb_on_ctrl_recv(spdylay_session *session,
-                    spdylay_frame_type type,
-                    spdylay_frame *frame,
-                    void *user_data)
-{
-  (void)user_data;
-
-  char **nv;
-  int32_t stream_id;
-  struct Proxy * proxy;
-
-  switch(type) {
-    case SPDYLAY_SYN_REPLY:
-      nv = frame->syn_reply.nv;
-      stream_id = frame->syn_reply.stream_id;
-    break;
-    case SPDYLAY_RST_STREAM:
-      stream_id = frame->rst_stream.stream_id;
-    break;
-    case SPDYLAY_HEADERS:
-      nv = frame->headers.nv;
-      stream_id = frame->headers.stream_id;
-    break;
-    default:
-      return;
-    break;
-  }
-
-  proxy = spdylay_session_get_stream_user_data(session, stream_id);
-  if(NULL == proxy)
-  {
-    PRINT_INFO2("received frame type %i for unkonwn stream id %i", type, stream_id);
-    return;
-    //DIE("no proxy obj");
-  }
-
-  switch(type) {
-    case SPDYLAY_SYN_REPLY:
-      PRINT_INFO2("received headers for %s", proxy->url);
-      http_create_response(proxy, nv);
-    break;
-    case SPDYLAY_RST_STREAM:
-      PRINT_INFO2("received reset stream for %s", proxy->url);
-      proxy->spdy_error = true;
-    break;
-    case SPDYLAY_HEADERS:
-      PRINT_INFO2("received headers for %s", proxy->url);
-      http_create_response(proxy, nv);
-    break;
-    default:
-      return;
-    break;
-  }
-
-  glob_opt.spdy_data_received = true;
-}
-
-
-/*
- * The implementation of spdylay_on_stream_close_callback type. We use
- * this function to know the response is fully received. Since we just
- * fetch 1 resource in this program, after reception of the response,
- * we submit GOAWAY and close the session.
- */
-static void
-spdy_cb_on_stream_close(spdylay_session *session,
-                       int32_t stream_id,
-                       spdylay_status_code status_code,
-                       void *user_data)
-{
-  (void)status_code;
-  (void)user_data;
-
-  struct Proxy * proxy = spdylay_session_get_stream_user_data(session, stream_id);
-
-  assert(NULL != proxy);
-
-  --glob_opt.streams_opened;
-  --proxy->spdy_connection->streams_opened;
-  PRINT_INFO2("closing stream: str opened %i; remove proxy %i", glob_opt.streams_opened, proxy->id);
-
-  DLL_remove(proxy->spdy_connection->proxies_head, proxy->spdy_connection->proxies_tail, proxy);
-  if(proxy->http_active)
-  {
-    proxy->spdy_active = false;
-  }
-  else
-  {
-    free_proxy(proxy);
-  }
-}
-
-
-/*
- * The implementation of spdylay_on_data_chunk_recv_callback type. We
- * use this function to print the received response body.
- */
-static void
-spdy_cb_on_data_chunk_recv(spdylay_session *session,
-                          uint8_t flags,
-                          int32_t stream_id,
-                          const uint8_t *data,
-                          size_t len,
-                          void *user_data)
-{
-  (void)flags;
-  (void)user_data;
-
-  struct Proxy *proxy;
-  proxy = spdylay_session_get_stream_user_data(session, stream_id);
-
-  if(NULL == proxy)
-  {
-    PRINT_INFO("proxy in spdy_cb_on_data_chunk_recv is NULL)");
-    return;
-        }
-
-  if(!copy_buffer(data, len, &proxy->http_body, &proxy->http_body_size))
-  {
-    //TODO handle it better?
-    PRINT_INFO("not enough memory (malloc/realloc returned NULL)");
-    return;
-  }
-  /*
-        if(NULL == proxy->http_body)
-                proxy->http_body = au_malloc(len);
-  else
-                proxy->http_body = realloc(proxy->http_body, proxy->http_body_size + len);
-        if(NULL == proxy->http_body)
-        {
-                PRINT_INFO("not enough memory (realloc returned NULL)");
-                return ;
-        }
-
-        memcpy(proxy->http_body + proxy->http_body_size, data, len);
-        proxy->http_body_size += len;
-  */
-  PRINT_INFO2("received data for %s; %zu bytes", proxy->url, len);
-  glob_opt.spdy_data_received = true;
-}
-
-
-static void
-spdy_cb_on_data_recv(spdylay_session *session,
-                                 uint8_t flags,
-                     int32_t stream_id,
-                     int32_t length,
-                     void *user_data)
-{
-  (void)length;
-  (void)user_data;
-
-        if(flags & SPDYLAY_DATA_FLAG_FIN)
-        {
-    struct Proxy *proxy;
-    proxy = spdylay_session_get_stream_user_data(session, stream_id);
-    proxy->done = true;
-    PRINT_INFO2("last data frame received for %s", proxy->url);
-        }
-}
-
-
-/*
- * Setup callback functions. Spdylay API offers many callback
- * functions, but most of them are optional. The send_callback is
- * always required. Since we use spdylay_session_recv(), the
- * recv_callback is also required.
- */
-static void
-spdy_setup_spdylay_callbacks(spdylay_session_callbacks *callbacks)
-{
-  memset(callbacks, 0, sizeof(spdylay_session_callbacks));
-  callbacks->send_callback = spdy_cb_send;
-  callbacks->recv_callback = spdy_cb_recv;
-  callbacks->before_ctrl_send_callback = spdy_cb_before_ctrl_send;
-  callbacks->on_ctrl_recv_callback = spdy_cb_on_ctrl_recv;
-  callbacks->on_stream_close_callback = spdy_cb_on_stream_close;
-  callbacks->on_data_chunk_recv_callback = spdy_cb_on_data_chunk_recv;
-  callbacks->on_data_recv_callback = spdy_cb_on_data_recv;
-}
-
-
-/*
- * Callback function for SSL/TLS NPN. Since this program only supports
- * SPDY protocol, if server does not offer SPDY protocol the Spdylay
- * library supports, we terminate program.
- */
-static int
-spdy_cb_ssl_select_next_proto(SSL* ssl,
-                                unsigned char **out,
-                                unsigned char *outlen,
-                                const unsigned char *in,
-                                unsigned int inlen,
-                                void *arg)
-{
-  (void)ssl;
-
-  int rv;
-  uint16_t *spdy_proto_version;
-
-  /* spdylay_select_next_protocol() selects SPDY protocol version the
-     Spdylay library supports. */
-  rv = spdylay_select_next_protocol(out, outlen, in, inlen);
-  if(rv <= 0) {
-    PRINT_INFO("Server did not advertise spdy/2 or spdy/3 protocol.");
-    return rv;
-  }
-  spdy_proto_version = (uint16_t*)arg;
-  *spdy_proto_version = rv;
-  return SSL_TLSEXT_ERR_OK;
-}
-
-
-/*
- * Setup SSL context. We pass |spdy_proto_version| to get negotiated
- * SPDY protocol version in NPN callback.
- */
-void
-spdy_ssl_init_ssl_ctx(SSL_CTX *ssl_ctx,
-                      uint16_t *spdy_proto_version)
-{
-  /* Disable SSLv2 and enable all workarounds for buggy servers */
-  SSL_CTX_set_options(ssl_ctx, SSL_OP_ALL|SSL_OP_NO_SSLv2 | SSL_OP_NO_COMPRESSION);
-  SSL_CTX_set_mode(ssl_ctx, SSL_MODE_AUTO_RETRY);
-  SSL_CTX_set_mode(ssl_ctx, SSL_MODE_RELEASE_BUFFERS);
-  /* Set NPN callback */
-  SSL_CTX_set_next_proto_select_cb(ssl_ctx, spdy_cb_ssl_select_next_proto,
-                                   spdy_proto_version);
-}
-
-
-static int
-spdy_ssl_handshake(SSL *ssl,
-                   int fd)
-{
-  int rv;
-
-  if(SSL_set_fd(ssl, fd) == 0)
-    spdy_dief("SSL_set_fd", ERR_error_string(ERR_get_error(), NULL));
-
-  ERR_clear_error();
-  rv = SSL_connect(ssl);
-  if(rv <= 0)
-    PRINT_INFO2("SSL_connect %s", ERR_error_string(ERR_get_error(), NULL));
-
-  return rv;
-}
-
-
-/*
- * Connects to the host |host| and port |port|.  This function returns
- * the file descriptor of the client socket.
- */
-static int
-spdy_socket_connect_to(const char *host,
-                       uint16_t port)
-{
-  struct addrinfo hints;
-  int fd = -1;
-  int rv;
-  char service[NI_MAXSERV];
-  struct addrinfo *res, *rp;
-
-  //TODO checks
-  snprintf(service, sizeof(service), "%u", port);
-  memset(&hints, 0, sizeof(struct addrinfo));
-  hints.ai_family = AF_UNSPEC;
-  hints.ai_socktype = SOCK_STREAM;
-  rv = getaddrinfo(host, service, &hints, &res);
-  if(rv != 0)
-  {
-          printf("%s\n",host);
-    spdy_dief("getaddrinfo", gai_strerror(rv));
-  }
-  for(rp = res; rp; rp = rp->ai_next)
-  {
-    fd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
-    if(fd == -1)
-      continue;
-    while((rv = connect(fd, rp->ai_addr, rp->ai_addrlen)) == -1 &&
-          errno == EINTR);
-    if(rv == 0)
-      break;
-    MHD_socket_close_ (fd);
-    fd = -1;
-  }
-  freeaddrinfo(res);
-
-  return fd;
-}
-
-
-static void
-spdy_socket_make_non_block(int fd)
-{
-  int flags;
-  int rv;
-
-  while((flags = fcntl(fd, F_GETFL, 0)) == -1 && errno == EINTR);
-
-  if(flags == -1)
-    spdy_dief("fcntl", strerror(errno));
-
-  while((rv = fcntl(fd, F_SETFL, flags | O_NONBLOCK)) == -1 && errno == EINTR);
-
-  if(rv == -1)
-    spdy_dief("fcntl", strerror(errno));
-}
-
-
-/*
- * Setting TCP_NODELAY is not mandatory for the SPDY protocol.
- */
-static void
-spdy_socket_set_tcp_nodelay(int fd)
-{
-  int val = 1;
-  int rv;
-
-  rv = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, (socklen_t)sizeof(val));
-  if(rv == -1)
-    spdy_dief("setsockopt", strerror(errno));
-}
-
-/*
- * Update |pollfd| based on the state of |connection|.
- */
- /*
-void
-spdy_ctl_poll(struct pollfd *pollfd,
-              struct SPDY_Connection *connection)
-{
-  pollfd->events = 0;
-  if(spdylay_session_want_read(connection->session) ||
-     connection->want_io & WANT_READ)
-  {
-    pollfd->events |= POLLIN;
-  }
-  if(spdylay_session_want_write(connection->session) ||
-     connection->want_io & WANT_WRITE)
-  {
-    pollfd->events |= POLLOUT;
-  }
-}*/
-
-
-/*
- * Update |selectfd| based on the state of |connection|.
- */
-bool
-spdy_ctl_select(fd_set * read_fd_set,
-                fd_set * write_fd_set,
-                fd_set * except_fd_set,
-                struct SPDY_Connection *connection)
-{
-  (void)except_fd_set;
-
-  bool ret = false;
-
-  if(spdylay_session_want_read(connection->session) ||
-     connection->want_io & WANT_READ)
-  {
-    FD_SET(connection->fd, read_fd_set);
-    ret = true;
-  }
-  if(spdylay_session_want_write(connection->session) ||
-     connection->want_io & WANT_WRITE)
-  {
-    FD_SET(connection->fd, write_fd_set);
-    ret = true;
-  }
-
-  return ret;
-}
-
-
-/*
- * Performs the network I/O.
- */
-int
-spdy_exec_io(struct SPDY_Connection *connection)
-{
-  int rv;
-
-  rv = spdylay_session_recv(connection->session);
-  if(rv != 0)
-  {
-    PRINT_INFO2("spdylay_session_recv %i", rv);
-    return rv;
-  }
-  rv = spdylay_session_send(connection->session);
-  if(rv != 0)
-    PRINT_INFO2("spdylay_session_send %i", rv);
-
-  return rv;
-}
-
-
-/*
- * Fetches the resource denoted by |uri|.
- */
-struct SPDY_Connection *
-spdy_connect(const struct URI *uri,
-             uint16_t port,
-             bool is_tls)
-{
-  spdylay_session_callbacks callbacks;
-  int fd;
-  SSL *ssl=NULL;
-  struct SPDY_Connection * connection = NULL;
-  int rv;
-
-  spdy_setup_spdylay_callbacks(&callbacks);
-
-  /* Establish connection and setup SSL */
-  PRINT_INFO2("connecting to %s:%i", uri->host, port);
-  fd = spdy_socket_connect_to(uri->host, port);
-  if(fd == -1)
-  {
-    PRINT_INFO("Could not open file descriptor");
-    return NULL;
-  }
-
-  if(is_tls)
-  {
-    ssl = SSL_new(glob_opt.ssl_ctx);
-    if(ssl == NULL) {
-      spdy_dief("SSL_new", ERR_error_string(ERR_get_error(), NULL));
-    }
-
-    //TODO non-blocking
-    /* To simplify the program, we perform SSL/TLS handshake in blocking
-       I/O. */
-    glob_opt.spdy_proto_version = 0;
-    rv = spdy_ssl_handshake(ssl, fd);
-    if(rv <= 0 || (glob_opt.spdy_proto_version != 3 && glob_opt.spdy_proto_version != 2))
-    {
-      PRINT_INFO("Closing SSL");
-      //no spdy on the other side
-      goto free_and_fail;
-    }
-  }
-  else
-  {
-    glob_opt.spdy_proto_version = 3;
-  }
-
-  if(NULL == (connection = au_malloc(sizeof(struct SPDY_Connection))))
-    goto free_and_fail;
-
-  connection->is_tls = is_tls;
-  connection->ssl = ssl;
-  connection->want_io = IO_NONE;
-  if(NULL == (connection->host = strdup(uri->host)))
-    goto free_and_fail;
-
-  /* Here make file descriptor non-block */
-  spdy_socket_make_non_block(fd);
-  spdy_socket_set_tcp_nodelay(fd);
-
-  PRINT_INFO2("[INFO] SPDY protocol version = %d\n", glob_opt.spdy_proto_version);
-  rv = spdylay_session_client_new(&(connection->session), glob_opt.spdy_proto_version,
-                                  &callbacks, connection);
-  if(rv != 0) {
-    spdy_diec("spdylay_session_client_new", rv);
-  }
-
-  connection->fd = fd;
-
-        return connection;
-
-        //for GOTO
-        free_and_fail:
-  if(NULL != connection)
-  {
-    free(connection->host);
-    free(connection);
-  }
-
-  if(is_tls)
-    SSL_shutdown(ssl);
-
-  MHD_socket_close_ (fd);
-
-  if(is_tls)
-    SSL_free(ssl);
-
-  return NULL;
-}
-
-
-void
-spdy_free_connection(struct SPDY_Connection * connection)
-{
-  struct Proxy *proxy;
-  struct Proxy *proxy_next;
-
-  if(NULL != connection)
-  {
-    for(proxy = connection->proxies_head; NULL != proxy; proxy=proxy_next)
-    {
-      proxy_next = proxy->next;
-      DLL_remove(connection->proxies_head, connection->proxies_tail, proxy);
-      proxy->spdy_active = false;
-      proxy->spdy_error = true;
-      PRINT_INFO2("spdy_free_connection for id %i", proxy->id);
-      if(!proxy->http_active)
-      {
-        free_proxy(proxy);
-      }
-    }
-    spdylay_session_del(connection->session);
-    SSL_free(connection->ssl);
-    free(connection->host);
-    free(connection);
-    //connection->session = NULL;
-  }
-}
-
-
-int
-spdy_request(const char **nv,
-             struct Proxy *proxy,
-             bool with_body)
-{
-  int ret;
-  uint16_t port;
-  struct SPDY_Connection *connection;
-  spdylay_data_provider post_data;
-
-  if(glob_opt.only_proxy)
-  {
-    connection = glob_opt.spdy_connection;
-  }
-  else
-  {
-    connection = glob_opt.spdy_connections_head;
-    while(NULL != connection)
-    {
-      if(0 == strcasecmp(proxy->uri->host, connection->host))
-        break;
-      connection = connection->next;
-    }
-
-    if(NULL == connection)
-    {
-      //connect to host
-      port = proxy->uri->port;
-      if(0 == port) port = 443;
-      connection = spdy_connect(proxy->uri, port, true);
-      if(NULL != connection)
-      {
-        DLL_insert(glob_opt.spdy_connections_head, glob_opt.spdy_connections_tail, connection);
-        glob_opt.total_spdy_connections++;
-      }
-      else
-        connection = glob_opt.spdy_connection;
-    }
-  }
-
-  if(NULL == connection)
-  {
-    PRINT_INFO("there is no proxy!");
-    return -1;
-  }
-
-  proxy->spdy_connection = connection;
-  if(with_body)
-  {
-    post_data.source.ptr = proxy;
-    post_data.read_callback = &spdy_cb_data_source_read;
-    ret = spdylay_submit_request(connection->session, 0, nv, &post_data, proxy);
-  }
-  else
-    ret = spdylay_submit_request(connection->session, 0, nv, NULL, proxy);
-
-  if(ret != 0) {
-    spdy_diec("spdylay_spdy_submit_request", ret);
-  }
-  PRINT_INFO2("adding proxy %i", proxy->id);
-  if(NULL != connection->proxies_head)
-    PRINT_INFO2("before proxy %i", connection->proxies_head->id);
-  DLL_insert(connection->proxies_head, connection->proxies_tail, proxy);
-
-  return ret;
-}
-
-/*
-void
-spdy_get_pollfdset(struct pollfd fds[],
-                   struct SPDY_Connection *connections[],
-                   unsigned int max_size,
-                   nfds_t *real_size)
-{
-  struct SPDY_Connection *connection;
-  struct Proxy *proxy;
-
-  *real_size = 0;
-  if(max_size<1)
-    return;
-
-  if(NULL != glob_opt.spdy_connection)
-  {
-    spdy_ctl_poll(&(fds[*real_size]), glob_opt.spdy_connection);
-    if(!fds[*real_size].events)
-    {
-      //PRINT_INFO("TODO drop connection");
-      glob_opt.streams_opened -= glob_opt.spdy_connection->streams_opened;
-
-      for(proxy = glob_opt.spdy_connection->proxies_head; NULL != proxy; proxy=proxy->next)
-      {
-        abort();
-        DLL_remove(glob_opt.spdy_connection->proxies_head, glob_opt.spdy_connection->proxies_tail, proxy);
-        proxy->spdy_active = false;
-      }
-      spdy_free_connection(glob_opt.spdy_connection);
-      glob_opt.spdy_connection = NULL;
-    }
-    else
-    {
-      fds[*real_size].fd = glob_opt.spdy_connection->fd;
-      connections[*real_size] = glob_opt.spdy_connection;
-      ++(*real_size);
-    }
-  }
-
-  connection = glob_opt.spdy_connections_head;
-
-  while(NULL != connection && *real_size < max_size)
-  {
-    assert(!glob_opt.only_proxy);
-    spdy_ctl_poll(&(fds[*real_size]), connection);
-    if(!fds[*real_size].events)
-    {
-      //PRINT_INFO("TODO drop connection");
-      glob_opt.streams_opened -= connection->streams_opened;
-      DLL_remove(glob_opt.spdy_connections_head, glob_opt.spdy_connections_tail, connection);
-      glob_opt.total_spdy_connections--;
-
-      for(proxy = connection->proxies_head; NULL != proxy; proxy=proxy->next)
-      {
-        abort();
-        DLL_remove(connection->proxies_head, connection->proxies_tail, proxy);
-        proxy->spdy_active = false;
-      }
-      spdy_free_connection(connection);
-    }
-    else
-    {
-      fds[*real_size].fd = connection->fd;
-      connections[*real_size] = connection;
-      ++(*real_size);
-    }
-    connection = connection->next;
-  }
-
-  //, "TODO max num of conn reached; close something"
-  assert(NULL == connection);
-}
-*/
-
-int
-spdy_get_selectfdset(fd_set * read_fd_set,
-                      fd_set * write_fd_set,
-                      fd_set * except_fd_set,
-                      struct SPDY_Connection *connections[],
-                      unsigned int max_size,
-                      nfds_t *real_size)
-{
-  struct SPDY_Connection *connection;
-  struct SPDY_Connection *next_connection;
-  bool ret;
-  int maxfd = 0;
-
-  *real_size = 0;
-  if(max_size<1)
-    return 0;
-
-  if(NULL != glob_opt.spdy_connection)
-  {
-    ret = spdy_ctl_select(read_fd_set,
-                                 write_fd_set,
-                                 except_fd_set, glob_opt.spdy_connection);
-    if(!ret)
-    {
-      glob_opt.streams_opened -= glob_opt.spdy_connection->streams_opened;
-
-      PRINT_INFO("spdy_free_connection in spdy_get_selectfdset");
-      spdy_free_connection(glob_opt.spdy_connection);
-      glob_opt.spdy_connection = NULL;
-    }
-    else
-    {
-      connections[*real_size] = glob_opt.spdy_connection;
-      ++(*real_size);
-      if(maxfd < glob_opt.spdy_connection->fd) maxfd = glob_opt.spdy_connection->fd;
-    }
-  }
-
-  connection = glob_opt.spdy_connections_head;
-
-  while(NULL != connection && *real_size < max_size)
-  {
-    assert(!glob_opt.only_proxy);
-    ret = spdy_ctl_select(read_fd_set,
-                                 write_fd_set,
-                                 except_fd_set, connection);
-
-    next_connection = connection->next;
-    if(!ret)
-    {
-      glob_opt.streams_opened -= connection->streams_opened;
-      DLL_remove(glob_opt.spdy_connections_head, glob_opt.spdy_connections_tail, connection);
-      glob_opt.total_spdy_connections--;
-
-      PRINT_INFO("spdy_free_connection in spdy_get_selectfdset");
-      spdy_free_connection(connection);
-    }
-    else
-    {
-      connections[*real_size] = connection;
-      ++(*real_size);
-      if(maxfd < connection->fd) maxfd = connection->fd;
-    }
-    connection = next_connection;
-  }
-
-  //, "TODO max num of conn reached; close something"
-  assert(NULL == connection);
-
-  return maxfd;
-}
-
-/*
-void
-spdy_run(struct pollfd fds[],
-         struct SPDY_Connection *connections[],
-         int size)
-{
-  int i;
-  int ret;
-  struct Proxy *proxy;
-
-  for(i=0; i<size; ++i)
-  {
-    //  PRINT_INFO2("exec about to be called for %s", connections[i]->host);
-    if(fds[i].revents & (POLLIN | POLLOUT))
-    {
-      ret = spdy_exec_io(connections[i]);
-      //PRINT_INFO2("%i",ret);
-      //if((spdy_pollfds[i].revents & POLLHUP) || (spdy_pollfds[0].revents & POLLERR))
-      //  PRINT_INFO("SPDY SPDY_Connection error");
-
-      //TODO POLLRDHUP
-      // always close on ret != 0?
-
-      if(0 != ret)
-      {
-        glob_opt.streams_opened -= connections[i]->streams_opened;
-        if(connections[i] == glob_opt.spdy_connection)
-        {
-          glob_opt.spdy_connection = NULL;
-        }
-        else
-        {
-          DLL_remove(glob_opt.spdy_connections_head, glob_opt.spdy_connections_tail, connections[i]);
-          glob_opt.total_spdy_connections--;
-        }
-        for(proxy = connections[i]->proxies_head; NULL != proxy; proxy=proxy->next)
-        {
-        abort();
-          DLL_remove(connections[i]->proxies_head, connections[i]->proxies_tail, proxy);
-          proxy->spdy_active = false;
-          proxy->spdy_error = true;
-          PRINT_INFO2("spdy_free_connection for id %i", proxy->id);
-        }
-        PRINT_INFO("spdy_free_connection in loop");
-        spdy_free_connection(connections[i]);
-      }
-    }
-    else
-      PRINT_INFO("not called");
-  }
-}
-*/
-
-void
-spdy_run_select(fd_set * read_fd_set,
-                fd_set * write_fd_set,
-                fd_set * except_fd_set,
-                struct SPDY_Connection *connections[],
-                int size)
-{
-  int i;
-  int ret;
-
-  for(i=0; i<size; ++i)
-  {
-    //  PRINT_INFO2("exec about to be called for %s", connections[i]->host);
-    if(FD_ISSET(connections[i]->fd, read_fd_set) || FD_ISSET(connections[i]->fd, write_fd_set) || FD_ISSET(connections[i]->fd, except_fd_set))
-    {
-      //raise(SIGINT);
-      ret = spdy_exec_io(connections[i]);
-
-      if(0 != ret)
-      {
-        glob_opt.streams_opened -= connections[i]->streams_opened;
-        if(connections[i] == glob_opt.spdy_connection)
-        {
-          glob_opt.spdy_connection = NULL;
-        }
-        else
-        {
-          DLL_remove(glob_opt.spdy_connections_head, glob_opt.spdy_connections_tail, connections[i]);
-          glob_opt.total_spdy_connections--;
-        }
-        PRINT_INFO("in spdy_run_select");
-        spdy_free_connection(connections[i]);
-      }
-    }
-    else
-    {
-      PRINT_INFO("not called");
-      //PRINT_INFO2("connection->want_io %i",connections[i]->want_io);
-      //PRINT_INFO2("read %i",spdylay_session_want_read(connections[i]->session));
-      //PRINT_INFO2("write %i",spdylay_session_want_write(connections[i]->session));
-      //raise(SIGINT);
-    }
-  }
-}
diff --git a/src/examples/mhd2spdy_spdy.h b/src/examples/mhd2spdy_spdy.h
deleted file mode 100644
index 4207c622..00000000
--- a/src/examples/mhd2spdy_spdy.h
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file mhd2spdy_spdy.h
- * @brief  SPDY part of the proxy. libspdylay is used for the client side.
- * @author Andrey Uzunov
- */
- 
-#ifndef SPDY_H
-#define SPDY_H
-
-#include "mhd2spdy_structures.h"
-
-
-struct SPDY_Connection *
-spdy_connect(const struct URI *uri,
-             uint16_t port,
-             bool is_tls);
-
-
-void
-spdy_ctl_poll(struct pollfd *pollfd,
-              struct SPDY_Connection *connection);
-
-
-bool
-spdy_ctl_select(fd_set * read_fd_set,
-                fd_set * write_fd_set, 
-                fd_set * except_fd_set,
-                struct SPDY_Connection *connection);
-
-
-int
-spdy_exec_io(struct SPDY_Connection *connection);
-
-
-void
-spdy_diec(const char *func,
-          int error_code);
-
-
-int 
-spdy_request(const char **nv,
-             struct Proxy *proxy,
-             bool with_body);
-
-
-void
-spdy_ssl_init_ssl_ctx(SSL_CTX *ssl_ctx,
-                      uint16_t *spdy_proto_version);
-
-
-void
-spdy_free_connection(struct SPDY_Connection * connection);
-
-
-void
-spdy_get_pollfdset(struct pollfd fds[],
-                   struct SPDY_Connection *connections[],
-                   unsigned int max_size,
-                   nfds_t *real_size);
-
-
-int
-spdy_get_selectfdset(fd_set * read_fd_set,
-                    fd_set * write_fd_set, 
-                    fd_set * except_fd_set,
-                    struct SPDY_Connection *connections[],
-                    unsigned int max_size,
-                    nfds_t *real_size);
-
-
-void
-spdy_run(struct pollfd fds[],
-        struct SPDY_Connection *connections[],
-        int size);
-
-
-void
-spdy_run_select(fd_set * read_fd_set,
-                fd_set * write_fd_set, 
-                fd_set * except_fd_set,
-                struct SPDY_Connection *connections[],
-                int size);
-
-
-#endif
diff --git a/src/examples/mhd2spdy_structures.c b/src/examples/mhd2spdy_structures.c
deleted file mode 100644
index 6d4a4076..00000000
--- a/src/examples/mhd2spdy_structures.c
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file mhd2spdy_structures.h
- * @brief  Common functions, macros.
- * @author Andrey Uzunov
- */
- 
-#include "mhd2spdy_structures.h"
-
-
-void
-free_uri(struct URI * uri)
-{
-  if(NULL != uri)
-  {
-    free(uri->full_uri);
-    free(uri->scheme);
-    free(uri->host_and_port);
-    free(uri->host);
-    free(uri->path);
-    free(uri->path_and_more);
-    free(uri->query);
-    free(uri->fragment);
-    uri->port = 0;
-    free(uri);
-  }
-}
-
-
-int
-init_parse_uri(regex_t * preg)
-{
-  // RFC 2396
-  // ^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?
-      /*
-        scheme    = $2
-      authority = $4
-      path      = $5
-      query     = $7
-      fragment  = $9
-      */
-  
-  return regcomp(preg, "^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?", REG_EXTENDED);
-}
-
-void
-deinit_parse_uri(regex_t * preg)
-{
-  regfree(preg);
-}
-  
-int
-parse_uri(regex_t * preg,
-          char * full_uri,
-          struct URI ** uri)
-{
-  int ret;
-  char *colon;
-  long long port;
-  size_t nmatch = 10;
-  regmatch_t pmatch[10];
-
-  if (0 != (ret = regexec(preg, full_uri, nmatch, pmatch, 0)))
-    return ret;
-    
-  *uri = au_malloc(sizeof(struct URI));
-  if(NULL == *uri)
-    return -200;
-    
-  (*uri)->full_uri = strdup(full_uri);
-  
-  asprintf(&((*uri)->scheme), "%.*s",pmatch[2].rm_eo - pmatch[2].rm_so, &full_uri[pmatch[2].rm_so]);
-  asprintf(&((*uri)->host_and_port), "%.*s",pmatch[4].rm_eo - pmatch[4].rm_so, &full_uri[pmatch[4].rm_so]);
-  asprintf(&((*uri)->path), "%.*s",pmatch[5].rm_eo - pmatch[5].rm_so, &full_uri[pmatch[5].rm_so]);
-  asprintf(&((*uri)->path_and_more), "%.*s",pmatch[9].rm_eo - pmatch[5].rm_so, &full_uri[pmatch[5].rm_so]);
-  asprintf(&((*uri)->query), "%.*s",pmatch[7].rm_eo - pmatch[7].rm_so, &full_uri[pmatch[7].rm_so]);
-  asprintf(&((*uri)->fragment), "%.*s",pmatch[9].rm_eo - pmatch[9].rm_so, &full_uri[pmatch[9].rm_so]);
-  
-  colon = strrchr((*uri)->host_and_port, ':');
-  if(NULL == colon)
-  {
-    (*uri)->host = strdup((*uri)->host_and_port);
-    (*uri)->port = 0;
-   
-    return 0;
-  }
-  
-  port = atoi(colon  + 1);
-  if(port<1 || port >= 256 * 256)
-  {
-    free_uri(*uri);
-    return -100;
-  }
-  (*uri)->port = port;
-  asprintf(&((*uri)->host), "%.*s", (int)(colon - (*uri)->host_and_port), (*uri)->host_and_port);
-  
-  return 0;
-}
-
-
-void
-free_proxy(struct Proxy *proxy)
-{
-  PRINT_INFO2("free proxy called for '%s'", proxy->url);
-  if(NULL != proxy->http_body && proxy->http_body_size > 0)
-    UPDATE_STAT(glob_stat.spdy_bytes_received_and_dropped, proxy->http_body_size);
-  free(proxy->http_body);
-  free_uri(proxy->uri);
-        free(proxy->url);
-        free(proxy->http_uri);
-        free(proxy);
-}
-
-
-void *au_malloc(size_t size)
-{
-  void *new_memory;
-  
-  new_memory = malloc(size);
-  if(NULL != new_memory)
-  {
-    glob_opt.global_memory += size;
-    memset(new_memory, 0, size);
-  }
-  return new_memory;
-}
-
-
-bool
-copy_buffer(const void *src, size_t src_size, void **dst, size_t *dst_size)
-{
-  if(0 == src_size)
-    return true;
-  
-  if(NULL == *dst)
-                *dst = malloc(src_size);
-        else
-                *dst = realloc(*dst, src_size + *dst_size);
-        if(NULL == *dst)
-                return false;
-
-        memcpy(*dst + *dst_size, src, src_size);
-        *dst_size += src_size;
-  
-  return true;
-}
diff --git a/src/examples/mhd2spdy_structures.h b/src/examples/mhd2spdy_structures.h
deleted file mode 100644
index f5679341..00000000
--- a/src/examples/mhd2spdy_structures.h
+++ /dev/null
@@ -1,296 +0,0 @@
-/*
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file mhd2spdy_structures.h
- * @brief  Common structures, functions, macros and global variables.
- * @author Andrey Uzunov
- */
-#ifndef STRUCTURES_H
-#define STRUCTURES_H
-
-#define _GNU_SOURCE
- 
-#include <unistd.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <string.h>
-#include <stdio.h>
-#include <ctype.h>
-#include <errno.h>
-#include <assert.h>
-#include <microhttpd.h>
-#include <signal.h>
-#include <poll.h>
-#include <fcntl.h>
-#include <regex.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <openssl/ssl.h>
-#include <openssl/err.h>
-#include <spdylay/spdylay.h>
-#include <getopt.h>
-
-
-/* WANT_READ if SSL connection needs more input; or WANT_WRITE if it
-   needs more output; or IO_NONE. This is necessary because SSL/TLS
-   re-negotiation is possible at any time. Spdylay API offers
-   similar functions like spdylay_session_want_read() and
-   spdylay_session_want_write() but they do not take into account
-   SSL connection. */
-enum
-{
-  IO_NONE,
-  WANT_READ,
-  WANT_WRITE
-};
-
-
-struct Proxy;
-
-
-struct SPDY_Connection {
-  SSL *ssl;
-  spdylay_session *session;
-  struct SPDY_Connection *prev;
-  struct SPDY_Connection *next;
-  struct Proxy *proxies_head;
-  struct Proxy *proxies_tail;
-  char *host;
-  int fd;
-  int want_io;
-  uint counter;
-  uint streams_opened;
-  bool is_tls;
-};
-
-
-struct URI
-{
-  char * full_uri;
-  char * scheme;
-  char * host_and_port;
-  char * host;
-  char * path;
-  char * path_and_more;
-  char * query;
-  char * fragment;
-  uint16_t port;
-};
-
-
-struct HTTP_URI;
-
-
-struct Proxy
-{
-        struct MHD_Connection *http_connection;
-        struct MHD_Response *http_response;
-        struct URI *uri;
-  struct HTTP_URI *http_uri;
-  struct SPDY_Connection *spdy_connection;
-  struct Proxy *next;
-  struct Proxy *prev;
-        char *url;
-        char *version;
-        void *http_body;
-        void *received_body;
-        size_t http_body_size;
-        size_t received_body_size;
-        ssize_t length;
-        int status;
-        int id;
-  int32_t stream_id;
-        bool done;
-        bool http_error;
-        bool spdy_error;
-  bool http_active;
-  bool spdy_active;
-  bool receiving_done;
-};
-
-
-struct HTTP_URI
-{
-  char * uri;
-  struct Proxy * proxy;
-};
-
-
-struct SPDY_Headers
-{
-  const char **nv;
-  int num;
-  int cnt;
-};
-
-
-struct global_options
-{
-  char *spdy2http_str;
-  struct SPDY_Connection *spdy_connection;
-  struct SPDY_Connection *spdy_connections_head;
-  struct SPDY_Connection *spdy_connections_tail;
-  int streams_opened;
-  int responses_pending;
-  regex_t uri_preg;
-  size_t global_memory;
-  SSL_CTX *ssl_ctx;
-  uint32_t total_spdy_connections;
-  uint16_t spdy_proto_version;
-  uint16_t listen_port;
-  bool verbose;
-  bool only_proxy;
-  bool spdy_data_received;
-  bool statistics;
-  bool ignore_rst_stream;
-}
-glob_opt;
-
-
-struct global_statistics
-{
-  //unsigned long long http_bytes_sent;
-  //unsigned long long http_bytes_received;
-  unsigned long long spdy_bytes_sent;
-  unsigned long long spdy_bytes_received;
-  unsigned long long spdy_bytes_received_and_dropped;
-}
-glob_stat;
-
-
-//forbidden headers
-#define SPDY_HTTP_HEADER_TRANSFER_ENCODING "transfer-encoding"
-#define SPDY_HTTP_HEADER_PROXY_CONNECTION "proxy-connection"
-#define SPDY_HTTP_HEADER_KEEP_ALIVE "keep-alive"
-#define SPDY_HTTP_HEADER_CONNECTION "connection"
-
-#define MAX_SPDY_CONNECTIONS 100
-
-#define SPDY_MAX_OUTLEN 4096
-
-/**
- * Insert an element at the head of a DLL. Assumes that head, tail and
- * element are structs with prev and next fields.
- *
- * @param head pointer to the head of the DLL (struct ? *)
- * @param tail pointer to the tail of the DLL (struct ? *)
- * @param element element to insert (struct ? *)
- */
-#define DLL_insert(head,tail,element) do { \
-        (element)->next = (head); \
-        (element)->prev = NULL; \
-        if ((tail) == NULL) \
-                (tail) = element; \
-        else \
-                (head)->prev = element; \
-        (head) = (element); } while (0)
-
-
-/**
- * Remove an element from a DLL. Assumes
- * that head, tail and element are structs
- * with prev and next fields.
- *
- * @param head pointer to the head of the DLL (struct ? *)
- * @param tail pointer to the tail of the DLL (struct ? *)
- * @param element element to remove (struct ? *)
- */
-#define DLL_remove(head,tail,element) do { \
-        if ((element)->prev == NULL) \
-                (head) = (element)->next;  \
-        else \
-                (element)->prev->next = (element)->next; \
-        if ((element)->next == NULL) \
-                (tail) = (element)->prev;  \
-        else \
-                (element)->next->prev = (element)->prev; \
-        (element)->next = NULL; \
-        (element)->prev = NULL; } while (0)
-
-
-#define PRINT_INFO(msg) do{\
-  if(glob_opt.verbose){\
-        printf("%i:%s\n", __LINE__, msg);\
-        fflush(stdout);\
-        }\
-  }\
-        while(0)
-
-
-#define PRINT_INFO2(fmt, ...) do{\
-  if(glob_opt.verbose){\
-        printf("%i\n", __LINE__);\
-        printf(fmt,##__VA_ARGS__);\
-        printf("\n");\
-        fflush(stdout);\
-        }\
-        }\
-        while(0)
-  
-
-#define DIE(msg) do{\
-        printf("FATAL ERROR (line %i): %s\n", __LINE__, msg);\
-        fflush(stdout);\
-  exit(EXIT_FAILURE);\
-        }\
-        while(0)
-  
-  
-#define UPDATE_STAT(stat, value) do{\
-  if(glob_opt.statistics)\
-  {\
-    stat += value;\
-  }\
-  }\
-  while(0)
-
-
-void
-free_uri(struct URI * uri);
-
-
-int
-init_parse_uri(regex_t * preg);
-
-
-void
-deinit_parse_uri(regex_t * preg);
-
-
-int
-parse_uri(regex_t * preg,
-          char * full_uri,
-          struct URI ** uri);
-
-
-void
-free_proxy(struct Proxy *proxy);
-
-
-void *
-au_malloc(size_t size);
-
-
-bool
-copy_buffer(const void *src, size_t src_size, void **dst, size_t *dst_size);
-
-#endif
diff --git a/src/examples/spdy_event_loop.c b/src/examples/spdy_event_loop.c
deleted file mode 100644
index 6b7192c3..00000000
--- a/src/examples/spdy_event_loop.c
+++ /dev/null
@@ -1,487 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file event_loop.c
- * @brief  shows how to use the daemon. THIS IS MAINLY A TEST AND DEBUG
- *               PROGRAM
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include <unistd.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <string.h>
-#include <stdio.h>
-#include <ctype.h>
-#include <errno.h>
-#include "microspdy.h"
-#include <sys/time.h>
-#include <time.h>
-#ifndef MINGW
-#include <arpa/inet.h>
-#endif
-//#include "../framinglayer/structures.h"
-//#include "../applicationlayer/alstructures.h"
-
-static int run = 1;
-
-static int run2 = 1;
-
-        
-static uint64_t loops;
-
-static time_t start;
-
-
-static void
-new_session_callback (void *cls,
-                                                struct SPDY_Session * session)
-{
-  (void)cls;
-  
-        char ipstr[1024];
-                
-        struct sockaddr *addr;
-        socklen_t addr_len = SPDY_get_remote_addr(session, &addr);      
-        
-        if(!addr_len)
-        {
-                printf("SPDY_get_remote_addr");
-                abort();
-        }
-        
-        if(AF_INET == addr->sa_family)
-        {
-                struct sockaddr_in * addr4 = (struct sockaddr_in *) addr;
-                if(NULL == inet_ntop(AF_INET, &(addr4->sin_addr), ipstr, sizeof(ipstr)))
-                {
-                        printf("inet_ntop");
-                        abort();
-                }
-                printf("New connection from: %s:%i\n", ipstr, ntohs(addr4->sin_port));
-                
-        }
-        else if(AF_INET6 == addr->sa_family)
-        {
-                struct sockaddr_in6 * addr6 = (struct sockaddr_in6 *) addr;
-                if(NULL == inet_ntop(AF_INET6, &(addr6->sin6_addr), ipstr, sizeof(ipstr)))
-                {
-                        printf("inet_ntop");
-                        abort();
-                }
-                printf("New connection from: %s:%i\n", ipstr, ntohs(addr6->sin6_port));
-                
-        }
-}
-
-
-static void
-session_closed_handler (void *cls,
-                                                struct SPDY_Session * session,
-                                                int by_client)
-{
-  (void)cls;
-  (void)session;
-  
-        //printf("session_closed_handler called\n");
-        
-        if(SPDY_YES != by_client)
-        {
-                //killchild(child,"wrong by_client");
-                printf("session closed by server\n");
-        }
-        else
-        {
-                printf("session closed by client\n");
-        }
-        
-        //session_closed_called = 1;
-}
-
-
-static void
-response_done_callback(void *cls,
-                                                struct SPDY_Response *response,
-                                                struct SPDY_Request *request,
-                                                enum SPDY_RESPONSE_RESULT status,
-                                                bool streamopened)
-{
-        (void)streamopened;
-        if(strcmp(cls, "/close (daemon1)") == 0)
-                run = 0;
-        else {
-                if(strcmp(cls, "/close (daemon2)") == 0) run2 = 0;
-                loops = 0;
-                start = time(NULL);
-        }
-        if(SPDY_RESPONSE_RESULT_SUCCESS != status)
-        {
-                printf("not sent frame cause %i", status);
-        }
-        printf("answer for %s was sent\n", (char*)cls);
-        //printf("raw sent headers %s\n", (char *)(response->headers)+8);
-        
-        SPDY_destroy_request(request);
-        SPDY_destroy_response(response);
-        free(cls);
-}
-
-/*
-static int
-print_headers (void *cls,
-                           const char *name, const char *value)
-{
-        (void)cls;
-        printf("%s: %s\n",name,value);
-        return SPDY_YES;
-}
- */
- 
- 
-/*       
-void
-new_request_cb (void *cls,
-                                                struct SPDY_Request * request,
-                                                uint8_t priority,
-                        const char *method,
-                        const char *path,
-                        const char *version,
-                        const char *host,
-                        const char *scheme,
-                                                struct SPDY_NameValue * headers)
-{
-        (void)cls;
-        (void)request;
-        printf("Priority: %i\nHTTP headers, scheme: %s\n\n%s %s %s\nHost: %s\n", priority,scheme,method,path,version,host);
-        SPDY_name_value_iterate(headers, &print_headers, NULL);
-}
-*/
-
-
-static int
-append_headers_to_data (void *cls,
-                           const char *name, const char * const *value, int num_values)
-{
-        char **data = cls;
-        void *tofree = *data;
-        int i;
-        
-        if(num_values)
-        for(i=0;i<num_values;++i)
-        {
-        asprintf(data,"%s%s: %s\n", *data,name,value[i]);
-        }
-        else
-        asprintf(data,"%s%s: \n", *data,name);
-        
-        free(tofree);
-        return SPDY_YES;
-}  
-
-
-static void
-standard_request_handler(void *cls,
-                                                struct SPDY_Request * request,
-                                                uint8_t priority,
-                        const char *method,
-                        const char *path,
-                        const char *version,
-                        const char *host,
-                        const char *scheme,
-                                                struct SPDY_NameValue * headers,
-            bool more)
-{
-  (void)more;
-  
-        char *html;
-        char *data;
-        struct SPDY_Response *response=NULL;
-        
-        printf("received request for '%s %s %s'\n", method, path, version);
-        if(strcmp(path,"/main.css")==0)
-        {
-                if(NULL != cls)
-                        asprintf(&html,"body{color:green;}");
-                else
-                        asprintf(&html,"body{color:red;}");
-                                
-                //struct SPDY_NameValue *headers=SPDY_name_value_create();
-                //SPDY_name_value_add(headers,"content-type","text/css");
-                
-                response = SPDY_build_response(200,NULL,SPDY_HTTP_VERSION_1_1,NULL,html,strlen(html));
-                free(html);
-        }
-        else
-        {
-                asprintf(&data,"Priority: %i\nHTTP headers, scheme: %s\n\n%s %s %s\nHost: %s\n", priority,scheme,method,path,version,host);
-                
-                SPDY_name_value_iterate(headers, &append_headers_to_data, &data);
-                
-                if(strcmp(path,"/close")==0)
-                {
-                        asprintf(&html,"<html>"
-                "<body><b>Closing now!<br>This is an answer to the following "
-                "request:</b><br><br><pre>%s</pre></body></html>",data);
-                }
-                else
-                {
-                        asprintf(&html,"<html><link href=\"main.css\" rel=\"stylesheet\" type=\"text/css\" />"
-                "<body><b>This is an answer to the following "
-                "request:</b><br><br><pre>%s</pre></body></html>",data);
-                }
-                
-                free(data);
-                
-                response = SPDY_build_response(200,NULL,SPDY_HTTP_VERSION_1_1,NULL,html,strlen(html));
-                free(html);
-        }
-        
-        if(NULL==response){
-                fprintf(stdout,"no response obj\n");
-                abort();
-        }
-        
-        char *pathcls;
-        asprintf(&pathcls, "%s (daemon%i)",path,NULL==cls ? 1 : 2);
-        if(SPDY_queue_response(request,response,true,false,&response_done_callback,pathcls)!=SPDY_YES)
-        {
-                fprintf(stdout,"queue\n");
-                abort();
-        }
-}
-
-
-static int
-new_post_data_cb (void * cls,
-                                         struct SPDY_Request *request,
-                                         const void * buf,
-                                         size_t size,
-                                         bool more)
-{
-  (void)cls;
-  (void)request;
-  (void)more;
-  
-        printf("DATA:\n===============================\n");
-  write(0, buf, size);
-        printf("\n===============================\n");
-  return SPDY_YES;
-}
-
-
-static void 
-sig_handler(int signo)
-{
-  (void)signo;
-  
-  printf("received signal\n");
-}
-
-
-int
-main (int argc, char *const *argv)
-{       
-        if(argc != 2) return 1;
-        
-        #ifndef MINGW
-        if (signal(SIGPIPE, sig_handler) == SIG_ERR)
-                printf("\ncan't catch SIGPIPE\n");
-        #endif
-        
-        SPDY_init();
-        
-        /*
-  struct sockaddr_in addr4;
-        struct in_addr inaddr4;
-        inaddr4.s_addr = htonl(INADDR_ANY);
-        addr4.sin_family = AF_INET;
-        addr4.sin_addr = inaddr4;
-        addr4.sin_port = htons(atoi(argv[1]));
-        */
-  
-        struct SPDY_Daemon *daemon = SPDY_start_daemon(atoi(argv[1]),
-         DATA_DIR "cert-and-key.pem",
-         DATA_DIR "cert-and-key.pem",
-        &new_session_callback,&session_closed_handler,&standard_request_handler,&new_post_data_cb,NULL,
-        SPDY_DAEMON_OPTION_SESSION_TIMEOUT, 10,
-        //SPDY_DAEMON_OPTION_SOCK_ADDR,  (struct sockaddr *)&addr4,
-        SPDY_DAEMON_OPTION_END);
-        
-        if(NULL==daemon){
-                printf("no daemon\n");
-                return 1;
-        }
-        
-  /*
-        struct sockaddr_in6 addr6;
-        addr6.sin6_family = AF_INET6;
-        addr6.sin6_addr = in6addr_any;
-        addr6.sin6_port = htons(atoi(argv[1]) + 1);
-        */
-  
-        struct SPDY_Daemon *daemon2 = SPDY_start_daemon(atoi(argv[1]) + 1,
-         DATA_DIR "cert-and-key.pem",
-         DATA_DIR "cert-and-key.pem",
-        &new_session_callback,NULL,&standard_request_handler,&new_post_data_cb,&main,
-        //SPDY_DAEMON_OPTION_SESSION_TIMEOUT, 0,
-        //SPDY_DAEMON_OPTION_SOCK_ADDR,  (struct sockaddr *)&addr6,
-        //SPDY_DAEMON_OPTION_FLAGS, SPDY_DAEMON_FLAG_ONLY_IPV6,
-        SPDY_DAEMON_OPTION_END);
-        
-        if(NULL==daemon2){
-                printf("no daemon\n");
-                return 1;
-        }
-        
-        do
-        {
-        unsigned long long timeoutlong=0;
-        struct timeval timeout;
-        volatile int rc; /* select() return code */ 
-        volatile int ret;
-
-        fd_set read_fd_set;
-        fd_set write_fd_set;
-        fd_set except_fd_set;
-        int maxfd = -1;
-
-        if(run && daemon != NULL)
-        {
-                loops++;
-                FD_ZERO(&read_fd_set);
-                FD_ZERO(&write_fd_set);
-                FD_ZERO(&except_fd_set);
-
-                ret = SPDY_get_timeout(daemon, &timeoutlong);
-                if(SPDY_NO == ret || timeoutlong > 1000)
-                {
-                        timeout.tv_sec = 1;
-      timeout.tv_usec = 0;
-                }
-                else
-                {
-                        timeout.tv_sec = timeoutlong / 1000;
-                        timeout.tv_usec = (timeoutlong % 1000) * 1000;
-                }
-    
-                printf("ret=%i; timeoutlong=%llu; sec=%llu; usec=%llu\n", ret, timeoutlong, (long long unsigned)timeout.tv_sec, (long long unsigned)timeout.tv_usec);
-                //raise(SIGINT);
-
-                /* get file descriptors from the transfers */ 
-                maxfd = SPDY_get_fdset (daemon,
-                &read_fd_set,
-                &write_fd_set, 
-                &except_fd_set);
-
-//struct timeval ts1,ts2;
-    //gettimeofday(&ts1, NULL);
-                rc = select(maxfd+1, &read_fd_set, &write_fd_set, &except_fd_set, &timeout);
-    //gettimeofday(&ts2, NULL);
-    printf("rc %i\n",rc);
-   // printf("time for select %i\n",ts2.tv_usec - ts1.tv_usec);
-   // printf("%i %i %i %i\n",ts1.tv_sec, ts1.tv_usec,ts2.tv_sec, ts2.tv_usec);
-
-                switch(rc) {
-                        case -1:
-                                /* select error */ 
-                                break;
-                        case 0:
-
-                                break;
-                        default:
-                                SPDY_run(daemon);
-
-                        break;
-                }
-        }
-        else if(daemon != NULL){
-        
-        printf("%lu loops in %llu secs\n", loops, (long long unsigned)(time(NULL) - start));
-                SPDY_stop_daemon(daemon);
-                daemon=NULL;
-        }
-
-        if(run2)
-        {
-                FD_ZERO(&read_fd_set);
-                FD_ZERO(&write_fd_set);
-                FD_ZERO(&except_fd_set);
-
-                ret = SPDY_get_timeout(daemon2, &timeoutlong);
-                //printf("tout %i\n",timeoutlong);
-                if(SPDY_NO == ret || timeoutlong > 1)
-                { 
-                        //do sth else
-                        //sleep(1);
-
-                        //try new connection
-                        timeout.tv_sec = 1;
-                        timeout.tv_usec = 0;
-                }
-                else
-                {
-                        timeout.tv_sec = timeoutlong;
-                        timeout.tv_usec = 0;//(timeoutlong % 1000) * 1000;
-                }
-
-                //printf("ret=%i; timeoutlong=%i; sec=%i; usec=%i\n", ret, timeoutlong, timeout.tv_sec, timeout.tv_usec);
-                //raise(SIGINT);
-
-                /* get file descriptors from the transfers */ 
-                maxfd = SPDY_get_fdset (daemon2,
-                &read_fd_set,
-                &write_fd_set, 
-                &except_fd_set);
-
-                rc = select(maxfd+1, &read_fd_set, &write_fd_set, &except_fd_set, &timeout);
-
-                switch(rc) {
-                        case -1:
-                                /* select error */ 
-                                break;
-                        case 0:
-
-                                break;
-                        default:
-                                SPDY_run(daemon2);
-
-                                break;
-                }
-        }
-        else if(daemon2 != NULL){
-                SPDY_stop_daemon(daemon2);
-                daemon2=NULL;
-        }
-        }
-        while(run || run2);
-
-        if(daemon != NULL){
-                SPDY_stop_daemon(daemon);
-        }
-        if(daemon2 != NULL){
-                SPDY_stop_daemon(daemon2);
-        }
-        
-        SPDY_deinit();
-        
-        return 0;
-}
-
diff --git a/src/examples/spdy_fileserver.c b/src/examples/spdy_fileserver.c
deleted file mode 100644
index 0a0254ff..00000000
--- a/src/examples/spdy_fileserver.c
+++ /dev/null
@@ -1,353 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file fileserver.c
- * @brief   Simple example how the lib can be used for serving
- *                      files directly read from the system
- * @author Andrey Uzunov
- */
-
-//for asprintf
-#define _GNU_SOURCE
-
-#include <unistd.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <string.h>
-#include <stdio.h>
-#include <ctype.h>
-#include <errno.h>
-#include "microspdy.h"
-#include "time.h"
-
-
-int run = 1;
-char* basedir;
-
-
-#define GET_MIME_TYPE(fname, mime)      do {\
-                unsigned int __len = strlen(fname);\
-                if (__len < 4 || '.' != (fname)[__len - 4]) \
-                {       \
-                        (mime) = strdup("application/octet-stream");\
-                        printf("MIME for %s is applic...\n", (fname));\
-                }\
-    else {\
-      const char * __ext = &(fname)[__len - 3];\
-      if(0 == strcmp(__ext, "jpg")) (mime) = strdup("image/jpeg");\
-      else if(0 == strcmp(__ext, "png")) (mime) = strdup("image/png");\
-      else if(0 == strcmp(__ext, "css")) (mime) = strdup("text/css");\
-      else if(0 == strcmp(__ext, "gif")) (mime) = strdup("image/gif");\
-      else if(0 == strcmp(__ext, "htm")) (mime) = strdup("text/html");\
-      else \
-      { \
-        (mime) = strdup("application/octet-stream");\
-        printf("MIME for %s is applic...\n", (fname));\
-      }\
-    }\
-                if(NULL == (mime))\
-                {\
-                        printf("no memory\n");\
-                        abort();\
-                }\
-        } while (0)
-
-
-static const char *DAY_NAMES[] =
-  { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
-
-static const char *MONTH_NAMES[] =
-  { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
-    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
-
-//taken from http://stackoverflow.com/questions/2726975/how-can-i-generate-an-rfc1123-date-string-from-c-code-win32
-//and modified for linux
-char *Rfc1123_DateTimeNow()
-{
-    const int RFC1123_TIME_LEN = 29;
-    time_t t;
-    struct tm tm;
-    char * buf = malloc(RFC1123_TIME_LEN+1);
-
-    if (NULL == buf)
-      return NULL;
-    time(&t);
-    gmtime_r( &t, &tm);
-
-    strftime(buf, RFC1123_TIME_LEN+1, "---, %d --- %Y %H:%M:%S GMT", &tm);
-    memcpy(buf, DAY_NAMES[tm.tm_wday], 3);
-    memcpy(buf+8, MONTH_NAMES[tm.tm_mon], 3);
-
-    return buf;
-}
-
-
-ssize_t
-response_callback (void *cls,
-                                                void *buffer,
-                                                size_t max,
-                                                bool *more)
-{
-        FILE *fd =(FILE*)cls;
-
-        int ret = fread(buffer,1,max,fd);
-        *more = feof(fd) == 0;
-
-        //if(!(*more))
-        //      fclose(fd);
-
-        return ret;
-}
-
-
-void
-response_done_callback(void *cls,
-                                                struct SPDY_Response *response,
-                                                struct SPDY_Request *request,
-                                                enum SPDY_RESPONSE_RESULT status,
-                                                bool streamopened)
-{
-        (void)streamopened;
-        (void)status;
-        //printf("answer for %s was sent\n", (char *)cls);
-
-        /*if(SPDY_RESPONSE_RESULT_SUCCESS != status)
-        {
-                printf("answer for %s was NOT sent, %i\n", (char *)cls,status);
-        }*/
-
-        SPDY_destroy_request(request);
-        SPDY_destroy_response(response);
-        if(NULL!=cls)fclose(cls);
-}
-
-void
-standard_request_handler(void *cls,
-                                                struct SPDY_Request * request,
-                                                uint8_t priority,
-                        const char *method,
-                        const char *path,
-                        const char *version,
-                        const char *host,
-                        const char *scheme,
-                                                struct SPDY_NameValue * headers,
-            bool more)
-{
-        (void)cls;
-        (void)request;
-        (void)priority;
-        (void)host;
-        (void)scheme;
-        (void)headers;
-        (void)method;
-        (void)version;
-        (void)more;
-
-        struct SPDY_Response *response=NULL;
-        struct SPDY_NameValue *resp_headers;
-        char *fname;
-        char *fsize;
-        char *mime=NULL;
-        char *date=NULL;
-        ssize_t filesize = -666;
-        FILE *fd = NULL;
-        int ret = -666;
-
-        //printf("received request for '%s %s %s'\n", method, path, version);
-        if(strlen(path) > 1 && NULL == strstr(path, "..") && '/' == path[0])
-        {
-                asprintf(&fname,"%s%s",basedir,path);
-                if(0 == access(fname, R_OK))
-                {
-                        if(NULL == (fd = fopen(fname,"r"))
-                                || 0 != (ret = fseek(fd, 0L, SEEK_END))
-                                || -1 == (filesize = ftell(fd))
-                                || 0 != (ret = fseek(fd, 0L, SEEK_SET)))
-                        {
-                                printf("Error on opening %s\n%p %i %zd\n",fname, fd, ret, filesize);
-                                response = SPDY_build_response(SPDY_HTTP_INTERNAL_SERVER_ERROR,NULL,SPDY_HTTP_VERSION_1_1,NULL,NULL,0);
-                        }
-                        else
-                        {
-                                if(NULL == (resp_headers = SPDY_name_value_create()))
-                                {
-                                        printf("SPDY_name_value_create failed\n");
-                                        abort();
-                                }
-
-                                date = Rfc1123_DateTimeNow();
-                                if(NULL == date
-                                        || SPDY_YES != SPDY_name_value_add(resp_headers,SPDY_HTTP_HEADER_DATE,date))
-                                {
-                                        printf("SPDY_name_value_add or Rfc1123_DateTimeNow failed\n");
-                                        abort();
-                                }
-                                free(date);
-
-                                if(-1 == asprintf(&fsize, "%zd", filesize)
-                                        || SPDY_YES != SPDY_name_value_add(resp_headers,SPDY_HTTP_HEADER_CONTENT_LENGTH,fsize))
-                                {
-                                        printf("SPDY_name_value_add or asprintf failed\n");
-                                        abort();
-                                }
-                                free(fsize);
-
-                                GET_MIME_TYPE(path,mime);
-                                if(SPDY_YES != SPDY_name_value_add(resp_headers,SPDY_HTTP_HEADER_CONTENT_TYPE,mime))
-                                {
-                                        printf("SPDY_name_value_add failed\n");
-                                        abort();
-                                }
-                                free(mime);
-
-                                if(SPDY_YES != SPDY_name_value_add(resp_headers,SPDY_HTTP_HEADER_SERVER,"libmicrospdy/fileserver"))
-                                {
-                                        printf("SPDY_name_value_add failed\n");
-                                        abort();
-                                }
-
-                                response = SPDY_build_response_with_callback(200,NULL,
-                                        SPDY_HTTP_VERSION_1_1,resp_headers,&response_callback,fd,SPDY_MAX_SUPPORTED_FRAME_SIZE);
-                                SPDY_name_value_destroy(resp_headers);
-                        }
-
-                        if(NULL==response){
-                                printf("no response obj\n");
-                                abort();
-                        }
-
-                        if(SPDY_queue_response(request,response,true,false,&response_done_callback,fd)!=SPDY_YES)
-                        {
-                                printf("queue\n");
-                                abort();
-                        }
-
-                        free(fname);
-                        return;
-                }
-                free(fname);
-        }
-
-        if(strcmp(path,"/close")==0)
-        {
-                run = 0;
-        }
-
-        response = SPDY_build_response(SPDY_HTTP_NOT_FOUND,NULL,SPDY_HTTP_VERSION_1_1,NULL,NULL,0);
-        printf("Not found %s\n",path);
-
-        if(NULL==response){
-                printf("no response obj\n");
-                abort();
-        }
-
-        if(SPDY_queue_response(request,response,true,false,&response_done_callback,NULL)!=SPDY_YES)
-        {
-                printf("queue\n");
-                abort();
-        }
-}
-
-int
-main (int argc, char *const *argv)
-{
-        unsigned long long timeoutlong=0;
-        struct timeval timeout;
-        int ret;
-        fd_set read_fd_set;
-        fd_set write_fd_set;
-        fd_set except_fd_set;
-        int maxfd = -1;
-        struct SPDY_Daemon *daemon;
-
-        if(argc != 5)
-        {
-                printf("Usage: %s cert-file key-file base-dir port\n", argv[0]);
-                return 1;
-        }
-
-        SPDY_init();
-
-        daemon = SPDY_start_daemon(atoi(argv[4]),
-                                                                argv[1],
-                                                                argv[2],
-                                                                NULL,
-                                                                NULL,
-                                                                &standard_request_handler,
-                                                                NULL,
-                                                                NULL,
-                                                                SPDY_DAEMON_OPTION_SESSION_TIMEOUT,
-                                                                1800,
-                                                                SPDY_DAEMON_OPTION_END);
-
-        if(NULL==daemon){
-                printf("no daemon\n");
-                return 1;
-        }
-
-        basedir = argv[3];
-
-        do
-        {
-                FD_ZERO(&read_fd_set);
-                FD_ZERO(&write_fd_set);
-                FD_ZERO(&except_fd_set);
-
-                ret = SPDY_get_timeout(daemon, &timeoutlong);
-                if(SPDY_NO == ret || timeoutlong > 1000)
-                {
-                        timeout.tv_sec = 1;
-      timeout.tv_usec = 0;
-                }
-                else
-                {
-                        timeout.tv_sec = timeoutlong / 1000;
-                        timeout.tv_usec = (timeoutlong % 1000) * 1000;
-                }
-
-                maxfd = SPDY_get_fdset (daemon,
-                                                                &read_fd_set,
-                                                                &write_fd_set,
-                                                                &except_fd_set);
-
-                ret = select(maxfd+1, &read_fd_set, &write_fd_set, &except_fd_set, &timeout);
-
-                switch(ret) {
-                        case -1:
-                                printf("select error: %i\n", errno);
-                                break;
-                        case 0:
-
-                                break;
-                        default:
-                                SPDY_run(daemon);
-
-                        break;
-                }
-        }
-        while(run);
-
-        SPDY_stop_daemon(daemon);
-
-        SPDY_deinit();
-
-        return 0;
-}
-
diff --git a/src/examples/spdy_response_with_callback.c b/src/examples/spdy_response_with_callback.c
deleted file mode 100644
index 5bd452d2..00000000
--- a/src/examples/spdy_response_with_callback.c
+++ /dev/null
@@ -1,236 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file response_with_callback.c
- * @brief  shows how to create responses with callbacks
- * @author Andrey Uzunov
- */
- 
-//for asprintf
-#define _GNU_SOURCE 
-
-#include <unistd.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <string.h>
-#include <stdio.h>
-#include <ctype.h>
-#include <errno.h>
-#include "microspdy.h"
-
-static int run = 1;
-
-
-static ssize_t
-response_callback (void *cls,
-                                                void *buffer,
-                                                size_t max,
-                                                bool *more)
-{
-        FILE *fd =(FILE*)cls;
-        
-        int ret = fread(buffer,1,max,fd);
-        *more = feof(fd) == 0;
-        
-        if(!(*more))
-                fclose(fd);
-        
-        return ret;
-}
-
-
-static void
-response_done_callback(void *cls,
-                       struct SPDY_Response *response,
-                       struct SPDY_Request *request,
-                       enum SPDY_RESPONSE_RESULT status,
-                       bool streamopened)
-{
-        (void)streamopened;
-        (void)status;
-  
-        printf("answer for %s was sent\n", (char *)cls);
-        
-        SPDY_destroy_request(request);
-        SPDY_destroy_response(response);
-        free(cls);
-}
-
-
-static void
-standard_request_handler(void *cls,
-                                                struct SPDY_Request * request,
-                                                uint8_t priority,
-                        const char *method,
-                        const char *path,
-                        const char *version,
-                        const char *host,
-                        const char *scheme,
-                                                struct SPDY_NameValue * headers,
-            bool more)
-{
-        (void)cls;
-        (void)request;
-        (void)priority;
-        (void)host;
-        (void)scheme;
-        (void)headers;
-        (void)more;
-        
-        char *html;
-        struct SPDY_Response *response=NULL;
-        struct SPDY_NameValue *resp_headers;
-        
-        printf("received request for '%s %s %s'\n", method, path, version);
-        if(strcmp(path,"/spdy-draft.txt")==0)
-        {
-                FILE *fd = fopen(DATA_DIR "spdy-draft.txt","r");
-                
-                if(NULL == (resp_headers = SPDY_name_value_create()))
-                {
-                        fprintf(stdout,"SPDY_name_value_create failed\n");
-                        abort();
-                }
-                if(SPDY_YES != SPDY_name_value_add(resp_headers,SPDY_HTTP_HEADER_CONTENT_TYPE,"text/plain"))
-                {
-                        fprintf(stdout,"SPDY_name_value_add failed\n");
-                        abort();
-                }
-                
-                response = SPDY_build_response_with_callback(200,NULL,
-                        SPDY_HTTP_VERSION_1_1,resp_headers,&response_callback,fd,SPDY_MAX_SUPPORTED_FRAME_SIZE);
-                SPDY_name_value_destroy(resp_headers);
-        }
-        else
-        {
-                if(strcmp(path,"/close")==0)
-                {
-                        asprintf(&html,"<html>"
-                "<body><b>Closing now!</body></html>");
-                        run = 0;
-                }
-                else
-                {
-                        asprintf(&html,"<html>"
-                "<body><a href=\"/spdy-draft.txt\">/spdy-draft.txt</a><br></body></html>");
-                }
-                
-                response = SPDY_build_response(200,NULL,SPDY_HTTP_VERSION_1_1,NULL,html,strlen(html));
-                free(html);
-        }
-        
-        if(NULL==response){
-                fprintf(stdout,"no response obj\n");
-                abort();
-        }
-        
-        void *clspath = strdup(path);
-        
-        if(SPDY_queue_response(request,response,true,false,&response_done_callback,clspath)!=SPDY_YES)
-        {
-                fprintf(stdout,"queue\n");
-                abort();
-        }
-}
-
-
-int
-main (int argc, char *const *argv)
-{       
-        unsigned long long timeoutlong=0;
-        struct timeval timeout;
-        int ret;
-        fd_set read_fd_set;
-        fd_set write_fd_set;
-        fd_set except_fd_set;
-        int maxfd = -1;
-        struct SPDY_Daemon *daemon;
-        
-        if(argc != 2)
-        {
-                return 1;
-        }
-
-        SPDY_init();
-        
-        daemon = SPDY_start_daemon(atoi(argv[1]),
-                                                                DATA_DIR "cert-and-key.pem",
-                                                                DATA_DIR "cert-and-key.pem",
-                                                                NULL,
-                                                                NULL,
-                                                                &standard_request_handler,
-                                                                NULL,
-                                                                NULL,
-                                                                SPDY_DAEMON_OPTION_SESSION_TIMEOUT,
-                                                                1800,
-                                                                SPDY_DAEMON_OPTION_END);
-        
-        if(NULL==daemon){
-                printf("no daemon\n");
-                return 1;
-        }
-        
-        do
-        {
-                FD_ZERO(&read_fd_set);
-                FD_ZERO(&write_fd_set);
-                FD_ZERO(&except_fd_set);
-
-                ret = SPDY_get_timeout(daemon, &timeoutlong);
-                if(SPDY_NO == ret || timeoutlong > 1000)
-                {
-                        timeout.tv_sec = 1;
-      timeout.tv_usec = 0;
-                }
-                else
-                {
-                        timeout.tv_sec = timeoutlong / 1000;
-                        timeout.tv_usec = (timeoutlong % 1000) * 1000;
-                }
-                
-                maxfd = SPDY_get_fdset (daemon,
-                                                                &read_fd_set,
-                                                                &write_fd_set, 
-                                                                &except_fd_set);
-                                                                
-                ret = select(maxfd+1, &read_fd_set, &write_fd_set, &except_fd_set, &timeout);
-                
-                switch(ret) {
-                        case -1:
-                                printf("select error: %i\n", errno);
-                                break;
-                        case 0:
-
-                                break;
-                        default:
-                                SPDY_run(daemon);
-
-                        break;
-                }
-        }
-        while(run);
-
-        SPDY_stop_daemon(daemon);
-        
-        SPDY_deinit();
-        
-        return 0;
-}
-
diff --git a/src/include/Makefile.am b/src/include/Makefile.am
index 437008fd..42425ad8 100644
--- a/src/include/Makefile.am
+++ b/src/include/Makefile.am
@@ -1,10 +1,6 @@
 # This Makefile.am is in the public domain
 SUBDIRS = .
 
-if ENABLE_SPDY
-microspdy = microspdy.h
-endif
-
-include_HEADERS = microhttpd.h $(microspdy)
+include_HEADERS = microhttpd.h 
 
 EXTRA_DIST = platform.h platform_interface.h w32functions.h autoinit_funcs.h
diff --git a/src/include/microspdy.h b/src/include/microspdy.h
deleted file mode 100644
index 7da5fbe6..00000000
--- a/src/include/microspdy.h
+++ /dev/null
@@ -1,1380 +0,0 @@
-/*

-    This file is part of libmicrospdy

-    Copyright Copyright (C) 2012, 2013 Christian Grothoff

-

-    This program is free software: you can redistribute it and/or modify

-    it under the terms of the GNU General Public License as published by

-    the Free Software Foundation, either version 3 of the License, or

-    (at your option) any later version.

-

-    This program is distributed in the hope that it will be useful,

-    but WITHOUT ANY WARRANTY; without even the implied warranty of

-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

-    GNU General Public License for more details.

-

-    You should have received a copy of the GNU General Public License

-    along with this program.  If not, see <http://www.gnu.org/licenses/>.

-*/

-

-/**

- * @file microspdy.h

- * @brief public interface to libmicrospdy

- * @author Andrey Uzunov

- * @author Christian Grothoff

- *

- * All symbols defined in this header start with SPDY_.  libmisrospdy is a small

- * SPDY daemon library. The application can start multiple daemons

- * and they are independent.<p>

- *

- * The header file defines various constants used by the SPDY and the HTTP protocol.

- * This does not mean that the lib actually interprets all of these

- * values. Not everything is implemented. The provided constants are exported as a convenience

- * for users of the library.  The lib does not verify that provided

- * HTTP headers and if their values conform to the SPDY protocol,

- * it only checks if the required headers for the SPDY requests and

- * responses are provided.<p>

- *

- * The library uses just a single thread.<p>

- *

- * Before including "microspdy.h" you should add the necessary

- * includes to define the types used in this file (which headers are needed may

- * depend on your platform; for possible suggestions consult

- * "platform.h" in the libmicrospdy distribution).<p>

- *

- * All of the functions returning SPDY_YES/SPDY_NO return

- * SPDY_INPUT_ERROR when any of the parameters are invalid, e.g.

- * required parameter is NULL.<p>

- *

- * The library does not check if anything at the application layer --

- * requests and responses -- is correct. For example, it

- * is up to the user to check if a client is sending HTTP body but the

- * method is GET.<p>

- *

- * The SPDY flow control is just partially implemented: the receiving

- * window is updated, and the client is notified, to prevent a client

- * from stop sending POST body data, for example.

- */

-#ifndef SPDY_MICROSPDY_H

-#define SPDY_MICROSPDY_H

-

-#include <zlib.h>

-#include <stdbool.h>

-

-/* While we generally would like users to use a configure-driven

-   build process which detects which headers are present and

-   hence works on any platform, we use "standard" includes here

-   to build out-of-the-box for beginning users on common systems.

-

-   Once you have a proper build system and go for more exotic

-   platforms, you should define MHD_PLATFORM_H in some header that

-   you always include *before* "microhttpd.h".  Then the following

-   "standard" includes won't be used (which might be a good

-   idea, especially on platforms where they do not exist). */

-#ifndef MHD_PLATFORM_H

-#include <unistd.h>

-#include <stdarg.h>

-#include <stdint.h>

-#ifdef __MINGW32__

-#include <ws2tcpip.h>

-#else

-#include <sys/time.h>

-#include <sys/types.h>

-#include <sys/socket.h>

-#endif

-#endif

-

-#ifndef _MHD_EXTERN

-#define _MHD_EXTERN extern

-#endif

-

-/**

- * return code for "YES".

- */

-#define SPDY_YES 1

-

-/**

- * return code for "NO".

- */

-#define SPDY_NO 0

-

-/**

- * return code for error when input parameters are wrong. To be returned

- * only by functions which return int. The others will return NULL on

- * input error.

- */

-#define SPDY_INPUT_ERROR -1

-

-/**

- * SPDY version supported by the lib.

- */

-#define SPDY_VERSION 3

-

-/**

- * The maximum allowed size (without 8 byte headers) of

- * SPDY frames (value length) is 8192. The lib will accept and

- * send frames with length at most this value here.

- */

-#define SPDY_MAX_SUPPORTED_FRAME_SIZE 8192

-

-/**

- * HTTP response codes.

- */

-#define SPDY_HTTP_CONTINUE 100

-#define SPDY_HTTP_SWITCHING_PROTOCOLS 101

-#define SPDY_HTTP_PROCESSING 102

-

-#define SPDY_HTTP_OK 200

-#define SPDY_HTTP_CREATED 201

-#define SPDY_HTTP_ACCEPTED 202

-#define SPDY_HTTP_NON_AUTHORITATIVE_INFORMATION 203

-#define SPDY_HTTP_NO_CONTENT 204

-#define SPDY_HTTP_RESET_CONTENT 205

-#define SPDY_HTTP_PARTIAL_CONTENT 206

-#define SPDY_HTTP_MULTI_STATUS 207

-

-#define SPDY_HTTP_MULTIPLE_CHOICES 300

-#define SPDY_HTTP_MOVED_PERMANENTLY 301

-#define SPDY_HTTP_FOUND 302

-#define SPDY_HTTP_SEE_OTHER 303

-#define SPDY_HTTP_NOT_MODIFIED 304

-#define SPDY_HTTP_USE_PROXY 305

-#define SPDY_HTTP_SWITCH_PROXY 306

-#define SPDY_HTTP_TEMPORARY_REDIRECT 307

-

-#define SPDY_HTTP_BAD_REQUEST 400

-#define SPDY_HTTP_UNAUTHORIZED 401

-#define SPDY_HTTP_PAYMENT_REQUIRED 402

-#define SPDY_HTTP_FORBIDDEN 403

-#define SPDY_HTTP_NOT_FOUND 404

-#define SPDY_HTTP_METHOD_NOT_ALLOWED 405

-#define SPDY_HTTP_METHOD_NOT_ACCEPTABLE 406

-#define SPDY_HTTP_PROXY_AUTHENTICATION_REQUIRED 407

-#define SPDY_HTTP_REQUEST_TIMEOUT 408

-#define SPDY_HTTP_CONFLICT 409

-#define SPDY_HTTP_GONE 410

-#define SPDY_HTTP_LENGTH_REQUIRED 411

-#define SPDY_HTTP_PRECONDITION_FAILED 412

-#define SPDY_HTTP_REQUEST_ENTITY_TOO_LARGE 413

-#define SPDY_HTTP_REQUEST_URI_TOO_LONG 414

-#define SPDY_HTTP_UNSUPPORTED_MEDIA_TYPE 415

-#define SPDY_HTTP_REQUESTED_RANGE_NOT_SATISFIABLE 416

-#define SPDY_HTTP_EXPECTATION_FAILED 417

-#define SPDY_HTTP_UNPROCESSABLE_ENTITY 422

-#define SPDY_HTTP_LOCKED 423

-#define SPDY_HTTP_FAILED_DEPENDENCY 424

-#define SPDY_HTTP_UNORDERED_COLLECTION 425

-#define SPDY_HTTP_UPGRADE_REQUIRED 426

-#define SPDY_HTTP_NO_RESPONSE 444

-#define SPDY_HTTP_RETRY_WITH 449

-#define SPDY_HTTP_BLOCKED_BY_WINDOWS_PARENTAL_CONTROLS 450

-#define SPDY_HTTP_UNAVAILABLE_FOR_LEGAL_REASONS 451

-

-#define SPDY_HTTP_INTERNAL_SERVER_ERROR 500

-#define SPDY_HTTP_NOT_IMPLEMENTED 501

-#define SPDY_HTTP_BAD_GATEWAY 502

-#define SPDY_HTTP_SERVICE_UNAVAILABLE 503

-#define SPDY_HTTP_GATEWAY_TIMEOUT 504

-#define SPDY_HTTP_HTTP_VERSION_NOT_SUPPORTED 505

-#define SPDY_HTTP_VARIANT_ALSO_NEGOTIATES 506

-#define SPDY_HTTP_INSUFFICIENT_STORAGE 507

-#define SPDY_HTTP_BANDWIDTH_LIMIT_EXCEEDED 509

-#define SPDY_HTTP_NOT_EXTENDED 510

-

-/**

- * HTTP headers are used in SPDY, but all of them MUST be lowercase.

- * Some are not valid in SPDY and MUST not be used

- */

-#define SPDY_HTTP_HEADER_ACCEPT "accept"

-#define SPDY_HTTP_HEADER_ACCEPT_CHARSET "accept-charset"

-#define SPDY_HTTP_HEADER_ACCEPT_ENCODING "accept-encoding"

-#define SPDY_HTTP_HEADER_ACCEPT_LANGUAGE "accept-language"

-#define SPDY_HTTP_HEADER_ACCEPT_RANGES "accept-ranges"

-#define SPDY_HTTP_HEADER_AGE "age"

-#define SPDY_HTTP_HEADER_ALLOW "allow"

-#define SPDY_HTTP_HEADER_AUTHORIZATION "authorization"

-#define SPDY_HTTP_HEADER_CACHE_CONTROL "cache-control"

-/* Connection header is forbidden in SPDY */

-#define SPDY_HTTP_HEADER_CONNECTION "connection"

-#define SPDY_HTTP_HEADER_CONTENT_ENCODING "content-encoding"

-#define SPDY_HTTP_HEADER_CONTENT_LANGUAGE "content-language"

-#define SPDY_HTTP_HEADER_CONTENT_LENGTH "content-length"

-#define SPDY_HTTP_HEADER_CONTENT_LOCATION "content-location"

-#define SPDY_HTTP_HEADER_CONTENT_MD5 "content-md5"

-#define SPDY_HTTP_HEADER_CONTENT_RANGE "content-range"

-#define SPDY_HTTP_HEADER_CONTENT_TYPE "content-type"

-#define SPDY_HTTP_HEADER_COOKIE "cookie"

-#define SPDY_HTTP_HEADER_DATE "date"

-#define SPDY_HTTP_HEADER_ETAG "etag"

-#define SPDY_HTTP_HEADER_EXPECT "expect"

-#define SPDY_HTTP_HEADER_EXPIRES "expires"

-#define SPDY_HTTP_HEADER_FROM "from"

-/* Host header is forbidden in SPDY */

-#define SPDY_HTTP_HEADER_HOST "host"

-#define SPDY_HTTP_HEADER_IF_MATCH "if-match"

-#define SPDY_HTTP_HEADER_IF_MODIFIED_SINCE "if-modified-since"

-#define SPDY_HTTP_HEADER_IF_NONE_MATCH "if-none-match"

-#define SPDY_HTTP_HEADER_IF_RANGE "if-range"

-#define SPDY_HTTP_HEADER_IF_UNMODIFIED_SINCE "if-unmodified-since"

-/* Keep-Alive header is forbidden in SPDY */

-#define SPDY_HTTP_HEADER_KEEP_ALIVE "keep-alive"

-#define SPDY_HTTP_HEADER_LAST_MODIFIED "last-modified"

-#define SPDY_HTTP_HEADER_LOCATION "location"

-#define SPDY_HTTP_HEADER_MAX_FORWARDS "max-forwards"

-#define SPDY_HTTP_HEADER_PRAGMA "pragma"

-#define SPDY_HTTP_HEADER_PROXY_AUTHENTICATE "proxy-authenticate"

-#define SPDY_HTTP_HEADER_PROXY_AUTHORIZATION "proxy-authorization"

-/* Proxy-Connection header is forbidden in SPDY */

-#define SPDY_HTTP_HEADER_PROXY_CONNECTION "proxy-connection"

-#define SPDY_HTTP_HEADER_RANGE "range"

-#define SPDY_HTTP_HEADER_REFERER "referer"

-#define SPDY_HTTP_HEADER_RETRY_AFTER "retry-after"

-#define SPDY_HTTP_HEADER_SERVER "server"

-#define SPDY_HTTP_HEADER_SET_COOKIE "set-cookie"

-#define SPDY_HTTP_HEADER_SET_COOKIE2 "set-cookie2"

-#define SPDY_HTTP_HEADER_TE "te"

-#define SPDY_HTTP_HEADER_TRAILER "trailer"

-/* Transfer-Encoding header is forbidden in SPDY */

-#define SPDY_HTTP_HEADER_TRANSFER_ENCODING "transfer-encoding"

-#define SPDY_HTTP_HEADER_UPGRADE "upgrade"

-#define SPDY_HTTP_HEADER_USER_AGENT "user-agent"

-#define SPDY_HTTP_HEADER_VARY "vary"

-#define SPDY_HTTP_HEADER_VIA "via"

-#define SPDY_HTTP_HEADER_WARNING "warning"

-#define SPDY_HTTP_HEADER_WWW_AUTHENTICATE "www-authenticate"

-

-/**

- * HTTP versions (a value must be provided in SPDY requests/responses).

- */

-#define SPDY_HTTP_VERSION_1_0 "HTTP/1.0"

-#define SPDY_HTTP_VERSION_1_1 "HTTP/1.1"

-

-/**

- * HTTP methods

- */

-#define SPDY_HTTP_METHOD_CONNECT "CONNECT"

-#define SPDY_HTTP_METHOD_DELETE "DELETE"

-#define SPDY_HTTP_METHOD_GET "GET"

-#define SPDY_HTTP_METHOD_HEAD "HEAD"

-#define SPDY_HTTP_METHOD_OPTIONS "OPTIONS"

-#define SPDY_HTTP_METHOD_POST "POST"

-#define SPDY_HTTP_METHOD_PUT "PUT"

-#define SPDY_HTTP_METHOD_TRACE "TRACE"

-

-/**

- * HTTP POST encodings, see also

- * http://www.w3.org/TR/html4/interact/forms.html#h-17.13.4

- */

-#define SPDY_HTTP_POST_ENCODING_FORM_URLENCODED "application/x-www-form-urlencoded"

-#define SPDY_HTTP_POST_ENCODING_MULTIPART_FORMDATA "multipart/form-data"

-

-

-/**

- * Handle for the daemon (listening on a socket).

- */

-struct SPDY_Daemon;

-

-

-/**

- * Handle for a SPDY session/connection.

- */

-struct SPDY_Session;

-

-

-/**

- * Handle for a SPDY request sent by a client. The structure has pointer

- * to the session's handler

- */

-struct SPDY_Request;

-

-

-/**

- * Handle for a response containing HTTP headers and data to be sent.

- * The structure has pointer to the session's handler

- * for this response.

- */

-struct SPDY_Response;

-

-

-/**

- * Collection of tuples of an HTTP header and values used in requests

- * and responses.

- */

-struct SPDY_NameValue;

-

-

-/**

- * Collection of tuples of a SPDY setting ID, value

- * and flags used to control the sessions.

- */

-struct SPDY_Settings;

-

-

-/**

- * SPDY IO sybsystem flags used by SPDY_init() and SPDY_deinit().<p>

- *

- * The values are used internally as flags, that is why they must be

- * powers of 2.

- */

-enum SPDY_IO_SUBSYSTEM

-{

-

-  /**

-   * No subsystem. For internal use.

-   */

-  SPDY_IO_SUBSYSTEM_NONE = 0,

-

-  /**

-   * Default TLS implementation provided by openSSL/libssl.

-   */

-  SPDY_IO_SUBSYSTEM_OPENSSL = 1,

-

-  /**

-   * No TLS is used.

-   */

-  SPDY_IO_SUBSYSTEM_RAW = 2

-};

-

-

-/**

- * SPDY daemon options. Passed in the varargs portion of

- * SPDY_start_daemon to customize the daemon. Each option must

- * be followed by a value of a specific type.<p>

- *

- * The values are used internally as flags, that is why they must be

- * powers of 2.

- */

-enum SPDY_DAEMON_OPTION

-{

-

-  /**

-   * No more options / last option.  This is used

-   * to terminate the VARARGs list.

-   */

-  SPDY_DAEMON_OPTION_END = 0,

-

-  /**

-   * Set a custom timeout for all connections.  Must be followed by

-   * a number of seconds, given as an 'unsigned int'.  Use

-   * zero for no timeout.

-   */

-  SPDY_DAEMON_OPTION_SESSION_TIMEOUT = 1,

-

-  /**

-   * Bind daemon to the supplied sockaddr. This option must be

-   * followed by a 'struct sockaddr *'.  The 'struct sockaddr*'

-   * should point to a 'struct sockaddr_in6' or to a

-   * 'struct sockaddr_in'.

-   */

-  SPDY_DAEMON_OPTION_SOCK_ADDR = 2,

-

-  /**

-   * Flags for the daemon. Must be followed by a SPDY_DAEMON_FLAG value

-   * which is the result of bitwise OR of desired flags.

-   */

-  SPDY_DAEMON_OPTION_FLAGS = 4,

-

-  /**

-   * IO subsystem type used by daemon and all its sessions. If not set,

-   * TLS provided by openssl is used. Must be followed by a

-   * SPDY_IO_SUBSYSTEM value.

-   */

-  SPDY_DAEMON_OPTION_IO_SUBSYSTEM = 8,

-

-  /**

-   * Maximum number of frames to be written to the socket at once. The

-   * library tries to send max_num_frames in a single call to SPDY_run

-   * for a single session. This means no requests can be received nor

-   * other sessions can send data as long the current one has enough

-   * frames to send and there is no error on writing. Thus, a big value

-   * will affect the performance. Small value gives fairnes for sessions.

-   * Must be followed by a positive integer (uin32_t). If not set, the

-   * default value 10 will be used.

-   */

-  SPDY_DAEMON_OPTION_MAX_NUM_FRAMES = 16

-};

-

-

-/**

- * Flags for starting SPDY daemon. They are used to set some settings

- * for the daemon, which do not require values.

- */

-enum SPDY_DAEMON_FLAG

-{

-  /**

-   * No flags selected.

-   */

-  SPDY_DAEMON_FLAG_NO = 0,

-

-  /**

-   * The server will bind only on IPv6 addresses. If the flag is set and

-   * the daemon is provided with IPv4 address or IPv6 is not supported,

-   * starting daemon will fail.

-   */

-  SPDY_DAEMON_FLAG_ONLY_IPV6 = 1,

-

-  /**

-   * All sessions' sockets will be set with TCP_NODELAY if the flag is

-   * used. Option considered only by SPDY_IO_SUBSYSTEM_RAW.

-   */

-  SPDY_DAEMON_FLAG_NO_DELAY = 2

-};

-

-

-/**

- * SPDY settings IDs sent by both client and server in SPDY SETTINGS frame.

- * They affect the whole SPDY session. Defined in SPDY Protocol - Draft 3.

- */

-enum SPDY_SETTINGS

-{

-

-  /**

-   * Allows the sender to send its expected upload bandwidth on this

-   * channel. This number is an estimate. The value should be the

-   * integral number of kilobytes per second that the sender predicts

-   * as an expected maximum upload channel capacity.

-   */

-  SPDY_SETTINGS_UPLOAD_BANDWIDTH = 1,

-

-  /**

-   * Allows the sender to send its expected download bandwidth on this

-   * channel. This number is an estimate. The value should be the

-   * integral number of kilobytes per second that the sender predicts as

-   * an expected maximum download channel capacity.

-   */

-  SPDY_SETTINGS_DOWNLOAD_BANDWIDTH = 2,

-

-  /**

-   * Allows the sender to send its expected round-trip-time on this

-   * channel. The round trip time is defined as the minimum amount of

-   * time to send a control frame from this client to the remote and

-   * receive a response. The value is represented in milliseconds.

-   */

-  SPDY_SETTINGS_ROUND_TRIP_TIME = 3,

-

-  /**

-   * Allows the sender to inform the remote endpoint the maximum number

-   * of concurrent streams which it will allow. By default there is no

-   * limit. For implementors it is recommended that this value be no

-   * smaller than 100.

-   */

-  SPDY_SETTINGS_MAX_CONCURRENT_STREAMS = 4,

-

-  /**

-   * Allows the sender to inform the remote endpoint of the current TCP

-   * CWND value.

-   */

-  SPDY_SETTINGS_CURRENT_CWND = 5,

-

-  /**

-   * Allows the sender to inform the remote endpoint the retransmission

-   * rate (bytes retransmitted / total bytes transmitted).

-   */

-  SPDY_SETTINGS_DOWNLOAD_RETRANS_RATE = 6,

-

-  /**

-   * Allows the sender to inform the remote endpoint the initial window

-   * size (in bytes) for new streams.

-   */

-  SPDY_SETTINGS_INITIAL_WINDOW_SIZE = 7,

-

-  /**

-   * Allows the server to inform the client if the new size of the

-   * client certificate vector.

-   */

-  SPDY_SETTINGS_CLIENT_CERTIFICATE_VECTOR_SIZE = 8

-};

-

-

-/**

- * Flags for each individual SPDY setting in the SPDY SETTINGS frame.

- * They affect only one setting to which they are set.

- * Defined in SPDY Protocol - Draft 3.

- */

-enum SPDY_FLAG_SETTINGS

-{

-

-  /**

-   * When set, the sender of this SETTINGS frame is requesting that the

-   * recipient persist the ID/Value and return it in future SETTINGS

-   * frames sent from the sender to this recipient. Because persistence

-   * is only implemented on the client, this flag is only sent by the

-   * server.

-   */

-  SPDY_FLAG_SETTINGS_PERSIST_VALUE = 1,

-

-  /**

-   * When set, the sender is notifying the recipient that this ID/Value

-   * pair was previously sent to the sender by the recipient with the

-   * #SPDY_FLAG_SETTINGS_PERSIST_VALUE, and the sender is returning it.

-   * Because persistence is only implemented on the client, this flag is

-   * only sent by the client.

-   */

-  SPDY_FLAG_SETTINGS_PERSISTED = 2

-};

-

-

-/**

- * Flag associated with a whole SPDY SETTINGS frame. Affect all the

- * settings in the frame. Defined in SPDY Protocol - Draft 3.

- */

-enum SPDY_FLAG_SETTINGS_FRAME

-{

-

-  /**

-   * When set, the client should clear any previously persisted SETTINGS

-   * ID/Value pairs. If this frame contains ID/Value pairs with the

-   * #SPDY_FLAG_SETTINGS_PERSIST_VALUE set, then the client will first

-   * clear its existing, persisted settings, and then persist the values

-   * with the flag set which are contained within this frame. Because

-   * persistence is only implemented on the client, this flag can only

-   * be used when the sender is the server.

-   */

-  SPDY_FLAG_SETTINGS_CLEAR_SETTINGS = 1

-};

-

-

-/**

- * SPDY settings function options. Passed in the varargs portion of

- * SPDY_SettingsReceivedCallback and SPDY_send_settings to customize

- * more the settings handling. Each option must

- * be followed by a value of a specific type.<p>

- *

- * The values are used internally as flags, that is why they must be

- * powers of 2.

- */

-enum SPDY_SETTINGS_OPTION

-{

-

-  /**

-   * No more options / last option.  This is used

-   * to terminate the VARARGs list.

-   */

-  SPDY_SETTINGS_OPTION_END = 0

-};

-

-

-/**

- * Used as a parameter for SPDY_ResponseResultCallback and shows if the

- * response was actually written to the TLS socket or discarded by the

- * lib for any reason (and respectively the reason).

- */

-enum SPDY_RESPONSE_RESULT

-{

-

-  /**

-   * The lib has written the full response to the TLS socket.

-   */

-  SPDY_RESPONSE_RESULT_SUCCESS = 0,

-

-  /**

-   * The session is being closed, so the data is being discarded

-   */

-  SPDY_RESPONSE_RESULT_SESSION_CLOSED = 1,

-

-  /**

-   * The stream for this response has been closed. May happen when the

-   * sender had sent first SYN_STREAM and after that RST_STREAM.

-   */

-  SPDY_RESPONSE_RESULT_STREAM_CLOSED = 2

-};

-

-

-/**

- * Callback for serious error condition. The default action is to print

- * an error message and abort().

- *

- * @param cls user specified value

- * @param file where the error occured

- * @param line where the error occured

- * @param reason error details message, may be NULL

- */

-typedef void

-(*SPDY_PanicCallback) (void * cls,

-                       const char *file,

-                       unsigned int line,

-                       const char *reason);

-

-

-/**

- * Callback for new SPDY session established by a client. Called

- * immediately after the TCP connection was established.

- *

- * @param cls client-defined closure

- * @param session handler for the new SPDY session

- */

-typedef void

-(*SPDY_NewSessionCallback) (void * cls,

-                            struct SPDY_Session * session);

-

-

-/**

- * Callback for closed session. Called after the TCP connection was

- * closed. In this callback function the user has the last

- * chance to access the SPDY_Session structure. After that the latter

- * will be cleaned!

- *

- * @param cls client-defined closure

- * @param session handler for the closed SPDY session

- * @param by_client #SPDY_YES if the session close was initiated by the

- *                                      client;

- *                  #SPDY_NO if closed by the server

- */

-typedef void

-(*SPDY_SessionClosedCallback) (void *cls,

-                               struct SPDY_Session *session,

-                               int by_client);

-

-

-/**

- * Iterator over name-value pairs.

- *

- * @param cls client-defined closure

- * @param name of the pair

- * @param value of the pair

- * @return #SPDY_YES to continue iterating,

- *         #SPDY_NO to abort the iteration

- */

-typedef int

-(*SPDY_NameValueIterator) (void *cls,

-                           const char *name,

-                           const char * const * value,

-                           int num_values);

-

-

-/**

- * Callback for received SPDY request. The functions is called whenever

- * a reqest comes, but will also be called if more headers/trailers are

- * received.

- *

- * @param cls client-defined closure

- * @param request handler. The request object is required for

- *                      sending responses.

- * @param priority of the SPDY stream which the request was

- *                      sent over

- * @param method HTTP method

- * @param path HTTP path

- * @param version HTTP version just like in HTTP request/response:

- *                      "HTTP/1.0" or "HTTP/1.1" currently

- * @param host called host as in HTTP

- * @param scheme used ("http" or "https"). In SPDY 3 it is only "https".

- * @param headers other HTTP headers from the request

- * @param more a flag saying if more data related to the request is

- *        expected to be received. HTTP body may arrive (e.g. POST data);

- *        then SPDY_NewDataCallback will be called for the connection.

- *        It is also possible that more headers/trailers arrive;

- *        then the same callback will be invoked. The user should detect

- *        that it is not the first invocation of the function for that

- *        request.

- */

-typedef void

-(*SPDY_NewRequestCallback) (void *cls,

-                            struct SPDY_Request *request,

-                            uint8_t priority,

-                            const char *method,

-                            const char *path,

-                            const char *version,

-                            const char *host,

-                            const char *scheme,

-                            struct SPDY_NameValue *headers,

-                            bool more);

-

-

-/**

- * Callback for received new data chunk (HTTP body) from a given

- * request (e.g. POST data).

- *

- * @param cls client-defined closure

- * @param request handler

- * @param buf data chunk from the POST data

- * @param size the size of the data chunk 'buf' in bytes. Note that it

- *             may be 0.

- * @param more false if this is the last chunk from the data. Note:

- *             true does not mean that more data will come, exceptional

- *             situation is possible

- * @return #SPDY_YES to continue calling the function,

- *         #SPDY_NO to stop calling the function for this request

- */

-typedef int

-(*SPDY_NewDataCallback) (void *cls,

-                         struct SPDY_Request *request,

-                         const void *buf,

-                         size_t size,

-                         bool more);

-// How about passing POST encoding information

-// here as well?

-//TODO

-

-

-/**

- * Callback to be used with SPDY_build_response_with_callback. The

- * callback will be called when the lib wants to write to the TLS socket.

- * The application should provide the data to be sent.

- *

- * @param cls client-defined closure

- * @param max maximum number of bytes that are allowed to be written

- *                      to the buffer.

- * @param more true if more data will be sent (i.e. the function must

- *                              be calleed again),

- *             false if this is the last chunk, the lib will close

- *                              the stream

- * @return number of bytes written to buffer. On error the call MUST

- *                      return value less than 0 to indicate the library.

- */

-typedef ssize_t

-(*SPDY_ResponseCallback) (void *cls,

-                          void *buffer,

-                          size_t max,

-                          bool *more);

-

-

-/**

- * Callback to be called when the last bytes from the response was sent

- * to the client or when the response was discarded from the lib. This

- * callback is a very good place to discard the request and the response

- * objects, if they will not be reused (e.g., sending the same response

- * again). If the stream is closed it is safe to discard the request

- * object.

- *

- * @param cls client-defined closure

- * @param response handler to the response that was just sent

- * @param request handler to the request for which the response was sent

- * @param status shows if actually the response was sent or it was

- *                      discarded by the lib for any reason (e.g., closing session,

- *                      closing stream, stopping daemon, etc.). It is possible that

- *                      status indicates an error but parts of the response headers

- *                      and/or body (in one

- *                      or several frames) were already sent to the client.

- * @param streamopened indicates if the the stream for this request/

- *                      response pair is still opened. If yes, the server may want

- *                      to use SPDY push to send something additional to the client

- *                      and/or close the stream.

- */

-typedef void

-(*SPDY_ResponseResultCallback) (void * cls,

-                                struct SPDY_Response *response,

-                                struct SPDY_Request *request,

-                                enum SPDY_RESPONSE_RESULT status,

-                                bool streamopened);

-

-

-/**

- * Callback to notify when SPDY ping response is received.

- *

- * @param session handler for which the ping request was sent

- * @param rtt the timespan between sending ping request and receiving it

- *                      from the library

- */

-typedef void

-(*SPDY_PingCallback) (void * cls,

-                      struct SPDY_Session *session,

-                      struct timeval *rtt);

-

-

-/**

- * Iterator over settings ID/Value/Flags tuples.

- *

- * @param cls client-defined closure

- * @param id SPDY settings ID

- * @param value value for this setting

- * @param flags flags for this tuple; use

- *                      `enum SPDY_FLAG_SETTINGS`

- * @return #SPDY_YES to continue iterating,

- *         #SPDY_NO to abort the iteration

- */

-typedef int

-(*SPDY_SettingsIterator) (void *cls,

-                          enum SPDY_SETTINGS id,

-                          int32_t value,

-                          uint8_t flags);

-

-

-/**

- * Callback to notify when SPDY SETTINGS are received from the client.

- *

- * @param session handler for which settings are received

- * @param settings ID/value/flags tuples of the settings

- * @param flags for the whole settings frame; use

- *                      enum SPDY_FLAG_SETTINGS_FRAME

- * @param ... list of options (type-value pairs,

- *        terminated with #SPDY_SETTINGS_OPTION_END).

- */

-typedef void

-(*SPDY_SettingsReceivedCallback) (struct SPDY_Session *session,

-                                  struct SPDY_Settings *settings,

-                                  uint8_t flags,

-                                  ...);

-

-

-/* Global functions for the library */

-

-

-/**

- * Init function for the whole library. It MUST be called before any

- * other function of the library to initialize things like TLS context

- * and possibly other stuff needed by the lib. Currently the call

- * always returns #SPDY_YES.

- *

- * @param io_subsystem the IO subsystem that will

- *        be initialized. Several can be used with bitwise OR. If no

- *        parameter is set, the default openssl subsystem will be used.

- * @return #SPDY_YES if the library was correctly initialized and its

- *                      functions can be used now;

- *                      #SPDY_NO on error

- */

-_MHD_EXTERN int

-(SPDY_init) (enum SPDY_IO_SUBSYSTEM io_subsystem, ...);

-#define SPDY_init() SPDY_init (SPDY_IO_SUBSYSTEM_OPENSSL)

-

-

-/**

- * Deinit function for the whole lib. It can be called after finishing

- * using the library. It frees and cleans up resources allocated in

- * SPDY_init. Currently the function does not do anything.

- */

-_MHD_EXTERN void

-SPDY_deinit (void);

-

-

-/**

- * Sets the global error handler to a different implementation. "cb"

- * will only be called in the case of typically fatal, serious

- * internal consistency issues.  These issues should only arise in the

- * case of serious memory corruption or similar problems with the

- * architecture as well as failed assertions.  While "cb" is allowed to

- * return and the lib will then try to continue, this is never safe.

- *

- * The default implementation that is used if no panic function is set

- * simply prints an error message and calls "abort".  Alternative

- * implementations might call "exit" or other similar functions.

- *

- * @param cb new error handler

- * @param cls passed to error handler

- */

-_MHD_EXTERN void

-SPDY_set_panic_func (SPDY_PanicCallback cb,

-                     void *cls);

-

-

-/* Daemon functions */

-

-

-/**

- * Start a SPDY webserver on the given port.

- *

- * @param port to bind to. The value is ignored if address structure

- *                      is passed as daemon option

- * @param certfile path to the certificate that will be used by server

- * @param keyfile path to the keyfile for the certificate

- * @param nscb callback called when a new SPDY session is

- *                      established     by a client

- * @param sccb callback called when a session is closed

- * @param nrcb callback called when a client sends request

- * @param npdcb callback called when HTTP body (POST data) is received

- *                      after request

- * @param cls common extra argument to all of the callbacks

- * @param ... list of options (type-value pairs,

- *        terminated with #SPDY_DAEMON_OPTION_END).

- * @return NULL on error, handle to daemon on success

- */

-_MHD_EXTERN struct SPDY_Daemon *

-SPDY_start_daemon (uint16_t port,

-                   const char *certfile,

-                   const char *keyfile,

-                   SPDY_NewSessionCallback nscb,

-                   SPDY_SessionClosedCallback sccb,

-                   SPDY_NewRequestCallback nrcb,

-                   SPDY_NewDataCallback npdcb,

-                   void *cls,

-                   ...);

-

-

-/**

- * Shutdown the daemon. First all sessions are closed. It is NOT safe

- * to call this function in user callbacks.

- *

- * @param daemon to stop

- */

-_MHD_EXTERN void

-SPDY_stop_daemon (struct SPDY_Daemon *daemon);

-

-

-/**

- * Obtain the select sets for this daemon. Only those are retrieved,

- * which some processing should be done for, i.e. not all sockets are

- * added to write_fd_set.<p>

- *

- * It is possible that there is

- * nothing to be read from a socket but there is data either in the

- * TLS subsystem's read buffers or in libmicrospdy's read buffers, which

- * waits for being processed. In such case the file descriptor will be

- * added to write_fd_set. Since it is very likely for the socket to be

- * ready for writing, the select used in the application's event loop

- * will return with success, SPDY_run will be called, the data will be

- * processed and maybe something will be written to the socket. Without

- * this behaviour, considering a proper event loop, data may stay in the

- * buffers, but run is never called.

- *

- * @param daemon to get sets from

- * @param read_fd_set read set

- * @param write_fd_set write set

- * @param except_fd_set except set

- * @return largest FD added to any of the sets

- */

-_MHD_EXTERN int

-SPDY_get_fdset (struct SPDY_Daemon *daemon,

-                fd_set *read_fd_set,

-                fd_set *write_fd_set,

-                fd_set *except_fd_set);

-

-

-/**

- * Obtain timeout value for select for this daemon. The returned value

- * is how long select

- * should at most block, not the timeout value set for connections.

- *

- * @param daemon to query for timeout

- * @param timeout will be set to the timeout value (in milliseconds)

- * @return #SPDY_YES on success

- *         #SPDY_NO if no connections exist that

- *                      would necessiate the use of a timeout right now

- */

-_MHD_EXTERN int

-SPDY_get_timeout (struct SPDY_Daemon *daemon,

-                  unsigned long long *timeout);

-

-

-/**

- * Run webserver operations. This method must be called in

- * the client event loop.

- *

- * @param daemon to run

- */

-_MHD_EXTERN void

-SPDY_run (struct SPDY_Daemon *daemon);

-

-

-/* SPDY Session handling functions */

-

-

-/**

- * Closes a SPDY session. SPDY clients and servers are expected to keep

- * sessions opened as long as possible. However, the server may want to

- * close some connections, e.g. if there are too many, to free some

- * resources. The function can also be used to close a specific session

- * if the client is not desired.

- *

- * @param session handler to be closed

- */

-_MHD_EXTERN void

-SPDY_close_session (struct SPDY_Session * session);

-

-

-/**

- * Associate a void pointer with a session. The data accessible by the

- * pointer can later be used wherever the session handler is available.

- *

- * @param session handler

- * @param cls any data pointed by a pointer to be accessible later

- */

-_MHD_EXTERN void

-SPDY_set_cls_to_session (struct SPDY_Session *session,

-                         void *cls);

-

-

-/**

- * Retrieves the pointer associated with SPDY_set_cls_to_session().

- *

- * @param session handler to get its cls

- * @return same pointer added by SPDY_set_cls_to_session() or

- *                      NULL when nothing was associated

- */

-_MHD_EXTERN void *

-SPDY_get_cls_from_session (struct SPDY_Session *session);

-

-

-/**

- * Retrieves the remote address of a given session.

- *

- * @param session handler to get its remote address

- * @param addr out parameter; pointing to remote address

- * @return length of the address structure

- */

-_MHD_EXTERN socklen_t

-SPDY_get_remote_addr (struct SPDY_Session *session,

-                      struct sockaddr **addr);

-

-

-/* SPDY name/value data structure handling functions */

-

-

-/**

- * Create a new NameValue structure. It is needed for putting inside the

- * HTTP headers and their values for a response. The user should later

- * destroy alone the structure.

- *

- * @return handler to the new empty structure or NULL on error

- */

-_MHD_EXTERN struct SPDY_NameValue *

-SPDY_name_value_create (void);

-

-

-/**

- * Add name/value pair to a NameValue structure. SPDY_NO will be returned

- * if the name/value pair is already in the structure. It is legal to

- * add different values for the same name.

- *

- * @param container structure to which the new pair is added

- * @param name for the value. Null-terminated string.

- * @param value the value itself. Null-terminated string.

- * @return #SPDY_NO on error or #SPDY_YES on success

- */

-_MHD_EXTERN int

-SPDY_name_value_add (struct SPDY_NameValue *container,

-                     const char *name,

-                     const char *value);

-

-

-/**

- * Lookup value for a name in a name/value structure.

- *

- * @param container structure in which to lookup

- * @param name the name to look for

- * @param num_values length of the returned array with values

- * @return NULL if no such item was found, or an array containing the

- *                      values

- */

-_MHD_EXTERN const char * const *

-SPDY_name_value_lookup (struct SPDY_NameValue *container,

-                        const char *name,

-                        int *num_values);

-

-

-/**

- * Iterate over name/value structure.

- *

- * @param container structure which to iterate over

- * @param iterator callback to call on each name/value pair;

- *        maybe NULL (then just count headers)

- * @param iterator_cls extra argument to @a iterator

- * @return number of entries iterated over

- */

-_MHD_EXTERN int

-SPDY_name_value_iterate (struct SPDY_NameValue *container,

-                         SPDY_NameValueIterator iterator,

-                         void *iterator_cls);

-

-

-/**

- * Destroy a NameValue structure. Use this function to destroy only

- * objects which, after passed to, will not be destroied by other

- * functions.

- *

- */

-_MHD_EXTERN void

-SPDY_name_value_destroy (struct SPDY_NameValue *container);

-

-

-/* SPDY request handling functions */

-

-

-/**

- * Gets the session responsible for the given

- * request.

- *

- * @param request for which the session is wanted

- * @return session handler for the request

- */

-_MHD_EXTERN struct SPDY_Session *

-SPDY_get_session_for_request (const struct SPDY_Request *request);

-

-

-/**

- * Associate a void pointer with a request. The data accessible by the

- * pointer can later be used wherever the request handler is available.

- *

- * @param request with which to associate a pointer

- * @param cls any data pointed by a pointer to be accessible later

- */

-_MHD_EXTERN void

-SPDY_set_cls_to_request (struct SPDY_Request *request,

-                         void *cls);

-

-

-/**

- * Retrieves the pointer associated with the request by

- * SPDY_set_cls_to_request().

- *

- * @param request to get its cls

- * @return same pointer added by SPDY_set_cls_to_request() or

- *                      NULL when nothing was associated

- */

-_MHD_EXTERN void *

-SPDY_get_cls_from_request (struct SPDY_Request *request);

-

-

-/* SPDY response handling functions */

-

-

-/**

- * Create response object containing all needed headers and data. The

- * response object is not bound to a request, so it can be used multiple

- * times with SPDY_queue_response() and schould be

- * destroied by calling the SPDY_destroy_response().<p>

- *

- * Currently the library does not provide compression of the body data.

- * It is up to the user to pass already compressed data and the

- * appropriate headers to this function when desired.

- *

- * @param status HTTP status code for the response (e.g. 404)

- * @param statustext HTTP status message for the response, which will

- *                      be appended to the status code (e.g. "OK"). Can be NULL

- * @param version HTTP version for the response (e.g. "http/1.1")

- * @param headers name/value structure containing additional HTTP headers.

- *                Can be NULL. Can be used multiple times, it is up to

- *                the user to destoy the object when not needed anymore.

- * @param data the body of the response. The lib will make a copy of it,

- *             so it is up to the user to take care of the memory

- *             pointed by data

- * @param size length of @a data. It can be 0, then the lib will send only

- *                              headers

- * @return NULL on error, handle to response object on success

- */

-_MHD_EXTERN struct SPDY_Response *

-SPDY_build_response (int status,

-                     const char *statustext,

-                     const char *version,

-                     struct SPDY_NameValue *headers,

-                     const void *data,

-                     size_t size);

-

-

-/**

- * Create response object containing all needed headers. The data will

- * be provided later when the lib calls the callback function (just

- * before writing it to the TLS socket). The

- * response object is not bound to a request, so it can be used multiple

- * times with SPDY_queue_response() and schould be

- * destroied by calling the SPDY_destroy_response().<p>

- *

- * Currently the library does not provide compression of the body data.

- * It is up to the user to pass already compressed data and the

- * appropriate headers to this function and the callback when desired.

- *

- * @param status HTTP status code for the response (e.g. 404)

- * @param statustext HTTP status message for the response, which will

- *                      be appended to the status code (e.g. "OK"). Can be NULL

- * @param version HTTP version for the response (e.g. "http/1.1")

- * @param headers name/value structure containing additional HTTP headers.

- *                Can be NULL. Can be used multiple times, it is up to

- *                the user to destoy the object when not needed anymore.

- * @param rcb callback to use to obtain response data

- * @param rcb_cls extra argument to @a rcb

- * @param block_size preferred block size for querying rcb (advisory only,

- *                   the lib will call rcb specifying the block size); clients

- *                   should pick a value that is appropriate for IO and

- *                   memory performance requirements. The function will

- *                   fail if the value is bigger than the maximum

- *                   supported value (SPDY_MAX_SUPPORTED_FRAME_SIZE).

- *                   Can be 0, then the lib will use

- *                   #SPDY_MAX_SUPPORTED_FRAME_SIZE instead.

- * @return NULL on error, handle to response object on success

- */

-_MHD_EXTERN struct SPDY_Response *

-SPDY_build_response_with_callback(int status,

-                                  const char *statustext,

-                                  const char *version,

-                                  struct SPDY_NameValue *headers,

-                                  SPDY_ResponseCallback rcb,

-                                  void *rcb_cls,

-                                  uint32_t block_size);

-

-

-/**

- * Queue response object to be sent to the client. A successfully queued

- * response may never be sent, e.g. when the stream gets closed. The

- * data will be added to the output queue. The call will fail, if the

- * output for this session

- * is closed (i.e. the session is closed, half or full) or the output

- * channel for the stream, on which the request was received, is closed

- * (i.e. the stream is closed, half or full).

- *

- * @param request object identifying the request to which the

- *                      response is returned

- * @param response object containg headers and data to be sent

- * @param closestream TRUE if the server does NOT intend to PUSH

- *                      something more associated to this request/response later,

- *                      FALSE otherwise

- * @param consider_priority if FALSE, the response will be added to the

- *                      end of the queue. If TRUE, the response will be added after

- *                      the last previously added response with priority of the

- *                      request grater or equal to that of the current one. This

- *                      means that the function should be called with TRUE each time

- *                      if one wants to be sure that the output queue behaves like

- *                      a priority queue

- * @param rrcb callback called when all the data was sent (last frame

- *                      from response) or when that frame was discarded (e.g. the

- *                      stream has been closed meanwhile)

- * @param rrcb_cls extra argument to @a rrcb

- * @return #SPDY_NO on error or #SPDY_YES on success

- */

-_MHD_EXTERN int

-SPDY_queue_response (struct SPDY_Request *request,

-                     struct SPDY_Response *response,

-                     bool closestream,

-                     bool consider_priority,

-                     SPDY_ResponseResultCallback rrcb,

-                     void *rrcb_cls);

-

-

-/**

- * Destroy a response structure. It should be called for all objects

- * returned by SPDY_build_response*() functions to free the memory

- * associated with the prepared response. It is safe to call this

- * function not before being sure that the response will not be used by

- * the lib anymore, this means after SPDY_ResponseResultCallback

- * callbacks were called for all calls to SPDY_queue_response() passing

- * this response.

- *

- * @param response to destroy

- */

-_MHD_EXTERN void

-SPDY_destroy_response (struct SPDY_Response *response);

-

-

-/* SPDY settings ID/value data structure handling functions */

-

-

-/**

- * Create a new SettingsIDValue structure. It is needed for putting

- * inside tuples of SPDY option, flags and value for sending to the

- * client.

- *

- * @return hendler to the new empty structure or NULL on error

- */

-_MHD_EXTERN const struct SPDY_Settings *

-SPDY_settings_create (void);

-

-

-/**

- * Add or update a tuple to a SettingsIDValue structure.

- *

- * @param container structure to which the new tuple is added

- * @param id SPDY settings ID that will be sent. If this ID already in

- *           container, the tupple for it will be updated (value and/or

- *           flags). If it is not in the container, a new tupple will be

- *           added.

- * @param flags SPDY settings flags applied only to this setting

- * @param value of the setting

- * @return #SPDY_NO on error

- *                      or #SPDY_YES if a new setting was added

- */

-_MHD_EXTERN int

-SPDY_settings_add (struct SPDY_Settings *container,

-                   enum SPDY_SETTINGS id,

-                   enum SPDY_FLAG_SETTINGS flags,

-                   int32_t value);

-

-

-/**

- * Lookup value and flags for an ID in a settings ID/value structure.

- *

- * @param container structure in which to lookup

- * @param id SPDY settings ID to search for

- * @param flags out param for SPDY settings flags for this setting;

- *                      check it against the flags in enum SPDY_FLAG_SETTINGS

- * @param value out param for the value of this setting

- * @return #SPDY_NO if the setting is not into the structure

- *                      or #SPDY_YES if it is into it

- */

-_MHD_EXTERN int

-SPDY_settings_lookup (const struct SPDY_Settings *container,

-                      enum SPDY_SETTINGS id,

-                      enum SPDY_FLAG_SETTINGS *flags,

-                      int32_t *value);

-

-

-/**

- * Iterate over settings ID/value structure.

- *

- * @param container structure which to iterate over

- * @param iterator callback to call on each ID/value pair;

- *        maybe NULL (then just count number of settings)

- * @param iterator_cls extra argument to iterator

- * @return number of entries iterated over

- */

-_MHD_EXTERN int

-SPDY_settings_iterate (const struct SPDY_Settings *container,

-                       SPDY_SettingsIterator iterator,

-                       void *iterator_cls);

-

-

-/**

- * Destroy a settings ID/value structure. Use this function to destroy

- * only objects which, after passed to, will not be destroied by other

- * functions.

- *

- * @param container structure which to detroy

- */

-_MHD_EXTERN void

-SPDY_settings_destroy (struct SPDY_Settings * container);

-

-

-/* SPDY SETTINGS handling functions */

-

-

-/**

- * Send SPDY SETTINGS to the client. The call will return fail if there

- * in invald setting into the settings container (e.g. invalid setting

- * ID).

- *

- * @param session SPDY_Session handler for which settings are being sent

- * @param settings ID/value pairs of the settings to be sent.

- *                      Can be used multiple times, it is up to the user to destoy

- *                      the object when not needed anymore.

- * @param flags for the whole settings frame. They are valid for all tuples

- * @param ... list of options (type-value pairs,

- *        terminated with #SPDY_SETTINGS_OPTION_END).

- * @return SPDY_NO on error or SPDY_YES on

- *                      success

- */

-_MHD_EXTERN int

-SPDY_send_settings (struct SPDY_Session *session,

-                    struct SPDY_Settings *settings,

-                    enum SPDY_FLAG_SETTINGS_FRAME flags,

-                    ...);

-

-

-/* SPDY misc functions */

-

-

-/**

- * Destroy a request structure. It should be called for all objects

- * received as a parameter in SPDY_NewRequestCallback to free the memory

- * associated with the request. It is safe to call this

- * function not before being sure that the request will not be used by

- * the lib anymore, this means after the stream, on which this request

- * had been sent, was closed and all SPDY_ResponseResultCallback

- * callbacks were called for all calls to SPDY_queue_response() passing

- * this request object.

- *

- * @param request to destroy

- */

-_MHD_EXTERN void

-SPDY_destroy_request (struct SPDY_Request * request);

-

-

-/**

- * Send SPDY ping to the client

- *

- * @param session handler for which the ping request is sent

- * @param rttcb callback called when ping response to the request is

- *                      received

- * @param rttcb_cls extra argument to @a rttcb

- * @return #SPDY_NO on error or #SPDY_YES on success

- */

-_MHD_EXTERN int

-SPDY_send_ping (struct SPDY_Session *session,

-                SPDY_PingCallback rttcb,

-                void *rttcb_cls);

-

-#endif

diff --git a/src/microspdy/Makefile.am b/src/microspdy/Makefile.am
deleted file mode 100644
index 7fb2c37f..00000000
--- a/src/microspdy/Makefile.am
+++ /dev/null
@@ -1,40 +0,0 @@
-# This Makefile.am is in the public domain
-AM_CPPFLAGS = \
-  -I$(top_srcdir)/src/include \
-  -I$(top_srcdir)/src/microspdy
-
-AM_CFLAGS = $(HIDDEN_VISIBILITY_CFLAGS)
-
-
-lib_LTLIBRARIES = \
-  libmicrospdy.la
-
-libmicrospdy_la_SOURCES = \
-  io.h io.c \
-  io_openssl.h io_openssl.c \
-  io_raw.h io_raw.c \
-  structures.h structures.c \
-  internal.h internal.c \
-  daemon.h daemon.c \
-  stream.h stream.c \
-  compression.h compression.c \
-  session.h session.c \
-  applicationlayer.c applicationlayer.h \
-  alstructures.c alstructures.h 
-libmicrospdy_la_LIBADD = \
-  $(SPDY_LIBDEPS)
-
-libmicrospdy_la_LDFLAGS = \
-  $(SPDY_LIB_LDFLAGS)
-
-libmicrospdy_la_CPPFLAGS = \
-  $(AM_CPPFLAGS) $(SPDY_LIB_CPPFLAGS) \
-  -DBUILDING_MHD_LIB=1
-
-libmicrospdy_la_CFLAGS = -Wextra \
-  $(AM_CFLAGS) $(SPDY_LIB_CFLAGS)
-
-
-if USE_COVERAGE
-  AM_CFLAGS += --coverage
-endif
diff --git a/src/microspdy/alstructures.c b/src/microspdy/alstructures.c
deleted file mode 100644
index b588a1c8..00000000
--- a/src/microspdy/alstructures.c
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file alstructures.c
- * @brief  structures only for the application layer
- * @author Andrey Uzunov
- */
- 
-#include "platform.h"
-#include "alstructures.h"
-#include "internal.h"
-
-void
-SPDY_destroy_request (struct SPDY_Request *request)
-{
-        if(NULL == request)
-        {
-                SPDYF_DEBUG("request is NULL");
-                return;
-        }
-        //strings into request struct are just references to strings in
-        //headers, so no need to free them twice
-        SPDY_name_value_destroy(request->headers);
-        free(request);
-}
diff --git a/src/microspdy/alstructures.h b/src/microspdy/alstructures.h
deleted file mode 100644
index 2eb36e82..00000000
--- a/src/microspdy/alstructures.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file alstructures.h
- * @brief  structures only for the application layer
- * @author Andrey Uzunov
- */
-
-#ifndef ALSTRUCTURES_H
-#define ALSTRUCTURES_H
-
-#include "platform.h"
-
-
-/**
- * Represents a SPDY request.
- */
-struct SPDY_Request
-{
-        /**
-         * SPDY stream in whose context the request was received
-         */
-        struct SPDYF_Stream *stream;
-        
-        /**
-         * Other HTTP headers from the request
-         */
-        struct SPDY_NameValue *headers;
-        
-        /**
-         * HTTP method
-         */
-        char *method;
-        
-        /**
-         * HTTP path
-         */
-        char *path;
-        
-        /**
-         * HTTP version just like in HTTP request/response: 
-         *                      "HTTP/1.0" or "HTTP/1.1" currently
-         */
-        char *version;
-        
-        /**
-         * called host as in HTTP
-         */
-        char *host;
-        
-        /**
-         * The scheme used ("http" or "https")
-         */
-        char *scheme;
-
-        /**
-         * Extra field to be used by the user with set/get func for whatever
-         * purpose he wants.
-         */
-        void *user_cls;
-};
-
-#endif
diff --git a/src/microspdy/applicationlayer.c b/src/microspdy/applicationlayer.c
deleted file mode 100644
index bf16b785..00000000
--- a/src/microspdy/applicationlayer.c
+++ /dev/null
@@ -1,748 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file applicationlayer.c
- * @brief  SPDY application or HTTP layer
- * @author Andrey Uzunov
- */
- 
-#include "platform.h"
-#include "applicationlayer.h"
-#include "alstructures.h"
-#include "structures.h"
-#include "internal.h"
-#include "daemon.h"
-#include "session.h"
-
-
-void
-spdy_callback_response_done(void *cls,
-                                                struct SPDY_Response *response,
-                                                struct SPDY_Request *request,
-                                                enum SPDY_RESPONSE_RESULT status,
-                                                bool streamopened)
-{
-        (void)cls;
-        (void)status;
-        (void)streamopened;
-  
-        SPDY_destroy_request(request);
-        SPDY_destroy_response(response);
-}
-
-
-/**
- * Callback called when new stream is created. It extracts the info from
- * the stream to create (HTTP) request object and pass it to the client.
- *
- * @param cls
- * @param stream the new SPDY stream
- * @return SPDY_YES on success, SPDY_NO on memomry error
- */
-static int
-spdy_handler_new_stream (void *cls,
-                                                struct SPDYF_Stream * stream)
-{
-        (void)cls;
-        unsigned int i;
-        char *method = NULL;
-        char *path = NULL;
-        char *version = NULL;
-        char *host = NULL;
-        char *scheme = NULL;
-        struct SPDY_Request * request = NULL;
-        struct SPDY_NameValue * headers = NULL;
-        struct SPDY_NameValue * iterator = stream->headers;
-        struct SPDY_Daemon *daemon;
-        
-        daemon = stream->session->daemon;
-        
-        //if the user doesn't care, ignore it
-        if(NULL == daemon->new_request_cb)
-                return SPDY_YES;
-        
-        if(NULL == (headers=SPDY_name_value_create()))
-                goto free_and_fail;
-        
-        if(NULL==(request = malloc(sizeof(struct SPDY_Request))))
-                goto free_and_fail;
-        
-        memset(request, 0, sizeof(struct SPDY_Request));
-        request->stream = stream;
-        
-        /* extract the mandatory fields from stream->headers' structure
-         * to pass them to the client */
-        while(iterator != NULL)
-        {
-                if(strcmp(":method",iterator->name) == 0)
-                {
-                        if(1 != iterator->num_values)
-                                break;
-                        method = iterator->value[0];
-                }
-                else if(strcmp(":path",iterator->name) == 0)
-                {
-                        if(1 != iterator->num_values)
-                                break;
-                        path = iterator->value[0];
-                }
-                else if(strcmp(":version",iterator->name) == 0)
-                {
-                        if(1 != iterator->num_values)
-                                break;
-                        version = iterator->value[0];
-                }
-                else if(strcmp(":host",iterator->name) == 0)
-                {
-                        //TODO can it have more values?
-                        if(1 != iterator->num_values)
-                                break;
-                        host = iterator->value[0];
-                }
-                else if(strcmp(":scheme",iterator->name) == 0)
-                {
-                        if(1 != iterator->num_values)
-                                break;
-                        scheme = iterator->value[0];
-                }
-                else
-                        for(i=0; i<iterator->num_values; ++i)
-                                if (SPDY_YES != SPDY_name_value_add(headers,iterator->name,iterator->value[i]))
-        {
-          SPDY_destroy_request(request);
-                                        goto free_and_fail;
-        }
-                
-                iterator = iterator->next;
-        }
-        
-        request->method=method;
-  request->path=path;
-  request->version=version;
-  request->host=host;
-  request->scheme=scheme;
-  request->headers=headers;
-        
-        //check request validity, all these fields are mandatory for a request
-        if(NULL == method || strlen(method) == 0
-                || NULL == path || strlen(path) == 0
-                || NULL == version || strlen(version) == 0
-                || NULL == host || strlen(host) == 0
-                || NULL == scheme || strlen(scheme) == 0
-                )
-        {
-                //TODO HTTP 400 Bad Request must be answered
-                
-                SPDYF_DEBUG("Bad request");
-                
-                SPDY_destroy_request(request);
-                
-                return SPDY_YES;
-        }
-        
-        //call client's callback function to notify
-        daemon->new_request_cb(daemon->cls,
-                                                request,
-                                                stream->priority,
-                        method,
-                        path,
-                        version,
-                        host,
-                        scheme,
-                                                headers,
-            !stream->is_in_closed);
-            
-  stream->cls = request;
-
-        return SPDY_YES;
-
-        //for GOTO
-        free_and_fail:
-        
-        SPDY_name_value_destroy(headers);
-        return SPDY_NO;
-}
-
-
-/**
- * TODO
- */
-static int
-spdy_handler_new_data (void * cls,
-                                         struct SPDYF_Stream *stream,
-                                         const void * buf,
-                                         size_t size,
-                                         bool more)
-{
-  return stream->session->daemon->received_data_cb(cls, stream->cls, buf, size, more);
-}
-
-
-
-/**
- * Callback to be called when the response queue object was handled and 
- * the data was already sent or discarded. 
- *
- * @param cls
- * @param response_queue the object which is being handled
- * @param status shows if actually the response was sent or it was
- *                      discarded by the lib for any reason (e.g., closing session,
- *                      closing stream, stopping daemon, etc.). It is possible that
- *                      status indicates an error but parts of the response headers
- *                      and/or body (in one
- *                      or several frames) were already sent to the client.
- */
-static void
-spdy_handler_response_queue_result(void * cls,
-                                                                struct SPDYF_Response_Queue *response_queue,
-                                                                enum SPDY_RESPONSE_RESULT status)
-{
-        int streamopened;
-        struct SPDY_Request *request = (struct SPDY_Request *)cls;
-        
-        SPDYF_ASSERT( ( (NULL == response_queue->data_frame) &&
-                        (NULL != response_queue->control_frame) ) ||
-                      ( (NULL != response_queue->data_frame) &&
-                        (NULL == response_queue->control_frame) ),
-                     "response queue must have either control frame or data frame");
-        
-        streamopened = !response_queue->stream->is_out_closed;
-        
-        response_queue->rrcb(response_queue->rrcb_cls, response_queue->response, request, status, streamopened);
-}
-
-
-int
-(SPDY_init) (enum SPDY_IO_SUBSYSTEM io_subsystem, ...)
-{
-        SPDYF_ASSERT(SPDYF_BUFFER_SIZE >= SPDY_MAX_SUPPORTED_FRAME_SIZE,
-                "Buffer size is less than max supported frame size!");
-        SPDYF_ASSERT(SPDY_MAX_SUPPORTED_FRAME_SIZE >= 32,
-                "Max supported frame size must be bigger than the minimal value!");
-        SPDYF_ASSERT(SPDY_IO_SUBSYSTEM_NONE == spdyf_io_initialized,
-                "SPDY_init must be called only once per program or after SPDY_deinit");
-    
-  if(SPDY_IO_SUBSYSTEM_OPENSSL & io_subsystem)
-  {
-    SPDYF_openssl_global_init();
-    spdyf_io_initialized |= SPDY_IO_SUBSYSTEM_OPENSSL;
-  }
-  else if(SPDY_IO_SUBSYSTEM_RAW & io_subsystem)
-  {
-    SPDYF_raw_global_init();
-    spdyf_io_initialized |= SPDY_IO_SUBSYSTEM_RAW;
-  }
-  
-        SPDYF_ASSERT(SPDY_IO_SUBSYSTEM_NONE != spdyf_io_initialized,
-                "SPDY_init could not find even one IO subsystem");
-    
-        return SPDY_YES;
-}
-
-
-void
-SPDY_deinit ()
-{
-        SPDYF_ASSERT(SPDY_IO_SUBSYSTEM_NONE != spdyf_io_initialized,
-                "SPDY_init has not been called!");
-    
-  if(SPDY_IO_SUBSYSTEM_OPENSSL & spdyf_io_initialized)
-    SPDYF_openssl_global_deinit();
-  else if(SPDY_IO_SUBSYSTEM_RAW & spdyf_io_initialized)
-    SPDYF_raw_global_deinit();
-  
-  spdyf_io_initialized = SPDY_IO_SUBSYSTEM_NONE;
-}
-
-
-void 
-SPDY_run (struct SPDY_Daemon *daemon)
-{
-        if(NULL == daemon)
-        {
-                SPDYF_DEBUG("daemon is NULL");
-                return;
-        }
-        
-        SPDYF_run(daemon);
-}
-
-
-int
-SPDY_get_timeout (struct SPDY_Daemon *daemon, 
-                     unsigned long long *timeout)
-{
-        if(NULL == daemon)
-        {
-                SPDYF_DEBUG("daemon is NULL");
-                return SPDY_INPUT_ERROR;
-        }
-        
-        return SPDYF_get_timeout(daemon,timeout);
-}
-
-
-int
-SPDY_get_fdset (struct SPDY_Daemon *daemon,
-                                fd_set *read_fd_set,
-                                fd_set *write_fd_set, 
-                                fd_set *except_fd_set)
-{
-        if(NULL == daemon
-                || NULL == read_fd_set
-                || NULL == write_fd_set
-                || NULL == except_fd_set)
-        {
-                SPDYF_DEBUG("a parameter is NULL");
-                return SPDY_INPUT_ERROR;
-        }
-        
-        return SPDYF_get_fdset(daemon,
-                                read_fd_set,
-                                write_fd_set, 
-                                except_fd_set,
-                                false);
-}
-
-
-struct SPDY_Daemon *
-SPDY_start_daemon (uint16_t port,
-                                const char *certfile,
-                                const char *keyfile,
-                     SPDY_NewSessionCallback nscb,
-                     SPDY_SessionClosedCallback sccb,
-                     SPDY_NewRequestCallback nrcb,
-                     SPDY_NewDataCallback npdcb,
-                     void * cls,
-                     ...)
-{
-        struct SPDY_Daemon *daemon;
-        va_list valist;
-        
-        if(SPDY_IO_SUBSYSTEM_NONE == spdyf_io_initialized)
-        {
-                SPDYF_DEBUG("library not initialized");
-                return NULL;
-        }
-  /*
-   * for now make this checks in framing layer
-        if(NULL == certfile)
-        {
-                SPDYF_DEBUG("certfile is NULL");
-                return NULL;
-        }
-        if(NULL == keyfile)
-        {
-                SPDYF_DEBUG("keyfile is NULL");
-                return NULL;
-        }
-  */
-        
-        va_start(valist, cls);
-        daemon = SPDYF_start_daemon_va ( port,
-                                certfile,
-                                keyfile,
-                      nscb,
-                      sccb,
-                      nrcb,
-                      npdcb,
-                      &spdy_handler_new_stream,
-                      &spdy_handler_new_data,
-                      cls,
-                      NULL,
-                      valist
-                     );
-        va_end(valist);
-        
-        return daemon;
-}
-
-
-void 
-SPDY_stop_daemon (struct SPDY_Daemon *daemon)
-{       
-        if(NULL == daemon)
-        {
-                SPDYF_DEBUG("daemon is NULL");
-                return;
-        }
-
-        SPDYF_stop_daemon(daemon);
-}
-
-
-struct SPDY_Response *
-SPDY_build_response(int status,
-                                        const char * statustext,
-                                        const char * version,
-                                        struct SPDY_NameValue * headers,
-                                        const void * data,
-                                        size_t size)
-{
-        struct SPDY_Response *response = NULL;
-        struct SPDY_NameValue ** all_headers = NULL; //TODO maybe array in stack is enough
-        char *fullstatus = NULL;
-        int ret;
-        int num_hdr_containers = 1;
-        
-        if(NULL == version)
-        {
-                SPDYF_DEBUG("version is NULL");
-                return NULL;
-        }
-        
-        if(NULL == (response = malloc(sizeof(struct SPDY_Response))))
-                goto free_and_fail;
-        memset(response, 0, sizeof(struct SPDY_Response));
-        
-        if(NULL != headers && !SPDYF_name_value_is_empty(headers))
-                num_hdr_containers = 2;
-        
-        if(NULL == (all_headers = malloc(num_hdr_containers * sizeof(struct SPDY_NameValue *))))
-                goto free_and_fail;
-        memset(all_headers, 0, num_hdr_containers * sizeof(struct SPDY_NameValue *));
-        
-        if(2 == num_hdr_containers)
-                all_headers[1] = headers;
-        
-        if(NULL == (all_headers[0] = SPDY_name_value_create()))
-                goto free_and_fail;
-        
-        if(NULL == statustext)
-                ret = asprintf(&fullstatus, "%i", status);
-        else
-                ret = asprintf(&fullstatus, "%i %s", status, statustext); 
-        if(-1 == ret)
-                goto free_and_fail;
-                
-        if(SPDY_YES != SPDY_name_value_add(all_headers[0], ":status", fullstatus))
-                goto free_and_fail;
-                
-        free(fullstatus);
-        fullstatus = NULL;
-        
-        if(SPDY_YES != SPDY_name_value_add(all_headers[0], ":version", version))
-                goto free_and_fail;
-        
-        if(0 >= (response->headers_size = SPDYF_name_value_to_stream(all_headers,
-                                                                                                num_hdr_containers,
-                                                                                                &(response->headers))))
-                goto free_and_fail;
-                
-        SPDY_name_value_destroy(all_headers[0]);
-        free(all_headers);
-  all_headers = NULL;
-        
-        if(size > 0)
-        {
-                //copy the data to the response object
-                if(NULL == (response->data = malloc(size)))
-                {
-                        free(response->headers);
-                        goto free_and_fail;
-                }
-                memcpy(response->data, data, size);
-                response->data_size = size;
-        }
-        
-        return response;
-        
-        //for GOTO
-        free_and_fail:
-        
-        free(fullstatus);
-        if(NULL != all_headers)
-                SPDY_name_value_destroy(all_headers[0]);
-        free(all_headers);
-        free(response);
-        
-        return NULL;
-}
-
-
-struct SPDY_Response *
-SPDY_build_response_with_callback(int status,
-                                        const char * statustext,
-                                        const char * version,
-                                        struct SPDY_NameValue * headers,
-                                        SPDY_ResponseCallback rcb,
-                                        void *rcb_cls,
-                                        uint32_t block_size)
-{
-        struct SPDY_Response *response;
-        
-        if(NULL == rcb)
-        {
-                SPDYF_DEBUG("rcb is NULL");
-                return NULL;
-        }
-        if(block_size > SPDY_MAX_SUPPORTED_FRAME_SIZE)
-        {
-                SPDYF_DEBUG("block_size is wrong");
-                return NULL;
-        }
-        
-        if(0 == block_size)
-                block_size = SPDY_MAX_SUPPORTED_FRAME_SIZE;
-        
-        response = SPDY_build_response(status,
-                                        statustext,
-                                        version,
-                                        headers,
-                                        NULL,
-                                        0);
-        
-        if(NULL == response)
-        {
-                return NULL;
-        }
-                        
-        response->rcb = rcb;
-        response->rcb_cls = rcb_cls;
-        response->rcb_block_size = block_size;
-        
-        return response;
-}
-
-
-int
-SPDY_queue_response (struct SPDY_Request * request,
-                                        struct SPDY_Response *response,
-                                        bool closestream,
-                                        bool consider_priority,
-                                        SPDY_ResponseResultCallback rrcb,
-                                        void * rrcb_cls)
-{
-        struct SPDYF_Response_Queue *headers_to_queue;
-        struct SPDYF_Response_Queue *body_to_queue;
-        SPDYF_ResponseQueueResultCallback frqcb = NULL;
-        void *frqcb_cls = NULL;
-        int int_consider_priority = consider_priority ? SPDY_YES : SPDY_NO;
-        
-        if(NULL == request)
-        {
-                SPDYF_DEBUG("request is NULL");
-                return SPDY_INPUT_ERROR;
-        }
-        if(NULL == response)
-        {
-                SPDYF_DEBUG("request is NULL");
-                return SPDY_INPUT_ERROR;
-        }
-        
-        if(request->stream->is_out_closed
-                || SPDY_SESSION_STATUS_CLOSING == request->stream->session->status)
-                return SPDY_NO;
-        
-        if(NULL != rrcb)
-        {
-                frqcb_cls = request;
-                frqcb = &spdy_handler_response_queue_result;
-        }
-        
-        if(response->data_size > 0)
-        {       
-                //SYN_REPLY and DATA will be queued
-                
-                if(NULL == (headers_to_queue = SPDYF_response_queue_create(false,
-                                                        response->headers,
-                                                        response->headers_size,
-                                                        response,
-                                                        request->stream,
-                                                        false,
-                                                        NULL,
-                                                        NULL,
-                                                        NULL,
-                                                        NULL)))
-                {
-                        return SPDY_NO;
-                }
-                
-                if(NULL == (body_to_queue = SPDYF_response_queue_create(true,
-                                                        response->data,
-                                                        response->data_size,
-                                                        response,
-                                                        request->stream,
-                                                        closestream,
-                                                        frqcb,
-                                                        frqcb_cls,
-                                                        rrcb,
-                                                        rrcb_cls)))
-                {
-                        SPDYF_response_queue_destroy(headers_to_queue);
-                        return SPDY_NO;
-                }
-                                                        
-                SPDYF_queue_response (headers_to_queue,
-                                                        request->stream->session,
-                                                        int_consider_priority);
-                                                        
-                SPDYF_queue_response (body_to_queue,
-                                                        request->stream->session,
-                                                        int_consider_priority);
-        }
-        else if(NULL == response->rcb)
-        {
-                //no "body" will be queued, e.g. HTTP 404 without body
-                
-                if(NULL == (headers_to_queue = SPDYF_response_queue_create(false,
-                                                        response->headers,
-                                                        response->headers_size,
-                                                        response,
-                                                        request->stream,
-                                                        closestream,
-                                                        frqcb,
-                                                        frqcb_cls,
-                                                        rrcb,
-                                                        rrcb_cls)))
-                {
-                        return SPDY_NO;
-                }
-                                                        
-                SPDYF_queue_response (headers_to_queue,
-                                                        request->stream->session,
-                                                        int_consider_priority);
-        }
-        else
-        {
-                //response with callbacks
-                
-                if(NULL == (headers_to_queue = SPDYF_response_queue_create(false,
-                                                        response->headers,
-                                                        response->headers_size,
-                                                        response,
-                                                        request->stream,
-                                                        false,
-                                                        NULL,
-                                                        NULL,
-                                                        NULL,
-                                                        NULL)))
-                {
-                        return SPDY_NO;
-                }
-                
-                if(NULL == (body_to_queue = SPDYF_response_queue_create(true,
-                                                        response->data,
-                                                        response->data_size,
-                                                        response,
-                                                        request->stream,
-                                                        closestream,
-                                                        frqcb,
-                                                        frqcb_cls,
-                                                        rrcb,
-                                                        rrcb_cls)))
-                {
-                        SPDYF_response_queue_destroy(headers_to_queue);
-                        return SPDY_NO;
-                }
-                                                        
-                SPDYF_queue_response (headers_to_queue,
-                                                        request->stream->session,
-                                                        int_consider_priority);
-                                                        
-                SPDYF_queue_response (body_to_queue,
-                                                        request->stream->session,
-                                                        int_consider_priority);
-        }
-                
-        return SPDY_YES;
-}
-
-
-socklen_t
-SPDY_get_remote_addr(struct SPDY_Session * session,
-                                         struct sockaddr ** addr)
-{
-        if(NULL == session)
-        {
-                SPDYF_DEBUG("session is NULL");
-                return 0;
-        }
-        
-        *addr = session->addr;
-        
-        return session->addr_len;
-}
-
-
-struct SPDY_Session *
-SPDY_get_session_for_request(const struct SPDY_Request * request)
-{
-        if(NULL == request)
-        {
-                SPDYF_DEBUG("request is NULL");
-                return NULL;
-        }
-        
-        return request->stream->session;
-}
-
-
-void *
-SPDY_get_cls_from_session(struct SPDY_Session * session)
-{
-        if(NULL == session)
-        {
-                SPDYF_DEBUG("session is NULL");
-                return NULL;
-        }
-        
-        return session->user_cls;
-}
-
-
-void
-SPDY_set_cls_to_session(struct SPDY_Session * session,
-                                                        void * cls)
-{
-        if(NULL == session)
-        {
-                SPDYF_DEBUG("session is NULL");
-                return;
-        }
-        
-        session->user_cls = cls;
-}
-
-
-void *
-SPDY_get_cls_from_request(struct SPDY_Request * request)
-{
-        if(NULL == request)
-        {
-                SPDYF_DEBUG("request is NULL");
-                return NULL;
-        }
-        
-        return request->user_cls;
-}
-
-
-void
-SPDY_set_cls_to_request(struct SPDY_Request * request,
-                                                        void * cls)
-{
-        if(NULL == request)
-        {
-                SPDYF_DEBUG("request is NULL");
-                return;
-        }
-        
-        request->user_cls = cls;
-}
diff --git a/src/microspdy/applicationlayer.h b/src/microspdy/applicationlayer.h
deleted file mode 100644
index a36760fe..00000000
--- a/src/microspdy/applicationlayer.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file applicationlayer.h
- * @brief  SPDY application or HTTP layer
- * @author Andrey Uzunov
- */
-
-#ifndef APPLICATIONLAYER_H
-#define APPLICATIONLAYER_H
-
-#include "platform.h"
-
-
-#endif
diff --git a/src/microspdy/compression.c b/src/microspdy/compression.c
deleted file mode 100644
index 532ab64a..00000000
--- a/src/microspdy/compression.c
+++ /dev/null
@@ -1,441 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file compression.c
- * @brief  zlib handling functions
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include "structures.h"
-#include "internal.h"
-#include "compression.h"
-
-/* spdy ver 3 specific dictionary used by zlib */
-static const unsigned char
-spdyf_zlib_dictionary[] = {
-        0x00, 0x00, 0x00, 0x07, 0x6f, 0x70, 0x74, 0x69,   // - - - - o p t i
-        0x6f, 0x6e, 0x73, 0x00, 0x00, 0x00, 0x04, 0x68,   // o n s - - - - h
-        0x65, 0x61, 0x64, 0x00, 0x00, 0x00, 0x04, 0x70,   // e a d - - - - p
-        0x6f, 0x73, 0x74, 0x00, 0x00, 0x00, 0x03, 0x70,   // o s t - - - - p
-        0x75, 0x74, 0x00, 0x00, 0x00, 0x06, 0x64, 0x65,   // u t - - - - d e
-        0x6c, 0x65, 0x74, 0x65, 0x00, 0x00, 0x00, 0x05,   // l e t e - - - -
-        0x74, 0x72, 0x61, 0x63, 0x65, 0x00, 0x00, 0x00,   // t r a c e - - -
-        0x06, 0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x00,   // - a c c e p t -
-        0x00, 0x00, 0x0e, 0x61, 0x63, 0x63, 0x65, 0x70,   // - - - a c c e p
-        0x74, 0x2d, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65,   // t - c h a r s e
-        0x74, 0x00, 0x00, 0x00, 0x0f, 0x61, 0x63, 0x63,   // t - - - - a c c
-        0x65, 0x70, 0x74, 0x2d, 0x65, 0x6e, 0x63, 0x6f,   // e p t - e n c o
-        0x64, 0x69, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x0f,   // d i n g - - - -
-        0x61, 0x63, 0x63, 0x65, 0x70, 0x74, 0x2d, 0x6c,   // a c c e p t - l
-        0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x00,   // a n g u a g e -
-        0x00, 0x00, 0x0d, 0x61, 0x63, 0x63, 0x65, 0x70,   // - - - a c c e p
-        0x74, 0x2d, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x73,   // t - r a n g e s
-        0x00, 0x00, 0x00, 0x03, 0x61, 0x67, 0x65, 0x00,   // - - - - a g e -
-        0x00, 0x00, 0x05, 0x61, 0x6c, 0x6c, 0x6f, 0x77,   // - - - a l l o w
-        0x00, 0x00, 0x00, 0x0d, 0x61, 0x75, 0x74, 0x68,   // - - - - a u t h
-        0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f,   // o r i z a t i o
-        0x6e, 0x00, 0x00, 0x00, 0x0d, 0x63, 0x61, 0x63,   // n - - - - c a c
-        0x68, 0x65, 0x2d, 0x63, 0x6f, 0x6e, 0x74, 0x72,   // h e - c o n t r
-        0x6f, 0x6c, 0x00, 0x00, 0x00, 0x0a, 0x63, 0x6f,   // o l - - - - c o
-        0x6e, 0x6e, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e,   // n n e c t i o n
-        0x00, 0x00, 0x00, 0x0c, 0x63, 0x6f, 0x6e, 0x74,   // - - - - c o n t
-        0x65, 0x6e, 0x74, 0x2d, 0x62, 0x61, 0x73, 0x65,   // e n t - b a s e
-        0x00, 0x00, 0x00, 0x10, 0x63, 0x6f, 0x6e, 0x74,   // - - - - c o n t
-        0x65, 0x6e, 0x74, 0x2d, 0x65, 0x6e, 0x63, 0x6f,   // e n t - e n c o
-        0x64, 0x69, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x10,   // d i n g - - - -
-        0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d,   // c o n t e n t -
-        0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65,   // l a n g u a g e
-        0x00, 0x00, 0x00, 0x0e, 0x63, 0x6f, 0x6e, 0x74,   // - - - - c o n t
-        0x65, 0x6e, 0x74, 0x2d, 0x6c, 0x65, 0x6e, 0x67,   // e n t - l e n g
-        0x74, 0x68, 0x00, 0x00, 0x00, 0x10, 0x63, 0x6f,   // t h - - - - c o
-        0x6e, 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x6c, 0x6f,   // n t e n t - l o
-        0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00,   // c a t i o n - -
-        0x00, 0x0b, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e,   // - - c o n t e n
-        0x74, 0x2d, 0x6d, 0x64, 0x35, 0x00, 0x00, 0x00,   // t - m d 5 - - -
-        0x0d, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74,   // - c o n t e n t
-        0x2d, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x00,   // - r a n g e - -
-        0x00, 0x0c, 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e,   // - - c o n t e n
-        0x74, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x00, 0x00,   // t - t y p e - -
-        0x00, 0x04, 0x64, 0x61, 0x74, 0x65, 0x00, 0x00,   // - - d a t e - -
-        0x00, 0x04, 0x65, 0x74, 0x61, 0x67, 0x00, 0x00,   // - - e t a g - -
-        0x00, 0x06, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74,   // - - e x p e c t
-        0x00, 0x00, 0x00, 0x07, 0x65, 0x78, 0x70, 0x69,   // - - - - e x p i
-        0x72, 0x65, 0x73, 0x00, 0x00, 0x00, 0x04, 0x66,   // r e s - - - - f
-        0x72, 0x6f, 0x6d, 0x00, 0x00, 0x00, 0x04, 0x68,   // r o m - - - - h
-        0x6f, 0x73, 0x74, 0x00, 0x00, 0x00, 0x08, 0x69,   // o s t - - - - i
-        0x66, 0x2d, 0x6d, 0x61, 0x74, 0x63, 0x68, 0x00,   // f - m a t c h -
-        0x00, 0x00, 0x11, 0x69, 0x66, 0x2d, 0x6d, 0x6f,   // - - - i f - m o
-        0x64, 0x69, 0x66, 0x69, 0x65, 0x64, 0x2d, 0x73,   // d i f i e d - s
-        0x69, 0x6e, 0x63, 0x65, 0x00, 0x00, 0x00, 0x0d,   // i n c e - - - -
-        0x69, 0x66, 0x2d, 0x6e, 0x6f, 0x6e, 0x65, 0x2d,   // i f - n o n e -
-        0x6d, 0x61, 0x74, 0x63, 0x68, 0x00, 0x00, 0x00,   // m a t c h - - -
-        0x08, 0x69, 0x66, 0x2d, 0x72, 0x61, 0x6e, 0x67,   // - i f - r a n g
-        0x65, 0x00, 0x00, 0x00, 0x13, 0x69, 0x66, 0x2d,   // e - - - - i f -
-        0x75, 0x6e, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69,   // u n m o d i f i
-        0x65, 0x64, 0x2d, 0x73, 0x69, 0x6e, 0x63, 0x65,   // e d - s i n c e
-        0x00, 0x00, 0x00, 0x0d, 0x6c, 0x61, 0x73, 0x74,   // - - - - l a s t
-        0x2d, 0x6d, 0x6f, 0x64, 0x69, 0x66, 0x69, 0x65,   // - m o d i f i e
-        0x64, 0x00, 0x00, 0x00, 0x08, 0x6c, 0x6f, 0x63,   // d - - - - l o c
-        0x61, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00,   // a t i o n - - -
-        0x0c, 0x6d, 0x61, 0x78, 0x2d, 0x66, 0x6f, 0x72,   // - m a x - f o r
-        0x77, 0x61, 0x72, 0x64, 0x73, 0x00, 0x00, 0x00,   // w a r d s - - -
-        0x06, 0x70, 0x72, 0x61, 0x67, 0x6d, 0x61, 0x00,   // - p r a g m a -
-        0x00, 0x00, 0x12, 0x70, 0x72, 0x6f, 0x78, 0x79,   // - - - p r o x y
-        0x2d, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e, 0x74,   // - a u t h e n t
-        0x69, 0x63, 0x61, 0x74, 0x65, 0x00, 0x00, 0x00,   // i c a t e - - -
-        0x13, 0x70, 0x72, 0x6f, 0x78, 0x79, 0x2d, 0x61,   // - p r o x y - a
-        0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61,   // u t h o r i z a
-        0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x00, 0x05,   // t i o n - - - -
-        0x72, 0x61, 0x6e, 0x67, 0x65, 0x00, 0x00, 0x00,   // r a n g e - - -
-        0x07, 0x72, 0x65, 0x66, 0x65, 0x72, 0x65, 0x72,   // - r e f e r e r
-        0x00, 0x00, 0x00, 0x0b, 0x72, 0x65, 0x74, 0x72,   // - - - - r e t r
-        0x79, 0x2d, 0x61, 0x66, 0x74, 0x65, 0x72, 0x00,   // y - a f t e r -
-        0x00, 0x00, 0x06, 0x73, 0x65, 0x72, 0x76, 0x65,   // - - - s e r v e
-        0x72, 0x00, 0x00, 0x00, 0x02, 0x74, 0x65, 0x00,   // r - - - - t e -
-        0x00, 0x00, 0x07, 0x74, 0x72, 0x61, 0x69, 0x6c,   // - - - t r a i l
-        0x65, 0x72, 0x00, 0x00, 0x00, 0x11, 0x74, 0x72,   // e r - - - - t r
-        0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x2d, 0x65,   // a n s f e r - e
-        0x6e, 0x63, 0x6f, 0x64, 0x69, 0x6e, 0x67, 0x00,   // n c o d i n g -
-        0x00, 0x00, 0x07, 0x75, 0x70, 0x67, 0x72, 0x61,   // - - - u p g r a
-        0x64, 0x65, 0x00, 0x00, 0x00, 0x0a, 0x75, 0x73,   // d e - - - - u s
-        0x65, 0x72, 0x2d, 0x61, 0x67, 0x65, 0x6e, 0x74,   // e r - a g e n t
-        0x00, 0x00, 0x00, 0x04, 0x76, 0x61, 0x72, 0x79,   // - - - - v a r y
-        0x00, 0x00, 0x00, 0x03, 0x76, 0x69, 0x61, 0x00,   // - - - - v i a -
-        0x00, 0x00, 0x07, 0x77, 0x61, 0x72, 0x6e, 0x69,   // - - - w a r n i
-        0x6e, 0x67, 0x00, 0x00, 0x00, 0x10, 0x77, 0x77,   // n g - - - - w w
-        0x77, 0x2d, 0x61, 0x75, 0x74, 0x68, 0x65, 0x6e,   // w - a u t h e n
-        0x74, 0x69, 0x63, 0x61, 0x74, 0x65, 0x00, 0x00,   // t i c a t e - -
-        0x00, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64,   // - - m e t h o d
-        0x00, 0x00, 0x00, 0x03, 0x67, 0x65, 0x74, 0x00,   // - - - - g e t -
-        0x00, 0x00, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75,   // - - - s t a t u
-        0x73, 0x00, 0x00, 0x00, 0x06, 0x32, 0x30, 0x30,   // s - - - - 2 0 0
-        0x20, 0x4f, 0x4b, 0x00, 0x00, 0x00, 0x07, 0x76,   // - O K - - - - v
-        0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x00, 0x00,   // e r s i o n - -
-        0x00, 0x08, 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31,   // - - H T T P - 1
-        0x2e, 0x31, 0x00, 0x00, 0x00, 0x03, 0x75, 0x72,   // - 1 - - - - u r
-        0x6c, 0x00, 0x00, 0x00, 0x06, 0x70, 0x75, 0x62,   // l - - - - p u b
-        0x6c, 0x69, 0x63, 0x00, 0x00, 0x00, 0x0a, 0x73,   // l i c - - - - s
-        0x65, 0x74, 0x2d, 0x63, 0x6f, 0x6f, 0x6b, 0x69,   // e t - c o o k i
-        0x65, 0x00, 0x00, 0x00, 0x0a, 0x6b, 0x65, 0x65,   // e - - - - k e e
-        0x70, 0x2d, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x00,   // p - a l i v e -
-        0x00, 0x00, 0x06, 0x6f, 0x72, 0x69, 0x67, 0x69,   // - - - o r i g i
-        0x6e, 0x31, 0x30, 0x30, 0x31, 0x30, 0x31, 0x32,   // n 1 0 0 1 0 1 2
-        0x30, 0x31, 0x32, 0x30, 0x32, 0x32, 0x30, 0x35,   // 0 1 2 0 2 2 0 5
-        0x32, 0x30, 0x36, 0x33, 0x30, 0x30, 0x33, 0x30,   // 2 0 6 3 0 0 3 0
-        0x32, 0x33, 0x30, 0x33, 0x33, 0x30, 0x34, 0x33,   // 2 3 0 3 3 0 4 3
-        0x30, 0x35, 0x33, 0x30, 0x36, 0x33, 0x30, 0x37,   // 0 5 3 0 6 3 0 7
-        0x34, 0x30, 0x32, 0x34, 0x30, 0x35, 0x34, 0x30,   // 4 0 2 4 0 5 4 0
-        0x36, 0x34, 0x30, 0x37, 0x34, 0x30, 0x38, 0x34,   // 6 4 0 7 4 0 8 4
-        0x30, 0x39, 0x34, 0x31, 0x30, 0x34, 0x31, 0x31,   // 0 9 4 1 0 4 1 1
-        0x34, 0x31, 0x32, 0x34, 0x31, 0x33, 0x34, 0x31,   // 4 1 2 4 1 3 4 1
-        0x34, 0x34, 0x31, 0x35, 0x34, 0x31, 0x36, 0x34,   // 4 4 1 5 4 1 6 4
-        0x31, 0x37, 0x35, 0x30, 0x32, 0x35, 0x30, 0x34,   // 1 7 5 0 2 5 0 4
-        0x35, 0x30, 0x35, 0x32, 0x30, 0x33, 0x20, 0x4e,   // 5 0 5 2 0 3 - N
-        0x6f, 0x6e, 0x2d, 0x41, 0x75, 0x74, 0x68, 0x6f,   // o n - A u t h o
-        0x72, 0x69, 0x74, 0x61, 0x74, 0x69, 0x76, 0x65,   // r i t a t i v e
-        0x20, 0x49, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61,   // - I n f o r m a
-        0x74, 0x69, 0x6f, 0x6e, 0x32, 0x30, 0x34, 0x20,   // t i o n 2 0 4 -
-        0x4e, 0x6f, 0x20, 0x43, 0x6f, 0x6e, 0x74, 0x65,   // N o - C o n t e
-        0x6e, 0x74, 0x33, 0x30, 0x31, 0x20, 0x4d, 0x6f,   // n t 3 0 1 - M o
-        0x76, 0x65, 0x64, 0x20, 0x50, 0x65, 0x72, 0x6d,   // v e d - P e r m
-        0x61, 0x6e, 0x65, 0x6e, 0x74, 0x6c, 0x79, 0x34,   // a n e n t l y 4
-        0x30, 0x30, 0x20, 0x42, 0x61, 0x64, 0x20, 0x52,   // 0 0 - B a d - R
-        0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x34, 0x30,   // e q u e s t 4 0
-        0x31, 0x20, 0x55, 0x6e, 0x61, 0x75, 0x74, 0x68,   // 1 - U n a u t h
-        0x6f, 0x72, 0x69, 0x7a, 0x65, 0x64, 0x34, 0x30,   // o r i z e d 4 0
-        0x33, 0x20, 0x46, 0x6f, 0x72, 0x62, 0x69, 0x64,   // 3 - F o r b i d
-        0x64, 0x65, 0x6e, 0x34, 0x30, 0x34, 0x20, 0x4e,   // d e n 4 0 4 - N
-        0x6f, 0x74, 0x20, 0x46, 0x6f, 0x75, 0x6e, 0x64,   // o t - F o u n d
-        0x35, 0x30, 0x30, 0x20, 0x49, 0x6e, 0x74, 0x65,   // 5 0 0 - I n t e
-        0x72, 0x6e, 0x61, 0x6c, 0x20, 0x53, 0x65, 0x72,   // r n a l - S e r
-        0x76, 0x65, 0x72, 0x20, 0x45, 0x72, 0x72, 0x6f,   // v e r - E r r o
-        0x72, 0x35, 0x30, 0x31, 0x20, 0x4e, 0x6f, 0x74,   // r 5 0 1 - N o t
-        0x20, 0x49, 0x6d, 0x70, 0x6c, 0x65, 0x6d, 0x65,   // - I m p l e m e
-        0x6e, 0x74, 0x65, 0x64, 0x35, 0x30, 0x33, 0x20,   // n t e d 5 0 3 -
-        0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x20,   // S e r v i c e -
-        0x55, 0x6e, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61,   // U n a v a i l a
-        0x62, 0x6c, 0x65, 0x4a, 0x61, 0x6e, 0x20, 0x46,   // b l e J a n - F
-        0x65, 0x62, 0x20, 0x4d, 0x61, 0x72, 0x20, 0x41,   // e b - M a r - A
-        0x70, 0x72, 0x20, 0x4d, 0x61, 0x79, 0x20, 0x4a,   // p r - M a y - J
-        0x75, 0x6e, 0x20, 0x4a, 0x75, 0x6c, 0x20, 0x41,   // u n - J u l - A
-        0x75, 0x67, 0x20, 0x53, 0x65, 0x70, 0x74, 0x20,   // u g - S e p t -
-        0x4f, 0x63, 0x74, 0x20, 0x4e, 0x6f, 0x76, 0x20,   // O c t - N o v -
-        0x44, 0x65, 0x63, 0x20, 0x30, 0x30, 0x3a, 0x30,   // D e c - 0 0 - 0
-        0x30, 0x3a, 0x30, 0x30, 0x20, 0x4d, 0x6f, 0x6e,   // 0 - 0 0 - M o n
-        0x2c, 0x20, 0x54, 0x75, 0x65, 0x2c, 0x20, 0x57,   // - - T u e - - W
-        0x65, 0x64, 0x2c, 0x20, 0x54, 0x68, 0x75, 0x2c,   // e d - - T h u -
-        0x20, 0x46, 0x72, 0x69, 0x2c, 0x20, 0x53, 0x61,   // - F r i - - S a
-        0x74, 0x2c, 0x20, 0x53, 0x75, 0x6e, 0x2c, 0x20,   // t - - S u n - -
-        0x47, 0x4d, 0x54, 0x63, 0x68, 0x75, 0x6e, 0x6b,   // G M T c h u n k
-        0x65, 0x64, 0x2c, 0x74, 0x65, 0x78, 0x74, 0x2f,   // e d - t e x t -
-        0x68, 0x74, 0x6d, 0x6c, 0x2c, 0x69, 0x6d, 0x61,   // h t m l - i m a
-        0x67, 0x65, 0x2f, 0x70, 0x6e, 0x67, 0x2c, 0x69,   // g e - p n g - i
-        0x6d, 0x61, 0x67, 0x65, 0x2f, 0x6a, 0x70, 0x67,   // m a g e - j p g
-        0x2c, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x67,   // - i m a g e - g
-        0x69, 0x66, 0x2c, 0x61, 0x70, 0x70, 0x6c, 0x69,   // i f - a p p l i
-        0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x78,   // c a t i o n - x
-        0x6d, 0x6c, 0x2c, 0x61, 0x70, 0x70, 0x6c, 0x69,   // m l - a p p l i
-        0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2f, 0x78,   // c a t i o n - x
-        0x68, 0x74, 0x6d, 0x6c, 0x2b, 0x78, 0x6d, 0x6c,   // h t m l - x m l
-        0x2c, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x70, 0x6c,   // - t e x t - p l
-        0x61, 0x69, 0x6e, 0x2c, 0x74, 0x65, 0x78, 0x74,   // a i n - t e x t
-        0x2f, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72,   // - j a v a s c r
-        0x69, 0x70, 0x74, 0x2c, 0x70, 0x75, 0x62, 0x6c,   // i p t - p u b l
-        0x69, 0x63, 0x70, 0x72, 0x69, 0x76, 0x61, 0x74,   // i c p r i v a t
-        0x65, 0x6d, 0x61, 0x78, 0x2d, 0x61, 0x67, 0x65,   // e m a x - a g e
-        0x3d, 0x67, 0x7a, 0x69, 0x70, 0x2c, 0x64, 0x65,   // - g z i p - d e
-        0x66, 0x6c, 0x61, 0x74, 0x65, 0x2c, 0x73, 0x64,   // f l a t e - s d
-        0x63, 0x68, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65,   // c h c h a r s e
-        0x74, 0x3d, 0x75, 0x74, 0x66, 0x2d, 0x38, 0x63,   // t - u t f - 8 c
-        0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x3d, 0x69,   // h a r s e t - i
-        0x73, 0x6f, 0x2d, 0x38, 0x38, 0x35, 0x39, 0x2d,   // s o - 8 8 5 9 -
-        0x31, 0x2c, 0x75, 0x74, 0x66, 0x2d, 0x2c, 0x2a,   // 1 - u t f - - -
-        0x2c, 0x65, 0x6e, 0x71, 0x3d, 0x30, 0x2e          // - e n q - 0 -
-};
-
-
-int
-SPDYF_zlib_deflate_init(z_stream *strm)
-{
-        int ret;
-        
-        strm->zalloc = Z_NULL;
-        strm->zfree = Z_NULL;
-        strm->opaque = Z_NULL;
-        //the second argument is "level of compression"
-        //use 0 for no compression; 9 for best compression
-        ret = deflateInit(strm, Z_DEFAULT_COMPRESSION);
-        if(ret != Z_OK)
-        {
-                SPDYF_DEBUG("deflate init");
-                return SPDY_NO;
-        }
-        ret = deflateSetDictionary(strm,
-                                   spdyf_zlib_dictionary,
-                                   sizeof(spdyf_zlib_dictionary));
-        if(ret != Z_OK)
-        {
-                SPDYF_DEBUG("deflate set dict");
-                deflateEnd(strm);
-                return SPDY_NO;
-        }
-        return SPDY_YES;
-}
-
-
-void
-SPDYF_zlib_deflate_end(z_stream *strm)
-{
-        deflateEnd(strm);
-}
-
-int
-SPDYF_zlib_deflate(z_stream *strm,
-                                        const void *src,
-                                        size_t src_size,
-                                        size_t *data_used,
-                                        void **dest,
-                                        size_t *dest_size)
-{
-        int ret;
-        int flush;
-        unsigned int have;
-        Bytef out[SPDYF_ZLIB_CHUNK];
-        
-        *dest = NULL;
-        *dest_size = 0;
-
-        do
-        {
-                /* check for big data bigger than the buffer used */
-                if(src_size > SPDYF_ZLIB_CHUNK)
-                {
-                        strm->avail_in = SPDYF_ZLIB_CHUNK;
-                        src_size -= SPDYF_ZLIB_CHUNK;
-                        /* flush is used for the loop to detect if we still
-                         * need to supply additional
-                         * data to the stream via avail_in and next_in. */
-                        flush = Z_NO_FLUSH;
-                }
-                else
-                {
-                        strm->avail_in = src_size;
-                        flush = Z_SYNC_FLUSH;
-                }
-                *data_used += strm->avail_in;
-
-                strm->next_in = (Bytef *)src;
-
-                /* Loop while output data is available */
-                do
-                {
-                        strm->avail_out = SPDYF_ZLIB_CHUNK;
-                        strm->next_out = out;
-
-                        /* No need to check return value of deflate.
-                        * (See zlib documentation at http://www.zlib.net/zlib_how.html */
-                        ret = deflate(strm, flush);
-                        have = SPDYF_ZLIB_CHUNK - strm->avail_out;
-
-                        /* (Re)allocate memory for dest and keep track of it's size. */
-                        *dest_size += have;
-                        *dest = realloc(*dest, *dest_size);
-                        if(!*dest)
-                        {
-                                SPDYF_DEBUG("realloc data for result");
-                                deflateEnd(strm);
-                                return SPDY_NO;
-                        }
-                        memcpy((*dest) + ((*dest_size) - have), out, have);
-                }
-                while(strm->avail_out == 0);
-                /* At this point, all of the input data should already
-                * have been used. */
-                SPDYF_ASSERT(strm->avail_in == 0,"compressing bug");
-        }
-        while(flush != Z_SYNC_FLUSH);
-        
-        return Z_OK == ret ? SPDY_YES : SPDY_NO;
-}
-
-
-int
-SPDYF_zlib_inflate_init(z_stream *strm)
-{
-        int ret;
-        
-        strm->zalloc = Z_NULL;
-        strm->zfree = Z_NULL;
-        strm->opaque = Z_NULL;
-        strm->avail_in = 0;
-        strm->next_in = Z_NULL;
-        //change 15 to lower value for performance and benchmark
-        //"The windowBits parameter is the base two logarithm of the
-        // maximum window size (the size of the history buffer)."
-        ret = inflateInit2(strm, 15);
-        if(ret != Z_OK)
-        {
-                SPDYF_DEBUG("Cannot inflateInit2 the stream");
-                return SPDY_NO;
-        }
-        return SPDY_YES;
-}
-
-
-void
-SPDYF_zlib_inflate_end(z_stream *strm)
-{
-        inflateEnd(strm);
-}
-
-
-int
-SPDYF_zlib_inflate(z_stream *strm,
-                                        const void *src,
-                                        size_t src_size,
-                                        void **dest,
-                                        size_t *dest_size)
-{
-        int ret = Z_OK;
-        uint32_t have;
-        Bytef out[SPDYF_ZLIB_CHUNK];
-        
-        *dest = NULL;
-        *dest_size = 0;
-
-        /* decompress until deflate stream ends or end of file */
-        do
-        {               
-                if(src_size > SPDYF_ZLIB_CHUNK)
-                {
-                        strm->avail_in = SPDYF_ZLIB_CHUNK;
-                        src_size -= SPDYF_ZLIB_CHUNK;
-                }
-                else
-                {
-                        strm->avail_in = src_size;
-                        src_size = 0;
-                }
-                
-                if(strm->avail_in == 0){
-                        //the loop breaks always here as the stream never ends
-                        break;
-                }
-                        
-                strm->next_in = (Bytef *) src;
-                /* run inflate() on input until output buffer not full */
-                do {
-                        strm->avail_out = SPDYF_ZLIB_CHUNK;
-                        strm->next_out = out;
-                        ret = inflate(strm, Z_SYNC_FLUSH);
-                        
-                        switch (ret)
-                        {
-                                case Z_STREAM_ERROR:
-                                        SPDYF_DEBUG("Error on inflate");
-                                        //no inflateEnd here, same in zlib example
-                                        return SPDY_NO;
-                                
-                                case Z_NEED_DICT:
-                                        ret = inflateSetDictionary(strm,
-                                                                                   spdyf_zlib_dictionary,
-                                                                                   sizeof(spdyf_zlib_dictionary));
-                                        if(ret != Z_OK)
-                                        {
-                                                SPDYF_DEBUG("Error on inflateSetDictionary");
-                                                inflateEnd(strm);
-                                                return SPDY_NO;
-                                        }
-                                        ret = inflate(strm, Z_SYNC_FLUSH);
-                                        if(Z_STREAM_ERROR == ret)
-                                        {
-                                                SPDYF_DEBUG("Error on inflate");
-                                                return SPDY_NO;
-                                        }
-                                        break;
-                                        
-                                case Z_DATA_ERROR:
-                                        SPDYF_DEBUG("Z_DATA_ERROR");
-                                        inflateEnd(strm);
-                                        return SPDY_NO;
-                                        
-                                case Z_MEM_ERROR:
-                                        SPDYF_DEBUG("Z_MEM_ERROR");
-                                        inflateEnd(strm);
-                                        return SPDY_NO;
-                        }
-                        have = SPDYF_ZLIB_CHUNK - strm->avail_out;
-                        *dest_size += have;
-                        /* (re)alloc memory for the output buffer */
-                        *dest = realloc(*dest, *dest_size);
-                        if(!*dest)
-                        {
-                                SPDYF_DEBUG("Cannot realloc memory");
-                                inflateEnd(strm);
-                                return SPDY_NO;
-                        }
-                        memcpy((*dest) + ((*dest_size) - have), out, have);
-                }
-                while (0 == strm->avail_out);
-        }
-        while (Z_STREAM_END != ret);
-        
-        return Z_OK == ret || Z_STREAM_END == ret ? SPDY_YES : SPDY_NO;
-}
diff --git a/src/microspdy/compression.h b/src/microspdy/compression.h
deleted file mode 100644
index 40746e78..00000000
--- a/src/microspdy/compression.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file compression.h
- * @brief  zlib handling functions
- * @author Andrey Uzunov
- */
-
-#ifndef COMPRESSION_H
-#define COMPRESSION_H
-
-#include "platform.h"
-
-/* size of buffers used by zlib on (de)compressing */
-#define SPDYF_ZLIB_CHUNK 16384
-
-
-/**
- * Initializes the zlib stream for compression. Must be called once
- * for a session on initialization.
- *
- * @param strm Zlib stream on which we work
- * @return SPDY_NO if zlib failed. SPDY_YES otherwise
- */             
-int
-SPDYF_zlib_deflate_init(z_stream *strm);
-
-
-/**
- * Deinitializes the zlib stream for compression. Should be called once
- * for a session on cleaning up.
- *
- * @param strm Zlib stream on which we work
- */     
-void
-SPDYF_zlib_deflate_end(z_stream *strm);
-
-
-/**
- * Compressing stream with zlib.
- *
- * @param strm Zlib stream on which we work
- * @param src stream of the data to be compressed
- * @param src_size size of the data
- * @param data_used the number of bytes from src_stream that were used
- *                                      TODO do we need
- * @param dest the resulting compressed stream. Should be NULL. Must be
- *                                      freed later manually.
- * @param dest_size size of the data after compression
- * @return SPDY_NO if malloc or zlib failed. SPDY_YES otherwise
- */
-int
-SPDYF_zlib_deflate(z_stream *strm,
-                                        const void *src,
-                                        size_t src_size,
-                                        size_t *data_used,
-                                        void **dest,
-                                        size_t *dest_size);
-     
-
-/**
- * Initializes the zlib stream for decompression. Must be called once
- * for a session.
- *
- * @param strm Zlib stream on which we work
- * @return SPDY_NO if zlib failed. SPDY_YES otherwise
- */                      
-int
-SPDYF_zlib_inflate_init(z_stream *strm);
-
-
-/**
- * Deinitializes the zlib stream for decompression. Should be called once
- * for a session on cleaning up.
- *
- * @param strm Zlib stream on which we work
- */     
-void
-SPDYF_zlib_inflate_end(z_stream *strm);
-
-
-/**
- * Decompressing stream with zlib.
- *
- * @param strm Zlib stream on which we work
- * @param src stream of the data to be decompressed
- * @param src_size size of the data
- * @param dest the resulting decompressed stream. Should be NULL. Must
- *                              be freed manually.
- * @param dest_size size of the data after decompression
- * @return SPDY_NO if malloc or zlib failed. SPDY_YES otherwise. If the
- *                      function fails, the SPDY session must be closed
- */
-int
-SPDYF_zlib_inflate(z_stream *strm,
-                                        const void *src,
-                                        size_t src_size,
-                                        void **dest,
-                                        size_t *dest_size);
-
-#endif
diff --git a/src/microspdy/daemon.c b/src/microspdy/daemon.c
deleted file mode 100644
index ca6f0da7..00000000
--- a/src/microspdy/daemon.c
+++ /dev/null
@@ -1,544 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file microspdy/daemon.c
- * @brief  daemon functionality
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include "structures.h"
-#include "internal.h"
-#include "session.h"
-#include "io.h"
-
-
-/**
- * Default implementation of the panic function,
- * prints an error message and aborts.
- *
- * @param cls unused
- * @param file name of the file with the problem
- * @param line line number with the problem
- * @param reason error message with details
- */
-static void
-spdyf_panic_std (void *cls,
-               const char *file,
-               unsigned int line,
-               const char *reason)
-{
-        (void)cls;
-        fprintf (stdout, "Fatal error in libmicrospdy %s:%u: %s\n",
-                file, line, reason);
-        //raise(SIGINT); //used for gdb
-        abort ();
-}
-
-
-/**
- * Global handler for fatal errors.
- */
-SPDY_PanicCallback spdyf_panic = &spdyf_panic_std;
-
-
-/**
- * Global closure argument for "spdyf_panic".
- */
-void *spdyf_panic_cls;
-
-
-/**
- * Free resources associated with all closed connections.
- * (destroy responses, free buffers, etc.).
- *
- * @param daemon daemon to clean up
- */
-static void
-spdyf_cleanup_sessions (struct SPDY_Daemon *daemon)
-{
-        struct SPDY_Session *session;
-
-        while (NULL != (session = daemon->cleanup_head))
-        {
-                DLL_remove (daemon->cleanup_head,
-                        daemon->cleanup_tail,
-                        session);
-
-                SPDYF_session_destroy(session);
-        }
-}
-
-
-/**
- * Closing of all connections handled by the daemon.
- *
- * @param daemon SPDY daemon
- */
-static void
-spdyf_close_all_sessions (struct SPDY_Daemon *daemon)
-{
-        struct SPDY_Session *session;
-
-        while (NULL != (session = daemon->sessions_head))
-        {
-                //prepare GOAWAY frame
-                SPDYF_prepare_goaway(session, SPDY_GOAWAY_STATUS_OK, true);
-                //try to send the frame (it is best effort, so it will maybe sent)
-                SPDYF_session_write(session,true);
-                SPDYF_session_close(session);
-        }
-
-        spdyf_cleanup_sessions(daemon);
-}
-
-
-/**
- * Parse a list of options given as varargs.
- *
- * @param daemon the daemon to initialize
- * @param valist the options
- * @return SPDY_YES on success, SPDY_NO on error
- */
-static int
-spdyf_parse_options_va (struct SPDY_Daemon *daemon,
-                  va_list valist)
-{
-        enum SPDY_DAEMON_OPTION opt;
-
-        while (SPDY_DAEMON_OPTION_END != (opt = (enum SPDY_DAEMON_OPTION) va_arg (valist, int)))
-        {
-                if(opt & daemon->options)
-                {
-                        SPDYF_DEBUG("Daemon option %i used twice",opt);
-                        return SPDY_NO;
-                }
-                daemon->options |= opt;
-
-                switch (opt)
-                {
-                        case SPDY_DAEMON_OPTION_SESSION_TIMEOUT:
-                                daemon->session_timeout = va_arg (valist, unsigned int) * 1000;
-                                break;
-                        case SPDY_DAEMON_OPTION_SOCK_ADDR:
-                                daemon->address = va_arg (valist, struct sockaddr *);
-                                break;
-                        case SPDY_DAEMON_OPTION_FLAGS:
-                                daemon->flags = va_arg (valist, enum SPDY_DAEMON_FLAG);
-                                break;
-                        case SPDY_DAEMON_OPTION_IO_SUBSYSTEM:
-                                daemon->io_subsystem = va_arg (valist, enum SPDY_IO_SUBSYSTEM);
-                                break;
-                        case SPDY_DAEMON_OPTION_MAX_NUM_FRAMES:
-                                daemon->max_num_frames = va_arg (valist, uint32_t);
-                                break;
-                        default:
-                                SPDYF_DEBUG("Wrong option for the daemon %i",opt);
-                                return SPDY_NO;
-                }
-        }
-        return SPDY_YES;
-}
-
-
-void
-SPDY_set_panic_func (SPDY_PanicCallback cb,
-                                        void *cls)
-{
-        spdyf_panic = cb;
-        spdyf_panic_cls = cls;
-}
-
-
-struct SPDY_Daemon *
-SPDYF_start_daemon_va (uint16_t port,
-                                        const char *certfile,
-                                        const char *keyfile,
-                                        SPDY_NewSessionCallback nscb,
-                                        SPDY_SessionClosedCallback sccb,
-                                        SPDY_NewRequestCallback nrcb,
-                                        SPDY_NewDataCallback npdcb,
-                                        SPDYF_NewStreamCallback fnscb,
-                                        SPDYF_NewDataCallback fndcb,
-                                        void * cls,
-                                        void * fcls,
-                                        va_list valist)
-{
-        struct SPDY_Daemon *daemon = NULL;
-        int afamily;
-        int option_on = 1;
-        int ret;
-        struct sockaddr_in* servaddr4 = NULL;
-#if HAVE_INET6
-        struct sockaddr_in6* servaddr6 = NULL;
-#endif
-        socklen_t addrlen;
-
-        if (NULL == (daemon = malloc (sizeof (struct SPDY_Daemon))))
-        {
-                SPDYF_DEBUG("malloc");
-                return NULL;
-        }
-        memset (daemon, 0, sizeof (struct SPDY_Daemon));
-        daemon->socket_fd = -1;
-        daemon->port = port;
-
-        if(SPDY_YES != spdyf_parse_options_va (daemon, valist))
-        {
-                SPDYF_DEBUG("parse");
-                goto free_and_fail;
-        }
-
-  if(0 == daemon->max_num_frames)
-    daemon->max_num_frames = SPDYF_NUM_SENT_FRAMES_AT_ONCE;
-
-        if(!port && NULL == daemon->address)
-        {
-                SPDYF_DEBUG("Port is 0");
-                goto free_and_fail;
-        }
-  if(0 == daemon->io_subsystem)
-    daemon->io_subsystem = SPDY_IO_SUBSYSTEM_OPENSSL;
-
-  if(SPDY_YES != SPDYF_io_set_daemon(daemon, daemon->io_subsystem))
-                goto free_and_fail;
-
-  if(SPDY_IO_SUBSYSTEM_RAW != daemon->io_subsystem)
-  {
-    if (NULL == certfile
-      || NULL == (daemon->certfile = strdup (certfile)))
-    {
-      SPDYF_DEBUG("strdup (certfile)");
-      goto free_and_fail;
-    }
-    if (NULL == keyfile
-      || NULL == (daemon->keyfile = strdup (keyfile)))
-    {
-      SPDYF_DEBUG("strdup (keyfile)");
-      goto free_and_fail;
-    }
-  }
-
-        daemon->new_session_cb = nscb;
-        daemon->session_closed_cb = sccb;
-        daemon->new_request_cb = nrcb;
-        daemon->received_data_cb = npdcb;
-        daemon->cls = cls;
-        daemon->fcls = fcls;
-        daemon->fnew_stream_cb = fnscb;
-        daemon->freceived_data_cb = fndcb;
-
-#if HAVE_INET6
-        //handling IPv6
-        if((daemon->flags & SPDY_DAEMON_FLAG_ONLY_IPV6)
-                && NULL != daemon->address && AF_INET6 != daemon->address->sa_family)
-        {
-                SPDYF_DEBUG("SPDY_DAEMON_FLAG_ONLY_IPV6 set but IPv4 address provided");
-                goto free_and_fail;
-        }
-
-  addrlen = sizeof (struct sockaddr_in6);
-
-        if(NULL == daemon->address)
-        {
-                if (NULL == (servaddr6 = malloc (addrlen)))
-                {
-                        SPDYF_DEBUG("malloc");
-                        goto free_and_fail;
-                }
-                memset (servaddr6, 0, addrlen);
-                servaddr6->sin6_family = AF_INET6;
-                servaddr6->sin6_addr = in6addr_any;
-                servaddr6->sin6_port = htons (port);
-                daemon->address = (struct sockaddr *) servaddr6;
-        }
-
-  if(AF_INET6 == daemon->address->sa_family)
-  {
-    afamily = PF_INET6;
-  }
-  else
-  {
-    afamily = PF_INET;
-  }
-#else
-        //handling IPv4
-        if(daemon->flags & SPDY_DAEMON_FLAG_ONLY_IPV6)
-        {
-                SPDYF_DEBUG("SPDY_DAEMON_FLAG_ONLY_IPV6 set but no support");
-                goto free_and_fail;
-        }
-
-  addrlen = sizeof (struct sockaddr_in);
-
-        if(NULL == daemon->address)
-        {
-                if (NULL == (servaddr4 = malloc (addrlen)))
-                {
-                        SPDYF_DEBUG("malloc");
-                        goto free_and_fail;
-                }
-                memset (servaddr4, 0, addrlen);
-                servaddr4->sin_family = AF_INET;
-                servaddr4->sin_addr = INADDR_ANY;
-                servaddr4->sin_port = htons (port);
-                daemon->address = (struct sockaddr *) servaddr4;
-        }
-
-        afamily = PF_INET;
-#endif
-
-        daemon->socket_fd = socket (afamily, SOCK_STREAM, 0);
-        if (-1 == daemon->socket_fd)
-        {
-                SPDYF_DEBUG("sock");
-                goto free_and_fail;
-        }
-
-        //setting option for the socket to reuse address
-        ret = setsockopt(daemon->socket_fd, SOL_SOCKET, SO_REUSEADDR, &option_on, sizeof(option_on));
-        if(ret)
-        {
-                SPDYF_DEBUG("WARNING: SO_REUSEADDR was not set for the server");
-        }
-
-#if HAVE_INET6
-        if(daemon->flags & SPDY_DAEMON_FLAG_ONLY_IPV6)
-        {
-                ret = setsockopt(daemon->socket_fd, IPPROTO_IPV6, IPV6_V6ONLY, &option_on, sizeof(option_on));
-                if(ret)
-                {
-                        SPDYF_DEBUG("setsockopt with IPPROTO_IPV6 failed");
-                        goto free_and_fail;
-                }
-        }
-#endif
-
-        if (-1 == bind (daemon->socket_fd, daemon->address, addrlen))
-        {
-                SPDYF_DEBUG("bind %i",errno);
-                goto free_and_fail;
-        }
-
-        if (listen (daemon->socket_fd, 20) < 0)
-        {
-                SPDYF_DEBUG("listen %i",errno);
-                goto free_and_fail;
-        }
-
-        if(SPDY_YES != daemon->fio_init(daemon))
-        {
-                SPDYF_DEBUG("tls");
-                goto free_and_fail;
-        }
-
-        return daemon;
-
-        //for GOTO
-        free_and_fail:
-        if(daemon->socket_fd > 0)
-                (void)MHD_socket_close_ (daemon->socket_fd);
-
-        free(servaddr4);
-#if HAVE_INET6
-        free(servaddr6);
-#endif
-        if(NULL != daemon->certfile)
-                free(daemon->certfile);
-        if(NULL != daemon->keyfile)
-                free(daemon->keyfile);
-        free (daemon);
-
-        return NULL;
-}
-
-
-void
-SPDYF_stop_daemon (struct SPDY_Daemon *daemon)
-{
-        daemon->fio_deinit(daemon);
-
-        shutdown (daemon->socket_fd, SHUT_RDWR);
-        spdyf_close_all_sessions (daemon);
-        (void)MHD_socket_close_ (daemon->socket_fd);
-
-        if(!(SPDY_DAEMON_OPTION_SOCK_ADDR & daemon->options))
-                free(daemon->address);
-
-        free(daemon->certfile);
-        free(daemon->keyfile);
-
-        free(daemon);
-}
-
-
-int
-SPDYF_get_timeout (struct SPDY_Daemon *daemon,
-                     unsigned long long *timeout)
-{
-        unsigned long long earliest_deadline = 0;
-        unsigned long long now;
-        struct SPDY_Session *pos;
-        bool have_timeout;
-
-        if(0 == daemon->session_timeout)
-                return SPDY_NO;
-
-        now = SPDYF_monotonic_time();
-        have_timeout = false;
-        for (pos = daemon->sessions_head; NULL != pos; pos = pos->next)
-        {
-                if ( (! have_timeout) ||
-                        (earliest_deadline > pos->last_activity + daemon->session_timeout) )
-                        earliest_deadline = pos->last_activity + daemon->session_timeout;
-
-                have_timeout = true;
-
-                if (SPDY_YES == pos->fio_is_pending(pos))
-                {
-                        earliest_deadline = 0;
-                        break;
-                }
-        }
-
-        if (!have_timeout)
-                return SPDY_NO;
-        if (earliest_deadline <= now)
-                *timeout = 0;
-        else
-                *timeout = earliest_deadline - now;
-
-        return SPDY_YES;
-}
-
-
-int
-SPDYF_get_fdset (struct SPDY_Daemon *daemon,
-                                fd_set *read_fd_set,
-                                fd_set *write_fd_set,
-                                fd_set *except_fd_set,
-                                bool all)
-{
-        (void)except_fd_set;
-        struct SPDY_Session *pos;
-        int fd;
-        int max_fd = -1;
-
-        fd = daemon->socket_fd;
-        if (-1 != fd)
-        {
-                FD_SET (fd, read_fd_set);
-                /* update max file descriptor */
-                max_fd = fd;
-        }
-
-        for (pos = daemon->sessions_head; NULL != pos; pos = pos->next)
-        {
-                fd = pos->socket_fd;
-                FD_SET(fd, read_fd_set);
-                if (all
-                    || (NULL != pos->response_queue_head) //frames pending
-                    || (NULL != pos->write_buffer) //part of last frame pending
-                    || (SPDY_SESSION_STATUS_CLOSING == pos->status) //the session is about to be closed
-                    || (daemon->session_timeout //timeout passed for the session
-                        && (pos->last_activity + daemon->session_timeout < SPDYF_monotonic_time()))
-                    || (SPDY_YES == pos->fio_is_pending(pos)) //data in TLS' read buffer pending
-                    || ((pos->read_buffer_offset - pos->read_buffer_beginning) > 0) // data in lib's read buffer pending
-                    )
-                        FD_SET(fd, write_fd_set);
-                if(fd > max_fd)
-                        max_fd = fd;
-        }
-
-        return max_fd;
-}
-
-
-void
-SPDYF_run (struct SPDY_Daemon *daemon)
-{
-        struct SPDY_Session *pos;
-        struct SPDY_Session *next;
-        int num_ready;
-        fd_set rs;
-        fd_set ws;
-        fd_set es;
-        int max;
-        struct timeval timeout;
-        int ds;
-
-        timeout.tv_sec = 0;
-        timeout.tv_usec = 0;
-        FD_ZERO (&rs);
-        FD_ZERO (&ws);
-        FD_ZERO (&es);
-        //here we need really all descriptors to see later which are ready
-        max = SPDYF_get_fdset(daemon,&rs,&ws,&es, true);
-
-        num_ready = select (max + 1, &rs, &ws, &es, &timeout);
-
-        if(num_ready < 1)
-                return;
-
-        if ( (-1 != (ds = daemon->socket_fd)) &&
-                (FD_ISSET (ds, &rs)) ){
-                SPDYF_session_accept(daemon);
-        }
-
-        next = daemon->sessions_head;
-        while (NULL != (pos = next))
-        {
-                next = pos->next;
-                ds = pos->socket_fd;
-                if (ds != -1)
-                {
-                        //fill the read buffer
-                        if (FD_ISSET (ds, &rs) || pos->fio_is_pending(pos)){
-                                SPDYF_session_read(pos);
-                        }
-
-                        //do something with the data in read buffer
-                        if(SPDY_NO == SPDYF_session_idle(pos))
-                        {
-                                //the session was closed, cannot write anymore
-                                //continue;
-                        }
-
-                        //write whatever has been put to the response queue
-                        //during read or idle operation, something might be put
-                        //on the response queue, thus call write operation
-                        if (FD_ISSET (ds, &ws)){
-                                if(SPDY_NO == SPDYF_session_write(pos, false))
-                                {
-                                        //SPDYF_session_close(pos);
-                                        //continue;
-                                }
-                        }
-
-                        /* the response queue has been flushed for half closed
-                         * connections, so let close them */
-                        /*if(pos->read_closed)
-                        {
-                                SPDYF_session_close(pos);
-                        }*/
-                }
-        }
-
-        spdyf_cleanup_sessions(daemon);
-}
diff --git a/src/microspdy/daemon.h b/src/microspdy/daemon.h
deleted file mode 100644
index cb3ed5fa..00000000
--- a/src/microspdy/daemon.h
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file daemon.h
- * @brief  daemon functionality
- * @author Andrey Uzunov
- */
-
-#ifndef DAEMON_H
-#define DAEMON_H
-
-#include "platform.h"
-
-
-/**
- * Global flags containing the initialized IO subsystems.
- */
-enum SPDY_IO_SUBSYSTEM spdyf_io_initialized;
-
-
-/**
- * Start a SPDDY webserver on the given port.
- *
- * @param port port to bind to
- * @param certfile path to the certificate that will be used by server
- * @param keyfile path to the keyfile for the certificate
- * @param nscb callback called when a new SPDY session is
- *                      established     by a client
- * @param sccb callback called when a client closes the session
- * @param nrcb callback called when a client sends request
- * @param npdcb callback called when HTTP POST params are received
- *                      after request
- * @param fnscb callback called when new stream is opened by a client
- * @param fndcb callback called when new data -- within a data frame --
- *        is received by the server
- * @param cls extra argument to all of the callbacks without those
- *                               specific only for the framing layer
- * @param fcls extra argument to all of the callbacks, specific only for
- *                              the framing layer (those vars starting with 'f').
- * @param valist va_list of options (type-value pairs,
- *        terminated with SPDY_DAEMON_OPTION_END).
- * @return NULL on error, handle to daemon on success
- */
-struct SPDY_Daemon *
-SPDYF_start_daemon_va (uint16_t port,
-                                        const char *certfile,
-                                        const char *keyfile,
-                                        SPDY_NewSessionCallback nscb,
-                                        SPDY_SessionClosedCallback sccb,
-                                        SPDY_NewRequestCallback nrcb,
-                                        SPDY_NewDataCallback npdcb,
-                                        SPDYF_NewStreamCallback fnscb,
-                                        SPDYF_NewDataCallback fndcb,
-                                        void * cls,
-                                        void * fcls,
-                                        va_list valist);
-
-
-/**
- * Run webserver operations (without blocking unless
- * in client callbacks). This method must be called in the client event
- * loop.
- *
- * @param daemon daemon to run
- */
-void 
-SPDYF_run (struct SPDY_Daemon *daemon);
-
-
-/**
- * Obtain timeout value for select for this daemon. The returned value
- * is how long select
- * should at most block, not the timeout value set for connections.
- *
- * @param daemon daemon to query for timeout
- * @param timeout set to the timeout (in milliseconds)
- * @return SPDY_YES on success, SPDY_NO if no connections exist that
- *                      would necessiate the use of a timeout right now
- */
-int
-SPDYF_get_timeout (struct SPDY_Daemon *daemon, 
-                     unsigned long long *timeout);
-
-
-/**
- * Obtain the select sets for this daemon. The idea of SPDYF_get_fdset
- * is to return such descriptors that the select in the application can
- * return and SPDY_run can be called only when this is really needed.
- * That means not all sockets will be added to write_fd_set.
- *
- * @param daemon daemon to get sets from
- * @param read_fd_set read set
- * @param write_fd_set write set
- * @param except_fd_set except set
- * @param all add all session's descriptors to write_fd_set or not
- * @return largest FD added
- */
-int
-SPDYF_get_fdset (struct SPDY_Daemon *daemon,
-                                fd_set *read_fd_set,
-                                fd_set *write_fd_set, 
-                                fd_set *except_fd_set,
-                                bool all);
-
-
-/**
- * Shutdown the daemon.
- *
- * @param daemon daemon to stop
- */                             
-void 
-SPDYF_stop_daemon (struct SPDY_Daemon *daemon);
-
-#endif
diff --git a/src/microspdy/internal.c b/src/microspdy/internal.c
deleted file mode 100644
index f0d2fc11..00000000
--- a/src/microspdy/internal.c
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file microspdy/internal.c
- * @brief  internal functions and macros for the framing layer
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include "structures.h"
-
-
-unsigned long long
-SPDYF_monotonic_time (void)
-{
-#ifdef HAVE_CLOCK_GETTIME
-#ifdef CLOCK_MONOTONIC
-  struct timespec ts;
-  if (0 == clock_gettime (CLOCK_MONOTONIC, &ts))
-    return ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
-#endif
-#endif
-  return time (NULL) * 1000;
-}
diff --git a/src/microspdy/internal.h b/src/microspdy/internal.h
deleted file mode 100644
index b5382c01..00000000
--- a/src/microspdy/internal.h
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file microspdy/internal.h
- * @brief  internal functions and macros for the framing layer
- * @author Andrey Uzunov
- */
-
-#ifndef INTERNAL_H_H
-#define INTERNAL_H_H
-
-#include "platform.h"
-#include "platform_interface.h"
-#include "microspdy.h"
-
-/**
- * size of read buffers for each connection
- * must be at least the size of SPDY_MAX_SUPPORTED_FRAME_SIZE
- */
-#define SPDYF_BUFFER_SIZE 8192
-
-/**
- * initial size of window for each stream (this is for the data
- * within data frames that can be handled)
- */
-#define SPDYF_INITIAL_WINDOW_SIZE 65536
-
-/**
- * number of frames written to the socket at once. After X frames
- * everything should be run again. In this way the application can
- * response to more important requests while a big file is still
- * being transmitted to the client
- */
-#define SPDYF_NUM_SENT_FRAMES_AT_ONCE 10
-
-
-/**
- * Handler for fatal errors.
- */
-extern SPDY_PanicCallback spdyf_panic;
-
-
-/**
- * Closure argument for "mhd_panic".
- */
-extern void *spdyf_panic_cls;
-
-
-/**
- * Trigger 'panic' action based on fatal errors.
- *
- * @param msg error message (const char *)
- */
-#define SPDYF_PANIC(msg) \
-        spdyf_panic (spdyf_panic_cls, __FILE__, __LINE__, msg)
-
-
-/**
- * Asserts the validity of an expression.
- *
- * @param expr (bool)
- * @param msg message to print on error (const char *)
- */
-#define SPDYF_ASSERT(expr, msg) \
-        if(!(expr)){\
-                SPDYF_PANIC(msg);\
-                abort();\
-        }
-
-
-/**
- * Convert 24 bit integer from host byte order to network byte order.
- *
- * @param n input value (int32_t)
- * @return converted value (uint32_t)
- */
-#if HAVE_BIG_ENDIAN
-#define HTON24(n) n
-#else
-#define HTON24(n) (((((uint32_t)(n) & 0xFF)) << 16)\
-        | (((uint32_t)(n) & 0xFF00))\
-        | ((((uint32_t)(n) & 0xFF0000)) >> 16))
-#endif
-
-
-/**
- * Convert 24 bit integer from network byte order to host byte order.
- *
- * @param n input value (int32_t)
- * @return converted value (uint32_t)
- */
-#if HAVE_BIG_ENDIAN
-#define NTOH24(n) n
-#else
-#define NTOH24(n) (((((uint32_t)(n) & 0xFF)) << 16)\
-        | (((uint32_t)(n) & 0xFF00))\
-        | ((((uint32_t)(n) & 0xFF0000)) >> 16))
-#endif
-
-
-/**
- * Convert 31 bit integer from network byte order to host byte order.
- *
- * @param n input value (int32_t)
- * @return converted value (uint32_t)
- */
-#if HAVE_BIG_ENDIAN
-#define NTOH31(n) n
-#else
-#define NTOH31(n) (((((uint32_t)(n) & 0x7F)) << 24) | \
-                  ((((uint32_t)(n) & 0xFF00)) << 8) | \
-                  ((((uint32_t)(n) & 0xFF0000)) >> 8) | \
-                  ((((uint32_t)(n) & 0xFF000000)) >> 24))
-#endif
-
-
-/**
- * Convert 31 bit integer from host byte order to network byte order.
- *
- * @param n input value (int32_t)
- * @return converted value (uint32_t)
- */
-#if HAVE_BIG_ENDIAN
-#define HTON31(n) n
-#else
-#define HTON31(n) (((((uint32_t)(n) & 0xFF)) << 24) | \
-                  ((((uint32_t)(n) & 0xFF00)) << 8) | \
-                  ((((uint32_t)(n) & 0xFF0000)) >> 8) | \
-                  ((((uint32_t)(n) & 0x7F000000)) >> 24))
-#endif
-
-
-/**
- * Print formatted debug value.
- *
- * @param fmt format (const char *)
- * @param ... args for format
- */
-#define SPDYF_DEBUG(fmt, ...) do { \
-        fprintf (stdout, "%s\n%u: ",__FILE__, __LINE__);\
-        fprintf(stdout,fmt,##__VA_ARGS__);\
-        fprintf(stdout,"\n");\
-        fflush(stdout); } while (0)
-
-
-/**
- * Print stream for debuging.
- *
- * @param strm (void *)
- * @param size (int)
- */
-#define SPDYF_PRINT_STREAM(strm, size) do { \
-        int ___i;\
-        for(___i=0;___i<size;___i++){\
-                fprintf(stdout,"%x ",*((uint8_t *) strm + ___i));\
-                fflush(stdout);\
-        }\
-        fprintf(stdout,"\n");\
-        } while (0)
-
-
-/**
- * Print message and raise SIGINT for debug purposes.
- *
- * @param msg message (const char *)
- */
-#define SPDYF_SIGINT(msg) do { \
-        fprintf(stdout,"%i : %s\n", __LINE__,__FILE__);\
-        fprintf(stdout,msg);\
-        fprintf(stdout,"\n");\
-        fflush(stdout);\
-        raise(SIGINT); } while (0)
-
-
-/**
- * Returns monotonic time, to be used for session timeouts.
- *
- * @return time in milliseconds
- */
-unsigned long long
-SPDYF_monotonic_time(void);
-
-#endif
diff --git a/src/microspdy/io.c b/src/microspdy/io.c
deleted file mode 100644
index c333c89a..00000000
--- a/src/microspdy/io.c
+++ /dev/null
@@ -1,90 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file io.c
- * @brief Generic functions for IO.
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include "structures.h"
-#include "internal.h"
-#include "io.h"
-
-
-int
-SPDYF_io_set_daemon(struct SPDY_Daemon *daemon,
-                    enum SPDY_IO_SUBSYSTEM io_subsystem)
-{
-  switch(io_subsystem)
-  {
-    case SPDY_IO_SUBSYSTEM_OPENSSL:
-      daemon->fio_init = &SPDYF_openssl_init;
-      daemon->fio_deinit = &SPDYF_openssl_deinit;
-      break;
-      
-    case SPDY_IO_SUBSYSTEM_RAW:
-      daemon->fio_init = &SPDYF_raw_init;
-      daemon->fio_deinit = &SPDYF_raw_deinit;
-      break;
-      
-    case SPDY_IO_SUBSYSTEM_NONE:
-    default:
-      SPDYF_DEBUG("Unsupported subsystem");
-      return SPDY_NO;
-  }
-  
-  return SPDY_YES;
-}
-
-
-int
-SPDYF_io_set_session(struct SPDY_Session *session,
-                     enum SPDY_IO_SUBSYSTEM io_subsystem)
-{
-  switch(io_subsystem)
-  {
-    case SPDY_IO_SUBSYSTEM_OPENSSL:
-      session->fio_new_session = &SPDYF_openssl_new_session;
-      session->fio_close_session = &SPDYF_openssl_close_session;
-      session->fio_is_pending = &SPDYF_openssl_is_pending;
-      session->fio_recv = &SPDYF_openssl_recv;
-      session->fio_send = &SPDYF_openssl_send;
-      session->fio_before_write = &SPDYF_openssl_before_write;
-      session->fio_after_write = &SPDYF_openssl_after_write;
-      break;
-      
-    case SPDY_IO_SUBSYSTEM_RAW:
-      session->fio_new_session = &SPDYF_raw_new_session;
-      session->fio_close_session = &SPDYF_raw_close_session;
-      session->fio_is_pending = &SPDYF_raw_is_pending;
-      session->fio_recv = &SPDYF_raw_recv;
-      session->fio_send = &SPDYF_raw_send;
-      session->fio_before_write = &SPDYF_raw_before_write;
-      session->fio_after_write = &SPDYF_raw_after_write;
-      break;
-      
-    case SPDY_IO_SUBSYSTEM_NONE:
-    default:
-      SPDYF_DEBUG("Unsupported subsystem");
-      return SPDY_NO;
-  }
-  
-  return SPDY_YES;
-}
diff --git a/src/microspdy/io.h b/src/microspdy/io.h
deleted file mode 100644
index c28ba21b..00000000
--- a/src/microspdy/io.h
+++ /dev/null
@@ -1,216 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file io.h
- * @brief  Signatures for IO functions.
- * @author Andrey Uzunov
- */
-
-#ifndef IO_H
-#define IO_H
-
-#include "platform.h"
-#include "io_openssl.h"
-#include "io_raw.h"
-
-
-/**
- * Used for return code when reading and writing to the TLS socket.
- */
-enum SPDY_IO_ERROR
-{
-        /**
-         * The connection was closed by the other party.
-         */
-        SPDY_IO_ERROR_CLOSED = 0,
-        
-        /**
-         * Any kind of error ocurred. The session has to be closed.
-         */
-        SPDY_IO_ERROR_ERROR = -2,
-        
-        /**
-         * The function had to return without processing any data. The whole
-         * cycle of events has to be called again (SPDY_run) as something
-         * either has to be written or read or the the syscall was
-         * interrupted by a signal.
-         */
-        SPDY_IO_ERROR_AGAIN = -3,
-};
-
-
-/**
- * Global initializing. Must be called only once in the program.
- *
- */
-typedef void
-(*SPDYF_IOGlobalInit) ();
-
-
-/**
- * Global deinitializing for the whole program. Should be called
- * at the end of the program.
- *
- */
-typedef void
-(*SPDYF_IOGlobalDeinit) ();
-
-
-/**
- * Initializing of io context for a specific daemon.
- * Must be called when the daemon starts.
- *
- * @param daemon SPDY_Daemon for which io will be used. Daemon's
- *                              certificate and key file are used for tls.
- * @return SPDY_YES on success or SPDY_NO on error
- */
-typedef int
-(*SPDYF_IOInit) (struct SPDY_Daemon *daemon);
-
-
-/**
- * Deinitializing io context for a daemon. Should be called
- * when the deamon is stopped.
- *
- * @param daemon SPDY_Daemon which is being stopped
- */
-typedef void
-(*SPDYF_IODeinit) (struct SPDY_Daemon *daemon);
-
-
-/**
- * Initializing io for a specific connection. Must be called
- * after the connection has been accepted.
- *
- * @param session SPDY_Session whose socket will be used
- * @return SPDY_NO if some funcs inside fail. SPDY_YES otherwise
- */
-typedef int
-(*SPDYF_IONewSession) (struct SPDY_Session *session);
-
-
-/**
- * Deinitializing io for a specific connection. Should be called
- * closing session's socket.
- *
- * @param session SPDY_Session whose socket is used
- */
-typedef void
-(*SPDYF_IOCloseSession) (struct SPDY_Session *session);
-
-
-/**
- * Reading from session's socket. Reads available data and put it to the
- * buffer.
- *
- * @param session for which data is received
- * @param buffer where data from the socket will be written to
- * @param size of the buffer
- * @return number of bytes (at most size) read from the connection
- *         0 if the other party has closed the connection
- *         SPDY_IO_ERROR code on error
- */
-typedef int
-(*SPDYF_IORecv) (struct SPDY_Session *session,
-                                void * buffer,
-                                size_t size);
-
-
-/**
- * Writing to session's socket. Writes the data given into the buffer to the
- *  socket.
- *
- * @param session whose context is used
- * @param buffer from where data will be written to the socket
- * @param size number of bytes to be taken from the buffer
- * @return number of bytes (at most size) from the buffer that has been
- *                      written to the connection
- *         0 if the other party has closed the connection
- *         SPDY_IO_ERROR code on error
- */
-typedef int
-(*SPDYF_IOSend) (struct SPDY_Session *session,
-                                const void * buffer,
-                                size_t size);
-
-
-/**
- * Checks if there is data staying in the buffers of the underlying
- * system that waits to be read. In case of TLS, this will call
- * something like SSL_pending().
- *
- * @param session which is checked
- * @return SPDY_YES if data is pending or SPDY_NO otherwise
- */
-typedef int
-(*SPDYF_IOIsPending) (struct SPDY_Session *session);
-
-
-/**
- * Called just before frames are about to be processed and written
- * to the socket.
- *
- * @param session
- * @return SPDY_NO if writing must not happen in the call;
- *         SPDY_YES otherwise
- */
-typedef int
-(*SPDYF_IOBeforeWrite) (struct SPDY_Session *session);
-
-
-/**
- * Called just after frames have been processed and written
- * to the socket.
- *
- * @param session
- * @param was_written has the same value as the write function for the
- *        session will return 
- * @return returned value will be used by the write function to return
- */
-typedef int
-(*SPDYF_IOAfterWrite) (struct SPDY_Session *session,
-                       int was_written);
-
-
-/**
- * Sets callbacks for the daemon with regard to the IO subsystem.
- *
- * @param daemon
- * @param io_subsystem the IO subsystem that will
- *        be initialized and used by daemon.
- * @return SPDY_YES on success or SPDY_NO otherwise
- */
-int
-SPDYF_io_set_daemon(struct SPDY_Daemon *daemon,
-                    enum SPDY_IO_SUBSYSTEM io_subsystem);
-
-
-/**
- * Sets callbacks for the session with regard to the IO subsystem.
- *
- * @param session
- * @param io_subsystem the IO subsystem that will
- *        be initialized and used by session.
- * @return SPDY_YES on success or SPDY_NO otherwise
- */
-int
-SPDYF_io_set_session(struct SPDY_Session *session,
-                     enum SPDY_IO_SUBSYSTEM io_subsystem);
-
-#endif
diff --git a/src/microspdy/io_openssl.c b/src/microspdy/io_openssl.c
deleted file mode 100644
index f71a9230..00000000
--- a/src/microspdy/io_openssl.c
+++ /dev/null
@@ -1,280 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file io_openssl.c
- * @brief  TLS handling using libssl. The current code assumes that
- *                      blocking I/O is in use.
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include "internal.h"
-#include "session.h"
-#include "io_openssl.h"
-
-
-/**
- * Callback to advertise spdy ver. 3 in Next Protocol Negotiation
- *
- * @param ssl openssl context for a connection
- * @param out must be set to the raw data that is advertised in NPN
- * @param outlen must be set to size of out
- * @param arg
- * @return SSL_TLSEXT_ERR_OK to do advertising
- */
-static int
-spdyf_next_protos_advertised_cb (SSL *ssl, const unsigned char **out, unsigned int *outlen, void *arg)
-{
-        (void)ssl;
-        (void)arg;
-        static unsigned char npn_spdy3[] = {0x06, // length of "spdy/3"
-                0x73,0x70,0x64,0x79,0x2f,0x33};// spdy/3
-
-        *out = npn_spdy3;
-        *outlen = 7; // total length of npn_spdy3
-        return SSL_TLSEXT_ERR_OK;
-}
-
-
-void
-SPDYF_openssl_global_init()
-{
-        //error strings are now not used by the lib
-    //SSL_load_error_strings();
-    //init libssl
-    SSL_library_init(); //always returns 1
-    //the table for looking up algos is not used now by the lib
-    //OpenSSL_add_all_algorithms();
-}
-
-
-void
-SPDYF_openssl_global_deinit()
-{
-        //if SSL_load_error_strings was called
-    //ERR_free_strings();
-    //if OpenSSL_add_all_algorithms was called
-    //EVP_cleanup();
-}
-
-
-int
-SPDYF_openssl_init(struct SPDY_Daemon *daemon)
-{
-    int options;
-    //create ssl context. TLSv1 used
-    if(NULL == (daemon->io_context = SSL_CTX_new(TLSv1_server_method())))
-    {
-                SPDYF_DEBUG("Couldn't create ssl context");
-                return SPDY_NO;
-        }
-        //set options for tls
-        //TODO DH is not enabled for easier debugging
-    //SSL_CTX_set_options(daemon->io_context, SSL_OP_SINGLE_DH_USE);
-
-    //TODO here session tickets are disabled for easier debuging with
-    //wireshark when using Chrome
-    // SSL_OP_NO_COMPRESSION disables TLS compression to avoid CRIME attack
-    options = SSL_OP_NO_TICKET;
-#ifdef SSL_OP_NO_COMPRESSION
-    options |= SSL_OP_NO_COMPRESSION;
-#elif OPENSSL_VERSION_NUMBER >= 0x00908000L /* workaround for OpenSSL 0.9.8 */
-    sk_SSL_COMP_zero(SSL_COMP_get_compression_methods());
-#endif
-
-    SSL_CTX_set_options(daemon->io_context, options);
-    if(1 != SSL_CTX_use_certificate_file(daemon->io_context, daemon->certfile , SSL_FILETYPE_PEM))
-    {
-                SPDYF_DEBUG("Couldn't load the cert file");
-                SSL_CTX_free(daemon->io_context);
-                return SPDY_NO;
-        }
-    if(1 != SSL_CTX_use_PrivateKey_file(daemon->io_context, daemon->keyfile, SSL_FILETYPE_PEM))
-    {
-                SPDYF_DEBUG("Couldn't load the name file");
-                SSL_CTX_free(daemon->io_context);
-                return SPDY_NO;
-        }
-    SSL_CTX_set_next_protos_advertised_cb(daemon->io_context, &spdyf_next_protos_advertised_cb, NULL);
-    if (1 != SSL_CTX_set_cipher_list(daemon->io_context, "HIGH"))
-    {
-                SPDYF_DEBUG("Couldn't set the desired cipher list");
-                SSL_CTX_free(daemon->io_context);
-                return SPDY_NO;
-        }
-
-        return SPDY_YES;
-}
-
-
-void
-SPDYF_openssl_deinit(struct SPDY_Daemon *daemon)
-{
-    SSL_CTX_free(daemon->io_context);
-}
-
-
-int
-SPDYF_openssl_new_session(struct SPDY_Session *session)
-{
-        int ret;
-
-        if(NULL == (session->io_context = SSL_new(session->daemon->io_context)))
-    {
-                SPDYF_DEBUG("Couldn't create ssl structure");
-                return SPDY_NO;
-        }
-        if(1 != (ret = SSL_set_fd(session->io_context, session->socket_fd)))
-    {
-                SPDYF_DEBUG("SSL_set_fd %i",ret);
-                SSL_free(session->io_context);
-                session->io_context = NULL;
-                return SPDY_NO;
-        }
-
-        //for non-blocking I/O SSL_accept may return -1
-        //and this function won't work
-        if(1 != (ret = SSL_accept(session->io_context)))
-    {
-                SPDYF_DEBUG("SSL_accept %i",ret);
-                SSL_free(session->io_context);
-                session->io_context = NULL;
-                return SPDY_NO;
-        }
-        /* alternatively
-        SSL_set_accept_state(session->io_context);
-        * may be called and then the negotiation will be done on reading
-        */
-
-        return SPDY_YES;
-}
-
-
-void
-SPDYF_openssl_close_session(struct SPDY_Session *session)
-{
-        //SSL_shutdown sends TLS "close notify" as in TLS standard.
-        //The function may fail as it waits for the other party to also close
-        //the TLS session. The lib just sends it and will close the socket
-        //after that because the browsers don't seem to care much about
-        //"close notify"
-        SSL_shutdown(session->io_context);
-
-        SSL_free(session->io_context);
-}
-
-
-int
-SPDYF_openssl_recv(struct SPDY_Session *session,
-                                void * buffer,
-                                size_t size)
-{
-        int ret;
-        int n = SSL_read(session->io_context,
-                                        buffer,
-                                        size);
-        //if(n > 0) SPDYF_DEBUG("recvd: %i",n);
-        if (n <= 0)
-        {
-                ret = SSL_get_error(session->io_context, n);
-                switch(ret)
-                {
-                        case SSL_ERROR_ZERO_RETURN:
-                                return 0;
-
-                        case SSL_ERROR_WANT_READ:
-                        case SSL_ERROR_WANT_WRITE:
-                                return SPDY_IO_ERROR_AGAIN;
-
-                        case SSL_ERROR_SYSCALL:
-                                if(EINTR == errno)
-                                        return SPDY_IO_ERROR_AGAIN;
-                                return SPDY_IO_ERROR_ERROR;
-                        default:
-                                return SPDY_IO_ERROR_ERROR;
-                }
-        }
-
-        return n;
-}
-
-
-int
-SPDYF_openssl_send(struct SPDY_Session *session,
-                                const void * buffer,
-                                size_t size)
-{
-        int ret;
-
-        int n = SSL_write(session->io_context,
-                                        buffer,
-                                        size);
-        //if(n > 0) SPDYF_DEBUG("sent: %i",n);
-        if (n <= 0)
-        {
-                ret = SSL_get_error(session->io_context, n);
-                switch(ret)
-                {
-                        case SSL_ERROR_ZERO_RETURN:
-                                return 0;
-
-                        case SSL_ERROR_WANT_READ:
-                        case SSL_ERROR_WANT_WRITE:
-                                return SPDY_IO_ERROR_AGAIN;
-
-                        case SSL_ERROR_SYSCALL:
-                                if(EINTR == errno)
-                                        return SPDY_IO_ERROR_AGAIN;
-                                return SPDY_IO_ERROR_ERROR;
-                        default:
-                                return SPDY_IO_ERROR_ERROR;
-                }
-        }
-
-        return n;
-}
-
-
-int
-SPDYF_openssl_is_pending(struct SPDY_Session *session)
-{
-        /* From openssl docs:
-         * BUGS
-SSL_pending() takes into account only bytes from the TLS/SSL record that is currently being processed (if any). If the SSL object's read_ahead flag is set, additional protocol bytes may have been read containing more TLS/SSL records; these are ignored by SSL_pending().
-         */
-        return SSL_pending(session->io_context) > 0 ? SPDY_YES : SPDY_NO;
-}
-
-
-int
-SPDYF_openssl_before_write(struct SPDY_Session *session)
-{
-  (void)session;
-
-  return SPDY_YES;
-}
-
-
-int
-SPDYF_openssl_after_write(struct SPDY_Session *session, int was_written)
-{
-  (void)session;
-
-  return was_written;
-}
diff --git a/src/microspdy/io_openssl.h b/src/microspdy/io_openssl.h
deleted file mode 100644
index a4e94293..00000000
--- a/src/microspdy/io_openssl.h
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file io_openssl.h
- * @brief  TLS handling. openssl with NPN is used, but as long as the
- *                      functions conform to this interface file, other libraries
- *                      can be used.
- * @author Andrey Uzunov
- */
-
-#ifndef IO_OPENSSL_H
-#define IO_OPENSSL_H
-
-#include "platform.h"
-#include "io.h"
-#include <openssl/err.h>
-#include <openssl/ssl.h>
-#include <openssl/rand.h>
-
-
-/**
- * Global initializing of openssl. Must be called only once in the program.
- *
- */
-void
-SPDYF_openssl_global_init();
-
-
-/**
- * Global deinitializing of openssl for the whole program. Should be called
- * at the end of the program.
- *
- */
-void
-SPDYF_openssl_global_deinit();
-
-
-/**
- * Initializing of openssl for a specific daemon.
- * Must be called when the daemon starts.
- *
- * @param daemon SPDY_Daemon for which openssl will be used. Daemon's
- *                              certificate and key file are used.
- * @return SPDY_YES on success or SPDY_NO on error
- */
-int
-SPDYF_openssl_init(struct SPDY_Daemon *daemon);
-
-
-/**
- * Deinitializing openssl for a daemon. Should be called
- * when the deamon is stopped.
- *
- * @param daemon SPDY_Daemon which is being stopped
- */
-void
-SPDYF_openssl_deinit(struct SPDY_Daemon *daemon);
-
-
-/**
- * Initializing openssl for a specific connection. Must be called
- * after the connection has been accepted.
- *
- * @param session SPDY_Session whose socket will be used by openssl
- * @return SPDY_NO if some openssl funcs fail. SPDY_YES otherwise
- */
-int
-SPDYF_openssl_new_session(struct SPDY_Session *session);
-
-
-/**
- * Deinitializing openssl for a specific connection. Should be called
- * closing session's socket.
- *
- * @param session SPDY_Session whose socket is used by openssl
- */
-void
-SPDYF_openssl_close_session(struct SPDY_Session *session);
-
-
-/**
- * Reading from a TLS socket. Reads available data and put it to the
- * buffer.
- *
- * @param session for which data is received
- * @param buffer where data from the socket will be written to
- * @param size of the buffer
- * @return number of bytes (at most size) read from the TLS connection
- *         0 if the other party has closed the connection
- *         SPDY_IO_ERROR code on error
- */
-int
-SPDYF_openssl_recv(struct SPDY_Session *session,
-                                void * buffer,
-                                size_t size);
-
-
-/**
- * Writing to a TLS socket. Writes the data given into the buffer to the
- * TLS socket.
- *
- * @param session whose context is used
- * @param buffer from where data will be written to the socket
- * @param size number of bytes to be taken from the buffer
- * @return number of bytes (at most size) from the buffer that has been
- *                      written to the TLS connection
- *         0 if the other party has closed the connection
- *         SPDY_IO_ERROR code on error
- */
-int
-SPDYF_openssl_send(struct SPDY_Session *session,
-                                const void * buffer,
-                                size_t size);
-
-
-/**
- * Checks if there is data staying in the buffers of the underlying
- * system that waits to be read.
- *
- * @param session which is checked
- * @return SPDY_YES if data is pending or SPDY_NO otherwise
- */
-int
-SPDYF_openssl_is_pending(struct SPDY_Session *session);
-
-
-/**
- * Nothing.
- *
- * @param session
- * @return SPDY_NO if writing must not happen in the call;
- *         SPDY_YES otherwise
- */
-int
-SPDYF_openssl_before_write(struct SPDY_Session *session);
-
-
-/**
- * Nothing.
- *
- * @param session
- * @param was_written has the same value as the write function for the
- *        session will return 
- * @return returned value will be used by the write function to return
- */
-int
-SPDYF_openssl_after_write(struct SPDY_Session *session, int was_written);
-
-
-#endif
diff --git a/src/microspdy/io_raw.c b/src/microspdy/io_raw.c
deleted file mode 100644
index 722f347e..00000000
--- a/src/microspdy/io_raw.c
+++ /dev/null
@@ -1,194 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file io_raw.c
- * @brief  IO for SPDY without TLS.
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include "internal.h"
-#include "session.h"
-#include "io_raw.h"
-//TODO put in in the right place
-#include <netinet/tcp.h>
-
-
-void
-SPDYF_raw_global_init()
-{
-}
-
-
-void
-SPDYF_raw_global_deinit()
-{
-}
-
-
-int
-SPDYF_raw_init(struct SPDY_Daemon *daemon)
-{
-  (void)daemon;
-  
-        return SPDY_YES;
-}
-
-
-void
-SPDYF_raw_deinit(struct SPDY_Daemon *daemon)
-{
-  (void)daemon;
-}
-
-
-int
-SPDYF_raw_new_session(struct SPDY_Session *session)
-{       
-  int fd_flags;
-  int val = 1;
-  int ret;
-  
-        //setting the socket to be non-blocking
-        fd_flags = fcntl (session->socket_fd, F_GETFL);
-        if ( -1 == fd_flags
-                || 0 != fcntl (session->socket_fd, F_SETFL, fd_flags | O_NONBLOCK))
-                SPDYF_DEBUG("WARNING: Couldn't set the new connection to be non-blocking");
-  
-  if(SPDY_DAEMON_FLAG_NO_DELAY & session->daemon->flags)
-  {
-    ret = setsockopt(session->socket_fd, IPPROTO_TCP, TCP_NODELAY, &val, (socklen_t)sizeof(val));
-    if(-1 == ret)
-      SPDYF_DEBUG("WARNING: Couldn't set the new connection to TCP_NODELAY");
-  }
-  
-        return SPDY_YES;
-}
-
-
-void
-SPDYF_raw_close_session(struct SPDY_Session *session)
-{
-  (void)session;
-}
-
-
-int
-SPDYF_raw_recv(struct SPDY_Session *session,
-                                void * buffer,
-                                size_t size)
-{
-        int n = read(session->socket_fd, 
-                                        buffer,
-                                        size);
-        //if(n > 0) SPDYF_DEBUG("recvd: %i",n);
-        if (n < 0)
-        {
-                switch(errno)
-                {                               
-                        case EAGAIN:
-#if EAGAIN != EWOULDBLOCK
-      case EWOULDBLOCK:
-#endif
-                        case EINTR:
-        return SPDY_IO_ERROR_AGAIN;
-                                
-                        default:
-                                return SPDY_IO_ERROR_ERROR;
-                }
-        }
-
-        return n;
-}
-
-
-int
-SPDYF_raw_send(struct SPDY_Session *session,
-                                const void * buffer,
-                                size_t size)
-{
-        int n = write(session->socket_fd, 
-                                        buffer,
-                                        size);
-        //if(n > 0) SPDYF_DEBUG("sent: %i",n);
-        if (n < 0)
-        {
-                switch(errno)
-                {                               
-                        case EAGAIN:
-#if EAGAIN != EWOULDBLOCK
-      case EWOULDBLOCK:
-#endif
-                        case EINTR:
-        return SPDY_IO_ERROR_AGAIN;
-                                
-                        default:
-                                return SPDY_IO_ERROR_ERROR;
-                }
-        }
-        
-        return n;
-}
-
-
-int
-SPDYF_raw_is_pending(struct SPDY_Session *session)
-{
-  (void)session;
-  
-        return SPDY_NO;
-}
-
-
-int
-SPDYF_raw_before_write(struct SPDY_Session *session)
-{
-#if HAVE_DECL_TCP_CORK
-  if(0 == (SPDY_DAEMON_FLAG_NO_DELAY & session->daemon->flags))
-  {
-    int val = 1;
-    int ret;
-    
-    ret = setsockopt(session->socket_fd, IPPROTO_TCP, TCP_CORK, &val, (socklen_t)sizeof(val));
-    if(-1 == ret)
-      SPDYF_DEBUG("WARNING: Couldn't set the new connection to TCP_CORK");
-  }
-#endif
-  
-        return SPDY_YES;
-}
-
-
-int
-SPDYF_raw_after_write(struct SPDY_Session *session, int was_written)
-{
-#if HAVE_DECL_TCP_CORK
-  if(SPDY_YES == was_written && 0 == (SPDY_DAEMON_FLAG_NO_DELAY & session->daemon->flags))
-  {
-    int val = 0;
-    int ret;
-    
-    ret = setsockopt(session->socket_fd, IPPROTO_TCP, TCP_CORK, &val, (socklen_t)sizeof(val));
-    if(-1 == ret)
-      SPDYF_DEBUG("WARNING: Couldn't unset the new connection to TCP_CORK");
-  }
-  
-#endif
-        return was_written;
-}
diff --git a/src/microspdy/io_raw.h b/src/microspdy/io_raw.h
deleted file mode 100644
index 8ca830bf..00000000
--- a/src/microspdy/io_raw.h
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file io_raw.h
- * @brief  IO for SPDY without TLS.
- * @author Andrey Uzunov
- */
-
-#ifndef IO_RAW_H
-#define IO_RAW_H
-
-#include "platform.h"
-
-
-/**
- * Must be called only once in the program.
- *
- */
-void
-SPDYF_raw_global_init();
-
-
-/**
- * Should be called
- * at the end of the program.
- *
- */
-void
-SPDYF_raw_global_deinit();
-
-
-/**
- * Must be called when the daemon starts.
- *
- * @param daemon SPDY_Daemon 
- * @return SPDY_YES on success or SPDY_NO on error
- */
-int
-SPDYF_raw_init(struct SPDY_Daemon *daemon);
-
-
-/**
- * Should be called
- * when the deamon is stopped.
- *
- * @param daemon SPDY_Daemon which is being stopped
- */
-void
-SPDYF_raw_deinit(struct SPDY_Daemon *daemon);
-
-
-/**
- * Must be called
- * after the connection has been accepted.
- *
- * @param session SPDY_Session whose socket will be used
- * @return SPDY_NO if some funcs fail. SPDY_YES otherwise
- */
-int
-SPDYF_raw_new_session(struct SPDY_Session *session);
-
-
-/**
- * Should be called
- * closing session's socket.
- *
- * @param session SPDY_Session whose socket is used
- */
-void
-SPDYF_raw_close_session(struct SPDY_Session *session);
-
-
-/**
- * Reading from socket. Reads available data and put it to the
- * buffer.
- *
- * @param session for which data is received
- * @param buffer where data from the socket will be written to
- * @param size of the buffer
- * @return number of bytes (at most size) read from the connection
- *         0 if the other party has closed the connection
- *         SPDY_IO_ERROR code on error
- */
-int
-SPDYF_raw_recv(struct SPDY_Session *session,
-                                void * buffer,
-                                size_t size);
-
-
-/**
- * Writing to socket. Writes the data given into the buffer to the
- * socket.
- *
- * @param session whose context is used
- * @param buffer from where data will be written to the socket
- * @param size number of bytes to be taken from the buffer
- * @return number of bytes (at most size) from the buffer that has been
- *                      written to the connection
- *         0 if the other party has closed the connection
- *         SPDY_IO_ERROR code on error
- */
-int
-SPDYF_raw_send(struct SPDY_Session *session,
-                                const void * buffer,
-                                size_t size);
-
-
-/**
- * Checks if there is data staying in the buffers of the underlying
- * system that waits to be read. Always returns SPDY_NO, as we do not
- * use a subsystem here.
- *
- * @param session which is checked
- * @return SPDY_YES if data is pending or SPDY_NO otherwise
- */
-int
-SPDYF_raw_is_pending(struct SPDY_Session *session);
-
-
-/**
- * Sets TCP_CORK.
- *
- * @param session
- * @return SPDY_NO if writing must not happen in the call;
- *         SPDY_YES otherwise
- */
-int
-SPDYF_raw_before_write(struct SPDY_Session *session);
-
-
-/**
- * Unsets TCP_CORK.
- *
- * @param session
- * @param was_written has the same value as the write function for the
- *        session will return 
- * @return returned value will be used by the write function to return
- */
-int
-SPDYF_raw_after_write(struct SPDY_Session *session, int was_written);
-
-#endif
diff --git a/src/microspdy/session.c b/src/microspdy/session.c
deleted file mode 100644
index 7cb8c3d1..00000000
--- a/src/microspdy/session.c
+++ /dev/null
@@ -1,1769 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file session.c
- * @brief  TCP connection/SPDY session handling. So far most of the
- *                      functions for handling SPDY framing layer are here.
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include "structures.h"
-#include "internal.h"
-#include "session.h"
-#include "compression.h"
-#include "stream.h"
-#include "io.h"
-
-
-/**
- * Handler for reading the full SYN_STREAM frame after we know that
- * the frame is such.
- * The function waits for the full frame and then changes status
- * of the session. New stream is created.
- *
- * @param session SPDY_Session whose read buffer is used.
- */
-static void
-spdyf_handler_read_syn_stream (struct SPDY_Session *session)
-{
-  size_t name_value_strm_size = 0;
-  unsigned int compressed_data_size;
-  int ret;
-  void *name_value_strm = NULL;
-  struct SPDYF_Control_Frame *frame;
-  struct SPDY_NameValue *headers;
-
-  SPDYF_ASSERT(SPDY_SESSION_STATUS_WAIT_FOR_SUBHEADER == session->status
-               || SPDY_SESSION_STATUS_WAIT_FOR_BODY == session->status,
-               "the function is called wrong");
-
-  frame = (struct SPDYF_Control_Frame *)session->frame_handler_cls;
-
-  //handle subheaders
-  if(SPDY_SESSION_STATUS_WAIT_FOR_SUBHEADER == session->status)
-    {
-      if(0 == frame->length)
-        {
-          //protocol error: incomplete frame
-          //we just ignore it since there is no stream id for which to
-          //send RST_STREAM
-          //TODO maybe GOAWAY and closing session is appropriate
-          SPDYF_DEBUG("zero long SYN_STREAM received");
-          session->status = SPDY_SESSION_STATUS_WAIT_FOR_HEADER;
-          free(frame);
-          return;
-        }
-
-      if(SPDY_YES != SPDYF_stream_new(session))
-        {
-          /* waiting for some more fields to create new stream
-             or something went wrong, SPDYF_stream_new has handled the
-             situation */
-          return;
-        }
-
-      session->current_stream_id = session->streams_head->stream_id;
-      if(frame->length > SPDY_MAX_SUPPORTED_FRAME_SIZE)
-        {
-          //TODO no need to create stream if this happens
-          session->status = SPDY_SESSION_STATUS_IGNORE_BYTES;
-          return;
-        }
-      else
-        session->status = SPDY_SESSION_STATUS_WAIT_FOR_BODY;
-    }
-
-  //handle body
-
-  //start reading the compressed name/value pairs (http headers)
-  compressed_data_size = frame->length //everything after length field
-    - 10;//4B stream id, 4B assoc strem id, 2B priority, unused and slot
-
-  if(session->read_buffer_offset - session->read_buffer_beginning < compressed_data_size)
-    {
-      // the full frame is not yet here, try later
-      return;
-    }
-
-  if ( (compressed_data_size > 0) &&
-       (SPDY_YES !=
-        SPDYF_zlib_inflate(&session->zlib_recv_stream,
-                           session->read_buffer + session->read_buffer_beginning,
-                           compressed_data_size,
-                           &name_value_strm,
-                           &name_value_strm_size)) )
-    {
-      /* something went wrong on inflating,
-       * the state of the stream for decompression is unknown
-       * and we may not be able to read anything more received on
-       * this session,
-       * so it is better to close the session */
-      free(name_value_strm);
-      free(frame);
-
-      /* mark the session for closing and close it, when
-       * everything on the output queue is already written */
-      session->status = SPDY_SESSION_STATUS_FLUSHING;
-
-      SPDYF_prepare_goaway(session, SPDY_GOAWAY_STATUS_INTERNAL_ERROR, false);
-
-      return;
-    }
-
-  if(0 == name_value_strm_size || 0 == compressed_data_size)
-    {
-      //Protocol error: send RST_STREAM
-      if(SPDY_YES != SPDYF_prepare_rst_stream(session, session->streams_head,
-                                              SPDY_RST_STREAM_STATUS_PROTOCOL_ERROR))
-        {
-          //no memory, try later to send RST
-          free(name_value_strm);
-          return;
-        }
-    }
-  else
-    {
-      ret = SPDYF_name_value_from_stream(name_value_strm, name_value_strm_size, &headers);
-      if(SPDY_NO == ret)
-        {
-          //memory error, try later
-          free(name_value_strm);
-          return;
-        }
-
-      session->streams_head->headers = headers;
-      //inform the application layer for the new stream received
-      if(SPDY_YES != session->daemon->fnew_stream_cb(session->daemon->fcls, session->streams_head))
-        {
-          //memory error, try later
-          free(name_value_strm);
-          return;
-        }
-
-      session->read_buffer_beginning += compressed_data_size;
-    }
-
-  //SPDYF_DEBUG("syn_stream received: id %i", session->current_stream_id);
-
-  //change state to wait for new frame
-  free(name_value_strm);
-  session->status = SPDY_SESSION_STATUS_WAIT_FOR_HEADER;
-  free(frame);
-}
-
-
-/**
- * Handler for reading the GOAWAY frame after we know that
- * the frame is such.
- * The function waits for the full frame and then changes status
- * of the session.
- *
- * @param session SPDY_Session whose read buffer is used.
- */
-static void
-spdyf_handler_read_goaway (struct SPDY_Session *session)
-{
-        struct SPDYF_Control_Frame *frame;
-        uint32_t last_good_stream_id;
-        uint32_t status_int;
-        enum SPDY_GOAWAY_STATUS status;
-
-        SPDYF_ASSERT(SPDY_SESSION_STATUS_WAIT_FOR_SUBHEADER == session->status,
-                "the function is called wrong");
-
-        frame = (struct SPDYF_Control_Frame *)session->frame_handler_cls;
-
-        if(frame->length > SPDY_MAX_SUPPORTED_FRAME_SIZE)
-        {
-                //this is a protocol error/attack
-                session->status = SPDY_SESSION_STATUS_IGNORE_BYTES;
-                return;
-        }
-
-        if(0 != frame->flags || 8 != frame->length)
-        {
-                //this is a protocol error
-                SPDYF_DEBUG("wrong GOAWAY received");
-                //anyway, it will be handled
-        }
-
-        if((session->read_buffer_offset - session->read_buffer_beginning) < frame->length)
-        {
-                //not all fields are received
-                //try later
-                return;
-        }
-
-        //mark that the session is almost closed
-        session->is_goaway_received = true;
-
-        if(8 == frame->length)
-        {
-                memcpy(&last_good_stream_id, session->read_buffer + session->read_buffer_beginning, 4);
-                last_good_stream_id = NTOH31(last_good_stream_id);
-                session->read_buffer_beginning += 4;
-
-                memcpy(&status_int, session->read_buffer + session->read_buffer_beginning, 4);
-                status = ntohl(status_int);
-                session->read_buffer_beginning += 4;
-
-                //TODO do something with last_good
-
-                //SPDYF_DEBUG("Received GOAWAY; status=%i; lastgood=%i",status,last_good_stream_id);
-
-                //do something according to the status
-                //TODO
-                switch(status)
-                {
-                        case SPDY_GOAWAY_STATUS_OK:
-                                break;
-                        case SPDY_GOAWAY_STATUS_PROTOCOL_ERROR:
-                                break;
-                        case SPDY_GOAWAY_STATUS_INTERNAL_ERROR:
-                                break;
-                }
-
-    //SPDYF_DEBUG("goaway received: status %i", status);
-        }
-
-        session->status = SPDY_SESSION_STATUS_WAIT_FOR_HEADER;
-        free(frame);
-}
-
-
-/**
- * Handler for reading RST_STREAM frames. After receiving the frame
- * the stream moves into closed state and status
- * of the session is changed. Frames, belonging to this stream, which
- * are still at the output queue, will be ignored later.
- *
- * @param session SPDY_Session whose read buffer is used.
- */
-static void
-spdyf_handler_read_rst_stream (struct SPDY_Session *session)
-{
-        struct SPDYF_Control_Frame *frame;
-        uint32_t stream_id;
-        int32_t status_int;
-        //enum SPDY_RST_STREAM_STATUS status; //for debug
-        struct SPDYF_Stream *stream;
-
-        SPDYF_ASSERT(SPDY_SESSION_STATUS_WAIT_FOR_SUBHEADER == session->status,
-                "the function is called wrong");
-
-        frame = (struct SPDYF_Control_Frame *)session->frame_handler_cls;
-
-        if(0 != frame->flags || 8 != frame->length)
-        {
-                //this is a protocol error
-                SPDYF_DEBUG("wrong RST_STREAM received");
-                //ignore as a large frame
-                session->status = SPDY_SESSION_STATUS_IGNORE_BYTES;
-                return;
-        }
-
-        if((session->read_buffer_offset - session->read_buffer_beginning) < frame->length)
-        {
-                //not all fields are received
-                //try later
-                return;
-        }
-
-    memcpy(&stream_id, session->read_buffer + session->read_buffer_beginning, 4);
-        stream_id = NTOH31(stream_id);
-        session->read_buffer_beginning += 4;
-
-    memcpy(&status_int, session->read_buffer + session->read_buffer_beginning, 4);
-        //status = ntohl(status_int); //for debug
-        session->read_buffer_beginning += 4;
-
-        session->status = SPDY_SESSION_STATUS_WAIT_FOR_HEADER;
-        free(frame);
-
-        //mark the stream as closed
-        stream = session->streams_head;
-        while(NULL != stream)
-        {
-                if(stream_id == stream->stream_id)
-                {
-                        stream->is_in_closed = true;
-                        stream->is_out_closed = true;
-                        break;
-                }
-                stream = stream->next;
-        }
-
-        //SPDYF_DEBUG("Received RST_STREAM; status=%i; id=%i",status,stream_id);
-
-        //do something according to the status
-        //TODO
-        /*switch(status)
-        {
-                case SPDY_RST_STREAM_STATUS_PROTOCOL_ERROR:
-                        break;
-        }*/
-}
-
-
-/**
- * Handler for reading DATA frames. In requests they are used for POST
- * arguments.
- *
- * @param session SPDY_Session whose read buffer is used.
- */
-static void
-spdyf_handler_read_data (struct SPDY_Session *session)
-{
-  int ret;
-  struct SPDYF_Data_Frame * frame;
-  struct SPDYF_Stream * stream;
-
-        SPDYF_ASSERT(SPDY_SESSION_STATUS_WAIT_FOR_SUBHEADER == session->status
-                || SPDY_SESSION_STATUS_WAIT_FOR_BODY == session->status,
-                "the function is called wrong");
-
-  //SPDYF_DEBUG("DATA frame received (POST?). Ignoring");
-
-  //SPDYF_SIGINT("");
-
-        frame = (struct SPDYF_Data_Frame *)session->frame_handler_cls;
-
-        //handle subheaders
-        if(SPDY_SESSION_STATUS_WAIT_FOR_SUBHEADER == session->status)
-        {
-                if(frame->length > SPDY_MAX_SUPPORTED_FRAME_SIZE)
-                {
-                        session->status = SPDY_SESSION_STATUS_IGNORE_BYTES;
-                        return;
-                }
-                else
-                        session->status = SPDY_SESSION_STATUS_WAIT_FOR_BODY;
-        }
-
-        //handle body
-
-        if(session->read_buffer_offset - session->read_buffer_beginning
-                >= frame->length)
-        {
-    stream = SPDYF_stream_find(frame->stream_id, session);
-
-    if(NULL == stream || stream->is_in_closed || NULL == session->daemon->received_data_cb)
-    {
-      if(NULL == session->daemon->received_data_cb)
-      SPDYF_DEBUG("No callback for DATA frame set; Ignoring DATA frame!");
-
-      //TODO send error?
-
-      //TODO for now ignore frame
-      session->read_buffer_beginning += frame->length;
-      session->status = SPDY_SESSION_STATUS_WAIT_FOR_HEADER;
-      free(frame);
-      return;
-    }
-
-    ret = session->daemon->freceived_data_cb(session->daemon->cls,
-                                      stream,
-                                      session->read_buffer + session->read_buffer_beginning,
-                                      frame->length,
-                                      0 == (SPDY_DATA_FLAG_FIN & frame->flags));
-
-    session->read_buffer_beginning += frame->length;
-
-    stream->window_size -= frame->length;
-
-    //TODO close in and send rst maybe
-    SPDYF_ASSERT(SPDY_YES == ret, "Cancel POST data is not yet implemented");
-
-    if(SPDY_DATA_FLAG_FIN & frame->flags)
-    {
-      stream->is_in_closed = true;
-    }
-    else if(stream->window_size < SPDYF_INITIAL_WINDOW_SIZE / 2)
-    {
-      //very simple implementation of flow control
-      //when the window's size is under the half of the initial value,
-      //increase it again up to the initial value
-
-      //prepare WINDOW_UPDATE
-      if(SPDY_YES == SPDYF_prepare_window_update(session, stream,
-            SPDYF_INITIAL_WINDOW_SIZE - stream->window_size))
-      {
-        stream->window_size = SPDYF_INITIAL_WINDOW_SIZE;
-      }
-      //else: do it later
-    }
-
-    //SPDYF_DEBUG("data received: id %i", frame->stream_id);
-
-    session->status = SPDY_SESSION_STATUS_WAIT_FOR_HEADER;
-    free(frame);
-        }
-}
-
-
-int
-SPDYF_handler_write_syn_reply (struct SPDY_Session *session)
-{
-        struct SPDYF_Response_Queue *response_queue = session->response_queue_head;
-        struct SPDYF_Stream *stream = response_queue->stream;
-        struct SPDYF_Control_Frame control_frame;
-        void *compressed_headers = NULL;
-        size_t compressed_headers_size=0;
-        size_t used_data=0;
-        size_t total_size;
-        uint32_t stream_id_nbo;
-
-        SPDYF_ASSERT(NULL == session->write_buffer, "the function is called not in the correct moment");
-
-        memcpy(&control_frame, response_queue->control_frame, sizeof(control_frame));
-
-        if(SPDY_YES != SPDYF_zlib_deflate(&session->zlib_send_stream,
-                response_queue->data,
-                response_queue->data_size,
-                &used_data,
-                &compressed_headers,
-                &compressed_headers_size))
-        {
-                /* something went wrong on compressing,
-                * the state of the stream for compression is unknown
-                * and we may not be able to send anything more on
-                * this session,
-                * so it is better to close the session right now */
-                session->status = SPDY_SESSION_STATUS_CLOSING;
-
-                free(compressed_headers);
-
-                return SPDY_NO;
-        }
-
-        //TODO do we need this used_Data
-        SPDYF_ASSERT(used_data == response_queue->data_size, "not everything was used by zlib");
-
-        total_size = sizeof(struct SPDYF_Control_Frame) //SPDY header
-                + 4 // stream id as "subheader"
-                + compressed_headers_size;
-
-        if(NULL == (session->write_buffer = malloc(total_size)))
-        {
-                /* no memory
-                 * since we do not save the compressed data anywhere and
-                 * the sending zlib stream is already in new state, we must
-                 * close the session */
-                session->status = SPDY_SESSION_STATUS_CLOSING;
-
-                free(compressed_headers);
-
-                return SPDY_NO;
-        }
-        session->write_buffer_beginning = 0;
-        session->write_buffer_offset = 0;
-        session->write_buffer_size = total_size;
-
-        control_frame.length = compressed_headers_size + 4; // compressed data + stream_id
-        SPDYF_CONTROL_FRAME_HTON(&control_frame);
-
-        //put frame headers to write buffer
-        memcpy(session->write_buffer + session->write_buffer_offset,&control_frame,sizeof(struct SPDYF_Control_Frame));
-        session->write_buffer_offset +=  sizeof(struct SPDYF_Control_Frame);
-
-        //put stream id to write buffer
-        stream_id_nbo = HTON31(stream->stream_id);
-        memcpy(session->write_buffer + session->write_buffer_offset, &stream_id_nbo, 4);
-        session->write_buffer_offset += 4;
-
-        //put compressed name/value pairs to write buffer
-        memcpy(session->write_buffer + session->write_buffer_offset, compressed_headers, compressed_headers_size);
-        session->write_buffer_offset +=  compressed_headers_size;
-
-        SPDYF_ASSERT(0 == session->write_buffer_beginning, "bug1");
-        SPDYF_ASSERT(session->write_buffer_offset == session->write_buffer_size, "bug2");
-
-        //DEBUG CODE, break compression state to see what happens
-/*      SPDYF_zlib_deflate(&session->zlib_send_stream,
-                "1234567890",
-                10,
-                &used_data,
-                &compressed_headers,
-                &compressed_headers_size);
-*/
-        free(compressed_headers);
-
-        session->last_replied_to_stream_id = stream->stream_id;
-
-  //SPDYF_DEBUG("syn_reply sent: id %i", stream->stream_id);
-
-        return SPDY_YES;
-}
-
-
-int
-SPDYF_handler_write_goaway (struct SPDY_Session *session)
-{
-        struct SPDYF_Response_Queue *response_queue = session->response_queue_head;
-        struct SPDYF_Control_Frame control_frame;
-        size_t total_size;
-        int last_good_stream_id;
-
-        SPDYF_ASSERT(NULL == session->write_buffer, "the function is called not in the correct moment");
-
-        memcpy(&control_frame, response_queue->control_frame, sizeof(control_frame));
-
-        session->is_goaway_sent = true;
-
-        total_size = sizeof(struct SPDYF_Control_Frame) //SPDY header
-                + 4 // last good stream id as "subheader"
-                + 4; // status code as "subheader"
-
-        if(NULL == (session->write_buffer = malloc(total_size)))
-        {
-                return SPDY_NO;
-        }
-        session->write_buffer_beginning = 0;
-        session->write_buffer_offset = 0;
-        session->write_buffer_size = total_size;
-
-        control_frame.length = 8; // always for GOAWAY
-        SPDYF_CONTROL_FRAME_HTON(&control_frame);
-
-        //put frame headers to write buffer
-        memcpy(session->write_buffer + session->write_buffer_offset,&control_frame,sizeof(struct SPDYF_Control_Frame));
-        session->write_buffer_offset +=  sizeof(struct SPDYF_Control_Frame);
-
-        //put last good stream id to write buffer
-        last_good_stream_id = HTON31(session->last_replied_to_stream_id);
-        memcpy(session->write_buffer + session->write_buffer_offset, &last_good_stream_id, 4);
-        session->write_buffer_offset +=  4;
-
-        //put "data" to write buffer. This is the status
-        memcpy(session->write_buffer + session->write_buffer_offset, response_queue->data, 4);
-        session->write_buffer_offset +=  4;
-        //data is not freed by the destroy function so:
-        //free(response_queue->data);
-
-  //SPDYF_DEBUG("goaway sent: status %i", NTOH31(*(uint32_t*)(response_queue->data)));
-
-        SPDYF_ASSERT(0 == session->write_buffer_beginning, "bug1");
-        SPDYF_ASSERT(session->write_buffer_offset == session->write_buffer_size, "bug2");
-
-        return SPDY_YES;
-}
-
-
-int
-SPDYF_handler_write_data (struct SPDY_Session *session)
-{
-        struct SPDYF_Response_Queue *response_queue = session->response_queue_head;
-        struct SPDYF_Response_Queue *new_response_queue;
-        size_t total_size;
-        struct SPDYF_Data_Frame data_frame;
-        ssize_t ret;
-        bool more;
-
-        SPDYF_ASSERT(NULL == session->write_buffer, "the function is called not in the correct moment");
-
-        memcpy(&data_frame, response_queue->data_frame, sizeof(data_frame));
-
-        if(NULL == response_queue->response->rcb)
-        {
-                //standard response with data into the struct
-                SPDYF_ASSERT(NULL != response_queue->data, "no data for the response");
-
-                total_size = sizeof(struct SPDYF_Data_Frame) //SPDY header
-                        + response_queue->data_size;
-
-                if(NULL == (session->write_buffer = malloc(total_size)))
-                {
-                        return SPDY_NO;
-                }
-                session->write_buffer_beginning = 0;
-                session->write_buffer_offset = 0;
-                session->write_buffer_size = total_size;
-
-                data_frame.length = response_queue->data_size;
-                SPDYF_DATA_FRAME_HTON(&data_frame);
-
-                //put SPDY headers to the writing buffer
-                memcpy(session->write_buffer + session->write_buffer_offset,&data_frame,sizeof(struct SPDYF_Data_Frame));
-                session->write_buffer_offset +=  sizeof(struct SPDYF_Data_Frame);
-
-                //put data to the writing buffer
-                memcpy(session->write_buffer + session->write_buffer_offset, response_queue->data, response_queue->data_size);
-                session->write_buffer_offset +=  response_queue->data_size;
-        }
-        else
-        {
-                /* response with callbacks. The lib will produce more than 1
-                 * data frames
-                 */
-
-                total_size = sizeof(struct SPDYF_Data_Frame) //SPDY header
-                        + SPDY_MAX_SUPPORTED_FRAME_SIZE; //max possible size
-
-                if(NULL == (session->write_buffer = malloc(total_size)))
-                {
-                        return SPDY_NO;
-                }
-                session->write_buffer_beginning = 0;
-                session->write_buffer_offset = 0;
-                session->write_buffer_size = total_size;
-
-                ret = response_queue->response->rcb(response_queue->response->rcb_cls,
-                        session->write_buffer + sizeof(struct SPDYF_Data_Frame),
-                        response_queue->response->rcb_block_size,
-                        &more);
-
-                if(ret < 0 || ret > response_queue->response->rcb_block_size)
-                {
-                        free(session->write_buffer);
-      session->write_buffer = NULL;
-
-      //send RST_STREAM
-      if(SPDY_YES == (ret = SPDYF_prepare_rst_stream(session,
-        response_queue->stream,
-        SPDY_RST_STREAM_STATUS_INTERNAL_ERROR)))
-      {
-        return SPDY_NO;
-      }
-
-      //else no memory
-                        //for now close session
-                        //TODO what?
-                        session->status = SPDY_SESSION_STATUS_CLOSING;
-
-                        return SPDY_NO;
-                }
-                if(0 == ret && more)
-                {
-                        //the app couldn't write anything to buf but later will
-                        free(session->write_buffer);
-                        session->write_buffer = NULL;
-                        session->write_buffer_size = 0;
-
-                        if(NULL != response_queue->next)
-                        {
-                                //put the frame at the end of the queue
-                                //otherwise - head of line blocking
-                                session->response_queue_head = response_queue->next;
-                                session->response_queue_head->prev = NULL;
-                                session->response_queue_tail->next = response_queue;
-                                response_queue->prev = session->response_queue_tail;
-                                response_queue->next = NULL;
-                                session->response_queue_tail = response_queue;
-                        }
-
-                        return SPDY_YES;
-                }
-
-                if(more)
-                {
-                        //create another response queue object to call the user cb again
-                        if(NULL == (new_response_queue = SPDYF_response_queue_create(true,
-                                                        NULL,
-                                                        0,
-                                                        response_queue->response,
-                                                        response_queue->stream,
-                                                        false,
-                                                        response_queue->frqcb,
-                                                        response_queue->frqcb_cls,
-                                                        response_queue->rrcb,
-                                                        response_queue->rrcb_cls)))
-                        {
-                                //TODO send RST_STREAM
-                                //for now close session
-                                session->status = SPDY_SESSION_STATUS_CLOSING;
-
-                                free(session->write_buffer);
-        session->write_buffer = NULL;
-                                return SPDY_NO;
-                        }
-
-                        //put it at second position on the queue
-                        new_response_queue->prev = response_queue;
-                        new_response_queue->next = response_queue->next;
-                        if(NULL == response_queue->next)
-                        {
-                                session->response_queue_tail = new_response_queue;
-                        }
-                        else
-                        {
-                                response_queue->next->prev = new_response_queue;
-                        }
-                        response_queue->next = new_response_queue;
-
-                        response_queue->frqcb = NULL;
-                        response_queue->frqcb_cls = NULL;
-                        response_queue->rrcb = NULL;
-                        response_queue->rrcb_cls = NULL;
-                }
-                else
-                {
-                        data_frame.flags |= SPDY_DATA_FLAG_FIN;
-                }
-
-                data_frame.length = ret;
-                SPDYF_DATA_FRAME_HTON(&data_frame);
-
-                //put SPDY headers to the writing buffer
-                memcpy(session->write_buffer + session->write_buffer_offset,
-                        &data_frame,
-                        sizeof(struct SPDYF_Data_Frame));
-                session->write_buffer_offset +=  sizeof(struct SPDYF_Data_Frame);
-                session->write_buffer_offset +=  ret;
-                session->write_buffer_size = session->write_buffer_offset;
-        }
-
-  //SPDYF_DEBUG("data sent: id %i", NTOH31(data_frame.stream_id));
-
-        SPDYF_ASSERT(0 == session->write_buffer_beginning, "bug1");
-        SPDYF_ASSERT(session->write_buffer_offset == session->write_buffer_size, "bug2");
-
-        return SPDY_YES;
-}
-
-
-int
-SPDYF_handler_write_rst_stream (struct SPDY_Session *session)
-{
-        struct SPDYF_Response_Queue *response_queue = session->response_queue_head;
-        struct SPDYF_Control_Frame control_frame;
-        size_t total_size;
-
-        SPDYF_ASSERT(NULL == session->write_buffer, "the function is called not in the correct moment");
-
-        memcpy(&control_frame, response_queue->control_frame, sizeof(control_frame));
-
-        total_size = sizeof(struct SPDYF_Control_Frame) //SPDY header
-                + 4 // stream id as "subheader"
-                + 4; // status code as "subheader"
-
-        if(NULL == (session->write_buffer = malloc(total_size)))
-        {
-                return SPDY_NO;
-        }
-        session->write_buffer_beginning = 0;
-        session->write_buffer_offset = 0;
-        session->write_buffer_size = total_size;
-
-        control_frame.length = 8; // always for RST_STREAM
-        SPDYF_CONTROL_FRAME_HTON(&control_frame);
-
-        //put frame headers to write buffer
-        memcpy(session->write_buffer + session->write_buffer_offset,&control_frame,sizeof(struct SPDYF_Control_Frame));
-        session->write_buffer_offset +=  sizeof(struct SPDYF_Control_Frame);
-
-        //put stream id to write buffer. This is the status
-        memcpy(session->write_buffer + session->write_buffer_offset, response_queue->data, 8);
-        session->write_buffer_offset +=  8;
-        //data is not freed by the destroy function so:
-        //free(response_queue->data);
-
-  //SPDYF_DEBUG("rst_stream sent: id %i", NTOH31((((uint64_t)response_queue->data) & 0xFFFF0000) >> 32));
-
-        SPDYF_ASSERT(0 == session->write_buffer_beginning, "bug1");
-        SPDYF_ASSERT(session->write_buffer_offset == session->write_buffer_size, "bug2");
-
-        return SPDY_YES;
-}
-
-
-int
-SPDYF_handler_write_window_update (struct SPDY_Session *session)
-{
-        struct SPDYF_Response_Queue *response_queue = session->response_queue_head;
-        struct SPDYF_Control_Frame control_frame;
-        size_t total_size;
-
-        SPDYF_ASSERT(NULL == session->write_buffer, "the function is called not in the correct moment");
-
-        memcpy(&control_frame, response_queue->control_frame, sizeof(control_frame));
-
-        total_size = sizeof(struct SPDYF_Control_Frame) //SPDY header
-                + 4 // stream id as "subheader"
-                + 4; // delta-window-size as "subheader"
-
-        if(NULL == (session->write_buffer = malloc(total_size)))
-        {
-                return SPDY_NO;
-        }
-        session->write_buffer_beginning = 0;
-        session->write_buffer_offset = 0;
-        session->write_buffer_size = total_size;
-
-        control_frame.length = 8; // always for WINDOW_UPDATE
-        SPDYF_CONTROL_FRAME_HTON(&control_frame);
-
-        //put frame headers to write buffer
-        memcpy(session->write_buffer + session->write_buffer_offset,&control_frame,sizeof(struct SPDYF_Control_Frame));
-        session->write_buffer_offset +=  sizeof(struct SPDYF_Control_Frame);
-
-        //put stream id and delta-window-size to write buffer
-        memcpy(session->write_buffer + session->write_buffer_offset, response_queue->data, 8);
-        session->write_buffer_offset +=  8;
-
-  //SPDYF_DEBUG("window_update sent: id %i", NTOH31((((uint64_t)response_queue->data) & 0xFFFF0000) >> 32));
-
-        SPDYF_ASSERT(0 == session->write_buffer_beginning, "bug1");
-        SPDYF_ASSERT(session->write_buffer_offset == session->write_buffer_size, "bug2");
-
-        return SPDY_YES;
-}
-
-
-void
-SPDYF_handler_ignore_frame (struct SPDY_Session *session)
-{
-        struct SPDYF_Control_Frame *frame;
-
-        SPDYF_ASSERT(SPDY_SESSION_STATUS_WAIT_FOR_SUBHEADER == session->status
-                || SPDY_SESSION_STATUS_WAIT_FOR_BODY == session->status,
-                "the function is called wrong");
-
-
-        frame = (struct SPDYF_Control_Frame *)session->frame_handler_cls;
-
-        //handle subheaders
-        if(SPDY_SESSION_STATUS_WAIT_FOR_SUBHEADER == session->status)
-        {
-                if(frame->length > SPDY_MAX_SUPPORTED_FRAME_SIZE)
-                {
-                        session->status = SPDY_SESSION_STATUS_IGNORE_BYTES;
-                        return;
-                }
-                else
-                        session->status = SPDY_SESSION_STATUS_WAIT_FOR_BODY;
-        }
-
-        //handle body
-
-        if(session->read_buffer_offset - session->read_buffer_beginning
-                >= frame->length)
-        {
-                session->read_buffer_beginning += frame->length;
-                session->status = SPDY_SESSION_STATUS_WAIT_FOR_HEADER;
-                free(frame);
-        }
-}
-
-
-int
-SPDYF_session_read (struct SPDY_Session *session)
-{
-        int bytes_read;
-        bool reallocate;
-        size_t actual_buf_size;
-
-        if(SPDY_SESSION_STATUS_CLOSING == session->status
-                || SPDY_SESSION_STATUS_FLUSHING == session->status)
-                return SPDY_NO;
-
-        //if the read buffer is full to the end, we need to reallocate space
-        if (session->read_buffer_size == session->read_buffer_offset)
-        {
-                //but only if the state of the session requires it
-                //i.e. no further proceeding is possible without reallocation
-                reallocate = false;
-                actual_buf_size = session->read_buffer_offset
-                        - session->read_buffer_beginning;
-                switch(session->status)
-                {
-                        case SPDY_SESSION_STATUS_WAIT_FOR_HEADER:
-
-                        case SPDY_SESSION_STATUS_IGNORE_BYTES:
-                                //we need space for a whole control frame header
-                                if(actual_buf_size < sizeof(struct SPDYF_Control_Frame))
-                                        reallocate = true;
-                                break;
-
-                        case SPDY_SESSION_STATUS_WAIT_FOR_SUBHEADER:
-
-                        case SPDY_SESSION_STATUS_WAIT_FOR_BODY:
-                                //we need as many bytes as set in length field of the
-                                //header
-                                SPDYF_ASSERT(NULL != session->frame_handler_cls,
-                                        "no frame for session");
-                                if(session->frame_handler != &spdyf_handler_read_data)
-                                {
-                                        if(actual_buf_size
-                                                < ((struct SPDYF_Control_Frame *)session->frame_handler_cls)->length)
-                                                reallocate = true;
-                                }
-                                else
-                                {
-                                        if(actual_buf_size
-                                                < ((struct SPDYF_Data_Frame *)session->frame_handler_cls)->length)
-                                                reallocate = true;
-                                }
-                                break;
-
-                        case SPDY_SESSION_STATUS_CLOSING:
-                        case SPDY_SESSION_STATUS_FLUSHING:
-                                //nothing needed
-                                break;
-                }
-
-                if(reallocate)
-                {
-                        //reuse the space in the buffer that was already read by the lib
-                        memmove(session->read_buffer,
-                                session->read_buffer + session->read_buffer_beginning,
-                                session->read_buffer_offset - session->read_buffer_beginning);
-
-                        session->read_buffer_offset -= session->read_buffer_beginning;
-                        session->read_buffer_beginning = 0;
-                }
-                else
-                {
-                        //will read next time
-                        //TODO optimize it, memmove more often?
-                        return SPDY_NO;
-                }
-        }
-
-        session->last_activity = SPDYF_monotonic_time();
-
-        //actual read from the TLS socket
-        bytes_read = session->fio_recv(session,
-                                        session->read_buffer + session->read_buffer_offset,
-                                        session->read_buffer_size - session->read_buffer_offset);
-
-        switch(bytes_read)
-        {
-                case SPDY_IO_ERROR_CLOSED:
-                        //The TLS connection was closed by the other party, clean
-                        //or not
-                        shutdown (session->socket_fd, SHUT_RD);
-                        session->read_closed = true;
-                        session->status = SPDY_SESSION_STATUS_CLOSING;
-                        return SPDY_YES;
-
-                case SPDY_IO_ERROR_ERROR:
-                        //any kind of error in the TLS subsystem
-                        //try to prepare GOAWAY frame
-                        SPDYF_prepare_goaway(session, SPDY_GOAWAY_STATUS_INTERNAL_ERROR, false);
-                        //try to flush the queue when write is called
-                        session->status = SPDY_SESSION_STATUS_FLUSHING;
-                        return SPDY_YES;
-
-                case SPDY_IO_ERROR_AGAIN:
-                        //read or write should be called again; leave it for the
-                        //next time
-                        return SPDY_NO;
-
-                //default:
-                        //something was really read from the TLS subsystem
-                        //just continue
-        }
-
-        session->read_buffer_offset += bytes_read;
-
-        return SPDY_YES;
-}
-
-
-int
-SPDYF_session_write (struct SPDY_Session *session,
-                     bool only_one_frame)
-{
-        unsigned int i;
-        int bytes_written;
-        struct SPDYF_Response_Queue *queue_head;
-        struct SPDYF_Response_Queue *response_queue;
-
-        if(SPDY_SESSION_STATUS_CLOSING == session->status)
-                return SPDY_NO;
-
-  if(SPDY_NO == session->fio_before_write(session))
-    return SPDY_NO;
-
-        for(i=0;
-                only_one_frame
-                ? i < 1
-                : i < session->max_num_frames;
-                ++i)
-        {
-                //if the buffer is not null, part of the last frame is still
-                //pending to be sent
-                if(NULL == session->write_buffer)
-                {
-                        //discard frames on closed streams
-                        response_queue = session->response_queue_head;
-
-                        while(NULL != response_queue)
-                        {
-                                //if stream is closed, remove not yet sent frames
-                                //associated with it
-                                //GOAWAY frames are not associated to streams
-                                //and still need to be sent
-                                if(NULL == response_queue->stream
-                                        || !response_queue->stream->is_out_closed)
-                                        break;
-
-                                DLL_remove(session->response_queue_head,session->response_queue_tail,response_queue);
-
-                                if(NULL != response_queue->frqcb)
-                                {
-                                        response_queue->frqcb(response_queue->frqcb_cls, response_queue, SPDY_RESPONSE_RESULT_STREAM_CLOSED);
-                                }
-
-                                SPDYF_response_queue_destroy(response_queue);
-                                response_queue = session->response_queue_head;
-                        }
-
-                        if(NULL == session->response_queue_head)
-                                break;//nothing on the queue
-
-                        //get next data from queue and put it to the write buffer
-                        // to send it
-                        if(SPDY_NO == session->response_queue_head->process_response_handler(session))
-                        {
-                                //error occured and the handler changed or not the
-                                //session's status appropriately
-                                if(SPDY_SESSION_STATUS_CLOSING == session->status)
-                                {
-                                        //try to send GOAWAY first if the current frame is different
-                                        if(session->response_queue_head->is_data
-                                                || SPDY_CONTROL_FRAME_TYPES_GOAWAY
-                                                        != session->response_queue_head->control_frame->type)
-                                        {
-                                                session->status = SPDY_SESSION_STATUS_FLUSHING;
-                                                SPDYF_prepare_goaway(session, SPDY_GOAWAY_STATUS_INTERNAL_ERROR, true);
-                                                SPDYF_session_write(session,true);
-                                                session->status = SPDY_SESSION_STATUS_CLOSING;
-                                        }
-                                        return SPDY_YES;
-                                }
-
-                                //just return from the loop to return from this function
-        ++i;
-                                break;
-                        }
-
-                        //check if something was prepared for writing
-                        //on respones with callbacks it is possible that their is no
-                        //data available
-                        if(0 == session->write_buffer_size)//nothing to write
-      {
-                                if(response_queue != session->response_queue_head)
-                                {
-                                        //the handler modified the queue
-                                        continue;
-                                }
-                                else
-                                {
-                                        //no need to try the same frame again
-          ++i;
-                                        break;
-                                }
-      }
-                }
-
-                session->last_activity = SPDYF_monotonic_time();
-
-                //actual write to the IO
-                bytes_written = session->fio_send(session,
-                        session->write_buffer + session->write_buffer_beginning,
-                        session->write_buffer_offset - session->write_buffer_beginning);
-
-                switch(bytes_written)
-                {
-                        case SPDY_IO_ERROR_CLOSED:
-                                //The TLS connection was closed by the other party, clean
-                                //or not
-                                shutdown (session->socket_fd, SHUT_RD);
-                                session->read_closed = true;
-                                session->status = SPDY_SESSION_STATUS_CLOSING;
-                                return SPDY_YES;
-
-                        case SPDY_IO_ERROR_ERROR:
-                                //any kind of error in the TLS subsystem
-                                //forbid more writing
-                                session->status = SPDY_SESSION_STATUS_CLOSING;
-                                return SPDY_YES;
-
-                        case SPDY_IO_ERROR_AGAIN:
-                                //read or write should be called again; leave it for the
-                                //next time; return from the function as we do not now
-                                //whether reading or writing is needed
-                                return i>0 ? SPDY_YES : SPDY_NO;
-
-                        //default:
-                                //something was really read from the TLS subsystem
-                                //just continue
-                }
-
-                session->write_buffer_beginning += bytes_written;
-
-                //check if the full buffer was written
-                if(session->write_buffer_beginning == session->write_buffer_size)
-                {
-                        //that response is handled, remove it from queue
-      free(session->write_buffer);
-                        session->write_buffer = NULL;
-                        session->write_buffer_size = 0;
-                        queue_head = session->response_queue_head;
-                        if(NULL == queue_head->next)
-                        {
-                                session->response_queue_head = NULL;
-                                session->response_queue_tail = NULL;
-                        }
-                        else
-                        {
-                                session->response_queue_head = queue_head->next;
-                                session->response_queue_head->prev = NULL;
-                        }
-
-                        //set stream to closed if the frame's fin flag is set
-                        SPDYF_stream_set_flags_on_write(queue_head);
-
-                        if(NULL != queue_head->frqcb)
-                        {
-                                //application layer callback to notify sending of the response
-                                queue_head->frqcb(queue_head->frqcb_cls, queue_head, SPDY_RESPONSE_RESULT_SUCCESS);
-                        }
-
-                        SPDYF_response_queue_destroy(queue_head);
-                }
-        }
-
-        if(SPDY_SESSION_STATUS_FLUSHING == session->status
-                && NULL == session->response_queue_head)
-                session->status = SPDY_SESSION_STATUS_CLOSING;
-
-        //return i>0 ? SPDY_YES : SPDY_NO;
-        return session->fio_after_write(session, i>0 ? SPDY_YES : SPDY_NO);
-}
-
-
-int
-SPDYF_session_idle (struct SPDY_Session *session)
-{
-        size_t read_buffer_beginning;
-        size_t frame_length;
-        struct SPDYF_Control_Frame* control_frame;
-        struct SPDYF_Data_Frame *data_frame;
-
-        //prepare session for closing if timeout is used and already passed
-        if(SPDY_SESSION_STATUS_CLOSING != session->status
-                && session->daemon->session_timeout
-                && (session->last_activity + session->daemon->session_timeout < SPDYF_monotonic_time()))
-        {
-                session->status = SPDY_SESSION_STATUS_CLOSING;
-                //best effort for sending GOAWAY
-                SPDYF_prepare_goaway(session, SPDY_GOAWAY_STATUS_OK, true);
-                SPDYF_session_write(session,true);
-        }
-
-        switch(session->status)
-        {
-                //expect new frame to arrive
-                case SPDY_SESSION_STATUS_WAIT_FOR_HEADER:
-                        session->current_stream_id = 0;
-                        //check if the whole frame header is already here
-                        //both frame types have the same length
-                        if(session->read_buffer_offset - session->read_buffer_beginning
-                                < sizeof(struct SPDYF_Control_Frame))
-                                return SPDY_NO;
-
-                        /* check the first bit to see if it is data or control frame
-                         * and also if the version is supported */
-                        if(0x80 == *(uint8_t *)(session->read_buffer + session->read_buffer_beginning)
-                                && SPDY_VERSION == *((uint8_t *)session->read_buffer + session->read_buffer_beginning + 1))
-                        {
-                                //control frame
-                                if(NULL == (control_frame = malloc(sizeof(struct SPDYF_Control_Frame))))
-                                {
-                                        SPDYF_DEBUG("No memory");
-                                        return SPDY_NO;
-                                }
-
-                                //get frame headers
-                                memcpy(control_frame,
-                                        session->read_buffer + session->read_buffer_beginning,
-                                        sizeof(struct SPDYF_Control_Frame));
-                                session->read_buffer_beginning += sizeof(struct SPDYF_Control_Frame);
-                                SPDYF_CONTROL_FRAME_NTOH(control_frame);
-
-                                session->status = SPDY_SESSION_STATUS_WAIT_FOR_SUBHEADER;
-                                //assign different frame handler according to frame type
-                                switch(control_frame->type){
-                                        case SPDY_CONTROL_FRAME_TYPES_SYN_STREAM:
-                                                session->frame_handler = &spdyf_handler_read_syn_stream;
-                                                break;
-                                        case SPDY_CONTROL_FRAME_TYPES_GOAWAY:
-                                                session->frame_handler = &spdyf_handler_read_goaway;
-                                                break;
-                                        case SPDY_CONTROL_FRAME_TYPES_RST_STREAM:
-                                                session->frame_handler = &spdyf_handler_read_rst_stream;
-                                                break;
-                                        default:
-                                                session->frame_handler = &SPDYF_handler_ignore_frame;
-                                }
-                                session->frame_handler_cls = control_frame;
-                                //DO NOT break the outer case
-                        }
-                        else if(0 == *(uint8_t *)(session->read_buffer + session->read_buffer_beginning))
-                        {
-                                //needed for POST
-                                //data frame
-                                if(NULL == (data_frame = malloc(sizeof(struct SPDYF_Data_Frame))))
-                                {
-                                        SPDYF_DEBUG("No memory");
-                                        return SPDY_NO;
-                                }
-
-                                //get frame headers
-                                memcpy(data_frame,
-                                        session->read_buffer + session->read_buffer_beginning,
-                                        sizeof(struct SPDYF_Data_Frame));
-                                session->read_buffer_beginning += sizeof(struct SPDYF_Data_Frame);
-                                SPDYF_DATA_FRAME_NTOH(data_frame);
-
-                                session->status = SPDY_SESSION_STATUS_WAIT_FOR_BODY;
-                                session->frame_handler = &spdyf_handler_read_data;
-                                session->frame_handler_cls = data_frame;
-                                //DO NOT brake the outer case
-                        }
-                        else
-                        {
-                                SPDYF_DEBUG("another protocol or version received!");
-
-                                /* According to the draft the lib should send here
-                                 * RST_STREAM with status UNSUPPORTED_VERSION. I don't
-                                 * see any sense of keeping the session open since
-                                 * we don't know how many bytes is the bogus "frame".
-                                 * And the latter normally will be HTTP request.
-                                 *
-                                 */
-
-                                //shutdown(session->socket_fd, SHUT_RD);
-                                session->status = SPDY_SESSION_STATUS_FLUSHING;
-                                SPDYF_prepare_goaway(session, SPDY_GOAWAY_STATUS_PROTOCOL_ERROR,false);
-                                //SPDYF_session_write(session,false);
-                                /* close connection since the client expects another
-                                protocol from us */
-                                //SPDYF_session_close(session);
-                                return SPDY_YES;
-                        }
-
-                //expect specific header fields after the standard header
-                case SPDY_SESSION_STATUS_WAIT_FOR_SUBHEADER:
-                        if(NULL!=session->frame_handler)
-                        {
-                                read_buffer_beginning = session->read_buffer_beginning;
-                                //if everything is ok, the "body" will also be processed
-                                //by the handler
-                                session->frame_handler(session);
-
-                                if(SPDY_SESSION_STATUS_IGNORE_BYTES == session->status)
-                                {
-                                        //check for larger than max supported frame
-                                        if(session->frame_handler != &spdyf_handler_read_data)
-                                        {
-                                                frame_length = ((struct SPDYF_Control_Frame *)session->frame_handler_cls)->length;
-                                        }
-                                        else
-                                        {
-                                                frame_length = ((struct SPDYF_Data_Frame *)session->frame_handler_cls)->length;
-                                        }
-
-                                        //if(SPDY_MAX_SUPPORTED_FRAME_SIZE < frame_length)
-                                        {
-                                                SPDYF_DEBUG("received frame with unsupported size: %zu", frame_length);
-                                                //the data being received must be ignored and
-                                                //RST_STREAM sent
-
-                                                //ignore bytes that will arive later
-                                                session->read_ignore_bytes = frame_length
-                                                        + read_buffer_beginning
-                                                        - session->read_buffer_offset;
-                                                //ignore what is already in read buffer
-                                                session->read_buffer_beginning = session->read_buffer_offset;
-
-                                                SPDYF_prepare_rst_stream(session,
-                                                        session->current_stream_id > 0 ? session->streams_head : NULL, //may be 0 here which is not good
-                                                        SPDY_RST_STREAM_STATUS_FRAME_TOO_LARGE);
-
-                                                //actually the read buffer can be bigger than the
-                                                //max supported size
-                                                session->status = session->read_ignore_bytes
-                                                        ? SPDY_SESSION_STATUS_IGNORE_BYTES
-                                                        : SPDY_SESSION_STATUS_WAIT_FOR_HEADER;
-
-                                                free(session->frame_handler_cls);
-                                        }
-                                }
-                        }
-
-                        if(SPDY_SESSION_STATUS_IGNORE_BYTES != session->status)
-                        {
-                                break;
-                        }
-
-                //ignoring data in read buffer
-                case SPDY_SESSION_STATUS_IGNORE_BYTES:
-                        SPDYF_ASSERT(session->read_ignore_bytes > 0,
-                                "Session is in wrong state");
-                        if(session->read_ignore_bytes
-                                > session->read_buffer_offset - session->read_buffer_beginning)
-                        {
-                                session->read_ignore_bytes -=
-                                        session->read_buffer_offset - session->read_buffer_beginning;
-                                session->read_buffer_beginning = session->read_buffer_offset;
-                        }
-                        else
-                        {
-                                session->read_buffer_beginning += session->read_ignore_bytes;
-                                session->read_ignore_bytes = 0;
-                                session->status = SPDY_SESSION_STATUS_WAIT_FOR_HEADER;
-                        }
-                        break;
-
-                //expect frame body (name/value pairs)
-                case SPDY_SESSION_STATUS_WAIT_FOR_BODY:
-                        if(NULL!=session->frame_handler)
-                                session->frame_handler(session);
-                        break;
-
-                case SPDY_SESSION_STATUS_FLUSHING:
-
-                        return SPDY_NO;
-
-                //because of error the session needs to be closed
-                case SPDY_SESSION_STATUS_CLOSING:
-                        //error should be already sent to the client
-                        SPDYF_session_close(session);
-                        return SPDY_YES;
-        }
-
-        return SPDY_YES;
-}
-
-
-void
-SPDYF_session_close (struct SPDY_Session *session)
-{
-        struct SPDY_Daemon *daemon = session->daemon;
-        int by_client = session->read_closed ? SPDY_YES : SPDY_NO;
-
-        //shutdown the tls and deinit the tls context
-        session->fio_close_session(session);
-        shutdown (session->socket_fd,
-                session->read_closed ? SHUT_WR : SHUT_RDWR);
-        session->read_closed = true;
-
-        //remove session from the list
-        DLL_remove (daemon->sessions_head,
-                daemon->sessions_tail,
-                session);
-        //add the session for the list for cleaning up
-        DLL_insert (daemon->cleanup_head,
-                daemon->cleanup_tail,
-                session);
-
-        //call callback for closed session
-        if(NULL != daemon->session_closed_cb)
-        {
-                daemon->session_closed_cb(daemon->cls, session, by_client);
-        }
-}
-
-
-int
-SPDYF_session_accept(struct SPDY_Daemon *daemon)
-{
-        int new_socket_fd;
-  int ret;
-        struct SPDY_Session *session = NULL;
-        socklen_t addr_len;
-        struct sockaddr *addr;
-
-#if HAVE_INET6
-        struct sockaddr_in6 addr6;
-
-        addr = (struct sockaddr *)&addr6;
-        addr_len = sizeof(addr6);
-#else
-        struct sockaddr_in addr4;
-
-        addr = (struct sockaddr *)&addr4;
-        addr_len = sizeof(addr6);
-#endif
-
-  new_socket_fd = accept (daemon->socket_fd, addr, &addr_len);
-
-  if(new_socket_fd < 1)
-                return SPDY_NO;
-
-        if (NULL == (session = malloc (sizeof (struct SPDY_Session))))
-  {
-                goto free_and_fail;
-        }
-        memset (session, 0, sizeof (struct SPDY_Session));
-
-        session->daemon = daemon;
-        session->socket_fd = new_socket_fd;
-  session->max_num_frames = daemon->max_num_frames;
-
-  ret = SPDYF_io_set_session(session, daemon->io_subsystem);
-  SPDYF_ASSERT(SPDY_YES == ret, "Somehow daemon->io_subsystem iswrong here");
-
-        //init TLS context, handshake will be done
-        if(SPDY_YES != session->fio_new_session(session))
-        {
-                goto free_and_fail;
-        }
-
-        //read buffer
-        session->read_buffer_size = SPDYF_BUFFER_SIZE;
-        if (NULL == (session->read_buffer = malloc (session->read_buffer_size)))
-    {
-                session->fio_close_session(session);
-                goto free_and_fail;
-        }
-
-        //address of the client
-        if (NULL == (session->addr = malloc (addr_len)))
-    {
-                session->fio_close_session(session);
-                goto free_and_fail;
-        }
-        memcpy (session->addr, addr, addr_len);
-
-        session->addr_len = addr_len;
-        session->status = SPDY_SESSION_STATUS_WAIT_FOR_HEADER;
-
-        //init zlib context for the whole session
-        if(SPDY_YES != SPDYF_zlib_deflate_init(&session->zlib_send_stream))
-    {
-                session->fio_close_session(session);
-                goto free_and_fail;
-        }
-        if(SPDY_YES != SPDYF_zlib_inflate_init(&session->zlib_recv_stream))
-    {
-                session->fio_close_session(session);
-                SPDYF_zlib_deflate_end(&session->zlib_send_stream);
-                goto free_and_fail;
-        }
-
-        //add it to daemon's list
-        DLL_insert(daemon->sessions_head,daemon->sessions_tail,session);
-
-        session->last_activity = SPDYF_monotonic_time();
-
-        if(NULL != daemon->new_session_cb)
-                daemon->new_session_cb(daemon->cls, session);
-
-        return SPDY_YES;
-
-        //for GOTO
-        free_and_fail:
-        /* something failed, so shutdown, close and free memory */
-        shutdown (new_socket_fd, SHUT_RDWR);
-        (void)MHD_socket_close_ (new_socket_fd);
-
-        if(NULL != session)
-        {
-                if(NULL != session->addr)
-                        free (session->addr);
-                if(NULL != session->read_buffer)
-                        free (session->read_buffer);
-                free (session);
-        }
-        return SPDY_NO;
-}
-
-
-void
-SPDYF_queue_response (struct SPDYF_Response_Queue *response_to_queue,
-                                                struct SPDY_Session *session,
-                                                int consider_priority)
-{
-        struct SPDYF_Response_Queue *pos;
-        struct SPDYF_Response_Queue *last;
-        uint8_t priority;
-
-        SPDYF_ASSERT(SPDY_YES != consider_priority || NULL != response_to_queue->stream,
-                "called with consider_priority but no stream provided");
-
-        last = response_to_queue;
-        while(NULL != last->next)
-        {
-                last = last->next;
-        }
-
-        if(SPDY_NO == consider_priority)
-        {
-                //put it at the end of the queue
-                response_to_queue->prev = session->response_queue_tail;
-                if (NULL == session->response_queue_head)
-                        session->response_queue_head = response_to_queue;
-                else
-                        session->response_queue_tail->next = response_to_queue;
-                session->response_queue_tail = last;
-                return;
-        }
-        else if(-1 == consider_priority)
-        {
-                //put it at the head of the queue
-                last->next = session->response_queue_head;
-                if (NULL == session->response_queue_tail)
-                        session->response_queue_tail = last;
-                else
-                        session->response_queue_head->prev = response_to_queue;
-                session->response_queue_head = response_to_queue;
-                return;
-        }
-
-        if(NULL == session->response_queue_tail)
-        {
-                session->response_queue_head = response_to_queue;
-                session->response_queue_tail = last;
-                return;
-        }
-
-        //search for the right position to put it
-        pos = session->response_queue_tail;
-        priority = response_to_queue->stream->priority;
-        while(NULL != pos
-                && pos->stream->priority > priority)
-        {
-                pos = pos->prev;
-        }
-
-        if(NULL == pos)
-        {
-                //put it on the head
-                session->response_queue_head->prev = last;
-                last->next = session->response_queue_head;
-                session->response_queue_head = response_to_queue;
-        }
-        else if(NULL == pos->next)
-        {
-                //put it at the end
-                response_to_queue->prev = pos;
-                pos->next = response_to_queue;
-                session->response_queue_tail = last;
-        }
-        else
-        {
-                response_to_queue->prev = pos;
-                last->next = pos->next;
-                pos->next = response_to_queue;
-                last->next->prev = last;
-        }
-}
-
-
-void
-SPDYF_session_destroy(struct SPDY_Session *session)
-{
-        struct SPDYF_Stream *stream;
-        struct SPDYF_Response_Queue *response_queue;
-
-        (void)MHD_socket_close_ (session->socket_fd);
-        SPDYF_zlib_deflate_end(&session->zlib_send_stream);
-        SPDYF_zlib_inflate_end(&session->zlib_recv_stream);
-
-        //clean up unsent data in the output queue
-        while (NULL != (response_queue = session->response_queue_head))
-        {
-                DLL_remove (session->response_queue_head,
-                        session->response_queue_tail,
-                        response_queue);
-
-                if(NULL != response_queue->frqcb)
-                {
-                        response_queue->frqcb(response_queue->frqcb_cls, response_queue, SPDY_RESPONSE_RESULT_SESSION_CLOSED);
-                }
-
-                SPDYF_response_queue_destroy(response_queue);
-        }
-
-        //clean up the streams belonging to this session
-        while (NULL != (stream = session->streams_head))
-        {
-                DLL_remove (session->streams_head,
-                        session->streams_tail,
-                        stream);
-
-                SPDYF_stream_destroy(stream);
-        }
-
-        free(session->addr);
-        free(session->read_buffer);
-        free(session->write_buffer);
-        free(session);
-}
-
-
-int
-SPDYF_prepare_goaway (struct SPDY_Session *session,
-                                        enum SPDY_GOAWAY_STATUS status,
-                                        bool in_front)
-{
-        struct SPDYF_Response_Queue *response_to_queue;
-        struct SPDYF_Control_Frame *control_frame;
-        uint32_t *data;
-
-        if(NULL == (response_to_queue = malloc(sizeof(struct SPDYF_Response_Queue))))
-        {
-                return SPDY_NO;
-        }
-        memset(response_to_queue, 0, sizeof(struct SPDYF_Response_Queue));
-
-        if(NULL == (control_frame = malloc(sizeof(struct SPDYF_Control_Frame))))
-        {
-                free(response_to_queue);
-                return SPDY_NO;
-        }
-        memset(control_frame, 0, sizeof(struct SPDYF_Control_Frame));
-
-        if(NULL == (data = malloc(4)))
-        {
-                free(control_frame);
-                free(response_to_queue);
-                return SPDY_NO;
-        }
-        *(data) = htonl(status);
-
-        control_frame->control_bit = 1;
-        control_frame->version = SPDY_VERSION;
-        control_frame->type = SPDY_CONTROL_FRAME_TYPES_GOAWAY;
-        control_frame->flags = 0;
-
-        response_to_queue->control_frame = control_frame;
-        response_to_queue->process_response_handler = &SPDYF_handler_write_goaway;
-        response_to_queue->data = data;
-        response_to_queue->data_size = 4;
-
-        SPDYF_queue_response (response_to_queue,
-                                                session,
-                                                in_front ? -1 : SPDY_NO);
-
-        return SPDY_YES;
-}
-
-
-int
-SPDYF_prepare_rst_stream (struct SPDY_Session *session,
-                                        struct SPDYF_Stream * stream,
-                                        enum SPDY_RST_STREAM_STATUS status)
-{
-        struct SPDYF_Response_Queue *response_to_queue;
-        struct SPDYF_Control_Frame *control_frame;
-        uint32_t *data;
-        uint32_t stream_id;
-
-  if(NULL == stream)
-    stream_id = 0;
-  else
-    stream_id = stream->stream_id;
-
-        if(NULL == (response_to_queue = malloc(sizeof(struct SPDYF_Response_Queue))))
-        {
-                return SPDY_NO;
-        }
-        memset(response_to_queue, 0, sizeof(struct SPDYF_Response_Queue));
-
-        if(NULL == (control_frame = malloc(sizeof(struct SPDYF_Control_Frame))))
-        {
-                free(response_to_queue);
-                return SPDY_NO;
-        }
-        memset(control_frame, 0, sizeof(struct SPDYF_Control_Frame));
-
-        if(NULL == (data = malloc(8)))
-        {
-                free(control_frame);
-                free(response_to_queue);
-                return SPDY_NO;
-        }
-        *(data) = HTON31(stream_id);
-        *(data + 1) = htonl(status);
-
-        control_frame->control_bit = 1;
-        control_frame->version = SPDY_VERSION;
-        control_frame->type = SPDY_CONTROL_FRAME_TYPES_RST_STREAM;
-        control_frame->flags = 0;
-
-        response_to_queue->control_frame = control_frame;
-        response_to_queue->process_response_handler = &SPDYF_handler_write_rst_stream;
-        response_to_queue->data = data;
-        response_to_queue->data_size = 8;
-        response_to_queue->stream = stream;
-
-        SPDYF_queue_response (response_to_queue,
-                                                session,
-                                                -1);
-
-        return SPDY_YES;
-}
-
-
-int
-SPDYF_prepare_window_update (struct SPDY_Session *session,
-                                        struct SPDYF_Stream * stream,
-                                        int32_t delta_window_size)
-{
-        struct SPDYF_Response_Queue *response_to_queue;
-        struct SPDYF_Control_Frame *control_frame;
-        uint32_t *data;
-
-  SPDYF_ASSERT(NULL != stream, "stream cannot be NULL");
-
-        if(NULL == (response_to_queue = malloc(sizeof(struct SPDYF_Response_Queue))))
-        {
-                return SPDY_NO;
-        }
-        memset(response_to_queue, 0, sizeof(struct SPDYF_Response_Queue));
-
-        if(NULL == (control_frame = malloc(sizeof(struct SPDYF_Control_Frame))))
-        {
-                free(response_to_queue);
-                return SPDY_NO;
-        }
-        memset(control_frame, 0, sizeof(struct SPDYF_Control_Frame));
-
-        if(NULL == (data = malloc(8)))
-        {
-                free(control_frame);
-                free(response_to_queue);
-                return SPDY_NO;
-        }
-        *(data) = HTON31(stream->stream_id);
-        *(data + 1) = HTON31(delta_window_size);
-
-        control_frame->control_bit = 1;
-        control_frame->version = SPDY_VERSION;
-        control_frame->type = SPDY_CONTROL_FRAME_TYPES_WINDOW_UPDATE;
-        control_frame->flags = 0;
-
-        response_to_queue->control_frame = control_frame;
-        response_to_queue->process_response_handler = &SPDYF_handler_write_window_update;
-        response_to_queue->data = data;
-        response_to_queue->data_size = 8;
-        response_to_queue->stream = stream;
-
-        SPDYF_queue_response (response_to_queue,
-                                                session,
-                                                -1);
-
-        return SPDY_YES;
-}
diff --git a/src/microspdy/session.h b/src/microspdy/session.h
deleted file mode 100644
index 29ab550f..00000000
--- a/src/microspdy/session.h
+++ /dev/null
@@ -1,281 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file session.h
- * @brief  TCP connection/SPDY session handling
- * @author Andrey Uzunov
- */
-
-#ifndef SESSION_H
-#define SESSION_H
-
-#include "platform.h"
-#include "structures.h"
-
-/**
- * Called by the daemon when the socket for the session has available
- * data to be read. Reads data from the TLS socket and puts it to the
- * session's read buffer. The latte
- *
- * @param session SPDY_Session for which data will be read.
- * @return SPDY_YES if something was read or session's status was
- *         changed. It is possible that error occurred but was handled
- *         and the status was therefore changed.
- *         SPDY_NO if nothing happened, e.g. the subsystem wants read/
- *         write to be called again.
- */
-int
-SPDYF_session_read (struct SPDY_Session *session);
-
-
-/**
- * Called by the daemon when the socket for the session is ready for some
- * data to be written to it. For one or more objects on the response
- * queue tries to fill in the write buffer, based on the frame on the
- * queue, and to write data to the TLS socket. 
- *
- * @param session SPDY_Session for which data will be written.
- * @param only_one_frame when true, the function will write at most one
- *        SPDY frame to the underlying IO subsystem;
- *        when false, the function will write up to
- *        session->max_num_frames SPDY frames
- * @return SPDY_YES if the session's internal writing state has changed:
- *         something was written and/or session's status was
- *         changed and/or response callback was called but did not provide
- *         data. It is possible that error occurred but was handled
- *         and the status was therefore changed.
- *         SPDY_NO if nothing happened. However, it is possible that some
- *         frames were discarded within the call, e.g. frames belonging
- *         to a closed stream.
- */
-int
-SPDYF_session_write (struct SPDY_Session *session,
-                     bool only_one_frame);
-
-
-/**
- * Called by the daemon on SPDY_run to handle the data in the read and write
- * buffer of a session. Based on the state and the content of the read
- * buffer new frames are received and interpreted, appropriate user
- * callbacks are called and maybe something is put on the response queue
- * ready to be handled by session_write.
- * 
- * @param session SPDY_Session which will be handled.
- * @return SPDY_YES if something from the read buffers was processed,
- *         session's status was changed and/or the session was closed.
- *         SPDY_NO if nothing happened, e.g. the session is in a state,
- *         not allowing processing read buffers.
- */
-int
-SPDYF_session_idle (struct SPDY_Session *session);
-
-
-/**
- * This function shutdowns the socket, moves the session structure to
- * daemon's queue for sessions to be cleaned up.
- * 
- * @param session SPDY_Session which will be handled.
- */
-void
-SPDYF_session_close (struct SPDY_Session *session);
-
-
-/**
- * Called to accept new TCP connection and create SPDY session.
- * 
- * @param daemon SPDY_Daemon whose listening socket is used.
- * @return SPDY_NO on any kind of error while accepting new TCP connection
- *                      and initializing new SPDY_Session.
- *         SPDY_YES otherwise.
- */
-int
-SPDYF_session_accept(struct SPDY_Daemon *daemon);
-
-
-/**
- * Puts SPDYF_Response_Queue object on the queue to be sent to the
- * client later.
- *
- * @param response_to_queue linked list of objects containing SPDY
- *                      frame and data to be added to the queue
- * @param session SPDY session for which the response is sent
- * @param consider_priority if SPDY_NO, the list will be added to the
- *                      end of the queue.
- *                      If SPDY_YES, the response will be added after
- *                      the last previously added response with priority of the
- *                      request grater or equal to that of the current one.
- *                      If -1, the object will be put at the head of the queue.
- */
-void
-SPDYF_queue_response (struct SPDYF_Response_Queue *response_to_queue,
-                                                struct SPDY_Session *session,
-                                                int consider_priority);
-
-
-/**
- * Cleans up the TSL context for the session, closes the TCP connection,
- * cleans up any data pointed by members of the session structure
- * (buffers, queue of responses, etc.) and frees the memory allocated by
- * the session itself.
- */                                             
-void
-SPDYF_session_destroy(struct SPDY_Session *session);
-
-
-/**
- * Prepares GOAWAY frame to tell the client to stop creating new streams.
- * The session should be closed soon after this call.
- * 
- * @param session SPDY session
- * @param status code for the GOAWAY frame
- * @param in_front whether or not to put the frame in front of everything
- *                      on the response queue
- * @return SPDY_NO on error (not enough memory) or
- *                      SPDY_YES on success
- */
-int
-SPDYF_prepare_goaway (struct SPDY_Session *session,
-                                        enum SPDY_GOAWAY_STATUS status,
-                                        bool in_front);
-
-
-/**
- * Prepares RST_STREAM frame to terminate a stream. This frame may or
- * not indicate an error. The frame will be put at the head of the queue.
- * This means that frames for this stream which are still in the queue
- * will be discarded soon.
- * 
- * @param session SPDY session
- * @param stream stream to terminate
- * @param status code for the RST_STREAM frame
- * @return SPDY_NO on memory error or
- *                      SPDY_YES on success
- */
-int
-SPDYF_prepare_rst_stream (struct SPDY_Session *session,
-                                        struct SPDYF_Stream * stream,
-                                        enum SPDY_RST_STREAM_STATUS status);
-
-
-/**
- * Prepares WINDOW_UPDATE frame to tell the other party that more
- * data can be sent on the stream. The frame will be put at the head of
- * the queue.
- * 
- * @param session SPDY session
- * @param stream stream to which the changed window will apply
- * @param delta_window_size how much the window grows
- * @return SPDY_NO on memory error or
- *                      SPDY_YES on success
- */
-int
-SPDYF_prepare_window_update (struct SPDY_Session *session,
-                                        struct SPDYF_Stream * stream,
-                                        int32_t delta_window_size);
-          
-
-/**
- * Handler called by session_write to fill the write buffer according to
- * the data frame waiting in the response queue.
- * When response data is given by user callback, the lib does not know
- * how many frames are needed. In such case this call produces
- * another ResponseQueue object and puts it on the queue while the the
- * user callback says that there will be more data.
- * 
- * @return SPDY_NO on error (not enough memory or the user calback for
- *         providing response data did something wrong). If
- *         the error is unrecoverable the handler changes session's
- *         status.
- *         SPDY_YES on success
- */     
-int
-SPDYF_handler_write_data (struct SPDY_Session *session);
-
-
-/**
- * Handler called by session_write to fill the write buffer based on the
- * control frame (SYN_REPLY) waiting in the response queue.
- * 
- * @param session SPDY session
- * @return SPDY_NO on error (zlib state is broken; the session MUST be
- *         closed). If
- *         the error is unrecoverable the handler changes session's
- *         status.
- *                      SPDY_YES on success
- */                     
-int
-SPDYF_handler_write_syn_reply (struct SPDY_Session *session);
-
-
-/**
- * Handler called by session_write to fill the write buffer based on the
- * control frame (GOAWAY) waiting in the response queue.
- * 
- * @param session SPDY session
- * @return SPDY_NO on error (not enough memory; by specification the
- *         session must be closed
- *         soon, thus there is no need to handle the error) or
- *                      SPDY_YES on success
- */                                     
-int
-SPDYF_handler_write_goaway (struct SPDY_Session *session);
-
-
-/**
- * Handler called by session_write to fill the write buffer based on the
- * control frame (RST_STREAM) waiting in the response queue.
- * 
- * @param session SPDY session
- * @return SPDY_NO on error (not enough memory). If
- *         the error is unrecoverable the handler changes session's
- *         status.
- *                      SPDY_YES on success
- */                             
-int
-SPDYF_handler_write_rst_stream (struct SPDY_Session *session);
-
-
-/**
- * Handler called by session_write to fill the write buffer based on the
- * control frame (WINDOW_UPDATE) waiting in the response queue.
- * 
- * @param session SPDY session
- * @return SPDY_NO on error (not enough memory). If
- *         the error is unrecoverable the handler changes session's
- *         status.
- *                      SPDY_YES on success
- */                     
-int
-SPDYF_handler_write_window_update (struct SPDY_Session *session);
-
-
-/**
- * Carefully ignore the full size of frames which are not yet supported
- * by the lib.
- * TODO Ignoring frames containing compressed bodies means that the
- * compress state will be corrupted on next received frame. According to
- * the draft the lib SHOULD try to decompress data also in corrupted
- * frames just to keep right compression state.
- * 
- * @param session SPDY_Session whose read buffer is used.
- */
-void
-SPDYF_handler_ignore_frame (struct SPDY_Session *session);
-
-#endif
diff --git a/src/microspdy/stream.c b/src/microspdy/stream.c
deleted file mode 100644
index 9b6dc08d..00000000
--- a/src/microspdy/stream.c
+++ /dev/null
@@ -1,169 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file stream.c
- * @brief  SPDY streams handling
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include "structures.h"
-#include "internal.h"
-#include "session.h"
-
-
-int
-SPDYF_stream_new (struct SPDY_Session *session)
-{
-        uint32_t stream_id;
-        uint32_t assoc_stream_id;
-        uint8_t priority;
-        uint8_t slot;
-        size_t buffer_pos = session->read_buffer_beginning;
-        struct SPDYF_Stream *stream;
-        struct SPDYF_Control_Frame *frame;
-        
-        if((session->read_buffer_offset - session->read_buffer_beginning) < 10)
-        {
-                //not all fields are received to create new stream
-                return SPDY_NO;
-        }
-        
-        frame = (struct SPDYF_Control_Frame *)session->frame_handler_cls;
-        
-        //get stream id of the new stream
-    memcpy(&stream_id, session->read_buffer + session->read_buffer_beginning, 4);
-        stream_id = NTOH31(stream_id);
-        session->read_buffer_beginning += 4;
-        if(stream_id <= session->last_in_stream_id || 0==(stream_id % 2))
-        {
-                //wrong stream id sent by client
-                //GOAWAY with PROTOCOL_ERROR MUST be sent
-                //TODO
-                
-                //ignore frame
-                session->frame_handler = &SPDYF_handler_ignore_frame;
-                return SPDY_NO;
-        }
-        else if(session->is_goaway_sent)
-        {
-                //the client is not allowed to create new streams anymore
-                //we MUST ignore the frame
-                session->frame_handler = &SPDYF_handler_ignore_frame;
-                return SPDY_NO;
-        }
-        
-        //set highest stream id for session
-        session->last_in_stream_id = stream_id;
-        
-        //get assoc stream id of the new stream
-        //this value is used with SPDY PUSH, thus nothing to do with it here
-    memcpy(&assoc_stream_id, session->read_buffer + session->read_buffer_beginning, 4);
-        assoc_stream_id = NTOH31(assoc_stream_id);
-        session->read_buffer_beginning += 4;
-
-        //get stream priority (3 bits)
-        //after it there are 5 bits that are not used
-        priority = *(uint8_t *)(session->read_buffer + session->read_buffer_beginning) >> 5;
-        session->read_buffer_beginning++;
-        
-        //get slot (see SPDY draft)
-        slot = *(uint8_t *)(session->read_buffer + session->read_buffer_beginning);
-        session->read_buffer_beginning++;
-        
-        if(NULL == (stream = malloc(sizeof(struct SPDYF_Stream))))
-        {
-                SPDYF_DEBUG("No memory");
-                //revert buffer state
-                session->read_buffer_beginning = buffer_pos;
-                return SPDY_NO;
-        }
-        memset(stream,0, sizeof(struct SPDYF_Stream));
-        stream->session = session;
-        stream->stream_id = stream_id;
-        stream->assoc_stream_id = assoc_stream_id;
-        stream->priority = priority;
-        stream->slot = slot;
-        stream->is_in_closed = (frame->flags & SPDY_SYN_STREAM_FLAG_FIN) != 0;
-        stream->flag_unidirectional = (frame->flags & SPDY_SYN_STREAM_FLAG_UNIDIRECTIONAL) != 0;
-        stream->is_out_closed = stream->flag_unidirectional;
-        stream->is_server_initiator = false;
-        stream->window_size = SPDYF_INITIAL_WINDOW_SIZE;
-        
-        //put the stream to the list of streams for the session
-        DLL_insert(session->streams_head, session->streams_tail, stream);
-        
-        return SPDY_YES;
-}
-
-
-void
-SPDYF_stream_destroy(struct SPDYF_Stream *stream)
-{
-        SPDY_name_value_destroy(stream->headers);
-        free(stream);
-        stream = NULL;
-}
-
-
-void
-SPDYF_stream_set_flags_on_write(struct SPDYF_Response_Queue *response_queue)
-{
-        struct SPDYF_Stream * stream = response_queue->stream;
-        
-        if(NULL != response_queue->data_frame)
-        {
-                stream->is_out_closed = (bool)(response_queue->data_frame->flags & SPDY_DATA_FLAG_FIN);
-        }
-        else if(NULL != response_queue->control_frame)
-        {
-                switch(response_queue->control_frame->type)
-                {
-                        case SPDY_CONTROL_FRAME_TYPES_SYN_REPLY:
-                                stream->is_out_closed = (bool)(response_queue->control_frame->flags & SPDY_SYN_REPLY_FLAG_FIN);
-                                break;
-                                
-                        case SPDY_CONTROL_FRAME_TYPES_RST_STREAM:
-                                if(NULL != stream)
-                                {
-                                        stream->is_out_closed = true;
-                                        stream->is_in_closed = true;
-                                }
-                                break;
-                                
-                }
-        }
-}
-
-
-//TODO add function *on_read
-
-
-struct SPDYF_Stream * 
-SPDYF_stream_find(uint32_t stream_id, struct SPDY_Session * session)
-{
-  struct SPDYF_Stream * stream = session->streams_head;
-  
-  while(NULL != stream && stream_id != stream->stream_id)
-  {
-    stream = stream->next;
-  }
-  
-  return stream;
-}
diff --git a/src/microspdy/stream.h b/src/microspdy/stream.h
deleted file mode 100644
index 220231f4..00000000
--- a/src/microspdy/stream.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file stream.h
- * @brief  SPDY streams handling
- * @author Andrey Uzunov
- */
-
-#ifndef STREAM_H
-#define STREAM_H
-
-#include "platform.h"
-
-
-/**
- * Reads data from session's read buffer and tries to create a new SPDY
- * stream. This function is called after control frame's header has been
- * read from the buffer (after the length field). If bogus frame is
- * received the function changes the read handler of the session and
- * fails, i.e. there is no need of further error handling by the caller.
- *
- * @param session SPDY_Session whose read buffer is being read
- * @return SPDY_YES if a new SPDY stream request was correctly received
- *                      and handled. SPDY_NO if the whole SPDY frame was not yet
- *                      received or memory error occurred.
- */
-int
-SPDYF_stream_new (struct SPDY_Session *session);
-
-
-/**
- * Destroys stream structure and whatever is in it.
- *
- * @param stream SPDY_Stream to destroy
- */
-void
-SPDYF_stream_destroy(struct SPDYF_Stream *stream);
-
-
-/**
- * Set stream flags if needed based on the type of the frame that was
- * just sent (e.g., close stream if it was RST_STREAM).
- *
- * @param response_queue sent for this stream
- */
-void
-SPDYF_stream_set_flags_on_write(struct SPDYF_Response_Queue *response_queue);
-
-
-/**
- * Find and return a session's stream, based on stream's ID.
- *
- * @param stream_id to search for
- * @param session whose streams are considered
- * @return SPDY_Stream with the desired ID. Can be NULL.
- */
-struct SPDYF_Stream * 
-SPDYF_stream_find(uint32_t stream_id, struct SPDY_Session * session);
-
-#endif
diff --git a/src/microspdy/structures.c b/src/microspdy/structures.c
deleted file mode 100644
index f00806bc..00000000
--- a/src/microspdy/structures.c
+++ /dev/null
@@ -1,638 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file structures.c
- * @brief  Functions for handling most of the structures in defined
- *                      in structures.h
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include "structures.h"
-#include "internal.h"
-#include "session.h"
-//TODO not for here?
-#include <ctype.h>
-
-
-int
-SPDYF_name_value_is_empty(struct SPDY_NameValue *container)
-{
-  SPDYF_ASSERT(NULL != container, "NULL is not an empty container!");
-  return (NULL == container->name && NULL == container->value) ? SPDY_YES : SPDY_NO;
-}
-
-struct SPDY_NameValue *
-SPDY_name_value_create ()
-{
-        struct SPDY_NameValue *pair;
-
-        if(NULL == (pair = malloc(sizeof(struct SPDY_NameValue))))
-                return NULL;
-
-        memset (pair, 0, sizeof (struct SPDY_NameValue));
-
-        return pair;
-}
-
-
-int
-SPDY_name_value_add (struct SPDY_NameValue *container,
-                                        const char *name,
-                                        const char *value)
-{
-        unsigned int i;
-        unsigned int len;
-        struct SPDY_NameValue *pair;
-        struct SPDY_NameValue *temp;
-        char **temp_value;
-        char *temp_string;
-
-        if(NULL == container || NULL == name || NULL == value || 0 == (len = strlen(name)))
-                return SPDY_INPUT_ERROR;
-  //TODO there is old code handling value==NULL
-  //update it to handle strlen(value)==0
-
-        for(i=0; i<len; ++i)
-        {
-          if(isupper((int) name[i]))
-                        return SPDY_INPUT_ERROR;
-        }
-
-        if(SPDYF_name_value_is_empty(container))
-        {
-                //container is empty/just created
-                if (NULL == (container->name = strdup (name)))
-                {
-                        return SPDY_NO;
-                }
-                if (NULL == (container->value = malloc(sizeof(char *))))
-                {
-                        free(container->name);
-                        return SPDY_NO;
-                }
-    /*if(NULL == value)
-      container->value[0] = NULL;
-                else */if (NULL == (container->value[0] = strdup (value)))
-                {
-                        free(container->value);
-                        free(container->name);
-                        return SPDY_NO;
-                }
-                container->num_values = 1;
-                return SPDY_YES;
-        }
-
-        pair = container;
-        while(NULL != pair)
-        {
-                if(0 == strcmp(pair->name, name))
-                {
-                        //the value will be added to this pair
-                        break;
-                }
-                pair = pair->next;
-        }
-
-        if(NULL == pair)
-        {
-                //the name doesn't exist in container, add new pair
-                if(NULL == (pair = malloc(sizeof(struct SPDY_NameValue))))
-                        return SPDY_NO;
-
-                memset(pair, 0, sizeof(struct SPDY_NameValue));
-
-                if (NULL == (pair->name = strdup (name)))
-                {
-                        free(pair);
-                        return SPDY_NO;
-                }
-                if (NULL == (pair->value = malloc(sizeof(char *))))
-                {
-                        free(pair->name);
-                        free(pair);
-                        return SPDY_NO;
-                }
-    /*if(NULL == value)
-      pair->value[0] = NULL;
-                else */if (NULL == (pair->value[0] = strdup (value)))
-                {
-                        free(pair->value);
-                        free(pair->name);
-                        free(pair);
-                        return SPDY_NO;
-                }
-                pair->num_values = 1;
-
-                temp = container;
-                while(NULL != temp->next)
-                        temp = temp->next;
-                temp->next = pair;
-                pair->prev = temp;
-
-                return SPDY_YES;
-        }
-
-        //check for duplication (case sensitive)
-        for(i=0; i<pair->num_values; ++i)
-                if(0 == strcmp(pair->value[i], value))
-                        return SPDY_NO;
-
-        if(strlen(pair->value[0]) > 0)
-        {
-                //the value will be appended to the others for this name
-                if (NULL == (temp_value = malloc((pair->num_values + 1) * sizeof(char *))))
-                {
-                        return SPDY_NO;
-                }
-                memcpy(temp_value, pair->value, pair->num_values * sizeof(char *));
-                if (NULL == (temp_value[pair->num_values] = strdup (value)))
-                {
-                        free(temp_value);
-                        return SPDY_NO;
-                }
-                free(pair->value);
-                pair->value = temp_value;
-                ++pair->num_values;
-                return SPDY_YES;
-        }
-
-        //just replace the empty value
-
-        if (NULL == (temp_string = strdup (value)))
-        {
-                return SPDY_NO;
-        }
-        free(pair->value[0]);
-        pair->value[0] = temp_string;
-
-        return SPDY_YES;
-}
-
-
-const char * const *
-SPDY_name_value_lookup (struct SPDY_NameValue *container,
-                                                const char *name,
-                                                int *num_values)
-{
-        struct SPDY_NameValue *temp = container;
-
-        if(NULL == container || NULL == name || NULL == num_values)
-                return NULL;
-        if(SPDYF_name_value_is_empty(container))
-                return NULL;
-
-        do
-        {
-                if(strcmp(name, temp->name) == 0)
-                {
-                        *num_values = temp->num_values;
-                        return (const char * const *)temp->value;
-                }
-
-                temp = temp->next;
-        }
-        while(NULL != temp);
-
-        return NULL;
-}
-
-
-void
-SPDY_name_value_destroy (struct SPDY_NameValue *container)
-{
-        unsigned int i;
-        struct SPDY_NameValue *temp = container;
-
-        while(NULL != temp)
-        {
-                container = container->next;
-                free(temp->name);
-                for(i=0; i<temp->num_values; ++i)
-                        free(temp->value[i]);
-                free(temp->value);
-                free(temp);
-                temp=container;
-        }
-}
-
-
-int
-SPDY_name_value_iterate (struct SPDY_NameValue *container,
-                           SPDY_NameValueIterator iterator,
-                           void *iterator_cls)
-{
-        int count;
-        int ret;
-        struct SPDY_NameValue *temp = container;
-
-        if(NULL == container)
-                return SPDY_INPUT_ERROR;
-
-        //check if container is an empty struct
-        if(SPDYF_name_value_is_empty(container))
-                return 0;
-
-        count = 0;
-
-        if(NULL == iterator)
-        {
-                do
-                {
-                        ++count;
-                        temp=temp->next;
-                }
-                while(NULL != temp);
-
-                return count;
-        }
-
-        //code duplication for avoiding if here
-        do
-        {
-                ++count;
-                ret = iterator(iterator_cls, temp->name, (const char * const *)temp->value, temp->num_values);
-                temp=temp->next;
-        }
-        while(NULL != temp && SPDY_YES == ret);
-
-        return count;
-}
-
-void
-SPDY_destroy_response(struct SPDY_Response *response)
-{
-  if(NULL == response)
-    return;
-        free(response->data);
-        free(response->headers);
-        free(response);
-}
-
-
-struct SPDYF_Response_Queue *
-SPDYF_response_queue_create(bool is_data,
-                                                void *data,
-                                                size_t data_size,
-                                                struct SPDY_Response *response,
-                                                struct SPDYF_Stream *stream,
-                                                bool closestream,
-                                                SPDYF_ResponseQueueResultCallback frqcb,
-                                                void *frqcb_cls,
-                                                SPDY_ResponseResultCallback rrcb,
-                                                void *rrcb_cls)
-{
-        struct SPDYF_Response_Queue *head = NULL;
-        struct SPDYF_Response_Queue *prev;
-        struct SPDYF_Response_Queue *response_to_queue;
-        struct SPDYF_Control_Frame *control_frame;
-        struct SPDYF_Data_Frame *data_frame;
-        unsigned int i;
-        bool is_last;
-
-        SPDYF_ASSERT((! is_data)
-                     || ((0 == data_size) && (NULL != response->rcb))
-                     || ((0 < data_size) && (NULL == response->rcb)),
-                     "either data or request->rcb must not be null");
-
-        if (is_data && (data_size > SPDY_MAX_SUPPORTED_FRAME_SIZE))
-        {
-                //separate the data in more frames and add them to the queue
-
-                prev=NULL;
-                for(i = 0; i < data_size; i += SPDY_MAX_SUPPORTED_FRAME_SIZE)
-                {
-                        is_last = (i + SPDY_MAX_SUPPORTED_FRAME_SIZE) >= data_size;
-
-                        if(NULL == (response_to_queue = malloc(sizeof(struct SPDYF_Response_Queue))))
-                                goto free_and_fail;
-
-                        memset(response_to_queue, 0, sizeof(struct SPDYF_Response_Queue));
-                        if(0 == i)
-                                head = response_to_queue;
-
-                        if(NULL == (data_frame = malloc(sizeof(struct SPDYF_Data_Frame))))
-                        {
-                                free(response_to_queue);
-                                goto free_and_fail;
-                        }
-                        memset(data_frame, 0, sizeof(struct SPDYF_Data_Frame));
-                        data_frame->control_bit = 0;
-                        data_frame->stream_id = stream->stream_id;
-                        if(is_last && closestream)
-                                data_frame->flags |= SPDY_DATA_FLAG_FIN;
-
-                        response_to_queue->data_frame = data_frame;
-                        response_to_queue->process_response_handler = &SPDYF_handler_write_data;
-                        response_to_queue->is_data = is_data;
-                        response_to_queue->stream = stream;
-                        if(is_last)
-                        {
-                                response_to_queue->frqcb = frqcb;
-                                response_to_queue->frqcb_cls = frqcb_cls;
-                                response_to_queue->rrcb = rrcb;
-                                response_to_queue->rrcb_cls = rrcb_cls;
-                        }
-                        response_to_queue->data = data + i;
-                        response_to_queue->data_size = is_last
-                                ? (data_size - 1) % SPDY_MAX_SUPPORTED_FRAME_SIZE + 1
-                                : SPDY_MAX_SUPPORTED_FRAME_SIZE;
-                        response_to_queue->response = response;
-
-                        response_to_queue->prev = prev;
-                        if(NULL != prev)
-                                prev->next = response_to_queue;
-                        prev = response_to_queue;
-                }
-
-                return head;
-
-                //for GOTO
-                free_and_fail:
-                while(NULL != head)
-                {
-                        response_to_queue = head;
-                        head = head->next;
-                        free(response_to_queue->data_frame);
-                        free(response_to_queue);
-                }
-                return NULL;
-        }
-
-        //create only one frame for data, data with callback or control frame
-
-        if(NULL == (response_to_queue = malloc(sizeof(struct SPDYF_Response_Queue))))
-        {
-                return NULL;
-        }
-        memset(response_to_queue, 0, sizeof(struct SPDYF_Response_Queue));
-
-        if(is_data)
-        {
-                if(NULL == (data_frame = malloc(sizeof(struct SPDYF_Data_Frame))))
-                {
-                        free(response_to_queue);
-                        return NULL;
-                }
-                memset(data_frame, 0, sizeof(struct SPDYF_Data_Frame));
-                data_frame->control_bit = 0;
-                data_frame->stream_id = stream->stream_id;
-                if(closestream && NULL == response->rcb)
-                        data_frame->flags |= SPDY_DATA_FLAG_FIN;
-
-                response_to_queue->data_frame = data_frame;
-                response_to_queue->process_response_handler = &SPDYF_handler_write_data;
-        }
-        else
-        {
-                if(NULL == (control_frame = malloc(sizeof(struct SPDYF_Control_Frame))))
-                {
-                        free(response_to_queue);
-                        return NULL;
-                }
-                memset(control_frame, 0, sizeof(struct SPDYF_Control_Frame));
-                control_frame->control_bit = 1;
-                control_frame->version = SPDY_VERSION;
-                control_frame->type = SPDY_CONTROL_FRAME_TYPES_SYN_REPLY;
-                if(closestream)
-                        control_frame->flags |= SPDY_SYN_REPLY_FLAG_FIN;
-
-                response_to_queue->control_frame = control_frame;
-                response_to_queue->process_response_handler = &SPDYF_handler_write_syn_reply;
-        }
-
-        response_to_queue->is_data = is_data;
-        response_to_queue->stream = stream;
-        response_to_queue->frqcb = frqcb;
-        response_to_queue->frqcb_cls = frqcb_cls;
-        response_to_queue->rrcb = rrcb;
-        response_to_queue->rrcb_cls = rrcb_cls;
-        response_to_queue->data = data;
-        response_to_queue->data_size = data_size;
-        response_to_queue->response = response;
-
-        return response_to_queue;
-}
-
-
-void
-SPDYF_response_queue_destroy(struct SPDYF_Response_Queue *response_queue)
-{
-        //data is not copied to the struct but only linked
-        //but this is not valid for GOAWAY and RST_STREAM
-        if(!response_queue->is_data
-                && (SPDY_CONTROL_FRAME_TYPES_RST_STREAM == response_queue->control_frame->type
-                || SPDY_CONTROL_FRAME_TYPES_GOAWAY == response_queue->control_frame->type))
-        {
-                free(response_queue->data);
-        }
-        if(response_queue->is_data)
-                free(response_queue->data_frame);
-        else
-                free(response_queue->control_frame);
-
-        free(response_queue);
-}
-
-
-/* Needed by testcase to be extern -- should this be
-   in the header? */
-_MHD_EXTERN ssize_t
-SPDYF_name_value_to_stream(struct SPDY_NameValue * container[],
-                           int num_containers,
-                           void **stream)
-{
-        size_t size;
-        int32_t num_pairs = 0;
-        int32_t value_size;
-        int32_t name_size;
-        int32_t temp;
-        unsigned int i;
-        unsigned int offset;
-        unsigned int value_offset;
-        struct SPDY_NameValue * iterator;
-        int j;
-
-        size = 4; //for num pairs
-
-        for(j=0; j<num_containers; ++j)
-        {
-    iterator = container[j];
-    while(iterator != NULL)
-    {
-      ++num_pairs;
-      size += 4 + strlen(iterator->name); //length + string
-
-      SPDYF_ASSERT(iterator->num_values>0, "num_values is 0");
-
-      size += 4; //value length
-
-      for(i=0; i<iterator->num_values; ++i)
-      {
-        //if(NULL == iterator->value[i])
-        //  continue;
-        size += strlen(iterator->value[i]); // string
-        if(i/* || !strlen(iterator->value[i])*/) ++size; //NULL separator
-      }
-
-      iterator = iterator->next;
-    }
-  }
-
-        if(NULL == (*stream = malloc(size)))
-        {
-                return -1;
-        }
-
-        //put num_pairs to the stream
-        num_pairs = htonl(num_pairs);
-        memcpy(*stream, &num_pairs, 4);
-        offset = 4;
-
-        //put all other headers to the stream
-        for(j=0; j<num_containers; ++j)
-        {
-    iterator = container[j];
-    while(iterator != NULL)
-    {
-      name_size = strlen(iterator->name);
-      temp = htonl(name_size);
-      memcpy(*stream + offset, &temp, 4);
-      offset += 4;
-      strncpy(*stream + offset, iterator->name, name_size);
-      offset += name_size;
-
-      value_offset = offset;
-      offset += 4;
-      for(i=0; i<iterator->num_values; ++i)
-      {
-        if(i /*|| !strlen(iterator->value[0])*/)
-        {
-          memset(*stream + offset, 0, 1);
-          ++offset;
-          //if(!i) continue;
-        }
-        //else if(NULL != iterator->value[i])
-        //{
-          strncpy(*stream + offset, iterator->value[i], strlen(iterator->value[i]));
-          offset += strlen(iterator->value[i]);
-        //}
-      }
-      value_size = offset - value_offset - 4;
-      value_size = htonl(value_size);
-      memcpy(*stream + value_offset, &value_size, 4);
-
-      iterator = iterator->next;
-    }
-  }
-
-        SPDYF_ASSERT(offset == size,"offset is wrong");
-
-        return size;
-}
-
-
-/* Needed by testcase to be extern -- should this be
-   in the header? */
-_MHD_EXTERN int
-SPDYF_name_value_from_stream(void *stream,
-                                                        size_t size,
-                                                        struct SPDY_NameValue ** container)
-{
-        int32_t num_pairs;
-        int32_t value_size;
-        int32_t name_size;
-        int i;
-        unsigned int offset = 0;
-        unsigned int value_end_offset;
-        char *name;
-        char *value;
-
-        if(NULL == (*container = SPDY_name_value_create ()))
-        {
-                return SPDY_NO;
-        }
-
-        //get number of pairs
-        memcpy(&num_pairs, stream, 4);
-        offset = 4;
-        num_pairs = ntohl(num_pairs);
-
-        if(num_pairs > 0)
-        {
-                for(i = 0; i < num_pairs; ++i)
-                {
-                        //get name size
-                        memcpy(&name_size, stream + offset, 4);
-                        offset += 4;
-                        name_size = ntohl(name_size);
-                        //get name
-                        if(NULL == (name = strndup(stream + offset, name_size)))
-                        {
-                                SPDY_name_value_destroy(*container);
-                                return SPDY_NO;
-                        }
-                        offset+=name_size;
-
-                        //get value size
-                        memcpy(&value_size, stream + offset, 4);
-                        offset += 4;
-                        value_size = ntohl(value_size);
-                        value_end_offset = offset + value_size;
-                        //get value
-                        do
-                        {
-                                if(NULL == (value = strndup(stream + offset, value_size)))
-                                {
-                                        free(name);
-                                        SPDY_name_value_destroy(*container);
-                                        return SPDY_NO;
-                                }
-                                offset += strlen(value);
-                                if(offset < value_end_offset)
-                                        ++offset; //NULL separator
-
-                                //add name/value to the struct
-                                if(SPDY_YES != SPDY_name_value_add(*container, name, value))
-                                {
-                                        free(name);
-                                        free(value);
-                                        SPDY_name_value_destroy(*container);
-                                        return SPDY_NO;
-                                }
-                                free(value);
-                        }
-                        while(offset < value_end_offset);
-
-                        free(name);
-
-                        if(offset != value_end_offset)
-                        {
-                                SPDY_name_value_destroy(*container);
-                                return SPDY_INPUT_ERROR;
-                        }
-                }
-        }
-
-        if(offset == size)
-                return SPDY_YES;
-
-        SPDY_name_value_destroy(*container);
-        return SPDY_INPUT_ERROR;
-}
diff --git a/src/microspdy/structures.h b/src/microspdy/structures.h
deleted file mode 100644
index e1f8797a..00000000
--- a/src/microspdy/structures.h
+++ /dev/null
@@ -1,1246 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file structures.h
- * @brief  internal and public structures -- most of the structs used by
- *                      the library are defined here
- * @author Andrey Uzunov
- */
-
-#ifndef STRUCTURES_H
-#define STRUCTURES_H
-
-#include "platform.h"
-#include "microspdy.h"
-#include "io.h"
-
-
-/**
- * All possible SPDY control frame types. The number is used in the header
- * of the control frame.
- */
-enum SPDY_CONTROL_FRAME_TYPES
-{
-        /**
-         * The SYN_STREAM control frame allows the sender to asynchronously
-         * create a stream between the endpoints.
-         */
-        SPDY_CONTROL_FRAME_TYPES_SYN_STREAM = 1,
-        
-        /**
-         * SYN_REPLY indicates the acceptance of a stream creation by
-         * the recipient of a SYN_STREAM frame.
-         */
-        SPDY_CONTROL_FRAME_TYPES_SYN_REPLY = 2,
-        
-        /**
-         * The RST_STREAM frame allows for abnormal termination of a stream.
-         * When sent by the creator of a stream, it indicates the creator
-         * wishes to cancel the stream. When sent by the recipient of a
-         * stream, it indicates an error or that the recipient did not want
-         * to accept the stream, so the stream should be closed.
-         */
-        SPDY_CONTROL_FRAME_TYPES_RST_STREAM = 3,
-        
-        /**
-         * A SETTINGS frame contains a set of id/value pairs for
-         * communicating configuration data about how the two endpoints may
-         * communicate. SETTINGS frames can be sent at any time by either
-         * endpoint, are optionally sent, and are fully asynchronous. When
-         * the server is the sender, the sender can request that
-         * configuration data be persisted by the client across SPDY
-         * sessions and returned to the server in future communications.
-         */
-        SPDY_CONTROL_FRAME_TYPES_SETTINGS = 4,
-        
-        /**
-         * The PING control frame is a mechanism for measuring a minimal
-         * round-trip time from the sender. It can be sent from the client
-         * or the server. Recipients of a PING frame should send an
-         * identical frame to the sender as soon as possible (if there is
-         * other pending data waiting to be sent, PING should take highest
-         * priority). Each ping sent by a sender should use a unique ID.
-         */
-        SPDY_CONTROL_FRAME_TYPES_PING = 6,
-        
-        /**
-         * The GOAWAY control frame is a mechanism to tell the remote side
-         * of the connection to stop creating streams on this session. It
-         * can be sent from the client or the server.
-         */
-        SPDY_CONTROL_FRAME_TYPES_GOAWAY = 7,
-        
-        /**
-         * The HEADERS frame augments a stream with additional headers. It
-         * may be optionally sent on an existing stream at any time.
-         * Specific application of the headers in this frame is
-         * application-dependent. The name/value header block within this
-         * frame is compressed.
-         */
-        SPDY_CONTROL_FRAME_TYPES_HEADERS = 8,
-        
-        /**
-         * The WINDOW_UPDATE control frame is used to implement per stream
-         * flow control in SPDY. Flow control in SPDY is per hop, that is,
-         * only between the two endpoints of a SPDY connection. If there are
-         * one or more intermediaries between the client and the origin
-         * server, flow control signals are not explicitly forwarded by the
-         * intermediaries.
-         */
-        SPDY_CONTROL_FRAME_TYPES_WINDOW_UPDATE = 9,
-        
-        /**
-         * The CREDENTIAL control frame is used by the client to send
-         * additional client certificates to the server. A SPDY client may
-         * decide to send requests for resources from different origins on
-         * the same SPDY session if it decides that that server handles both
-         * origins. For example if the IP address associated with both
-         * hostnames matches and the SSL server certificate presented in the
-         * initial handshake is valid for both hostnames. However, because
-         * the SSL connection can contain at most one client certificate,
-         * the client needs a mechanism to send additional client
-         * certificates to the server.
-         */
-        SPDY_CONTROL_FRAME_TYPES_CREDENTIAL = 11
-};
-
-
-/**
- * SPDY_SESSION_STATUS is used to show the current receiving state 
- * of each session, i.e. what is expected to come now, and how it should
- * be handled.
- */
-enum SPDY_SESSION_STATUS
-{
-        /**
-         * The session is in closing state, do not read read anything from
-         * it. Do not write anything to it.
-         */
-        SPDY_SESSION_STATUS_CLOSING = 0,
-        
-        /**
-         * Wait for new SPDY frame to come.
-         */
-        SPDY_SESSION_STATUS_WAIT_FOR_HEADER = 1,
-        
-        /**
-         * The standard 8 byte header of the SPDY frame was received and
-         * handled. Wait for the specific (sub)headers according to the
-         * frame type.
-         */
-        SPDY_SESSION_STATUS_WAIT_FOR_SUBHEADER = 2,
-        
-        /**
-         * The specific (sub)headers were received and handled. Wait for the
-         * "body", i.e. wait for the name/value pairs compressed by zlib.
-         */
-        SPDY_SESSION_STATUS_WAIT_FOR_BODY = 3,
-        
-        /**
-         * Ignore all the bytes read from the socket, e.g. larger frames.
-         */
-        SPDY_SESSION_STATUS_IGNORE_BYTES= 4,
-        
-        /**
-         * The session is in pre-closing state, do not read read anything
-         * from it. In this state the output queue will be written to the
-         * socket.
-         */
-        SPDY_SESSION_STATUS_FLUSHING = 5,
-};
-
-
-/**
- * Specific flags for the SYN_STREAM control frame.
- */
-enum SPDY_SYN_STREAM_FLAG
-{
-        /**
-         * The sender won't send any more frames on this stream.
-         */
-        SPDY_SYN_STREAM_FLAG_FIN = 1,
-        
-        /**
-         * The sender creates this stream as unidirectional.
-         */
-        SPDY_SYN_STREAM_FLAG_UNIDIRECTIONAL = 2
-};
-
-
-/**
- * Specific flags for the SYN_REPLY control frame.
- */
-enum SPDY_SYN_REPLY_FLAG
-{
-        /**
-         * The sender won't send any more frames on this stream.
-         */
-        SPDY_SYN_REPLY_FLAG_FIN = 1
-};
-
-
-/**
- * Specific flags for the data frame.
- */
-enum SPDY_DATA_FLAG
-{
-        /**
-         * The sender won't send any more frames on this stream.
-         */
-        SPDY_DATA_FLAG_FIN = 1,
-        
-        /**
-         * The data in the frame is compressed. 
-         * This flag appears only in the draft on ietf.org but not on
-         * chromium.org.
-         */
-        SPDY_DATA_FLAG_COMPRESS = 2
-};
-
-/**
- * Status code within RST_STREAM control frame.
- */
-enum SPDY_RST_STREAM_STATUS
-{
-        /**
-         * This is a generic error, and should only be used if a more
-         * specific error is not available.
-         */
-        SPDY_RST_STREAM_STATUS_PROTOCOL_ERROR = 1,
-        
-        /**
-         * This is returned when a frame is received for a stream which is
-         * not active.
-         */
-        SPDY_RST_STREAM_STATUS_INVALID_STREAM = 2,
-        
-        /**
-         * Indicates that the stream was refused before any processing has
-         * been done on the stream.
-         */
-        SPDY_RST_STREAM_STATUS_REFUSED_STREAM = 3,
-        
-        /**
-         * Indicates that the recipient of a stream does not support the
-         * SPDY version requested.
-         */
-        SPDY_RST_STREAM_STATUS_UNSUPPORTED_VERSION = 4,
-        
-        /**
-         * Used by the creator of a stream to indicate that the stream is
-         * no longer needed.
-         */
-        SPDY_RST_STREAM_STATUS_CANCEL = 5,
-        
-        /**
-         * This is a generic error which can be used when the implementation
-         * has internally failed, not due to anything in the protocol.
-         */
-        SPDY_RST_STREAM_STATUS_INTERNAL_ERROR = 6,
-        
-        /**
-         * The endpoint detected that its peer violated the flow control
-         * protocol.
-         */
-        SPDY_RST_STREAM_STATUS_FLOW_CONTROL_ERROR = 7,
-        
-        /**
-         * The endpoint received a SYN_REPLY for a stream already open.
-         */
-        SPDY_RST_STREAM_STATUS_STREAM_IN_USE = 8,
-        
-        /**
-         * The endpoint received a data or SYN_REPLY frame for a stream
-         * which is half closed.
-         */
-        SPDY_RST_STREAM_STATUS_STREAM_ALREADY_CLOSED = 9,
-        
-        /**
-         * The server received a request for a resource whose origin does
-         * not have valid credentials in the client certificate vector.
-         */
-        SPDY_RST_STREAM_STATUS_INVALID_CREDENTIALS = 10,
-        
-        /**
-         * The endpoint received a frame which this implementation could not
-         * support. If FRAME_TOO_LARGE is sent for a SYN_STREAM, HEADERS,
-         * or SYN_REPLY frame without fully processing the compressed
-         * portion of those frames, then the compression state will be
-         * out-of-sync with the other endpoint. In this case, senders of
-         * FRAME_TOO_LARGE MUST close the session.
-         */
-        SPDY_RST_STREAM_STATUS_FRAME_TOO_LARGE = 11
-};
-
-
-/**
- * Status code within GOAWAY control frame.
- */
-enum SPDY_GOAWAY_STATUS
-{
-        /**
-         * This is a normal session teardown.
-         */
-        SPDY_GOAWAY_STATUS_OK = 0,
-        
-        /**
-         * This is a generic error, and should only be used if a more
-         * specific error is not available.
-         */
-        SPDY_GOAWAY_STATUS_PROTOCOL_ERROR = 1,
-        
-        /**
-         * This is a generic error which can be used when the implementation
-         * has internally failed, not due to anything in the protocol.
-         */
-        SPDY_GOAWAY_STATUS_INTERNAL_ERROR = 11
-};
-
-
-struct SPDYF_Stream;
-
-struct SPDYF_Response_Queue;
-
-
-/**
- * Callback for received new data chunk.
- *
- * @param cls client-defined closure
- * @param stream handler
- * @param buf data chunk from the data
- * @param size the size of the data chunk 'buf' in bytes
- * @param more false if this is the last frame received on this stream. Note:
- *             true does not mean that more data will come, exceptional
- *             situation is possible
- * @return SPDY_YES to continue calling the function,
- *         SPDY_NO to stop calling the function for this stream
- */
-typedef int
-(*SPDYF_NewDataCallback) (void * cls,
-                                         struct SPDYF_Stream *stream,
-                                         const void * buf,
-                                         size_t size,
-                                         bool more);
-           
-           
-/**
- * Callback for new stream. To be used in the application layer of the
- * lib.
- *
- * @param cls
- * @param stream the new stream
- * @return SPDY_YES on success,
- *         SPDY_NO if error occurs
- */
-typedef int
-(*SPDYF_NewStreamCallback) (void *cls,
-                                                struct SPDYF_Stream * stream);
-
-
-/**
- * Callback to be called when the response queue object was handled and 
- * the data was already sent. 
- *
- * @param cls
- * @param response_queue the SPDYF_Response_Queue structure which will
- *                      be cleaned very soon
- * @param status shows if actually the response was sent or it was
- *                      discarded by the lib for any reason (e.g., closing session,
- *                      closing stream, stopping daemon, etc.). It is possible that
- *                      status indicates an error but part of the response (in one
- *                      or several frames) was sent to the client.
- */
-typedef void
-(*SPDYF_ResponseQueueResultCallback) (void * cls,
-                                                                struct SPDYF_Response_Queue *response_queue,
-                                                                enum SPDY_RESPONSE_RESULT status);
-
-
-/**
- * Representation of the control frame's headers, which are common for
- * all types.
- */
-struct __attribute__((__packed__)) SPDYF_Control_Frame
-{
-        uint16_t version : 15;
-        uint16_t control_bit : 1; /* always 1 for control frames */
-        uint16_t type;
-        uint32_t flags : 8;
-        uint32_t length : 24;
-};
-
-
-/**
- * Representation of the data frame's headers.
- */
-struct __attribute__((__packed__)) SPDYF_Data_Frame
-{
-        uint32_t stream_id : 31;
-        uint32_t control_bit : 1; /* always 0 for data frames */
-        uint32_t flags : 8;
-        uint32_t length : 24;
-};
-
-
-/**
- * Queue of the responses, to be handled (e.g. compressed) and sent later.
- */
-struct SPDYF_Response_Queue
-{
-        /**
-         * This is a doubly-linked list.
-         */
-        struct SPDYF_Response_Queue *next;
-
-        /**
-         * This is a doubly-linked list.
-         */
-        struct SPDYF_Response_Queue *prev;
-
-        /**
-         * Stream (Request) for which is the response.
-         */
-        struct SPDYF_Stream *stream;
-
-        /**
-         * Response structure with all the data (uncompressed headers) to be sent.
-         */
-        struct SPDY_Response *response;
-
-        /**
-         * Control frame. The length field should be set after compressing
-         * the headers!
-         */
-        struct SPDYF_Control_Frame *control_frame;
-
-        /**
-         * Data frame. The length field should be set after compressing
-         * the body!
-         */
-        struct SPDYF_Data_Frame *data_frame;
-
-        /**
-         * Data to be sent: name/value pairs in control frames or body in data frames.
-         */
-        void *data;
-
-        /**
-         * Specific handler for different frame types.
-         */
-        int (* process_response_handler)(struct SPDY_Session *session);
-
-        /**
-         * Callback to be called when the last bytes from the response was sent
-         * to the client.
-         */
-        SPDYF_ResponseQueueResultCallback frqcb;
-        
-        /**
-         * Closure for frqcb.
-         */
-        void *frqcb_cls;
-
-        /**
-         * Callback to be used by the application layer.
-         */
-        SPDY_ResponseResultCallback rrcb;
-        
-        /**
-         * Closure for rcb.
-         */
-        void *rrcb_cls;
-
-        /**
-         * Data size.
-         */
-        size_t data_size;
-
-        /**
-         * True if data frame should be sent. False if control frame should
-         * be sent.
-         */
-        bool is_data;
-};
-
-
-
-/**
- * Collection of HTTP headers used in requests and responses.
- */
-struct SPDY_NameValue
-{
-        /**
-        * This is a doubly-linked list.
-        */
-        struct SPDY_NameValue *next;
-
-        /**
-        * This is a doubly-linked list.
-        */
-        struct SPDY_NameValue *prev;
-
-        /**
-        * Null terminated string for name.
-        */
-    char *name;
-
-        /**
-        * Array of Null terminated strings for value. num_values is the
-        * length of the array.
-        */
-        char **value;
-
-        /**
-        * Number of values, this is >= 0.
-        */
-        unsigned int num_values;
-};
-
-
-/**
- * Represents a SPDY stream
- */ 
-struct SPDYF_Stream
-{
-        /**
-         * This is a doubly-linked list.
-         */
-        struct SPDYF_Stream *next;
-
-        /**
-         * This is a doubly-linked list.
-         */
-        struct SPDYF_Stream *prev;
-
-        /**
-         * Reference to the SPDY_Session struct.
-         */
-        struct SPDY_Session *session;
-        
-        /**
-         * Name value pairs, sent within the frame which created the stream.
-         */
-        struct SPDY_NameValue *headers;
-        
-        /**
-         * Any object to be used by the application layer.
-         */
-        void *cls;
-  
-        /**
-         * This stream's ID.
-         */
-        uint32_t stream_id;
-        
-        /**
-         * Stream to which this one is associated.
-         */
-        uint32_t assoc_stream_id;
-        
-        /**
-         * The window of the data within data frames.
-         */
-        uint32_t window_size;
-        
-        /**
-         * Stream priority. 0 is the highest, 7 is the lowest.
-         */
-        uint8_t priority;
-        
-        /**
-         * Integer specifying the index in the server's CREDENTIAL vector of
-         * the client certificate to be used for this request The value 0
-         * means no client certificate should be associated with this stream.
-         */
-        uint8_t slot;
-        
-        /**
-         * If initially the stream was created as unidirectional.
-         */
-        bool flag_unidirectional;
-        
-        /**
-         * If the stream won't be used for receiving frames anymore. The 
-         * client has sent FLAG_FIN or the stream was terminated with
-         * RST_STREAM.
-         */
-        bool is_in_closed;
-        
-        /**
-         * If the stream won't be used for sending out frames anymore. The 
-         * server has sent FLAG_FIN or the stream was terminated with
-         * RST_STREAM.
-         */
-        bool is_out_closed;
-        
-        /**
-         * Which entity (server/client) has created the stream.
-         */
-        bool is_server_initiator;
-};
-
-
-/**
- * Represents a SPDY session which is just a TCP connection
- */ 
-struct SPDY_Session
-{
-        /**
-         * zlib stream for decompressing all the name/pair values from the
-         * received frames. All the received compressed data must be
-         * decompressed within one context: this stream. Thus, it should be
-         * unique for the session and initialized at its creation.
-         */
-        z_stream zlib_recv_stream;
-
-        /**
-         * zlib stream for compressing all the name/pair values from the
-         * frames to be sent. All the sent compressed data must be
-         * compressed within one context: this stream. Thus, it should be
-         * unique for the session and initialized at its creation.
-         */
-        z_stream zlib_send_stream;
-        
-        /**
-         * This is a doubly-linked list.
-         */
-        struct SPDY_Session *next;
-
-        /**
-         * This is a doubly-linked list.
-         */
-        struct SPDY_Session *prev;
-
-        /**
-         * Reference to the SPDY_Daemon struct.
-         */
-        struct SPDY_Daemon *daemon;
-
-        /**
-         * Foreign address (of length addr_len).
-         */
-        struct sockaddr *addr;
-
-        /**
-         * Head of doubly-linked list of the SPDY streams belonging to the
-         * session.
-         */
-        struct SPDYF_Stream *streams_head;
-
-        /**
-         * Tail of doubly-linked list of the streams.
-         */
-        struct SPDYF_Stream *streams_tail;
-
-        /**
-         * Unique IO context for the session. Initialized on each creation
-         * (actually when the TCP connection is established).
-         */
-        void *io_context;
-        
-        /**
-         * Head of doubly-linked list of the responses.
-         */
-        struct SPDYF_Response_Queue *response_queue_head;
-        
-        /**
-         * Tail of doubly-linked list of the responses.
-         */
-        struct SPDYF_Response_Queue *response_queue_tail;
-
-        /**
-         * Buffer for reading requests.
-         */
-        void *read_buffer;
-
-        /**
-         * Buffer for writing responses.
-         */
-        void *write_buffer;
-
-        /**
-         * Specific handler for the frame that is currently being received.
-         */
-        void (*frame_handler) (struct SPDY_Session * session);
-
-        /**
-         * Closure for frame_handler.
-         */
-        void *frame_handler_cls;
-
-        /**
-         * Extra field to be used by the user with set/get func for whatever
-         * purpose he wants.
-         */
-        void *user_cls;
-
-        /**
-         * Function to initialize the IO context for a new session.
-         */
-        SPDYF_IONewSession fio_new_session;
-
-        /**
-         * Function to deinitialize the IO context for a session.
-         */
-        SPDYF_IOCloseSession fio_close_session;
-
-        /**
-         * Function to read data from socket.
-         */
-        SPDYF_IORecv fio_recv;
-
-        /**
-         * Function to write data to socket.
-         */
-        SPDYF_IOSend fio_send;
-
-        /**
-         * Function to check for pending data in IO buffers.
-         */
-        SPDYF_IOIsPending fio_is_pending;
-
-        /**
-         * Function to call before writing set of frames.
-         */
-        SPDYF_IOBeforeWrite fio_before_write;
-
-        /**
-         * Function to call after writing set of frames.
-         */
-        SPDYF_IOAfterWrite fio_after_write;
-
-        /**
-         * Number of bytes that the lib must ignore immediately after they 
-         * are read from the TLS socket without adding them to the read buf.
-         * This is needed, for instance, when receiving frame bigger than
-         * the buffer to avoid deadlock situations.
-         */
-        size_t read_ignore_bytes;
-
-        /**
-         * Size of read_buffer (in bytes).  This value indicates
-         * how many bytes we're willing to read into the buffer;
-         * the real buffer is one byte longer to allow for
-         * adding zero-termination (when needed).
-         */
-        size_t read_buffer_size;
-
-        /**
-         * Position where we currently append data in
-         * read_buffer (last valid position).
-         */
-        size_t read_buffer_offset;
-
-        /**
-         * Position until where everything was already read
-         */
-        size_t read_buffer_beginning;
-
-        /**
-         * Size of write_buffer (in bytes).  This value indicates
-         * how many bytes we're willing to prepare for writing.
-         */
-        size_t write_buffer_size;
-
-        /**
-         * Position where we currently append data in
-         * write_buffer (last valid position).
-         */
-        size_t write_buffer_offset;
-
-        /**
-         * Position until where everything was already written to the socket
-         */
-        size_t write_buffer_beginning;
-        
-        /**
-         * Last time this connection had any activity
-         * (reading or writing). In milliseconds.
-         */
-        unsigned long long last_activity;
-
-        /**
-         * Socket for this connection.  Set to -1 if
-         * this connection has died (daemon should clean
-         * up in that case).
-         */
-        int socket_fd;
-
-        /**
-         * Length of the foreign address.
-         */
-        socklen_t addr_len;
-        
-        /**
-         * The biggest stream ID for this session for streams initiated
-         * by the client.
-         */
-        uint32_t last_in_stream_id;
-        
-        /**
-         * The biggest stream ID for this session for streams initiated
-         * by the server.
-         */
-        uint32_t last_out_stream_id;
-        
-        /**
-         * This value is updated whenever SYN_REPLY or RST_STREAM are sent
-         * and is used later in GOAWAY frame.
-         * TODO it is not clear in the draft what happens when streams are
-         * not answered in the order of their IDs. Moreover, why should we
-         * send GOAWAY with the ID of received bogus SYN_STREAM with huge ID?
-         */
-        uint32_t last_replied_to_stream_id;
-        
-        /**
-         * Shows the stream id of the currently handled frame. This value is
-         * to be used when sending RST_STREAM in answer to a problematic
-         * frame, e.g. larger than supported.
-         */
-        uint32_t current_stream_id;
-        
-        /**
-         * Maximum number of frames to be written to the socket at once. The
-   * library tries to send max_num_frames in a single call to SPDY_run
-   * for a single session. This means no requests can be received nor
-   * other sessions can send data as long the current one has enough
-   * frames to send and there is no error on writing.
-         */
-        uint32_t max_num_frames;
-
-        /**
-         * Shows the current receiving state the session, i.e. what is
-         * expected to come now, and how it shold be handled.
-         */
-        enum SPDY_SESSION_STATUS status;
-
-        /**
-         * Has this socket been closed for reading (i.e.
-         * other side closed the connection)?  If so,
-         * we must completely close the connection once
-         * we are done sending our response (and stop
-         * trying to read from this socket).
-         */
-        bool read_closed;
-
-        /**
-         * If the server sends GOAWAY, it must ignore all SYN_STREAMS for
-         * this session. Normally the server will soon close the TCP session.
-         */
-        bool is_goaway_sent;
-
-        /**
-         * If the server receives GOAWAY, it must not send new SYN_STREAMS 
-         * on this session. Normally the client will soon close the TCP
-         * session.
-         */
-        bool is_goaway_received;
-};
-
-
-/**
- * State and settings kept for each SPDY daemon.
- */
-struct SPDY_Daemon
-{
-
-        /**
-         * Tail of doubly-linked list of our current, active sessions.
-         */
-        struct SPDY_Session *sessions_head;
-
-        /**
-         * Tail of doubly-linked list of our current, active sessions.
-         */
-        struct SPDY_Session *sessions_tail;
-        
-        /**
-         * Tail of doubly-linked list of connections to clean up.
-         */
-        struct SPDY_Session *cleanup_head;
-
-        /**
-         * Tail of doubly-linked list of connections to clean up.
-         */
-        struct SPDY_Session *cleanup_tail;
-
-        /**
-         * Unique IO context for the daemon. Initialized on daemon start.
-         */
-        void *io_context;
-
-        /**
-         * Certificate file of the server. File path is kept here.
-         */
-        char *certfile;
-
-        /**
-         * Key file for the certificate of the server. File path is
-         * kept here.
-         */
-        char *keyfile;
-        
-
-        /**
-         * The address to which the listening socket is bound.
-         */
-        struct sockaddr *address;
-        
-        /**
-         * Callback called when a new SPDY session is
-         * established by a client
-         */
-        SPDY_NewSessionCallback new_session_cb;
-
-        /**
-         * Callback called when a client closes the session
-         */
-        SPDY_SessionClosedCallback session_closed_cb;
-
-        /**
-         * Callback called when a client sends request
-         */
-        SPDY_NewRequestCallback new_request_cb;
-
-        /**
-        * Callback called when HTTP POST params are received
-        * after request. To be used by the application layer
-        */
-        SPDY_NewDataCallback received_data_cb;
-
-        /**
-        * Callback called when DATA frame is received.
-        */
-        SPDYF_NewDataCallback freceived_data_cb;
-
-        /**
-         * Closure argument for all the callbacks that can be used by the client.
-         */
-        void *cls;
-
-        /**
-         * Callback called when new stream is created.
-         */
-        SPDYF_NewStreamCallback fnew_stream_cb;
-
-        /**
-         * Closure argument for all the callbacks defined in the framing layer.
-         */
-        void *fcls;
-
-        /**
-         * Function to initialize the IO context for the daemon.
-         */
-        SPDYF_IOInit fio_init;
-
-        /**
-         * Function to deinitialize the IO context for the daemon.
-         */
-        SPDYF_IODeinit fio_deinit;
-
-        /**
-         * After how many milliseconds of inactivity should
-         * connections time out? Zero for no timeout.
-         */
-        unsigned long long session_timeout;
-
-        /**
-         * Listen socket.
-         */
-        int socket_fd;
-        
-        /**
-   * This value is inherited by all sessions of the daemon.
-         * Maximum number of frames to be written to the socket at once. The
-   * library tries to send max_num_frames in a single call to SPDY_run
-   * for a single session. This means no requests can be received nor
-   * other sessions can send data as long the current one has enough
-   * frames to send and there is no error on writing.
-         */
-        uint32_t max_num_frames;
-
-        /**
-         * Daemon's options.
-         */
-        enum SPDY_DAEMON_OPTION options;
-
-        /**
-         * Daemon's flags.
-         */
-        enum SPDY_DAEMON_FLAG flags;
-
-        /**
-         * IO subsystem type used by daemon and all its sessions.
-         */
-        enum SPDY_IO_SUBSYSTEM io_subsystem;
-
-        /**
-         * Listen port.
-         */
-        uint16_t port;
-};
-
-
-/**
- * Represents a SPDY response.
- */
-struct SPDY_Response
-{
-        /**
-         * Raw uncompressed stream of the name/value pairs in SPDY frame
-         * used for the HTTP headers.
-         */
-    void *headers;
-        
-        /**
-         * Raw stream of the data to be sent. Equivalent to the body in HTTP
-         * response.
-         */
-        void *data;
-        
-        /**
-         * Callback function to be used when the response data is provided
-         * with callbacks. In this case data must be NULL and data_size must
-         * be 0.
-         */
-        SPDY_ResponseCallback rcb;
-        
-        /**
-         * Extra argument to rcb.
-         */
-        void *rcb_cls;
-        
-        /**
-         * Length of headers.
-         */
-        size_t headers_size;
-        
-        /**
-         * Length of data.
-         */
-        size_t data_size;
-        
-        /**
-         * The callback func will be called to get that amount of bytes to
-         * put them into a DATA frame. It is either user preffered or
-         * the maximum supported by the lib value.
-         */
-        uint32_t rcb_block_size;
-};
-
-
-/* Macros for handling data and structures */
-
-
-/**
- * Insert an element at the head of a DLL. Assumes that head, tail and
- * element are structs with prev and next fields.
- *
- * @param head pointer to the head of the DLL (struct ? *)
- * @param tail pointer to the tail of the DLL (struct ? *)
- * @param element element to insert (struct ? *)
- */
-#define DLL_insert(head,tail,element) do { \
-        (element)->next = (head); \
-        (element)->prev = NULL; \
-        if ((tail) == NULL) \
-                (tail) = element; \
-        else \
-                (head)->prev = element; \
-        (head) = (element); } while (0)
-
-
-/**
- * Remove an element from a DLL. Assumes
- * that head, tail and element are structs
- * with prev and next fields.
- *
- * @param head pointer to the head of the DLL (struct ? *)
- * @param tail pointer to the tail of the DLL (struct ? *)
- * @param element element to remove (struct ? *)
- */
-#define DLL_remove(head,tail,element) do { \
-        if ((element)->prev == NULL) \
-                (head) = (element)->next;  \
-        else \
-                (element)->prev->next = (element)->next; \
-        if ((element)->next == NULL) \
-                (tail) = (element)->prev;  \
-        else \
-                (element)->next->prev = (element)->prev; \
-        (element)->next = NULL; \
-        (element)->prev = NULL; } while (0)
-
-
-/**
- * Convert all integers in a SPDY control frame headers structure from
- * host byte order to network byte order.
- *
- * @param frame input and output structure (struct SPDY_Control_Frame *)
- */
-#if HAVE_BIG_ENDIAN
-#define SPDYF_CONTROL_FRAME_HTON(frame)
-#else
-#define SPDYF_CONTROL_FRAME_HTON(frame) do { \
-        (*((uint16_t *) frame  )) = (*((uint8_t *) (frame) +1 )) | ((*((uint8_t *) frame  ))<<8);\
-        (frame)->type = htons((frame)->type); \
-        (frame)->length = HTON24((frame)->length); \
-        } while (0)
-#endif
-
-
-/**
- * Convert all integers in a SPDY control frame headers structure from
- * network byte order to host byte order.
- *
- * @param frame input and output structure (struct SPDY_Control_Frame *)
- */     
-#if HAVE_BIG_ENDIAN
-#define SPDYF_CONTROL_FRAME_NTOH(frame)
-#else
-#define SPDYF_CONTROL_FRAME_NTOH(frame) do { \
-        (*((uint16_t *) frame  )) = (*((uint8_t *) (frame) +1 )) | ((*((uint8_t *) frame  ))<<8);\
-        (frame)->type = ntohs((frame)->type); \
-        (frame)->length = NTOH24((frame)->length); \
-        } while (0)
-#endif
-
-
-/**
- * Convert all integers in a SPDY data frame headers structure from
- * host byte order to network byte order.
- *
- * @param frame input and output structure (struct SPDY_Data_Frame *)
- */
-#if HAVE_BIG_ENDIAN
-#define SPDYF_DATA_FRAME_HTON(frame)
-#else
-#define SPDYF_DATA_FRAME_HTON(frame) do { \
-        *((uint32_t *) frame  ) = htonl(*((uint32_t *) frame  ));\
-        (frame)->length = HTON24((frame)->length); \
-        } while (0)
-#endif
-
-
-/**
- * Convert all integers in a SPDY data frame headers structure from
- * network byte order to host byte order.
- *
- * @param frame input and output structure (struct SPDY_Data_Frame *)
- */     
-#if HAVE_BIG_ENDIAN
-#define SPDYF_DATA_FRAME_NTOH(frame)
-#else
-#define SPDYF_DATA_FRAME_NTOH(frame) do { \
-        *((uint32_t *) frame  ) = ntohl(*((uint32_t *) frame  ));\
-        (frame)->length = NTOH24((frame)->length); \
-        } while (0)
-#endif
-
-
-/**
- * Creates one or more new SPDYF_Response_Queue object to be put on the
- * response queue.
- *
- * @param is_data whether new data frame or new control frame will be
- *                crerated
- * @param data the row stream which will be used as the body of the frame
- * @param data_size length of data
- * @param response object, part of which is the frame
- * @param stream on which data is to be sent 
- * @param closestream TRUE if the frame must close the stream (with flag) 
- * @param frqcb callback to notify application layer when the frame
- *              has been sent or discarded 
- * @param frqcb_cls closure for frqcb
- * @param rrcb callback used by the application layer to notify the
- *             application when the frame has been sent or discarded.
- *             frqcb will call it 
- * @param rrcb_cls closure for rrcb
- * @return double linked list of SPDYF_Response_Queue structures: one or
- *         more frames are returned based on the size of the data
- */
-struct SPDYF_Response_Queue *
-SPDYF_response_queue_create(bool is_data,
-                                                void *data,
-                                                size_t data_size,
-                                                struct SPDY_Response *response,
-                                                struct SPDYF_Stream *stream,
-                                                bool closestream,
-                                                SPDYF_ResponseQueueResultCallback frqcb,
-                                                void *frqcb_cls,
-                                                SPDY_ResponseResultCallback rrcb,
-                                                void *rrcb_cls);
-
-
-/**
- * Destroys SPDYF_Response_Queue structure and whatever is in it.
- *
- * @param response_queue to destroy
- */
-void
-SPDYF_response_queue_destroy(struct SPDYF_Response_Queue *response_queue);
-
-
-/**
- * Checks if the container is empty, i.e. created but no values were
- * added to it.
- *
- * @param container
- * @return SPDY_YES if empty
- *         SPDY_NO if not
- */
-int
-SPDYF_name_value_is_empty(struct SPDY_NameValue *container);
-
-
-/**
- * Transforms raw binary decomressed stream of headers
- * into SPDY_NameValue, containing all of the headers and values.
- *
- * @param stream that is to be transformed
- * @param size length of the stream
- * @param container will contain the newly created SPDY_NameValue
- *        container. Should point to NULL.
- * @return SPDY_YES on success
- *         SPDY_NO on memory error
- *         SPDY_INPUT_ERROR if the provided stream is not valid
- */
-int
-SPDYF_name_value_from_stream(void *stream,
-                                                        size_t size,
-                                                        struct SPDY_NameValue ** container);
-
-
-/**
- * Transforms array of objects of name/values tuples, containing HTTP
- * headers, into raw binary stream. The resulting stream is ready to
- * be compressed and sent.
- *
- * @param container one or more SPDY_NameValue objects. Each object
- *        contains multiple number of name/value tuples.
- * @param num_containers length of the array
- * @param stream will contain the resulting stream. Should point to NULL.
- * @return length of stream or value less than 0 indicating error
- */
-ssize_t
-SPDYF_name_value_to_stream(struct SPDY_NameValue * container[],
-                                                        int num_containers,
-                                                        void **stream);
-
-#endif
diff --git a/src/spdy2http/Makefile.am b/src/spdy2http/Makefile.am
deleted file mode 100644
index f7432a9b..00000000
--- a/src/spdy2http/Makefile.am
+++ /dev/null
@@ -1,29 +0,0 @@
-# This Makefile.am is in the public domain
-SUBDIRS  = .
-
-AM_CFLAGS =
-
-if USE_COVERAGE
-  AM_CFLAGS += -fprofile-arcs -ftest-coverage
-endif
-
-AM_CPPFLAGS = \
- -I$(top_srcdir) \
- -I$(top_srcdir)/src/include \
- -I$(top_srcdir)/src/applicationlayer \
- -DDATA_DIR=\"$(top_srcdir)/src/datadir/\" \
- $(LIBCURL_CPPFLAGS)
-
-if !HAVE_W32
-PERF_GET_CONCURRENT=perf_get_concurrent
-endif
-
-bin_PROGRAMS = \
- microspdy2http
-
-microspdy2http_SOURCES = \
- proxy.c 
-microspdy2http_LDADD = \
-  $(top_builddir)/src/microspdy/libmicrospdy.la \
- -lz \
- $(LIBCURL)
diff --git a/src/spdy2http/proxy.c b/src/spdy2http/proxy.c
deleted file mode 100644
index 02144ad9..00000000
--- a/src/spdy2http/proxy.c
+++ /dev/null
@@ -1,1411 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file proxy.c
- * @brief   Translates incoming SPDY requests to http server on localhost.
- *                      Uses libcurl.
- *                      No error handling for curl requests.
- *      TODO:
- * - test all options!
- * - don't abort on lack of memory
- * - Correct recapitalizetion of header names before giving the headers
- * to curl.
- * - curl does not close sockets when connection is closed and no
- * new sockets are opened (they stay in CLOSE_WAIT)
- * - add '/' when a user requests http://example.com . Now this is a bad
- * request
- * - curl returns 0 or 1 ms for timeout even when nothing will be done;
- * thus the loop uses CPU for nothing
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include <unistd.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <string.h>
-#include <stdio.h>
-#include <ctype.h>
-#include <errno.h>
-#include "microspdy.h"
-#include <curl/curl.h>
-#include <assert.h>
-#include <getopt.h>
-#include <regex.h>
-
-#define ERROR_RESPONSE "502 Bad Gateway"
-
-
-struct global_options
-{
-  char *http_backend;
-  char *cert;
-  char *cert_key;
-  char *listen_host;
-  unsigned int timeout;
-  uint16_t listen_port;
-  bool verbose;
-  bool curl_verbose;
-  bool transparent;
-  bool http10;
-  bool notls;
-  bool nodelay;
-  bool ipv4;
-  bool ipv6;
-} glob_opt;
-
-
-struct URI
-{
-  char * full_uri;
-  char * scheme;
-  char * host_and_port;
-  //char * host_and_port_for_connecting;
-  char * host;
-  char * path;
-  char * path_and_more;
-  char * query;
-  char * fragment;
-  uint16_t port;
-};
-
-
-#define PRINT_INFO(msg) do{\
-        fprintf(stdout, "%i:%s\n", __LINE__, msg);\
-        fflush(stdout);\
-        }\
-        while(0)
-
-
-#define PRINT_INFO2(fmt, ...) do{\
-        fprintf(stdout, "%i\n", __LINE__);\
-        fprintf(stdout, fmt,##__VA_ARGS__);\
-        fprintf(stdout, "\n");\
-        fflush(stdout);\
-        }\
-        while(0)
-
-
-#define PRINT_VERBOSE(msg) do{\
-  if(glob_opt.verbose){\
-        fprintf(stdout, "%i:%s\n", __LINE__, msg);\
-        fflush(stdout);\
-        }\
-  }\
-        while(0)
-
-
-#define PRINT_VERBOSE2(fmt, ...) do{\
-  if(glob_opt.verbose){\
-        fprintf(stdout, "%i\n", __LINE__);\
-        fprintf(stdout, fmt,##__VA_ARGS__);\
-        fprintf(stdout, "\n");\
-        fflush(stdout);\
-        }\
-        }\
-        while(0)
-
-
-#define CURL_SETOPT(handle, opt, val) do{\
-        int ret; \
-        if(CURLE_OK != (ret = curl_easy_setopt(handle, opt, val))) \
-        { \
-                PRINT_INFO2("curl_easy_setopt failed (%i = %i)", opt, ret); \
-                abort(); \
-        } \
-        }\
-        while(0)
-
-
-#define DIE(msg) do{\
-        printf("FATAL ERROR (line %i): %s\n", __LINE__, msg);\
-        fflush(stdout);\
-  exit(EXIT_FAILURE);\
-        }\
-        while(0)
-
-
-static int loop = 1;
-
-static CURLM *multi_handle;
-
-static int still_running = 0; /* keep number of running handles */
-
-static regex_t uri_preg;
-
-static bool call_spdy_run;
-static bool call_curl_run;
-
-int debug_num_curls;
-
-
-struct Proxy
-{
-        char *url;
-        struct SPDY_Request *request;
-        struct SPDY_Response *response;
-        CURL *curl_handle;
-        struct curl_slist *curl_headers;
-        struct SPDY_NameValue *headers;
-        char *version;
-        char *status_msg;
-        void *http_body;
-        void *received_body;
-  bool *session_alive;
-        size_t http_body_size;
-        size_t received_body_size;
-        //ssize_t length;
-        int status;
-  //bool done;
-  bool receiving_done;
-  bool is_curl_read_paused;
-  bool is_with_body_data;
-  //bool error;
-  bool curl_done;
-  bool curl_error;
-  bool spdy_done;
-  bool spdy_error;
-};
-
-
-static void
-free_uri(struct URI * uri)
-{
-  if(NULL != uri)
-  {
-    free(uri->full_uri);
-    free(uri->scheme);
-    free(uri->host_and_port);
-    //free(uri->host_and_port_for_connecting);
-    free(uri->host);
-    free(uri->path);
-    free(uri->path_and_more);
-    free(uri->query);
-    free(uri->fragment);
-    uri->port = 0;
-    free(uri);
-  }
-}
-
-
-static int
-init_parse_uri(regex_t * preg)
-{
-  // RFC 2396
-  // ^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?
-      /*
-        scheme    = $2
-      authority = $4
-      path      = $5
-      query     = $7
-      fragment  = $9
-      */
-
-  return regcomp(preg, "^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?", REG_EXTENDED);
-}
-
-
-static void
-deinit_parse_uri(regex_t * preg)
-{
-  regfree(preg);
-}
-
-
-static int
-parse_uri(regex_t * preg, const char * full_uri, struct URI ** uri)
-{
-  //TODO memeory checks
-  int ret;
-  char *colon;
-  long long port;
-  size_t nmatch = 10;
-  regmatch_t pmatch[10];
-
-  if (0 != (ret = regexec(preg, full_uri, nmatch, pmatch, 0)))
-    return ret;
-
-  *uri = malloc(sizeof(struct URI));
-  if(NULL == *uri)
-    return -200;
-
-  (*uri)->full_uri = strdup(full_uri);
-
-  asprintf(&((*uri)->scheme),
-           "%.*s",
-           (int) (pmatch[2].rm_eo - pmatch[2].rm_so),
-           &full_uri[pmatch[2].rm_so]);
-  asprintf(&((*uri)->host_and_port), "%.*s",
-           (int) (pmatch[4].rm_eo - pmatch[4].rm_so),
-           &full_uri[pmatch[4].rm_so]);
-  asprintf(&((*uri)->path),
-           "%.*s",
-           (int) (pmatch[5].rm_eo - pmatch[5].rm_so),
-           &full_uri[pmatch[5].rm_so]);
-  asprintf(&((*uri)->path_and_more),
-           "%.*s",
-           (int) (pmatch[9].rm_eo - pmatch[5].rm_so),
-           &full_uri[pmatch[5].rm_so]);
-  asprintf(&((*uri)->query),
-           "%.*s",
-           (int) (pmatch[7].rm_eo - pmatch[7].rm_so),
-           &full_uri[pmatch[7].rm_so]);
-  asprintf(&((*uri)->fragment),
-           "%.*s",
-           (int) (pmatch[9].rm_eo - pmatch[9].rm_so),
-           &full_uri[pmatch[9].rm_so]);
-
-  colon = strrchr((*uri)->host_and_port, ':');
-  if(NULL == colon)
-  {
-    (*uri)->host = strdup((*uri)->host_and_port);
-    /*if(0 == strcasecmp("http", uri->scheme))
-    {
-      uri->port = 80;
-      asprintf(&(uri->host_and_port_for_connecting), "%s:80", uri->host_and_port);
-    }
-    else if(0 == strcasecmp("https", uri->scheme))
-    {
-      uri->port = 443;
-      asprintf(&(uri->host_and_port_for_connecting), "%s:443", uri->host_and_port);
-    }
-    else
-    {
-      PRINT_INFO("no standard scheme!");
-      */(*uri)->port = 0;
-      /*uri->host_and_port_for_connecting = strdup(uri->host_and_port);
-    }*/
-    return 0;
-  }
-
-  port = atoi(colon  + 1);
-  if(port<1 || port >= 256 * 256)
-  {
-    free_uri(*uri);
-    return -100;
-  }
-  (*uri)->port = port;
-  asprintf(&((*uri)->host), "%.*s", (int)(colon - (*uri)->host_and_port), (*uri)->host_and_port);
-
-  return 0;
-}
-
-
-static bool
-store_in_buffer(const void *src, size_t src_size, void **dst, size_t *dst_size)
-{
-  if(0 == src_size)
-    return true;
-
-  if(NULL == *dst)
-                *dst = malloc(src_size);
-        else
-                *dst = realloc(*dst, src_size + *dst_size);
-        if(NULL == *dst)
-                return false;
-
-        memcpy(*dst + *dst_size, src, src_size);
-        *dst_size += src_size;
-
-  return true;
-}
-
-
-static ssize_t
-get_from_buffer(void **src, size_t *src_size, void *dst, size_t max_size)
-{
-  size_t ret;
-  void *newbody;
-
-        if(max_size >= *src_size)
-        {
-                ret = *src_size;
-                newbody = NULL;
-        }
-        else
-        {
-                ret = max_size;
-                if(NULL == (newbody = malloc(*src_size - max_size)))
-                        return -1;
-                memcpy(newbody, *src + ret, *src_size - ret);
-        }
-        memcpy(dst, *src, ret);
-        free(*src);
-        *src = newbody;
-        *src_size -= ret;
-
-  return ret;
-}
-
-
-static void
-catch_signal(int signal)
-{
-  (void)signal;
-
-  loop = 0;
-}
-
-static void
-new_session_cb (void * cls,
-                                                        struct SPDY_Session * session)
-{
-  (void)cls;
-
-  bool *session_alive;
-
-  PRINT_VERBOSE("new session");
-  //TODO clean this memory
-  if(NULL == (session_alive = malloc(sizeof(bool))))
-  {
-                        DIE("no memory");
-  }
-  *session_alive = true;
-  SPDY_set_cls_to_session(session,
-                                                session_alive);
-}
-
-static void
-session_closed_cb (void * cls,
-                                                                struct SPDY_Session * session,
-                                                                int by_client)
-{
-  (void)cls;
-
-  bool *session_alive;
-
-  PRINT_VERBOSE2("session closed; by client: %i", by_client);
-
-  session_alive = SPDY_get_cls_from_session(session);
-  assert(NULL != session_alive);
-
-  *session_alive = false;
-}
-
-
-static int
-spdy_post_data_cb (void * cls,
-                                         struct SPDY_Request *request,
-                                         const void * buf,
-                                         size_t size,
-                                         bool more)
-{
-  (void)cls;
-  int ret;
-        struct Proxy *proxy = (struct Proxy *)SPDY_get_cls_from_request(request);
-
-  if(!store_in_buffer(buf, size, &proxy->received_body, &proxy->received_body_size))
-        {
-                PRINT_INFO("not enough memory (malloc/realloc returned NULL)");
-                return 0;
-        }
-
-  proxy->receiving_done = !more;
-
-  PRINT_VERBOSE2("POST bytes from SPDY: %zu", size);
-
-  call_curl_run = true;
-
-  if(proxy->is_curl_read_paused)
-  {
-    if(CURLE_OK != (ret = curl_easy_pause(proxy->curl_handle, CURLPAUSE_CONT)))
-    {
-      PRINT_INFO2("curl_easy_pause returned %i", ret);
-      abort();
-    }
-    PRINT_VERBOSE("curl_read_cb pause resumed");
-  }
-
-  return SPDY_YES;
-}
-
-
-ssize_t
-response_callback (void *cls,
-                                                void *buffer,
-                                                size_t max,
-                                                bool *more)
-{
-        ssize_t ret;
-        struct Proxy *proxy = (struct Proxy *)cls;
-
-  *more = true;
-
-  assert(!proxy->spdy_error);
-
-  if(proxy->curl_error)
-  {
-    PRINT_VERBOSE("tell spdy about the error");
-    return -1;
-  }
-
-        if(!proxy->http_body_size)//nothing to write now
-  {
-    PRINT_VERBOSE("nothing to write now");
-    if(proxy->curl_done || proxy->curl_error) *more = false;
-                return 0;
-  }
-
-  ret = get_from_buffer(&(proxy->http_body), &(proxy->http_body_size), buffer, max);
-  if(ret < 0)
-  {
-    PRINT_INFO("no memory");
-    //TODO error?
-    return -1;
-  }
-
-  if((proxy->curl_done || proxy->curl_error) && 0 == proxy->http_body_size) *more = false;
-
-  PRINT_VERBOSE2("given bytes to microspdy: %zd", ret);
-
-        return ret;
-}
-
-
-static void
-cleanup(struct Proxy *proxy)
-{
-  int ret;
-
-  //fprintf(stderr, "free proxy for %s\n", proxy->url);
-
-        if(CURLM_OK != (ret = curl_multi_remove_handle(multi_handle, proxy->curl_handle)))
-        {
-                PRINT_INFO2("curl_multi_remove_handle failed (%i)", ret);
-    DIE("bug in cleanup");
-        }
-  debug_num_curls--;
-  //TODO bug on ku6.com or amazon.cn
-  // after curl_multi_remove_handle returned CURLM_BAD_EASY_HANDLE
-        curl_slist_free_all(proxy->curl_headers);
-        curl_easy_cleanup(proxy->curl_handle);
-
-        free(proxy->url);
-        free(proxy);
-}
-
-
-static void
-response_done_callback(void *cls,
-                                                struct SPDY_Response *response,
-                                                struct SPDY_Request *request,
-                                                enum SPDY_RESPONSE_RESULT status,
-                                                bool streamopened)
-{
-        (void)streamopened;
-        struct Proxy *proxy = (struct Proxy *)cls;
-
-        if(SPDY_RESPONSE_RESULT_SUCCESS != status)
-        {
-    free(proxy->http_body);
-    proxy->http_body = NULL;
-    proxy->spdy_error = true;
-        }
-        cleanup(proxy);
-        SPDY_destroy_request(request);
-        SPDY_destroy_response(response);
-}
-
-
-static size_t
-curl_header_cb(void *ptr, size_t size, size_t nmemb, void *userp)
-{
-        size_t realsize = size * nmemb;
-        struct Proxy *proxy = (struct Proxy *)userp;
-        char *line = (char *)ptr;
-        char *name;
-        char *value;
-        char *status;
-        unsigned int i;
-        unsigned int pos;
-        int ret;
-  int num_values;
-  const char * const * values;
-  bool abort_it;
-
-        //printf("curl_header_cb %s\n", line);
-  if(!*(proxy->session_alive))
-  {
-    PRINT_VERBOSE("headers received, but session is dead");
-    proxy->spdy_error = true;
-    proxy->curl_error = true;
-    return 0;
-  }
-
-  //trailer
-  if(NULL != proxy->response) return 0;
-
-        if('\r' == line[0] || '\n' == line[0])
-        {
-                //all headers were already handled; prepare spdy frames
-                if(NULL == (proxy->response = SPDY_build_response_with_callback(proxy->status,
-                                                        proxy->status_msg,
-                                                        proxy->version,
-                                                        proxy->headers,
-                                                        &response_callback,
-                                                        proxy,
-                                                        0)))
-                                                        //256)))
-                        DIE("no response");
-
-                SPDY_name_value_destroy(proxy->headers);
-    proxy->headers = NULL;
-                free(proxy->status_msg);
-    proxy->status_msg = NULL;
-                free(proxy->version);
-    proxy->version = NULL;
-
-                if(SPDY_YES != SPDY_queue_response(proxy->request,
-                                                        proxy->response,
-                                                        true,
-                                                        false,
-                                                        &response_done_callback,
-                                                        proxy))
-    {
-                        //DIE("no queue");
-      //TODO right?
-      proxy->spdy_error = true;
-      proxy->curl_error = true;
-      PRINT_VERBOSE2("no queue in curl_header_cb for %s", proxy->url);
-      SPDY_destroy_response(proxy->response);
-      proxy->response = NULL;
-      return 0;
-    }
-
-    call_spdy_run = true;
-
-                return realsize;
-        }
-
-        pos = 0;
-        if(NULL == proxy->version)
-        {
-                //first line from headers
-                //version
-                for(i=pos; i<realsize && ' '!=line[i]; ++i);
-                if(i == realsize)
-                        DIE("error on parsing headers");
-                if(NULL == (proxy->version = strndup(line, i - pos)))
-        DIE("No memory");
-                pos = i+1;
-
-                //status (number)
-                for(i=pos; i<realsize && ' '!=line[i] && '\r'!=line[i] && '\n'!=line[i]; ++i);
-                if(NULL == (status = strndup(&(line[pos]), i - pos)))
-        DIE("No memory");
-                proxy->status = atoi(status);
-                free(status);
-                if(i<realsize && '\r'!=line[i] && '\n'!=line[i])
-                {
-                        //status (message)
-                        pos = i+1;
-                        for(i=pos; i<realsize && '\r'!=line[i] && '\n'!=line[i]; ++i);
-                        if(NULL == (proxy->status_msg = strndup(&(line[pos]), i - pos)))
-        DIE("No memory");
-                }
-    PRINT_VERBOSE2("Header line received '%s' '%i' '%s' ", proxy->version, proxy->status, proxy->status_msg);
-                return realsize;
-        }
-
-        //other lines
-        //header name
-        for(i=pos; i<realsize && ':'!=line[i] && '\r'!=line[i] && '\n'!=line[i]; ++i)
-                line[i] = tolower(line[i]); //spdy requires lower case
-        if(NULL == (name = strndup(line, i - pos)))
-        DIE("No memory");
-        if(0 == strcmp(SPDY_HTTP_HEADER_CONNECTION, name)
-                || 0 == strcmp(SPDY_HTTP_HEADER_KEEP_ALIVE, name)
-                || 0 == strcmp(SPDY_HTTP_HEADER_TRANSFER_ENCODING, name)
-    )
-        {
-                //forbidden in spdy, ignore
-                free(name);
-                return realsize;
-        }
-        if(i == realsize || '\r'==line[i] || '\n'==line[i])
-        {
-                //no value. is it possible?
-                if(SPDY_YES != SPDY_name_value_add(proxy->headers, name, ""))
-                        DIE("SPDY_name_value_add failed");
-                return realsize;
-        }
-
-        //header value
-        pos = i+1;
-        while(pos<realsize && isspace(line[pos])) ++pos; //remove leading space
-        for(i=pos; i<realsize && '\r'!=line[i] && '\n'!=line[i]; ++i);
-        if(NULL == (value = strndup(&(line[pos]), i - pos)))
-        DIE("No memory");
-  PRINT_VERBOSE2("Adding header: '%s': '%s'", name, value);
-        if(SPDY_YES != (ret = SPDY_name_value_add(proxy->headers, name, value)))
-        {
-    abort_it=true;
-    if(NULL != (values = SPDY_name_value_lookup(proxy->headers, name, &num_values)))
-      for(i=0; i<(unsigned int)num_values; ++i)
-        if(0 == strcasecmp(value, values[i]))
-        {
-          abort_it=false;
-          PRINT_VERBOSE2("header appears more than once with same value '%s: %s'", name, value);
-          break;
-        }
-
-    if(abort_it)
-    {
-      PRINT_INFO2("SPDY_name_value_add failed (%i) for '%s'", ret, name);
-      abort();
-    }
-        }
-        free(name);
-        free(value);
-
-        return realsize;
-}
-
-
-static size_t
-curl_write_cb(void *contents, size_t size, size_t nmemb, void *userp)
-{
-        size_t realsize = size * nmemb;
-        struct Proxy *proxy = (struct Proxy *)userp;
-
-        //printf("curl_write_cb %i\n", realsize);
-  if(!*(proxy->session_alive))
-  {
-    PRINT_VERBOSE("data received, but session is dead");
-      proxy->spdy_error = true;
-      proxy->curl_error = true;
-    return 0;
-  }
-
-  if(!store_in_buffer(contents, realsize, &proxy->http_body, &proxy->http_body_size))
-        {
-                PRINT_INFO("not enough memory (malloc/realloc returned NULL)");
-      proxy->curl_error = true;
-                return 0;
-        }
-  /*
-        if(NULL == proxy->http_body)
-                proxy->http_body = malloc(realsize);
-        else
-                proxy->http_body = realloc(proxy->http_body, proxy->http_body_size + realsize);
-        if(NULL == proxy->http_body)
-        {
-                PRINT_INFO("not enough memory (realloc returned NULL)");
-                return 0;
-        }
-
-        memcpy(proxy->http_body + proxy->http_body_size, contents, realsize);
-        proxy->http_body_size += realsize;
-  */
-
-  PRINT_VERBOSE2("received bytes from curl: %zu", realsize);
-
-  call_spdy_run = true;
-
-        return realsize;
-}
-
-
-static size_t
-curl_read_cb(void *ptr, size_t size, size_t nmemb, void *userp)
-{
-        ssize_t ret;
-        size_t max = size * nmemb;
-        struct Proxy *proxy = (struct Proxy *)userp;
-        //void *newbody;
-
-
-  if((proxy->receiving_done && !proxy->received_body_size) || !proxy->is_with_body_data || max < 1)
-  {
-    PRINT_VERBOSE("curl_read_cb last call");
-    return 0;
-  }
-
-  if(!*(proxy->session_alive))
-  {
-    PRINT_VERBOSE("POST is still being sent, but session is dead");
-    return CURL_READFUNC_ABORT;
-  }
-
-        if(!proxy->received_body_size)//nothing to write now
-  {
-    PRINT_VERBOSE("curl_read_cb called paused");
-    proxy->is_curl_read_paused = true;
-                return CURL_READFUNC_PAUSE;//TODO curl pause should be used
-  }
-
-  ret = get_from_buffer(&(proxy->received_body), &(proxy->received_body_size), ptr, max);
-  if(ret < 0)
-  {
-    PRINT_INFO("no memory");
-    return CURL_READFUNC_ABORT;
-  }
-
-        /*
-        if(max >= proxy->received_body_size)
-        {
-                ret = proxy->received_body_size;
-                newbody = NULL;
-        }
-        else
-        {
-                ret = max;
-                if(NULL == (newbody = malloc(proxy->received_body_size - max)))
-                {
-                        PRINT_INFO("no memory");
-                        return CURL_READFUNC_ABORT;
-                }
-                memcpy(newbody, proxy->received_body + max, proxy->received_body_size - max);
-        }
-        memcpy(ptr, proxy->received_body, ret);
-        free(proxy->received_body);
-        proxy->received_body = newbody;
-        proxy->received_body_size -= ret;
-  * */
-
-  PRINT_VERBOSE2("given POST bytes to curl: %zd", ret);
-
-        return ret;
-}
-
-
-static int
-iterate_cb (void *cls, const char *name, const char * const * value, int num_values)
-{
-        struct Proxy *proxy = (struct Proxy *)cls;
-  struct curl_slist **curl_headers = (&(proxy->curl_headers));
-  char *line;
-  int line_len = strlen(name) + 3; //+ ": \0"
-  int i;
-
-  for(i=0; i<num_values; ++i)
-  {
-                if(i) line_len += 2; //", "
-                line_len += strlen(value[i]);
-        }
-
-        if(NULL == (line = malloc(line_len)))//no recovery
-    DIE("No memory");
-        line[0] = 0;
-
-  strcat(line, name);
-  strcat(line, ": ");
-  //all spdy header names are lower case;
-  //for simplicity here we just capitalize the first letter
-  line[0] = toupper(line[0]);
-
-        for(i=0; i<num_values; ++i)
-        {
-                if(i) strcat(line, ", ");
-  PRINT_VERBOSE2("Adding request header: '%s' len %ld", value[i], strlen(value[i]));
-                strcat(line, value[i]);
-        }
-  PRINT_VERBOSE2("Adding request header: '%s'", line);
-  if(NULL == (*curl_headers = curl_slist_append(*curl_headers, line)))
-                DIE("curl_slist_append failed");
-        free(line);
-
-        return SPDY_YES;
-}
-
-
-static void
-standard_request_handler(void *cls,
-                        struct SPDY_Request * request,
-                        uint8_t priority,
-                        const char *method,
-                        const char *path,
-                        const char *version,
-                        const char *host,
-                        const char *scheme,
-                        struct SPDY_NameValue * headers,
-                        bool more)
-{
-        (void)cls;
-        (void)priority;
-        (void)host;
-        (void)scheme;
-
-        struct Proxy *proxy;
-        int ret;
-  struct URI *uri;
-  struct SPDY_Session *session;
-
-  proxy = SPDY_get_cls_from_request(request);
-  if(NULL != proxy)
-  {
-    //ignore trailers or more headers
-    return;
-  }
-
-        PRINT_VERBOSE2("received request for '%s %s %s'\n", method, path, version);
-
-  //TODO not freed once in a while
-        if(NULL == (proxy = malloc(sizeof(struct Proxy))))
-    DIE("No memory");
-        memset(proxy, 0, sizeof(struct Proxy));
-
-  //fprintf(stderr, "new  proxy for %s\n", path);
-
-  session = SPDY_get_session_for_request(request);
-  assert(NULL != session);
-  proxy->session_alive = SPDY_get_cls_from_session(session);
-  assert(NULL != proxy->session_alive);
-
-  SPDY_set_cls_to_request(request, proxy);
-
-        proxy->request = request;
-        proxy->is_with_body_data = more;
-        if(NULL == (proxy->headers = SPDY_name_value_create()))
-        DIE("No memory");
-
-  if(glob_opt.transparent)
-  {
-    if(NULL != glob_opt.http_backend) //use always same host
-      ret = asprintf(&(proxy->url),"%s://%s%s", scheme, glob_opt.http_backend, path);
-    else //use host header
-      ret = asprintf(&(proxy->url),"%s://%s%s", scheme, host, path);
-    if(-1 == ret)
-        DIE("No memory");
-
-    ret = parse_uri(&uri_preg, proxy->url, &uri);
-    if(ret != 0)
-      DIE("parsing built uri failed");
-  }
-  else
-  {
-    ret = parse_uri(&uri_preg, path, &uri);
-    PRINT_INFO2("path %s '%s' '%s'", path, uri->scheme, uri->host);
-    if(ret != 0 || !strlen(uri->scheme) || !strlen(uri->host))
-      DIE("parsing received uri failed");
-
-    if(NULL != glob_opt.http_backend) //use backend host
-    {
-      ret = asprintf(&(proxy->url),"%s://%s%s", uri->scheme, glob_opt.http_backend, uri->path_and_more);
-      if(-1 == ret)
-        DIE("No memory");
-    }
-    else //use request path
-      if(NULL == (proxy->url = strdup(path)))
-        DIE("No memory");
-  }
-
-  free_uri(uri);
-
-  PRINT_VERBOSE2("curl will request '%s'", proxy->url);
-
-  SPDY_name_value_iterate(headers, &iterate_cb, proxy);
-
-        if(NULL == (proxy->curl_handle = curl_easy_init()))
-    {
-                PRINT_INFO("curl_easy_init failed");
-                abort();
-        }
-
-        if(glob_opt.curl_verbose)
-    CURL_SETOPT(proxy->curl_handle, CURLOPT_VERBOSE, 1);
-
-  if(0 == strcmp(SPDY_HTTP_METHOD_POST,method))
-  {
-    if(NULL == (proxy->curl_headers = curl_slist_append(proxy->curl_headers, "Expect:")))
-      DIE("curl_slist_append failed");
-    CURL_SETOPT(proxy->curl_handle, CURLOPT_POST, 1);
-    CURL_SETOPT(proxy->curl_handle, CURLOPT_READFUNCTION, curl_read_cb);
-    CURL_SETOPT(proxy->curl_handle, CURLOPT_READDATA, proxy);
-  }
-
-  if(glob_opt.timeout)
-    CURL_SETOPT(proxy->curl_handle, CURLOPT_TIMEOUT, glob_opt.timeout);
-        CURL_SETOPT(proxy->curl_handle, CURLOPT_URL, proxy->url);
-        if(glob_opt.http10)
-                CURL_SETOPT(proxy->curl_handle, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
-        CURL_SETOPT(proxy->curl_handle, CURLOPT_WRITEFUNCTION, curl_write_cb);
-        CURL_SETOPT(proxy->curl_handle, CURLOPT_WRITEDATA, proxy);
-        CURL_SETOPT(proxy->curl_handle, CURLOPT_HEADERFUNCTION, curl_header_cb);
-        CURL_SETOPT(proxy->curl_handle, CURLOPT_HEADERDATA, proxy);
-        CURL_SETOPT(proxy->curl_handle, CURLOPT_PRIVATE, proxy);
-        CURL_SETOPT(proxy->curl_handle, CURLOPT_HTTPHEADER, proxy->curl_headers);
-  CURL_SETOPT(proxy->curl_handle, CURLOPT_SSL_VERIFYPEER, 0L);//TODO
-  CURL_SETOPT(proxy->curl_handle, CURLOPT_SSL_VERIFYHOST, 0L);
-  if(glob_opt.ipv4 && !glob_opt.ipv6)
-    CURL_SETOPT(proxy->curl_handle, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
-  else if(glob_opt.ipv6 && !glob_opt.ipv4)
-    CURL_SETOPT(proxy->curl_handle, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V6);
-
-        if(CURLM_OK != (ret = curl_multi_add_handle(multi_handle, proxy->curl_handle)))
-        {
-                PRINT_INFO2("curl_multi_add_handle failed (%i)", ret);
-                abort();
-        }
-  debug_num_curls++;
-
-  //~5ms additional latency for calling this
-        if(CURLM_OK != (ret = curl_multi_perform(multi_handle, &still_running))
-                && CURLM_CALL_MULTI_PERFORM != ret)
-        {
-                PRINT_INFO2("curl_multi_perform failed (%i)", ret);
-                abort();
-        }
-
-  call_curl_run = true;
-}
-
-
-static int
-run ()
-{
-  unsigned long long timeoutlong = 0;
-  unsigned long long timeout_spdy = 0;
-  long timeout_curl = -1;
-        struct timeval timeout;
-        int ret;
-        int ret_curl;
-        int ret_spdy;
-        fd_set rs;
-        fd_set ws;
-        fd_set es;
-        int maxfd = -1;
-        int maxfd_curl = -1;
-        struct SPDY_Daemon *daemon;
-  CURLMsg *msg;
-  int msgs_left;
-  struct Proxy *proxy;
-  struct sockaddr_in *addr;
-  struct addrinfo hints;
-  char service[NI_MAXSERV];
-  struct addrinfo *gai;
-  enum SPDY_IO_SUBSYSTEM io = glob_opt.notls ? SPDY_IO_SUBSYSTEM_RAW : SPDY_IO_SUBSYSTEM_OPENSSL;
-  enum SPDY_DAEMON_FLAG flags = SPDY_DAEMON_FLAG_NO;
-  //struct SPDY_Response *error_response;
-  char *curl_private;
-
-        signal(SIGPIPE, SIG_IGN);
-
-  if (signal(SIGINT, catch_signal) == SIG_ERR)
-    PRINT_VERBOSE("signal failed");
-
-  srand(time(NULL));
-  if(init_parse_uri(&uri_preg))
-    DIE("Regexp compilation failed");
-
-        SPDY_init();
-
-  if(glob_opt.nodelay)
-    flags |= SPDY_DAEMON_FLAG_NO_DELAY;
-
-  if(NULL == glob_opt.listen_host)
-        {
-    daemon = SPDY_start_daemon(glob_opt.listen_port,
-                                                                glob_opt.cert,
-                                                                glob_opt.cert_key,
-                                                                &new_session_cb,
-                                                                &session_closed_cb,
-                                                                &standard_request_handler,
-                                                                &spdy_post_data_cb,
-                                                                NULL,
-                                                                SPDY_DAEMON_OPTION_SESSION_TIMEOUT,
-                                                                1800,
-                SPDY_DAEMON_OPTION_IO_SUBSYSTEM,
-                io,
-                SPDY_DAEMON_OPTION_FLAGS,
-                flags,
-                                                                SPDY_DAEMON_OPTION_END);
-  }
-  else
-  {
-    snprintf (service, sizeof(service), "%u", glob_opt.listen_port);
-    memset (&hints, 0, sizeof(struct addrinfo));
-    hints.ai_family = AF_INET;
-    hints.ai_socktype = SOCK_STREAM;
-
-    ret = getaddrinfo(glob_opt.listen_host, service, &hints, &gai);
-    if(ret != 0)
-      DIE("problem with specified host");
-
-    addr = (struct sockaddr_in *) gai->ai_addr;
-
-    daemon = SPDY_start_daemon(0,
-                                                                glob_opt.cert,
-                                                                glob_opt.cert_key,
-                                                                &new_session_cb,
-                                                                &session_closed_cb,
-                                                                &standard_request_handler,
-                                                                &spdy_post_data_cb,
-                                                                NULL,
-                                                                SPDY_DAEMON_OPTION_SESSION_TIMEOUT,
-                                                                1800,
-                SPDY_DAEMON_OPTION_IO_SUBSYSTEM,
-                io,
-                SPDY_DAEMON_OPTION_FLAGS,
-                flags,
-                SPDY_DAEMON_OPTION_SOCK_ADDR,
-                addr,
-                //SPDY_DAEMON_OPTION_MAX_NUM_FRAMES,
-                //1,
-                                                                SPDY_DAEMON_OPTION_END);
-  }
-
-        if(NULL==daemon){
-                printf("no daemon\n");
-                return 1;
-        }
-
-        multi_handle = curl_multi_init();
-        if(NULL==multi_handle)
-                DIE("no multi_handle");
-
-        timeout.tv_usec = 0;
-
-        do
-        {
-                FD_ZERO(&rs);
-                FD_ZERO(&ws);
-                FD_ZERO(&es);
-
-    PRINT_VERBOSE2("num  curls %i", debug_num_curls);
-
-    ret_spdy = SPDY_get_timeout(daemon, &timeout_spdy);
-    if(SPDY_NO == ret_spdy || timeout_spdy > 5000)
-      timeoutlong = 5000;
-    else
-      timeoutlong = timeout_spdy;
-    PRINT_VERBOSE2("SPDY timeout %lld; %i", timeout_spdy, ret_spdy);
-
-    if(CURLM_OK != (ret_curl = curl_multi_timeout(multi_handle, &timeout_curl)))
-    {
-      PRINT_VERBOSE2("curl_multi_timeout failed (%i)", ret_curl);
-      //curl_timeo = timeoutlong;
-    }
-    else if(timeout_curl >= 0 && timeoutlong > (unsigned long)timeout_curl)
-      timeoutlong = (unsigned long)timeout_curl;
-
-    PRINT_VERBOSE2("curl timeout %ld", timeout_curl);
-
-    timeout.tv_sec = timeoutlong / 1000;
-                timeout.tv_usec = (timeoutlong % 1000) * 1000;
-
-                maxfd = SPDY_get_fdset (daemon,
-                                                                &rs,
-                                                                &ws,
-                                                                &es);
-                assert(-1 != maxfd);
-
-                if(CURLM_OK != (ret = curl_multi_fdset(multi_handle, &rs,
-                                                                &ws,
-                                                                &es, &maxfd_curl)))
-                {
-                        PRINT_INFO2("curl_multi_fdset failed (%i)", ret);
-                        abort();
-                }
-
-    if(maxfd_curl > maxfd)
-      maxfd = maxfd_curl;
-
-    PRINT_VERBOSE2("timeout before %lld %lld", (unsigned long long)timeout.tv_sec, (unsigned long long)timeout.tv_usec);
-    ret = select(maxfd+1, &rs, &ws, &es, &timeout);
-    PRINT_VERBOSE2("timeout after %lld %lld; ret is %i", (unsigned long long)timeout.tv_sec, (unsigned long long)timeout.tv_usec, ret);
-
-                /*switch(ret) {
-                        case -1:
-                                PRINT_INFO2("select error: %i", errno);
-                                break;
-                        case 0:
-                                break;
-                        default:*/
-
-      //the second part should not happen with current implementation
-      if(ret > 0 || (SPDY_YES == ret_spdy && 0 == timeout_spdy))
-      {
-                                PRINT_VERBOSE("run spdy");
-                                SPDY_run(daemon);
-        call_spdy_run = false;
-      }
-
-      //if(ret > 0 || (CURLM_OK == ret_curl && 0 == timeout_curl) || call_curl_run)
-      {
-                                PRINT_VERBOSE("run curl");
-                                if(CURLM_OK != (ret = curl_multi_perform(multi_handle, &still_running))
-                                        && CURLM_CALL_MULTI_PERFORM != ret)
-                                {
-                                        PRINT_INFO2("curl_multi_perform failed (%i)", ret);
-                                        abort();
-                                }
-        call_curl_run = false;
-      }
-                        /*break;
-                }*/
-
-    while ((msg = curl_multi_info_read(multi_handle, &msgs_left))) {
-      if (msg->msg == CURLMSG_DONE) {
-        PRINT_VERBOSE("A curl handler is done");
-        if(CURLE_OK != (ret = curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, &curl_private)))
-        {
-          PRINT_INFO2("err %i",ret);
-          abort();
-        }
-        assert(NULL != curl_private);
-        proxy = (struct Proxy *)curl_private;
-        if(CURLE_OK == msg->data.result)
-        {
-          proxy->curl_done = true;
-          call_spdy_run = true;
-          //TODO what happens with proxy when the client resets a stream
-          //and response_done is not yet set for the last frame? is it
-          //possible?
-        }
-        else
-        {
-          PRINT_VERBOSE2("bad curl result (%i) for '%s'", msg->data.result, proxy->url);
-          if(proxy->spdy_done || proxy->spdy_error || (NULL == proxy->response && !*(proxy->session_alive)))
-          {
-            PRINT_VERBOSE("cleaning");
-            SPDY_name_value_destroy(proxy->headers);
-            SPDY_destroy_request(proxy->request);
-            SPDY_destroy_response(proxy->response);
-            cleanup(proxy);
-          }
-          else if(NULL == proxy->response && *(proxy->session_alive))
-          {
-            //generate error for the client
-            PRINT_VERBOSE("will send Bad Gateway");
-            SPDY_name_value_destroy(proxy->headers);
-            proxy->headers = NULL;
-            if(NULL == (proxy->response = SPDY_build_response(SPDY_HTTP_BAD_GATEWAY,
-                  NULL,
-                  SPDY_HTTP_VERSION_1_1,
-                  NULL,
-                  ERROR_RESPONSE,
-                  strlen(ERROR_RESPONSE))))
-              DIE("no response");
-            if(SPDY_YES != SPDY_queue_response(proxy->request,
-                      proxy->response,
-                      true,
-                      false,
-                      &response_done_callback,
-                      proxy))
-            {
-              //clean and forget
-              PRINT_VERBOSE("cleaning");
-              SPDY_destroy_request(proxy->request);
-              SPDY_destroy_response(proxy->response);
-              cleanup(proxy);
-            }
-          }
-          else
-          {
-            proxy->curl_error = true;
-          }
-          call_spdy_run = true;
-          //TODO spdy should be notified to send RST_STREAM
-        }
-      }
-      else PRINT_INFO("shouldn't happen");
-    }
-
-    if(call_spdy_run)
-    {
-      PRINT_VERBOSE("second call to SPDY_run");
-      SPDY_run(daemon);
-      call_spdy_run = false;
-    }
-
-    if(glob_opt.verbose)
-    {
-
-#ifdef HAVE_CLOCK_GETTIME
-#ifdef CLOCK_MONOTONIC
-    struct timespec ts;
-
-    if (0 == clock_gettime(CLOCK_MONOTONIC, &ts))
-    PRINT_VERBOSE2 ("time now %lld %lld",
-                    (unsigned long long) ts.tv_sec,
-                    (unsigned long long) ts.tv_nsec);
-#endif
-#endif
-    }
-
-  }
-  while(loop);
-
-        SPDY_stop_daemon(daemon);
-
-        curl_multi_cleanup(multi_handle);
-
-        SPDY_deinit();
-
-  deinit_parse_uri(&uri_preg);
-
-        return 0;
-}
-
-
-static void
-display_usage()
-{
-  printf(
-    "Usage: microspdy2http -p <PORT> [-c <CERTIFICATE>] [-k <CERT-KEY>]\n"
-    "                      [-rvh0DtT] [-b <HTTP-SERVER>] [-l <HOST>]\n\n"
-    "OPTIONS:\n"
-    "    -p, --port            Listening port.\n"
-    "    -l, --host            Listening host. If not set, will listen on [::]\n"
-    "    -c, --certificate     Path to a certificate file. Requiered if\n"
-    "                          --no-tls is not set.\n"
-    "    -k, --certificate-key Path to a key file for the certificate.\n"
-    "                          Requiered if --no-tls is not set.\n"
-    "    -b, --backend-server  If set, the proxy will connect always to it.\n"
-    "                          Otherwise the proxy will connect to the URL\n"
-    "                          which is specified in the path or 'Host:'.\n"
-    "    -v, --verbose         Print debug information.\n"
-    "    -r, --no-tls          Do not use TLS. Client must use SPDY/3.\n"
-    "    -h, --curl-verbose    Print debug information for curl.\n"
-    "    -0, --http10          Prefer HTTP/1.0 connections to the next hop.\n"
-    "    -D, --no-delay        This makes sense only if --no-tls is used.\n"
-    "                          TCP_NODELAY will be used for all sessions' sockets.\n"
-    "    -4, --curl-ipv4       Curl may use IPv4 to connect to the final destination.\n"
-    "    -6, --curl-ipv6       Curl may use IPv6 to connect to the final destination.\n"
-    "                          If neither --curl-ipv4 nor --curl-ipv6 is set,\n"
-    "                          both will be used by default.\n"
-    "    -T, --timeout         Maximum time in seconds for each HTTP transfer.\n"
-    "                          Use 0 for no timeout; this is the default value.\n"
-    "    -t, --transparent     If set, the proxy will fetch an URL which\n"
-    "                          is based on 'Host:' header and requested path.\n"
-    "                          Otherwise, full URL in the requested path is required.\n\n"
-
-  );
-}
-
-
-int
-main (int argc, char *const *argv)
-{
-
-  int getopt_ret;
-  int option_index;
-  struct option long_options[] = {
-    {"port",  required_argument, 0, 'p'},
-    {"certificate",  required_argument, 0, 'c'},
-    {"certificate-key",  required_argument, 0, 'k'},
-    {"backend-server",  required_argument, 0, 'b'},
-    {"no-tls",  no_argument, 0, 'r'},
-    {"verbose",  no_argument, 0, 'v'},
-    {"curl-verbose",  no_argument, 0, 'h'},
-    {"http10",  no_argument, 0, '0'},
-    {"no-delay",  no_argument, 0, 'D'},
-    {"transparent",  no_argument, 0, 't'},
-    {"curl-ipv4",  no_argument, 0, '4'},
-    {"curl-ipv6",  no_argument, 0, '6'},
-    {"timeout",  required_argument, 0, 'T'},
-    {0, 0, 0, 0}
-  };
-
-  while (1)
-  {
-    getopt_ret = getopt_long( argc, argv, "p:l:c:k:b:rv0Dth46T:", long_options, &option_index);
-    if (getopt_ret == -1)
-      break;
-
-    switch(getopt_ret)
-    {
-      case 'p':
-        glob_opt.listen_port = atoi(optarg);
-        break;
-
-      case 'l':
-        glob_opt.listen_host= strdup(optarg);
-        if(NULL == glob_opt.listen_host)
-          return 1;
-        break;
-
-      case 'c':
-        glob_opt.cert = strdup(optarg);
-        break;
-
-      case 'k':
-        glob_opt.cert_key = strdup(optarg);
-        break;
-
-      case 'b':
-        glob_opt.http_backend = strdup(optarg);
-        if(NULL == glob_opt.http_backend)
-          return 1;
-        break;
-
-      case 'r':
-        glob_opt.notls = true;
-        break;
-
-      case 'v':
-        glob_opt.verbose = true;
-        break;
-
-      case 'h':
-        glob_opt.curl_verbose = true;
-        break;
-
-      case '0':
-        glob_opt.http10 = true;
-        break;
-
-      case 'D':
-        glob_opt.nodelay = true;
-        break;
-
-      case 't':
-        glob_opt.transparent = true;
-        break;
-
-      case '4':
-        glob_opt.ipv4 = true;
-        break;
-
-      case '6':
-        glob_opt.ipv6 = true;
-        break;
-
-      case 'T':
-        glob_opt.timeout = atoi(optarg);
-        break;
-
-      case 0:
-        PRINT_INFO("0 from getopt");
-        break;
-
-      case '?':
-        display_usage();
-        return 1;
-
-      default:
-        DIE("default from getopt");
-    }
-  }
-
-  if(
-    0 == glob_opt.listen_port
-    || (!glob_opt.notls && (NULL == glob_opt.cert || NULL == glob_opt.cert_key))
-    //|| !glob_opt.transparent && NULL != glob_opt.http_backend
-    )
-  {
-    display_usage();
-    return 1;
-  }
-
-  return run();
-}
-
diff --git a/src/testspdy/Makefile.am b/src/testspdy/Makefile.am
deleted file mode 100644
index 9d78bec1..00000000
--- a/src/testspdy/Makefile.am
+++ /dev/null
@@ -1,115 +0,0 @@
-# This Makefile.am is in the public domain
-SUBDIRS  = .
-
-AM_CFLAGS = -DDATA_DIR=\"$(top_srcdir)/src/datadir/\"
-
-if USE_COVERAGE
-  AM_CFLAGS += -fprofile-arcs -ftest-coverage
-endif
-
-AM_CPPFLAGS = \
- -I$(top_srcdir) \
- -I$(top_srcdir)/src/include \
- -I$(top_srcdir)/src/applicationlayer \
- $(LIBCURL_CPPFLAGS)
-
-if !HAVE_W32
-PERF_GET_CONCURRENT=perf_get_concurrent
-endif
-
-if ENABLE_SPDY
-if HAVE_OPENSSL
-check_PROGRAMS = \
-  test_daemon_start_stop \
-  test_daemon_start_stop_many \
-  test_struct_namevalue
-
-if HAVE_SPDYLAY  
-check_PROGRAMS += \
-  test_new_connection  \
-  test_request_response \
-  test_notls \
-  test_request_response_with_callback \
-  test_misc \
-  test_session_timeout
-  #test_requests_with_assets 
-if HAVE_CURL_BINARY
-check_PROGRAMS +=  \
-  test_proxies
-endif 
-endif
-endif 
-endif 
-
-
-TESTS = $(check_PROGRAMS)
-
-
-SPDY_SOURCES= \
- common.h common.c
-
-SPDY_LDADD=  \
- $(top_builddir)/src/microspdy/libmicrospdy.la \
- -lz
-
-test_daemon_start_stop_SOURCES = \
- test_daemon_start_stop.c \
- $(SPDY_SOURCES) 
-test_daemon_start_stop_LDADD =  $(SPDY_LDADD)
-
-test_daemon_start_stop_many_SOURCES = \
- test_daemon_start_stop_many.c  \
- $(SPDY_SOURCES) 
-test_daemon_start_stop_many_LDADD = $(SPDY_LDADD)
-
-test_struct_namevalue_SOURCES = \
- test_struct_namevalue.c  \
- $(SPDY_SOURCES) 
-test_struct_namevalue_LDADD = $(SPDY_LDADD)
-
-if HAVE_SPDYLAY
-test_new_connection_SOURCES = \
- test_new_connection.c  \
- $(SPDY_SOURCES) 
-test_new_connection_LDADD = $(SPDY_LDADD) \
- -lspdylay
-
-test_request_response_SOURCES = \
- test_request_response.c  \
- $(SPDY_SOURCES) 
-test_request_response_LDADD = $(SPDY_LDADD) \
- -lspdylay
-
-test_notls_SOURCES = \
- test_notls.c  \
- $(SPDY_SOURCES) 
-test_notls_LDADD = $(SPDY_LDADD) \
- -lspdylay
-
-test_request_response_with_callback_SOURCES = \
- test_request_response_with_callback.c  \
- $(SPDY_SOURCES) 
-test_request_response_with_callback_LDADD = $(SPDY_LDADD)
-
-#test_requests_with_assets_SOURCES = \
-# test_requests_with_assets.c  \
-# $(SPDY_SOURCES) 
-#test_requests_with_assets_LDADD = $(SPDY_LDADD)
-
-test_misc_SOURCES = \
- test_misc.c  \
- $(SPDY_SOURCES) 
-test_misc_LDADD = $(SPDY_LDADD)
-
-test_session_timeout_SOURCES = \
- test_session_timeout.c  \
- $(SPDY_SOURCES) 
-test_session_timeout_LDADD = $(SPDY_LDADD)
-
-
-test_proxies_SOURCES = \
- test_proxies.c \
- $(SPDY_SOURCES) 
-test_proxies_LDADD = $(SPDY_LDADD)
-
-endif
diff --git a/src/testspdy/common.c b/src/testspdy/common.c
deleted file mode 100644
index e150209e..00000000
--- a/src/testspdy/common.c
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file common.c
- * @brief  Common functions used by the tests.
- * @author Andrey Uzunov
- */
- 
-
-#include "common.h"
-#include <sys/time.h>
-
-#ifdef __GNUC__
-#define FUNC_CONSTRUCTOR(f) static void __attribute__ ((constructor)) f
-#define FUNC_DESTRUCTOR(f) static void __attribute__ ((destructor)) f
-#else  // !__GNUC__
-#define FUNC_CONSTRUCTOR(f) _MHD_EXTERN void f
-#define FUNC_DESTRUCTOR(f) _MHD_EXTERN void f
-#endif  // __GNUC__
-
-FUNC_CONSTRUCTOR (constructor)()
-{
-        printf("\nTEST START -------------------------------------------------------\n");
-}
-
-FUNC_DESTRUCTOR (destructor)()
-{
-        printf("------------------------------------------------------- TEST END\n");
-}
-
-uint16_t
-get_port(uint16_t min)
-{
-        struct timeval tv;
-        gettimeofday(&tv, NULL);
-        if(2 > min) min=2;
-        uint16_t port =  min + (tv.tv_usec+10) % ((1 << 16)  - min);
-        
-        //port = 12345;
-        printf("Port used: %i\n", port);
-        
-        return port;
-}
diff --git a/src/testspdy/common.h b/src/testspdy/common.h
deleted file mode 100644
index 70ee2614..00000000
--- a/src/testspdy/common.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file common.h
- * @brief  Common functions used by the tests.
- * @author Andrey Uzunov
- */
- 
-#include <stdlib.h>
-#include <unistd.h>
-#include <stdint.h>
-#include <stdio.h>
-
-#define FAIL_TEST(msg) do{\
-        printf("%i:%s\n", __LINE__, msg);\
-        fflush(stdout);\
-        exit(-10);\
-        }\
-        while(0)
-        
-uint16_t
-get_port(uint16_t min);
diff --git a/src/testspdy/test_daemon_start_stop.c b/src/testspdy/test_daemon_start_stop.c
deleted file mode 100644
index d3aec6a1..00000000
--- a/src/testspdy/test_daemon_start_stop.c
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file daemon_start_stop.c
- * @brief  starts and stops a SPDY daemon
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include "microspdy.h"
-#include "common.h"
-
-int
-main()
-{
-        SPDY_init();
-        
-        struct SPDY_Daemon *daemon = SPDY_start_daemon(get_port(16123),
-         DATA_DIR "cert-and-key.pem",
-         DATA_DIR "cert-and-key.pem",
-        NULL,NULL,NULL,NULL,NULL,SPDY_DAEMON_OPTION_END);
-        
-        if(NULL==daemon){
-                printf("no daemon\n");
-                return 1;
-        }
-        
-        SPDY_stop_daemon(daemon);
-        
-        SPDY_deinit();
-        
-        return 0;
-}
diff --git a/src/testspdy/test_daemon_start_stop_many.c b/src/testspdy/test_daemon_start_stop_many.c
deleted file mode 100644
index b8788def..00000000
--- a/src/testspdy/test_daemon_start_stop_many.c
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file daemon_start_stop_many.c
- * @brief  starts and stops several SPDY daemons, reusing port numbers
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include "microspdy.h"
-#include "common.h"
-
-int
-main()
-{
-        int i;
-        int j;
-        int num_daemons = 3;
-        int num_tries = 5;
-        int port = get_port(15123);
-        struct SPDY_Daemon *daemon[num_daemons];
-        
-        SPDY_init();
-        
-        for(i=0; i<num_tries; ++i)
-        {
-                for(j=0;j<num_daemons;++j)
-                {
-                        daemon[j] = SPDY_start_daemon(port + j,
-                        DATA_DIR "cert-and-key.pem",
-                        DATA_DIR "cert-and-key.pem",
-                        NULL,NULL,NULL,NULL,NULL,SPDY_DAEMON_OPTION_END);
-        
-                        if(NULL==daemon[j]){
-                                printf("no daemon\n");
-                                return 1;
-                        }
-                }
-                
-                
-                for(j=0;j<num_daemons;++j)
-                {
-                        SPDY_stop_daemon(daemon[j]);
-                }
-        }
-        
-        SPDY_deinit();
-        
-        return 0;
-}
diff --git a/src/testspdy/test_misc.c b/src/testspdy/test_misc.c
deleted file mode 100644
index 39b672b4..00000000
--- a/src/testspdy/test_misc.c
+++ /dev/null
@@ -1,289 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file misc.c
- * @brief  tests a lot of small calls and callbacks. TODO mention what
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include "microspdy.h"
-#include "stdio.h"
-#include <sys/wait.h>
-#include "common.h"
-
-int port;
-
-#define HTML "<html><head>\
-<link href=\"main.css\" rel=\"stylesheet\" type=\"text/css\" />\
-</head><body>This is libmicrospdy</body></html>"
-
-#define CSS "body{font-size:15px}"
-
-#define SESSION_CLS "1234567890"
-
-#define REQUEST_CLS "1234567890REQ"
-
-pid_t parent;
-pid_t child;
-
-struct SPDY_Session *session1;
-struct SPDY_Session *session2;
-
-void
-killchild()
-{
-        kill(child, SIGKILL);
-        exit(1);
-}
-
-void
-killparent()
-{
-        kill(parent, SIGKILL);
-        _exit(1);
-}
-
-
-void
-create_child()
-{
-        parent = getpid();
-
-        child = fork();
-        if (-1 == child)
-        {
-                fprintf(stderr, "can't fork, error %d\n", errno);
-                exit(EXIT_FAILURE);
-        }
-
-        if (child == 0)
-        {
-                int devnull;
-                char *uri;
-                fflush(stdout);
-                devnull = open("/dev/null", O_WRONLY);
-                if (-1 == devnull)
-                  abort ();
-                if (1 != devnull)
-                {
-                        dup2(devnull, 1);
-                        close(devnull);
-                }
-                asprintf(&uri,"https://127.0.0.1:%i/",port);
-                execlp("spdycat", "spdycat","-anv",uri,NULL );
-                printf("execlp failed\n");
-                killparent();
-        }
-}
-
-void
-response_done_callback(void *cls,
-                                                                struct SPDY_Response * response,
-                                                                struct SPDY_Request * request,
-                                                                enum SPDY_RESPONSE_RESULT status,
-                                                bool streamopened)
-{
-  (void)status;
-  (void)streamopened;
-
-        if(strcmp(cls,"/main.css"))
-        {
-                session1 = SPDY_get_session_for_request(request);
-                if(NULL == session1)
-                {
-                        printf("SPDY_get_session_for_request failed\n");
-                        killchild();
-                }
-
-                char *session_cls = strdup(SESSION_CLS);
-                SPDY_set_cls_to_session(session1,session_cls);
-        }
-        else
-        {
-                session2 = SPDY_get_session_for_request(request);
-                if(session1 != session2)
-                {
-                        printf("SPDY_get_session_for_request failed the second time\n");
-                        killchild();
-                }
-                printf("SPDY_get_session_for_request tested...\n");
-
-                void *session_cls = SPDY_get_cls_from_session(session2);
-                if(NULL == session_cls || strcmp(session_cls, SESSION_CLS))
-                {
-                        printf("SPDY_get_cls_from_session failed\n");
-                        killchild();
-                }
-                printf("SPDY_set_cls_to_session tested...\n");
-                printf("SPDY_get_cls_from_session tested...\n");
-
-                void *request_cls = SPDY_get_cls_from_request(request);
-                if(NULL == request_cls || strcmp(request_cls, REQUEST_CLS))
-                {
-                        printf("SPDY_get_cls_from_request failed\n");
-                        killchild();
-                }
-                printf("SPDY_set_cls_to_request tested...\n");
-                printf("SPDY_get_cls_from_request tested...\n");
-        }
-
-        SPDY_destroy_request(request);
-        SPDY_destroy_response(response);
-        free(cls);
-}
-
-void
-standard_request_handler(void *cls,
-                                                struct SPDY_Request * request,
-                                                uint8_t priority,
-                        const char *method,
-                        const char *path,
-                        const char *version,
-                        const char *host,
-                        const char *scheme,
-                                                struct SPDY_NameValue * headers,
-            bool more)
-{
-        (void)cls;
-        (void)request;
-        (void)priority;
-        (void)host;
-        (void)scheme;
-        (void)headers;
-        (void)method;
-        (void)version;
-        (void)more;
-
-        struct SPDY_Response *response=NULL;
-        char *cls_path = strdup(path);
-
-        if(strcmp(path,"/main.css")==0)
-        {
-                char *request_cls = strdup(REQUEST_CLS);
-                SPDY_set_cls_to_request(request,request_cls);
-                response = SPDY_build_response(200,NULL,SPDY_HTTP_VERSION_1_1,NULL,CSS,strlen(CSS));
-        }
-        else
-        {
-                response = SPDY_build_response(200,NULL,SPDY_HTTP_VERSION_1_1,NULL,HTML,strlen(HTML));
-        }
-
-        if(NULL==response){
-                fprintf(stdout,"no response obj\n");
-                killchild();
-        }
-
-        if(SPDY_queue_response(request,response,true,false,&response_done_callback,cls_path)!=SPDY_YES)
-        {
-                fprintf(stdout,"queue\n");
-                killchild();
-        }
-}
-
-int
-parentproc()
-{
-        int childstatus;
-        unsigned long long timeoutlong=0;
-        struct timeval timeout;
-        int ret;
-        fd_set read_fd_set;
-        fd_set write_fd_set;
-        fd_set except_fd_set;
-        int maxfd = -1;
-        struct SPDY_Daemon *daemon;
-
-        daemon = SPDY_start_daemon(port,
-                                                                DATA_DIR "cert-and-key.pem",
-                                                                DATA_DIR "cert-and-key.pem",
-                                                                NULL,
-                                                                NULL,
-                                                                &standard_request_handler,
-                                                                NULL,
-                                                                NULL,
-                                                                SPDY_DAEMON_OPTION_SESSION_TIMEOUT,
-                                                                1800,
-                                                                SPDY_DAEMON_OPTION_END);
-
-        if(NULL==daemon){
-                printf("no daemon\n");
-                return 1;
-        }
-
-        create_child();
-
-        do
-        {
-                FD_ZERO(&read_fd_set);
-                FD_ZERO(&write_fd_set);
-                FD_ZERO(&except_fd_set);
-
-                ret = SPDY_get_timeout(daemon, &timeoutlong);
-                if(SPDY_NO == ret || timeoutlong > 1000)
-                {
-                        timeout.tv_sec = 1;
-      timeout.tv_usec = 0;
-                }
-                else
-                {
-                        timeout.tv_sec = timeoutlong / 1000;
-                        timeout.tv_usec = (timeoutlong % 1000) * 1000;
-                }
-
-                maxfd = SPDY_get_fdset (daemon,
-                                                                &read_fd_set,
-                                                                &write_fd_set,
-                                                                &except_fd_set);
-
-                ret = select(maxfd+1, &read_fd_set, &write_fd_set, &except_fd_set, &timeout);
-
-                switch(ret) {
-                        case -1:
-                                printf("select error: %i\n", errno);
-                                break;
-                        case 0:
-
-                                break;
-                        default:
-                                SPDY_run(daemon);
-
-                        break;
-                }
-        }
-        while(waitpid(child,&childstatus,WNOHANG) != child);
-
-        SPDY_stop_daemon(daemon);
-
-        return WEXITSTATUS(childstatus);
-}
-
-
-int
-main()
-{
-        port = get_port(13123);
-        SPDY_init();
-
-        int ret = parentproc();
-
-        SPDY_deinit();
-
-        return ret;
-}
diff --git a/src/testspdy/test_new_connection.c b/src/testspdy/test_new_connection.c
deleted file mode 100644
index 3543c983..00000000
--- a/src/testspdy/test_new_connection.c
+++ /dev/null
@@ -1,1012 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file test_new_connection.c
- * @brief  tests new connection callback. spdycli.c
- *                      code is reused here
- * @author Andrey Uzunov
- * @author Tatsuhiro Tsujikawa
- */
-
-//TODO child exits with ret val 1 sometimes
-
-#include "platform.h"
-#include "microspdy.h"
-#include <sys/wait.h>
-#include "common.h"
-
-#define RESPONSE_BODY "<html><body><b>Hi, this is libmicrospdy!</b></body></html>"
-
-#define CLS "anything"
-
-int port;
-int loop = 1;
-
-pid_t parent;
-pid_t child;
-
-int
-spdylay_printf(const char *format, ...)
-{
-  (void)format;
-
-        return 0;
-}
-
-int
-spdylay_fprintf(FILE *stream, const char *format, ...)
-{
-  (void)stream;
-  (void)format;
-
-        return 0;
-}
-
-void
-killchild(int pid, char *message)
-{
-        printf("%s\n",message);
-        kill(pid, SIGKILL);
-        exit(1);
-}
-
-void
-killparent(int pid, char *message)
-{
-        printf("%s\n",message);
-        kill(pid, SIGKILL);
-        _exit(2);
-}
-
-
-/*****
- * start of code needed to utilize spdylay
- */
-
-#include <stdint.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <poll.h>
-#include <signal.h>
-#include <stdio.h>
-#include <assert.h>
-
-#include <spdylay/spdylay.h>
-
-#include <openssl/ssl.h>
-#include <openssl/err.h>
-
-enum {
-  IO_NONE,
-  WANT_READ,
-  WANT_WRITE
-};
-
-struct Connection {
-  SSL *ssl;
-  spdylay_session *session;
-  /* WANT_READ if SSL connection needs more input; or WANT_WRITE if it
-     needs more output; or IO_NONE. This is necessary because SSL/TLS
-     re-negotiation is possible at any time. Spdylay API offers
-     similar functions like spdylay_session_want_read() and
-     spdylay_session_want_write() but they do not take into account
-     SSL connection. */
-  int want_io;
-};
-
-struct Request {
-  char *host;
-  uint16_t port;
-  /* In this program, path contains query component as well. */
-  char *path;
-  /* This is the concatenation of host and port with ":" in
-     between. */
-  char *hostport;
-  /* Stream ID for this request. */
-  int32_t stream_id;
-  /* The gzip stream inflater for the compressed response. */
-  spdylay_gzip *inflater;
-};
-
-struct URI {
-  const char *host;
-  size_t hostlen;
-  uint16_t port;
-  /* In this program, path contains query component as well. */
-  const char *path;
-  size_t pathlen;
-  const char *hostport;
-  size_t hostportlen;
-};
-
-/*
- * Returns copy of string |s| with the length |len|. The returned
- * string is NULL-terminated.
- */
-static char* strcopy(const char *s, size_t len)
-{
-  char *dst;
-  dst = malloc(len+1);
-  if (NULL == dst)
-    abort ();
-  memcpy(dst, s, len);
-  dst[len] = '\0';
-  return dst;
-}
-
-/*
- * Prints error message |msg| and exit.
- */
-static void die(const char *msg)
-{
-  fprintf(stderr, "FATAL: %s\n", msg);
-  exit(EXIT_FAILURE);
-}
-
-/*
- * Prints error containing the function name |func| and message |msg|
- * and exit.
- */
-static void dief(const char *func, const char *msg)
-{
-  fprintf(stderr, "FATAL: %s: %s\n", func, msg);
-  exit(EXIT_FAILURE);
-}
-
-/*
- * Prints error containing the function name |func| and error code
- * |error_code| and exit.
- */
-static void diec(const char *func, int error_code)
-{
-  fprintf(stderr, "FATAL: %s: error_code=%d, msg=%s\n", func, error_code,
-          spdylay_strerror(error_code));
-  exit(EXIT_FAILURE);
-}
-
-/*
- * Check response is content-encoding: gzip. We need this because SPDY
- * client is required to support gzip.
- */
-static void check_gzip(struct Request *req, char **nv)
-{
-  int gzip = 0;
-  size_t i;
-  for(i = 0; nv[i]; i += 2) {
-    if(strcmp("content-encoding", nv[i]) == 0) {
-      gzip = strcmp("gzip", nv[i+1]) == 0;
-      break;
-    }
-  }
-  if(gzip) {
-    int rv;
-    if(req->inflater) {
-      return;
-    }
-    rv = spdylay_gzip_inflate_new(&req->inflater);
-    if(rv != 0) {
-      die("Can't allocate inflate stream.");
-    }
-  }
-}
-
-/*
- * The implementation of spdylay_send_callback type. Here we write
- * |data| with size |length| to the network and return the number of
- * bytes actually written. See the documentation of
- * spdylay_send_callback for the details.
- */
-static ssize_t send_callback(spdylay_session *session,
-                             const uint8_t *data, size_t length, int flags,
-                             void *user_data)
-{
-  (void)session;
-  (void)flags;
-
-  struct Connection *connection;
-  ssize_t rv;
-  connection = (struct Connection*)user_data;
-  connection->want_io = IO_NONE;
-  ERR_clear_error();
-  rv = SSL_write(connection->ssl, data, length);
-  if(rv < 0) {
-    int err = SSL_get_error(connection->ssl, rv);
-    if(err == SSL_ERROR_WANT_WRITE || err == SSL_ERROR_WANT_READ) {
-      connection->want_io = (err == SSL_ERROR_WANT_READ ?
-                             WANT_READ : WANT_WRITE);
-      rv = SPDYLAY_ERR_WOULDBLOCK;
-    } else {
-      rv = SPDYLAY_ERR_CALLBACK_FAILURE;
-    }
-  }
-  return rv;
-}
-
-/*
- * The implementation of spdylay_recv_callback type. Here we read data
- * from the network and write them in |buf|. The capacity of |buf| is
- * |length| bytes. Returns the number of bytes stored in |buf|. See
- * the documentation of spdylay_recv_callback for the details.
- */
-static ssize_t recv_callback(spdylay_session *session,
-                             uint8_t *buf, size_t length, int flags,
-                             void *user_data)
-{
-  (void)session;
-  (void)flags;
-
-  struct Connection *connection;
-  ssize_t rv;
-  connection = (struct Connection*)user_data;
-  connection->want_io = IO_NONE;
-  ERR_clear_error();
-  rv = SSL_read(connection->ssl, buf, length);
-  if(rv < 0) {
-    int err = SSL_get_error(connection->ssl, rv);
-    if(err == SSL_ERROR_WANT_WRITE || err == SSL_ERROR_WANT_READ) {
-      connection->want_io = (err == SSL_ERROR_WANT_READ ?
-                             WANT_READ : WANT_WRITE);
-      rv = SPDYLAY_ERR_WOULDBLOCK;
-    } else {
-      rv = SPDYLAY_ERR_CALLBACK_FAILURE;
-    }
-  } else if(rv == 0) {
-    rv = SPDYLAY_ERR_EOF;
-  }
-  return rv;
-}
-
-/*
- * The implementation of spdylay_before_ctrl_send_callback type.  We
- * use this function to get stream ID of the request. This is because
- * stream ID is not known when we submit the request
- * (spdylay_submit_request).
- */
-static void before_ctrl_send_callback(spdylay_session *session,
-                                      spdylay_frame_type type,
-                                      spdylay_frame *frame,
-                                      void *user_data)
-{
-  (void)user_data;
-
-  if(type == SPDYLAY_SYN_STREAM) {
-    struct Request *req;
-    int stream_id = frame->syn_stream.stream_id;
-    req = spdylay_session_get_stream_user_data(session, stream_id);
-    if(req && req->stream_id == -1) {
-      req->stream_id = stream_id;
-      spdylay_printf("[INFO] Stream ID = %d\n", stream_id);
-    }
-  }
-}
-
-static void on_ctrl_send_callback(spdylay_session *session,
-                                  spdylay_frame_type type,
-                                  spdylay_frame *frame, void *user_data)
-{
-  (void)user_data;
-
-  char **nv;
-  const char *name = NULL;
-  int32_t stream_id;
-  size_t i;
-  switch(type) {
-  case SPDYLAY_SYN_STREAM:
-    nv = frame->syn_stream.nv;
-    name = "SYN_STREAM";
-    stream_id = frame->syn_stream.stream_id;
-    break;
-  default:
-    break;
-  }
-  if(name && spdylay_session_get_stream_user_data(session, stream_id)) {
-    spdylay_printf("[INFO] C ----------------------------> S (%s)\n", name);
-    for(i = 0; nv[i]; i += 2) {
-      spdylay_printf("       %s: %s\n", nv[i], nv[i+1]);
-    }
-  }
-}
-
-static void on_ctrl_recv_callback(spdylay_session *session,
-                                  spdylay_frame_type type,
-                                  spdylay_frame *frame, void *user_data)
-{
-  (void)user_data;
-
-  struct Request *req;
-  char **nv;
-  const char *name = NULL;
-  int32_t stream_id;
-  size_t i;
-  switch(type) {
-  case SPDYLAY_SYN_REPLY:
-    nv = frame->syn_reply.nv;
-    name = "SYN_REPLY";
-    stream_id = frame->syn_reply.stream_id;
-    break;
-  case SPDYLAY_HEADERS:
-    nv = frame->headers.nv;
-    name = "HEADERS";
-    stream_id = frame->headers.stream_id;
-    break;
-  default:
-    break;
-  }
-  if(!name) {
-    return;
-  }
-  req = spdylay_session_get_stream_user_data(session, stream_id);
-  if(req) {
-    check_gzip(req, nv);
-    spdylay_printf("[INFO] C <---------------------------- S (%s)\n", name);
-    for(i = 0; nv[i]; i += 2) {
-      spdylay_printf("       %s: %s\n", nv[i], nv[i+1]);
-    }
-  }
-}
-
-/*
- * The implementation of spdylay_on_stream_close_callback type. We use
- * this function to know the response is fully received. Since we just
- * fetch 1 resource in this program, after reception of the response,
- * we submit GOAWAY and close the session.
- */
-static void on_stream_close_callback(spdylay_session *session,
-                                     int32_t stream_id,
-                                     spdylay_status_code status_code,
-                                     void *user_data)
-{
-  (void)user_data;
-  (void)status_code;
-  struct Request *req;
-  req = spdylay_session_get_stream_user_data(session, stream_id);
-  if(req) {
-    int rv;
-    rv = spdylay_submit_goaway(session, SPDYLAY_GOAWAY_OK);
-    if(rv != 0) {
-      diec("spdylay_submit_goaway", rv);
-    }
-  }
-}
-
-#define MAX_OUTLEN 4096
-
-/*
- * The implementation of spdylay_on_data_chunk_recv_callback type. We
- * use this function to print the received response body.
- */
-static void on_data_chunk_recv_callback(spdylay_session *session, uint8_t flags,
-                                        int32_t stream_id,
-                                        const uint8_t *data, size_t len,
-                                        void *user_data)
-{
-  (void)user_data;
-  (void)flags;
-
-  struct Request *req;
-  req = spdylay_session_get_stream_user_data(session, stream_id);
-  if(req) {
-    spdylay_printf("[INFO] C <---------------------------- S (DATA)\n");
-    spdylay_printf("       %lu bytes\n", (unsigned long int)len);
-    if(req->inflater) {
-      while(len > 0) {
-        uint8_t out[MAX_OUTLEN];
-        size_t outlen = MAX_OUTLEN;
-        size_t tlen = len;
-        int rv;
-        rv = spdylay_gzip_inflate(req->inflater, out, &outlen, data, &tlen);
-        if(rv == -1) {
-          spdylay_submit_rst_stream(session, stream_id, SPDYLAY_INTERNAL_ERROR);
-          break;
-        }
-        fwrite(out, 1, outlen, stdout);
-        data += tlen;
-        len -= tlen;
-      }
-    } else {
-      /* TODO add support gzip */
-      fwrite(data, 1, len, stdout);
-
-      //check if the data is correct
-      if(strcmp(RESPONSE_BODY, (char *)data) != 0)
-                killparent(parent, "\nreceived data is not the same");
-    }
-    spdylay_printf("\n");
-  }
-}
-
-/*
- * Setup callback functions. Spdylay API offers many callback
- * functions, but most of them are optional. The send_callback is
- * always required. Since we use spdylay_session_recv(), the
- * recv_callback is also required.
- */
-static void setup_spdylay_callbacks(spdylay_session_callbacks *callbacks)
-{
-  memset(callbacks, 0, sizeof(spdylay_session_callbacks));
-  callbacks->send_callback = send_callback;
-  callbacks->recv_callback = recv_callback;
-  callbacks->before_ctrl_send_callback = before_ctrl_send_callback;
-  callbacks->on_ctrl_send_callback = on_ctrl_send_callback;
-  callbacks->on_ctrl_recv_callback = on_ctrl_recv_callback;
-  callbacks->on_stream_close_callback = on_stream_close_callback;
-  callbacks->on_data_chunk_recv_callback = on_data_chunk_recv_callback;
-}
-
-/*
- * Callback function for SSL/TLS NPN. Since this program only supports
- * SPDY protocol, if server does not offer SPDY protocol the Spdylay
- * library supports, we terminate program.
- */
-static int select_next_proto_cb(SSL* ssl,
-                                unsigned char **out, unsigned char *outlen,
-                                const unsigned char *in, unsigned int inlen,
-                                void *arg)
-{
-  (void)ssl;
-
-  int rv;
-  uint16_t *spdy_proto_version;
-  /* spdylay_select_next_protocol() selects SPDY protocol version the
-     Spdylay library supports. */
-  rv = spdylay_select_next_protocol(out, outlen, in, inlen);
-  if(rv <= 0) {
-    die("Server did not advertise spdy/2 or spdy/3 protocol.");
-  }
-  spdy_proto_version = (uint16_t*)arg;
-  *spdy_proto_version = rv;
-  return SSL_TLSEXT_ERR_OK;
-}
-
-/*
- * Setup SSL context. We pass |spdy_proto_version| to get negotiated
- * SPDY protocol version in NPN callback.
- */
-static void init_ssl_ctx(SSL_CTX *ssl_ctx, uint16_t *spdy_proto_version)
-{
-  /* Disable SSLv2 and enable all workarounds for buggy servers */
-  SSL_CTX_set_options(ssl_ctx, SSL_OP_ALL|SSL_OP_NO_SSLv2);
-  SSL_CTX_set_mode(ssl_ctx, SSL_MODE_AUTO_RETRY);
-  SSL_CTX_set_mode(ssl_ctx, SSL_MODE_RELEASE_BUFFERS);
-  /* Set NPN callback */
-  SSL_CTX_set_next_proto_select_cb(ssl_ctx, select_next_proto_cb,
-                                   spdy_proto_version);
-}
-
-static void ssl_handshake(SSL *ssl, int fd)
-{
-  int rv;
-  if(SSL_set_fd(ssl, fd) == 0) {
-    dief("SSL_set_fd", ERR_error_string(ERR_get_error(), NULL));
-  }
-  ERR_clear_error();
-  rv = SSL_connect(ssl);
-  if(rv <= 0) {
-    dief("SSL_connect", ERR_error_string(ERR_get_error(), NULL));
-  }
-}
-
-/*
- * Connects to the host |host| and port |port|.  This function returns
- * the file descriptor of the client socket.
- */
-static int connect_to(const char *host, uint16_t port)
-{
-  struct addrinfo hints;
-  int fd = -1;
-  int rv;
-  char service[NI_MAXSERV];
-  struct addrinfo *res, *rp;
-  snprintf(service, sizeof(service), "%u", port);
-  memset(&hints, 0, sizeof(struct addrinfo));
-  hints.ai_family = AF_UNSPEC;
-  hints.ai_socktype = SOCK_STREAM;
-  rv = getaddrinfo(host, service, &hints, &res);
-  if(rv != 0) {
-    dief("getaddrinfo", gai_strerror(rv));
-  }
-  for(rp = res; rp; rp = rp->ai_next) {
-    fd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
-    if(fd == -1) {
-      continue;
-    }
-    while((rv = connect(fd, rp->ai_addr, rp->ai_addrlen)) == -1 &&
-          errno == EINTR);
-    if(rv == 0) {
-      break;
-    }
-    MHD_socket_close_(fd);
-    fd = -1;
-  }
-  freeaddrinfo(res);
-  return fd;
-}
-
-static void make_non_block(int fd)
-{
-  int flags, rv;
-  while((flags = fcntl(fd, F_GETFL, 0)) == -1 && errno == EINTR);
-  if(flags == -1) {
-    dief("fcntl", strerror(errno));
-  }
-  while((rv = fcntl(fd, F_SETFL, flags | O_NONBLOCK)) == -1 && errno == EINTR);
-  if(rv == -1) {
-    dief("fcntl", strerror(errno));
-  }
-}
-
-/*
- * Setting TCP_NODELAY is not mandatory for the SPDY protocol.
- */
-static void set_tcp_nodelay(int fd)
-{
-  int val = 1;
-  int rv;
-  rv = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, (socklen_t)sizeof(val));
-  if(rv == -1) {
-    dief("setsockopt", strerror(errno));
-  }
-}
-
-/*
- * Update |pollfd| based on the state of |connection|.
- */
-static void ctl_poll(struct pollfd *pollfd, struct Connection *connection)
-{
-  pollfd->events = 0;
-  if(spdylay_session_want_read(connection->session) ||
-     connection->want_io == WANT_READ) {
-    pollfd->events |= POLLIN;
-  }
-  if(spdylay_session_want_write(connection->session) ||
-     connection->want_io == WANT_WRITE) {
-    pollfd->events |= POLLOUT;
-  }
-}
-
-/*
- * Submits the request |req| to the connection |connection|.  This
- * function does not send packets; just append the request to the
- * internal queue in |connection->session|.
- */
-static void submit_request(struct Connection *connection, struct Request *req)
-{
-  int pri = 0;
-  int rv;
-  const char *nv[15];
-  /* We always use SPDY/3 style header even if the negotiated protocol
-     version is SPDY/2. The library translates the header name as
-     necessary. Make sure that the last item is NULL! */
-  nv[0] = ":method";     nv[1] = "GET";
-  nv[2] = ":path";       nv[3] = req->path;
-  nv[4] = ":version";    nv[5] = "HTTP/1.1";
-  nv[6] = ":scheme";     nv[7] = "https";
-  nv[8] = ":host";       nv[9] = req->hostport;
-  nv[10] = "accept";     nv[11] = "*/*";
-  nv[12] = "user-agent"; nv[13] = "spdylay/"SPDYLAY_VERSION;
-  nv[14] = NULL;
-  rv = spdylay_submit_request(connection->session, pri, nv, NULL, req);
-  if(rv != 0) {
-    diec("spdylay_submit_request", rv);
-  }
-}
-
-/*
- * Performs the network I/O.
- */
-static void exec_io(struct Connection *connection)
-{
-  int rv;
-  rv = spdylay_session_recv(connection->session);
-  if(rv != 0) {
-    diec("spdylay_session_recv", rv);
-  }
-  rv = spdylay_session_send(connection->session);
-  if(rv != 0) {
-    diec("spdylay_session_send", rv);
-  }
-}
-
-static void request_init(struct Request *req, const struct URI *uri)
-{
-  req->host = strcopy(uri->host, uri->hostlen);
-  req->port = uri->port;
-  req->path = strcopy(uri->path, uri->pathlen);
-  req->hostport = strcopy(uri->hostport, uri->hostportlen);
-  req->stream_id = -1;
-  req->inflater = NULL;
-}
-
-static void request_free(struct Request *req)
-{
-  free(req->host);
-  free(req->path);
-  free(req->hostport);
-  spdylay_gzip_inflate_del(req->inflater);
-}
-
-/*
- * Fetches the resource denoted by |uri|.
- */
-static void
-fetch_uri(const struct URI *uri)
-{
-  spdylay_session_callbacks callbacks;
-  int fd;
-  SSL_CTX *ssl_ctx;
-  SSL *ssl;
-  struct Request req;
-  struct Connection connection;
-  int rv;
-  nfds_t npollfds = 1;
-  struct pollfd pollfds[1];
-  uint16_t spdy_proto_version;
-
-  request_init(&req, uri);
-
-  setup_spdylay_callbacks(&callbacks);
-
-  /* Establish connection and setup SSL */
-  fd = connect_to(req.host, req.port);
-  if (-1 == fd)
-    abort ();
-  ssl_ctx = SSL_CTX_new(SSLv23_client_method());
-  if(ssl_ctx == NULL) {
-    dief("SSL_CTX_new", ERR_error_string(ERR_get_error(), NULL));
-  }
-  init_ssl_ctx(ssl_ctx, &spdy_proto_version);
-  ssl = SSL_new(ssl_ctx);
-  if(ssl == NULL) {
-    dief("SSL_new", ERR_error_string(ERR_get_error(), NULL));
-  }
-  /* To simplify the program, we perform SSL/TLS handshake in blocking
-     I/O. */
-  ssl_handshake(ssl, fd);
-
-  connection.ssl = ssl;
-  connection.want_io = IO_NONE;
-
-  /* Here make file descriptor non-block */
-  make_non_block(fd);
-  set_tcp_nodelay(fd);
-
-  spdylay_printf("[INFO] SPDY protocol version = %d\n", spdy_proto_version);
-  rv = spdylay_session_client_new(&connection.session, spdy_proto_version,
-                                  &callbacks, &connection);
-  if(rv != 0) {
-    diec("spdylay_session_client_new", rv);
-  }
-
-  /* Submit the HTTP request to the outbound queue. */
-  submit_request(&connection, &req);
-
-  pollfds[0].fd = fd;
-  ctl_poll(pollfds, &connection);
-
-  /* Event loop */
-  while(spdylay_session_want_read(connection.session) ||
-        spdylay_session_want_write(connection.session)) {
-    int nfds = poll(pollfds, npollfds, -1);
-    if(nfds == -1) {
-      dief("poll", strerror(errno));
-    }
-    if(pollfds[0].revents & (POLLIN | POLLOUT)) {
-      exec_io(&connection);
-    }
-    if((pollfds[0].revents & POLLHUP) || (pollfds[0].revents & POLLERR)) {
-      die("Connection error");
-    }
-    ctl_poll(pollfds, &connection);
-  }
-
-  /* Resource cleanup */
-  spdylay_session_del(connection.session);
-  SSL_shutdown(ssl);
-  SSL_free(ssl);
-  SSL_CTX_free(ssl_ctx);
-  shutdown(fd, SHUT_WR);
-  MHD_socket_close_ (fd);
-  request_free(&req);
-}
-
-
-static int
-parse_uri(struct URI *res, const char *uri)
-{
-  /* We only interested in https */
-  size_t len, i, offset;
-  memset(res, 0, sizeof(struct URI));
-  len = strlen(uri);
-  if(len < 9 || memcmp("https://", uri, 8) != 0) {
-    return -1;
-  }
-  offset = 8;
-  res->host = res->hostport = &uri[offset];
-  res->hostlen = 0;
-  if(uri[offset] == '[') {
-    /* IPv6 literal address */
-    ++offset;
-    ++res->host;
-    for(i = offset; i < len; ++i) {
-      if(uri[i] == ']') {
-        res->hostlen = i-offset;
-        offset = i+1;
-        break;
-      }
-    }
-  } else {
-    const char delims[] = ":/?#";
-    for(i = offset; i < len; ++i) {
-      if(strchr(delims, uri[i]) != NULL) {
-        break;
-      }
-    }
-    res->hostlen = i-offset;
-    offset = i;
-  }
-  if(res->hostlen == 0) {
-    return -1;
-  }
-  /* Assuming https */
-  res->port = 443;
-  if(offset < len) {
-    if(uri[offset] == ':') {
-      /* port */
-      const char delims[] = "/?#";
-      int port = 0;
-      ++offset;
-      for(i = offset; i < len; ++i) {
-        if(strchr(delims, uri[i]) != NULL) {
-          break;
-        }
-        if('0' <= uri[i] && uri[i] <= '9') {
-          port *= 10;
-          port += uri[i]-'0';
-          if(port > 65535) {
-            return -1;
-          }
-        } else {
-          return -1;
-        }
-      }
-      if(port == 0) {
-        return -1;
-      }
-      offset = i;
-      res->port = port;
-    }
-  }
-  res->hostportlen = uri+offset-res->host;
-  for(i = offset; i < len; ++i) {
-    if(uri[i] == '#') {
-      break;
-    }
-  }
-  if(i-offset == 0) {
-    res->path = "/";
-    res->pathlen = 1;
-  } else {
-    res->path = &uri[offset];
-    res->pathlen = i-offset;
-  }
-  return 0;
-}
-
-
-/*****
- * end of code needed to utilize spdylay
- */
-
-
-/*****
- * start of code needed to utilize microspdy
- */
-
-void
-new_session_callback (void *cls,
-                                                struct SPDY_Session * session)
-{
-        char ipstr[1024];
-
-        struct sockaddr *addr;
-        socklen_t addr_len = SPDY_get_remote_addr(session, &addr);
-
-        if(!addr_len)
-        {
-                printf("SPDY_get_remote_addr");
-                abort();
-        }
-
-        if(strcmp(CLS,cls)!=0)
-        {
-                killchild(child,"wrong cls");
-        }
-
-        if(AF_INET == addr->sa_family)
-        {
-                struct sockaddr_in * addr4 = (struct sockaddr_in *) addr;
-                if(NULL == inet_ntop(AF_INET, &(addr4->sin_addr), ipstr, sizeof(ipstr)))
-                {
-                        killchild(child,"inet_ntop");
-                }
-                printf("New connection from: %s:%i\n", ipstr, ntohs(addr4->sin_port));
-
-                loop = 0;
-        }
-#if HAVE_INET6
-        else if(AF_INET6 == addr->sa_family)
-        {
-                struct sockaddr_in6 * addr6 = (struct sockaddr_in6 *) addr;
-                if(NULL == inet_ntop(AF_INET6, &(addr6->sin6_addr), ipstr, sizeof(ipstr)))
-                {
-                        killchild(child,"inet_ntop");
-                }
-                printf("New connection from: %s:%i\n", ipstr, ntohs(addr6->sin6_port));
-
-                loop = 0;
-        }
-#endif
-        else
-        {
-                killchild(child,"wrong family");
-        }
-}
-
-/*****
- * end of code needed to utilize microspdy
- */
-
-//child process
-void
-childproc(int parent)
-{
-  struct URI uri;
-  struct sigaction act;
-  int rv;
-  char *uristr;
-
-  memset(&act, 0, sizeof(struct sigaction));
-  act.sa_handler = SIG_IGN;
-  sigaction(SIGPIPE, &act, 0);
-
-        asprintf(&uristr, "https://127.0.0.1:%i/",port);
-
-  SSL_load_error_strings();
-  SSL_library_init();
-
-  rv = parse_uri(&uri, uristr);
-  if(rv != 0) {
-    killparent(parent,"parse_uri failed");
-  }
-  fetch_uri(&uri);
-}
-
-//parent proc
-int
-parentproc(int child)
-{
-        int childstatus = 0;
-        unsigned long long timeoutlong=0;
-        struct timeval timeout;
-        int ret;
-        fd_set read_fd_set;
-        fd_set write_fd_set;
-        fd_set except_fd_set;
-        int maxfd = -1;
-        struct SPDY_Daemon *daemon;
-
-        SPDY_init();
-
-        daemon = SPDY_start_daemon(port,
-                                                                DATA_DIR "cert-and-key.pem",
-                                                                DATA_DIR "cert-and-key.pem",
-                                                                &new_session_callback,NULL,NULL,NULL,CLS,SPDY_DAEMON_OPTION_END);
-
-        if(NULL==daemon){
-                printf("no daemon\n");
-                return 1;
-        }
-
-        do
-        {
-                FD_ZERO(&read_fd_set);
-                FD_ZERO(&write_fd_set);
-                FD_ZERO(&except_fd_set);
-
-                ret = SPDY_get_timeout(daemon, &timeoutlong);
-                if(SPDY_NO == ret || timeoutlong > 1000)
-                {
-                        timeout.tv_sec = 1;
-      timeout.tv_usec = 0;
-                }
-                else
-                {
-                        timeout.tv_sec = timeoutlong / 1000;
-                        timeout.tv_usec = (timeoutlong % 1000) * 1000;
-                }
-
-                maxfd = SPDY_get_fdset (daemon,
-                                                                &read_fd_set,
-                                                                &write_fd_set,
-                                                                &except_fd_set);
-
-                ret = select(maxfd+1, &read_fd_set, &write_fd_set, &except_fd_set, &timeout);
-
-                switch(ret) {
-                        case -1:
-                                printf("select error: %i\n", errno);
-                                killchild(child, "select error");
-                                break;
-                        case 0:
-
-                                break;
-                        default:
-                                SPDY_run(daemon);
-
-                        break;
-                }
-        }
-        while(loop && waitpid(child,&childstatus,WNOHANG) != child);
-
-        SPDY_stop_daemon(daemon);
-
-        SPDY_deinit();
-
-        if(loop)
-                return WEXITSTATUS(childstatus);
-        if(waitpid(child,&childstatus,WNOHANG) == child)
-                return WEXITSTATUS(childstatus);
-
-        kill(child,SIGKILL);
-
-        waitpid(child,&childstatus,0);
-
-        return 0;
-}
-
-int main()
-{
-        port = get_port(14123);
-        parent = getpid();
-
-   child = fork();
-   if (child == -1)
-   {
-      fprintf(stderr, "can't fork, error %d\n", errno);
-      exit(EXIT_FAILURE);
-   }
-
-   if (child == 0)
-   {
-      childproc(parent);
-      _exit(0);
-   }
-   else
-   {
-           int ret = parentproc(child);
-      exit(ret);
-   }
-   return 1;
-}
diff --git a/src/testspdy/test_notls.c b/src/testspdy/test_notls.c
deleted file mode 100644
index 4b70edc5..00000000
--- a/src/testspdy/test_notls.c
+++ /dev/null
@@ -1,973 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file request_response.c
- * @brief  tests receiving request and sending response. spdycli.c (spdylay)
- *                      code is reused here
- * @author Andrey Uzunov
- * @author Tatsuhiro Tsujikawa
- */
-
-#include "platform.h"
-#include "microspdy.h"
-#include <sys/wait.h>
-#include "common.h"
-
-#define RESPONSE_BODY "<html><body><b>Hi, this is libmicrospdy!</b></body></html>"
-
-#define CLS "anything"
-
-pid_t parent;
-pid_t child;
-char *rcvbuf;
-int rcvbuf_c = 0;
-
-int session_closed_called = 0;
-
-void
-killchild(int pid, char *message)
-{
-        printf("%s\n",message);
-        kill(pid, SIGKILL);
-        exit(1);
-}
-
-void
-killparent(int pid, char *message)
-{
-        printf("%s\n",message);
-        kill(pid, SIGKILL);
-        _exit(1);
-}
-
-
-/*****
- * start of code needed to utilize spdylay
- */
-
-#include <stdint.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <poll.h>
-#include <signal.h>
-#include <stdio.h>
-#include <assert.h>
-
-#include <spdylay/spdylay.h>
-
-enum {
-  IO_NONE,
-  WANT_READ,
-  WANT_WRITE
-};
-
-struct Connection {
-  spdylay_session *session;
-  /* WANT_READ if SSL connection needs more input; or WANT_WRITE if it
-     needs more output; or IO_NONE. This is necessary because SSL/TLS
-     re-negotiation is possible at any time. Spdylay API offers
-     similar functions like spdylay_session_want_read() and
-     spdylay_session_want_write() but they do not take into account
-     SSL connection. */
-  int want_io;
-  int fd;
-};
-
-struct Request {
-  char *host;
-  uint16_t port;
-  /* In this program, path contains query component as well. */
-  char *path;
-  /* This is the concatenation of host and port with ":" in
-     between. */
-  char *hostport;
-  /* Stream ID for this request. */
-  int32_t stream_id;
-  /* The gzip stream inflater for the compressed response. */
-  spdylay_gzip *inflater;
-};
-
-struct URI {
-  const char *host;
-  size_t hostlen;
-  uint16_t port;
-  /* In this program, path contains query component as well. */
-  const char *path;
-  size_t pathlen;
-  const char *hostport;
-  size_t hostportlen;
-};
-
-/*
- * Returns copy of string |s| with the length |len|. The returned
- * string is NULL-terminated.
- */
-static char* strcopy(const char *s, size_t len)
-{
-  char *dst;
-  dst = malloc(len+1);
-  if (NULL == dst)
-    abort ();
-  memcpy(dst, s, len);
-  dst[len] = '\0';
-  return dst;
-}
-
-/*
- * Prints error message |msg| and exit.
- */
-static void die(const char *msg)
-{
-  fprintf(stderr, "FATAL: %s\n", msg);
-  exit(EXIT_FAILURE);
-}
-
-/*
- * Prints error containing the function name |func| and message |msg|
- * and exit.
- */
-static void dief(const char *func, const char *msg)
-{
-  fprintf(stderr, "FATAL: %s: %s\n", func, msg);
-  exit(EXIT_FAILURE);
-}
-
-/*
- * Prints error containing the function name |func| and error code
- * |error_code| and exit.
- */
-static void diec(const char *func, int error_code)
-{
-  fprintf(stderr, "FATAL: %s: error_code=%d, msg=%s\n", func, error_code,
-          spdylay_strerror(error_code));
-  exit(EXIT_FAILURE);
-}
-
-/*
- * Check response is content-encoding: gzip. We need this because SPDY
- * client is required to support gzip.
- */
-static void check_gzip(struct Request *req, char **nv)
-{
-  int gzip = 0;
-  size_t i;
-  for(i = 0; nv[i]; i += 2) {
-    if(strcmp("content-encoding", nv[i]) == 0) {
-      gzip = strcmp("gzip", nv[i+1]) == 0;
-      break;
-    }
-  }
-  if(gzip) {
-    int rv;
-    if(req->inflater) {
-      return;
-    }
-    rv = spdylay_gzip_inflate_new(&req->inflater);
-    if(rv != 0) {
-      die("Can't allocate inflate stream.");
-    }
-  }
-}
-
-/*
- * The implementation of spdylay_send_callback type. Here we write
- * |data| with size |length| to the network and return the number of
- * bytes actually written. See the documentation of
- * spdylay_send_callback for the details.
- */
-static ssize_t send_callback(spdylay_session *session,
-                             const uint8_t *data, size_t length, int flags,
-                             void *user_data)
-{
-  (void)session;
-  (void)flags;
-
-  struct Connection *connection;
-  ssize_t rv;
-  connection = (struct Connection*)user_data;
-  connection->want_io = IO_NONE;
-
-    rv = write(connection->fd,
-            data,
-            length);
-
-    if (rv < 0)
-    {
-      switch(errno)
-      {
-        case EAGAIN:
-  #if EAGAIN != EWOULDBLOCK
-        case EWOULDBLOCK:
-  #endif
-          connection->want_io = WANT_WRITE;
-          rv = SPDYLAY_ERR_WOULDBLOCK;
-          break;
-
-        default:
-          rv = SPDYLAY_ERR_CALLBACK_FAILURE;
-      }
-    }
-  return rv;
-}
-
-/*
- * The implementation of spdylay_recv_callback type. Here we read data
- * from the network and write them in |buf|. The capacity of |buf| is
- * |length| bytes. Returns the number of bytes stored in |buf|. See
- * the documentation of spdylay_recv_callback for the details.
- */
-static ssize_t recv_callback(spdylay_session *session,
-                             uint8_t *buf, size_t length, int flags,
-                             void *user_data)
-{
-  (void)session;
-  (void)flags;
-
-  struct Connection *connection;
-  ssize_t rv;
-  connection = (struct Connection*)user_data;
-  connection->want_io = IO_NONE;
-
-    rv = read(connection->fd,
-            buf,
-            length);
-
-    if (rv < 0)
-    {
-      switch(errno)
-      {
-        case EAGAIN:
-  #if EAGAIN != EWOULDBLOCK
-        case EWOULDBLOCK:
-  #endif
-          connection->want_io = WANT_READ;
-          rv = SPDYLAY_ERR_WOULDBLOCK;
-          break;
-
-        default:
-          rv = SPDYLAY_ERR_CALLBACK_FAILURE;
-      }
-    }
-    else if(rv == 0)
-      rv = SPDYLAY_ERR_EOF;
-  return rv;
-}
-
-/*
- * The implementation of spdylay_before_ctrl_send_callback type.  We
- * use this function to get stream ID of the request. This is because
- * stream ID is not known when we submit the request
- * (spdylay_submit_request).
- */
-static void before_ctrl_send_callback(spdylay_session *session,
-                                      spdylay_frame_type type,
-                                      spdylay_frame *frame,
-                                      void *user_data)
-{
-  (void)user_data;
-
-  if(type == SPDYLAY_SYN_STREAM) {
-    struct Request *req;
-    int stream_id = frame->syn_stream.stream_id;
-    req = spdylay_session_get_stream_user_data(session, stream_id);
-    if(req && req->stream_id == -1) {
-      req->stream_id = stream_id;
-      printf("[INFO] Stream ID = %d\n", stream_id);
-    }
-  }
-}
-
-static void on_ctrl_send_callback(spdylay_session *session,
-                                  spdylay_frame_type type,
-                                  spdylay_frame *frame, void *user_data)
-{
-  (void)user_data;
-
-  char **nv;
-  const char *name = NULL;
-  int32_t stream_id;
-  size_t i;
-  switch(type) {
-  case SPDYLAY_SYN_STREAM:
-    nv = frame->syn_stream.nv;
-    name = "SYN_STREAM";
-    stream_id = frame->syn_stream.stream_id;
-    break;
-  default:
-    break;
-  }
-  if(name && spdylay_session_get_stream_user_data(session, stream_id)) {
-    printf("[INFO] C ----------------------------> S (%s)\n", name);
-    for(i = 0; nv[i]; i += 2) {
-      printf("       %s: %s\n", nv[i], nv[i+1]);
-    }
-  }
-}
-
-static void on_ctrl_recv_callback(spdylay_session *session,
-                                  spdylay_frame_type type,
-                                  spdylay_frame *frame, void *user_data)
-{
-  (void)user_data;
-
-  struct Request *req;
-  char **nv;
-  const char *name = NULL;
-  int32_t stream_id;
-  size_t i;
-  switch(type) {
-  case SPDYLAY_SYN_REPLY:
-    nv = frame->syn_reply.nv;
-    name = "SYN_REPLY";
-    stream_id = frame->syn_reply.stream_id;
-    break;
-  case SPDYLAY_HEADERS:
-    nv = frame->headers.nv;
-    name = "HEADERS";
-    stream_id = frame->headers.stream_id;
-    break;
-  default:
-    break;
-  }
-  if(!name) {
-    return;
-  }
-  req = spdylay_session_get_stream_user_data(session, stream_id);
-  if(req) {
-    check_gzip(req, nv);
-    printf("[INFO] C <---------------------------- S (%s)\n", name);
-    for(i = 0; nv[i]; i += 2) {
-      printf("       %s: %s\n", nv[i], nv[i+1]);
-    }
-  }
-}
-
-/*
- * The implementation of spdylay_on_stream_close_callback type. We use
- * this function to know the response is fully received. Since we just
- * fetch 1 resource in this program, after reception of the response,
- * we submit GOAWAY and close the session.
- */
-static void on_stream_close_callback(spdylay_session *session,
-                                     int32_t stream_id,
-                                     spdylay_status_code status_code,
-                                     void *user_data)
-{
-  (void)status_code;
-  (void)user_data;
-
-  struct Request *req;
-  req = spdylay_session_get_stream_user_data(session, stream_id);
-  if(req) {
-    int rv;
-    rv = spdylay_submit_goaway(session, SPDYLAY_GOAWAY_OK);
-    if(rv != 0) {
-      diec("spdylay_submit_goaway", rv);
-    }
-  }
-}
-
-#define MAX_OUTLEN 4096
-
-/*
- * The implementation of spdylay_on_data_chunk_recv_callback type. We
- * use this function to print the received response body.
- */
-static void on_data_chunk_recv_callback(spdylay_session *session, uint8_t flags,
-                                        int32_t stream_id,
-                                        const uint8_t *data, size_t len,
-                                        void *user_data)
-{
-  (void)flags;
-  (void)user_data;
-
-  struct Request *req;
-  req = spdylay_session_get_stream_user_data(session, stream_id);
-  if(req) {
-    printf("[INFO] C <---------------------------- S (DATA)\n");
-    printf("       %lu bytes\n", (unsigned long int)len);
-    if(req->inflater) {
-      while(len > 0) {
-        uint8_t out[MAX_OUTLEN];
-        size_t outlen = MAX_OUTLEN;
-        size_t tlen = len;
-        int rv;
-        rv = spdylay_gzip_inflate(req->inflater, out, &outlen, data, &tlen);
-        if(rv == -1) {
-          spdylay_submit_rst_stream(session, stream_id, SPDYLAY_INTERNAL_ERROR);
-          break;
-        }
-        fwrite(out, 1, outlen, stdout);
-        data += tlen;
-        len -= tlen;
-      }
-    } else {
-      /* TODO add support gzip */
-      fwrite(data, 1, len, stdout);
-
-      //check if the data is correct
-      //if(strcmp(RESPONSE_BODY, data) != 0)
-                //killparent(parent, "\nreceived data is not the same");
-      if(len + rcvbuf_c > strlen(RESPONSE_BODY))
-                killparent(parent, "\nreceived data is not the same");
-
-                strcpy(rcvbuf + rcvbuf_c,(char*)data);
-                rcvbuf_c+=len;
-    }
-    printf("\n");
-  }
-}
-
-/*
- * Setup callback functions. Spdylay API offers many callback
- * functions, but most of them are optional. The send_callback is
- * always required. Since we use spdylay_session_recv(), the
- * recv_callback is also required.
- */
-static void setup_spdylay_callbacks(spdylay_session_callbacks *callbacks)
-{
-  memset(callbacks, 0, sizeof(spdylay_session_callbacks));
-  callbacks->send_callback = send_callback;
-  callbacks->recv_callback = recv_callback;
-  callbacks->before_ctrl_send_callback = before_ctrl_send_callback;
-  callbacks->on_ctrl_send_callback = on_ctrl_send_callback;
-  callbacks->on_ctrl_recv_callback = on_ctrl_recv_callback;
-  callbacks->on_stream_close_callback = on_stream_close_callback;
-  callbacks->on_data_chunk_recv_callback = on_data_chunk_recv_callback;
-}
-
-
-/*
- * Connects to the host |host| and port |port|.  This function returns
- * the file descriptor of the client socket.
- */
-static int connect_to(const char *host, uint16_t port)
-{
-  struct addrinfo hints;
-  int fd = -1;
-  int rv;
-  char service[NI_MAXSERV];
-  struct addrinfo *res, *rp;
-  snprintf(service, sizeof(service), "%u", port);
-  memset(&hints, 0, sizeof(struct addrinfo));
-  hints.ai_family = AF_UNSPEC;
-  hints.ai_socktype = SOCK_STREAM;
-  rv = getaddrinfo(host, service, &hints, &res);
-  if(rv != 0) {
-    dief("getaddrinfo", gai_strerror(rv));
-  }
-  for(rp = res; rp; rp = rp->ai_next) {
-    fd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
-    if(fd == -1) {
-      continue;
-    }
-    while((rv = connect(fd, rp->ai_addr, rp->ai_addrlen)) == -1 &&
-          errno == EINTR);
-    if(rv == 0) {
-      break;
-    }
-    MHD_socket_close_(fd);
-    fd = -1;
-    dief("connect", strerror(errno));
-  }
-  freeaddrinfo(res);
-  return fd;
-}
-
-static void make_non_block(int fd)
-{
-  int flags, rv;
-  while((flags = fcntl(fd, F_GETFL, 0)) == -1 && errno == EINTR);
-  if(flags == -1) {
-    dief("fcntl1", strerror(errno));
-  }
-  while((rv = fcntl(fd, F_SETFL, flags | O_NONBLOCK)) == -1 && errno == EINTR);
-  if(rv == -1) {
-    dief("fcntl2", strerror(errno));
-  }
-}
-
-/*
- * Setting TCP_NODELAY is not mandatory for the SPDY protocol.
- */
-static void set_tcp_nodelay(int fd)
-{
-  int val = 1;
-  int rv;
-  rv = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, (socklen_t)sizeof(val));
-  if(rv == -1) {
-    dief("setsockopt", strerror(errno));
-  }
-}
-
-/*
- * Update |pollfd| based on the state of |connection|.
- */
-static void ctl_poll(struct pollfd *pollfd, struct Connection *connection)
-{
-  pollfd->events = 0;
-  if(spdylay_session_want_read(connection->session) ||
-     connection->want_io == WANT_READ) {
-    pollfd->events |= POLLIN;
-  }
-  if(spdylay_session_want_write(connection->session) ||
-     connection->want_io == WANT_WRITE) {
-    pollfd->events |= POLLOUT;
-  }
-}
-
-/*
- * Submits the request |req| to the connection |connection|.  This
- * function does not send packets; just append the request to the
- * internal queue in |connection->session|.
- */
-static void submit_request(struct Connection *connection, struct Request *req)
-{
-  int pri = 0;
-  int rv;
-  const char *nv[15];
-  /* We always use SPDY/3 style header even if the negotiated protocol
-     version is SPDY/2. The library translates the header name as
-     necessary. Make sure that the last item is NULL! */
-  nv[0] = ":method";     nv[1] = "GET";
-  nv[2] = ":path";       nv[3] = req->path;
-  nv[4] = ":version";    nv[5] = "HTTP/1.1";
-  nv[6] = ":scheme";     nv[7] = "https";
-  nv[8] = ":host";       nv[9] = req->hostport;
-  nv[10] = "accept";     nv[11] = "*/*";
-  nv[12] = "user-agent"; nv[13] = "spdylay/"SPDYLAY_VERSION;
-  nv[14] = NULL;
-  rv = spdylay_submit_request(connection->session, pri, nv, NULL, req);
-  if(rv != 0) {
-    diec("spdylay_submit_request", rv);
-  }
-}
-
-/*
- * Performs the network I/O.
- */
-static void exec_io(struct Connection *connection)
-{
-  int rv;
-  rv = spdylay_session_recv(connection->session);
-  if(rv != 0) {
-    diec("spdylay_session_recv", rv);
-  }
-  rv = spdylay_session_send(connection->session);
-  if(rv != 0) {
-    diec("spdylay_session_send", rv);
-  }
-}
-
-static void request_init(struct Request *req, const struct URI *uri)
-{
-  req->host = strcopy(uri->host, uri->hostlen);
-  req->port = uri->port;
-  req->path = strcopy(uri->path, uri->pathlen);
-  req->hostport = strcopy(uri->hostport, uri->hostportlen);
-  req->stream_id = -1;
-  req->inflater = NULL;
-}
-
-static void request_free(struct Request *req)
-{
-  free(req->host);
-  free(req->path);
-  free(req->hostport);
-  spdylay_gzip_inflate_del(req->inflater);
-}
-
-/*
- * Fetches the resource denoted by |uri|.
- */
-static void fetch_uri(const struct URI *uri)
-{
-  spdylay_session_callbacks callbacks;
-  int fd;
-  struct Request req;
-  struct Connection connection;
-  int rv;
-  nfds_t npollfds = 1;
-  struct pollfd pollfds[1];
-  uint16_t spdy_proto_version = 3;
-
-  request_init(&req, uri);
-
-  setup_spdylay_callbacks(&callbacks);
-
-  /* Establish connection and setup SSL */
-  fd = connect_to(req.host, req.port);
-  if (-1 == fd)
-    abort ();
-
-  connection.fd = fd;
-  connection.want_io = IO_NONE;
-
-  /* Here make file descriptor non-block */
-  make_non_block(fd);
-  set_tcp_nodelay(fd);
-
-  printf("[INFO] SPDY protocol version = %d\n", spdy_proto_version);
-  rv = spdylay_session_client_new(&connection.session, spdy_proto_version,
-                                  &callbacks, &connection);
-  if(rv != 0) {
-    diec("spdylay_session_client_new", rv);
-  }
-
-  /* Submit the HTTP request to the outbound queue. */
-  submit_request(&connection, &req);
-
-  pollfds[0].fd = fd;
-  ctl_poll(pollfds, &connection);
-
-  /* Event loop */
-  while(spdylay_session_want_read(connection.session) ||
-        spdylay_session_want_write(connection.session)) {
-    int nfds = poll(pollfds, npollfds, -1);
-    if(nfds == -1) {
-      dief("poll", strerror(errno));
-    }
-    if(pollfds[0].revents & (POLLIN | POLLOUT)) {
-      exec_io(&connection);
-    }
-    if((pollfds[0].revents & POLLHUP) || (pollfds[0].revents & POLLERR)) {
-      die("Connection error");
-    }
-    ctl_poll(pollfds, &connection);
-  }
-
-  /* Resource cleanup */
-  spdylay_session_del(connection.session);
-  shutdown(fd, SHUT_WR);
-  MHD_socket_close_(fd);
-  request_free(&req);
-}
-
-static int parse_uri(struct URI *res, const char *uri)
-{
-  /* We only interested in https */
-  size_t len, i, offset;
-  memset(res, 0, sizeof(struct URI));
-  len = strlen(uri);
-  if(len < 9 || memcmp("https://", uri, 8) != 0) {
-    return -1;
-  }
-  offset = 8;
-  res->host = res->hostport = &uri[offset];
-  res->hostlen = 0;
-  if(uri[offset] == '[') {
-    /* IPv6 literal address */
-    ++offset;
-    ++res->host;
-    for(i = offset; i < len; ++i) {
-      if(uri[i] == ']') {
-        res->hostlen = i-offset;
-        offset = i+1;
-        break;
-      }
-    }
-  } else {
-    const char delims[] = ":/?#";
-    for(i = offset; i < len; ++i) {
-      if(strchr(delims, uri[i]) != NULL) {
-        break;
-      }
-    }
-    res->hostlen = i-offset;
-    offset = i;
-  }
-  if(res->hostlen == 0) {
-    return -1;
-  }
-  /* Assuming https */
-  res->port = 443;
-  if(offset < len) {
-    if(uri[offset] == ':') {
-      /* port */
-      const char delims[] = "/?#";
-      int port = 0;
-      ++offset;
-      for(i = offset; i < len; ++i) {
-        if(strchr(delims, uri[i]) != NULL) {
-          break;
-        }
-        if('0' <= uri[i] && uri[i] <= '9') {
-          port *= 10;
-          port += uri[i]-'0';
-          if(port > 65535) {
-            return -1;
-          }
-        } else {
-          return -1;
-        }
-      }
-      if(port == 0) {
-        return -1;
-      }
-      offset = i;
-      res->port = port;
-    }
-  }
-  res->hostportlen = uri+offset-res->host;
-  for(i = offset; i < len; ++i) {
-    if(uri[i] == '#') {
-      break;
-    }
-  }
-  if(i-offset == 0) {
-    res->path = "/";
-    res->pathlen = 1;
-  } else {
-    res->path = &uri[offset];
-    res->pathlen = i-offset;
-  }
-  return 0;
-}
-
-
-/*****
- * end of code needed to utilize spdylay
- */
-
-
-/*****
- * start of code needed to utilize microspdy
- */
-
-
-void
-standard_request_handler(void *cls,
-                                                struct SPDY_Request * request,
-                                                uint8_t priority,
-                        const char *method,
-                        const char *path,
-                        const char *version,
-                        const char *host,
-                        const char *scheme,
-                                                struct SPDY_NameValue * headers,
-            bool more)
-{
-        (void)cls;
-        (void)request;
-        (void)priority;
-        (void)host;
-        (void)scheme;
-        (void)headers;
-        (void)method;
-        (void)version;
-        (void)more;
-
-        struct SPDY_Response *response=NULL;
-
-        if(strcmp(CLS,cls)!=0)
-        {
-                killchild(child,"wrong cls");
-        }
-
-        response = SPDY_build_response(200,NULL,SPDY_HTTP_VERSION_1_1,NULL,RESPONSE_BODY,strlen(RESPONSE_BODY));
-
-        if(NULL==response){
-                fprintf(stdout,"no response obj\n");
-                exit(3);
-        }
-
-        if(SPDY_queue_response(request,response,true,false,NULL,(void*)strdup(path))!=SPDY_YES)
-        {
-                fprintf(stdout,"queue\n");
-                exit(4);
-        }
-}
-
-void
-session_closed_handler (void *cls,
-                                                struct SPDY_Session * session,
-                                                int by_client)
-{
-        printf("session_closed_handler called\n");
-
-        if(strcmp(CLS,cls)!=0)
-        {
-                killchild(child,"wrong cls");
-        }
-
-        if(SPDY_YES != by_client)
-        {
-                //killchild(child,"wrong by_client");
-                printf("session closed by server\n");
-        }
-        else
-        {
-                printf("session closed by client\n");
-        }
-
-        if(NULL == session)
-        {
-                killchild(child,"session is NULL");
-        }
-
-        session_closed_called = 1;
-}
-
-
-/*****
- * end of code needed to utilize microspdy
- */
-
-//child process
-void
-childproc(int port)
-{
-  struct URI uri;
-  struct sigaction act;
-  int rv;
-  char *uristr;
-
-  memset(&act, 0, sizeof(struct sigaction));
-  act.sa_handler = SIG_IGN;
-  sigaction(SIGPIPE, &act, 0);
-
-        usleep(10000);
-        asprintf(&uristr, "https://127.0.0.1:%i/",port);
-        if(NULL == (rcvbuf = malloc(strlen(RESPONSE_BODY)+1)))
-                killparent(parent,"no memory");
-
-  rv = parse_uri(&uri, uristr);
-  if(rv != 0) {
-    killparent(parent,"parse_uri failed");
-  }
-  fetch_uri(&uri);
-
-  if(strcmp(rcvbuf, RESPONSE_BODY))
-    killparent(parent,"received data is different");
-}
-
-//parent proc
-int
-parentproc( int port)
-{
-        int childstatus;
-        unsigned long long timeoutlong=0;
-        struct timeval timeout;
-        int ret;
-        fd_set read_fd_set;
-        fd_set write_fd_set;
-        fd_set except_fd_set;
-        int maxfd = -1;
-        struct SPDY_Daemon *daemon;
-
-        SPDY_init();
-
-        daemon = SPDY_start_daemon(port,
-                                                                NULL,
-                                                                NULL,
-                                                                NULL,&session_closed_handler,&standard_request_handler,NULL,CLS,
-                SPDY_DAEMON_OPTION_IO_SUBSYSTEM, SPDY_IO_SUBSYSTEM_RAW,
-                SPDY_DAEMON_OPTION_FLAGS, SPDY_DAEMON_FLAG_NO_DELAY,
-                SPDY_DAEMON_OPTION_END);
-
-        if(NULL==daemon){
-                printf("no daemon\n");
-                return 1;
-        }
-
-        do
-        {
-                FD_ZERO(&read_fd_set);
-                FD_ZERO(&write_fd_set);
-                FD_ZERO(&except_fd_set);
-
-                ret = SPDY_get_timeout(daemon, &timeoutlong);
-                if(SPDY_NO == ret || timeoutlong > 1000)
-                {
-                        timeout.tv_sec = 1;
-      timeout.tv_usec = 0;
-                }
-                else
-                {
-                        timeout.tv_sec = timeoutlong / 1000;
-                        timeout.tv_usec = (timeoutlong % 1000) * 1000;
-                }
-
-                maxfd = SPDY_get_fdset (daemon,
-                                                                &read_fd_set,
-                                                                &write_fd_set,
-                                                                &except_fd_set);
-
-                ret = select(maxfd+1, &read_fd_set, &write_fd_set, &except_fd_set, &timeout);
-
-                switch(ret) {
-                        case -1:
-                                printf("select error: %i\n", errno);
-                                killchild(child, "select error");
-                                break;
-                        case 0:
-
-                                break;
-                        default:
-                                SPDY_run(daemon);
-
-                        break;
-                }
-        }
-        while(waitpid(child,&childstatus,WNOHANG) != child);
-
-        //give chance to the client to close socket and handle this in run
-        usleep(100000);
-        SPDY_run(daemon);
-
-        SPDY_stop_daemon(daemon);
-
-        SPDY_deinit();
-
-        return WEXITSTATUS(childstatus);
-}
-
-int main()
-{
-        int port = get_port(12123);
-        parent = getpid();
-
-   child = fork();
-   if (child == -1)
-   {
-      fprintf(stderr, "can't fork, error %d\n", errno);
-      exit(EXIT_FAILURE);
-   }
-
-   if (child == 0)
-   {
-      childproc(port);
-      _exit(0);
-   }
-   else
-   {
-           int ret = parentproc(port);
-           if(1 == session_closed_called && 0 == ret)
-      exit(0);
-      else
-      exit(ret ? ret : 21);
-   }
-   return 1;
-}
diff --git a/src/testspdy/test_proxies.c b/src/testspdy/test_proxies.c
deleted file mode 100644
index 44a0c1bd..00000000
--- a/src/testspdy/test_proxies.c
+++ /dev/null
@@ -1,255 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file test_proxies.c
- * @brief  test curl > mhd2spdylay > microspdy2http > mhd
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include "microspdy.h"
-#include "common.h"
-#include <sys/wait.h>
-#include <stdio.h>   /* printf, stderr, fprintf */
-#include <sys/types.h> /* pid_t */
-#include <unistd.h>  /* _exit, fork */
-#include <stdlib.h>  /* exit */
-#include <errno.h>   /* errno */
-#include <sys/wait.h> /* pid_t */
-#include "common.h"
-
-#ifdef _WIN32
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN 1
-#endif /* !WIN32_LEAN_AND_MEAN */
-#include <windows.h>
-#endif
-
-#define EXPECTED_BODY "<html><head><title>libmicrohttpd demo</title></head><body>libmicrohttpd demo</body></html>"
-
-
-pid_t parent;
-        pid_t child_mhd;
-        pid_t child_spdy2http;
-        pid_t child_mhd2spdy;
-        pid_t child_curl;
-
-        uint16_t mhd_port;
-        uint16_t spdy2http_port;
-        uint16_t mhd2spdy_port;
-
-void
-killproc(int pid, const char *message)
-{
-        printf("%s\nkilling %i\n",message,pid);
-        kill(pid, SIGKILL);
-}
-
-
-void killchildren()
-{
-    if(0 != child_mhd)
-      killproc(child_mhd,"kill mhd\n");
-    if(0 != child_spdy2http)
-      killproc(child_spdy2http,"kill spdy2http\n");
-    if(0 != child_mhd2spdy)
-      killproc(child_mhd2spdy,"kill mhd2spdy\n");
-    if(0 != child_curl)
-      killproc(child_curl,"kill curl\n");
-}
-
-pid_t au_fork()
-{
-  pid_t child = fork();
-        if (child == -1)
-        {
-    killchildren();
-
-                killproc(parent,"fork failed\n");
-        }
-
-        return child;
-}
-
-
-int main()
-{
-  //pid_t child;
-        int childstatus;
-        pid_t wpid;
-
-        parent = getpid();
-        mhd_port = get_port(4000);
-        spdy2http_port = get_port(4100);
-        mhd2spdy_port = get_port(4200);
-
-        child_mhd = au_fork();
-        if (child_mhd == 0)
-        {
-    //run MHD
-                pid_t devnull;
-    char *port_s;
-
-                close(1);
-                devnull = open("/dev/null", O_WRONLY);
-                if (-1 == devnull)
-                  abort();
-                if (1 != devnull)
-                {
-                        dup2(devnull, 1);
-                        close(devnull);
-                }
-    asprintf(&port_s, "%i", mhd_port);
-                execlp ("../examples/minimal_example", "minimal_example", port_s, NULL);
-                fprintf(stderr, "executing mhd failed\nFor this test 'make' must be run before 'make check'!\n");
-    //killchildren();
-    _exit(1);
-        }
-
-
-        child_spdy2http = au_fork();
-        if (child_spdy2http == 0)
-        {
-    //run spdy2http
-                pid_t devnull;
-    char *port_s;
-    //char *url;
-
-                close(1);
-                devnull = open("/dev/null", O_WRONLY);
-                if (-1 == devnull)
-                  abort();
-                if (1 != devnull)
-                {
-                        dup2(devnull, 1);
-                        close(devnull);
-                }
-    //asprintf(&url, "127.0.0.1:%i", mhd_port);
-    asprintf(&port_s, "%i", spdy2http_port);
-    sleep(1);
-                execlp ("../spdy2http/microspdy2http", "microspdy2http", "-v4rtT", "10", "-p", port_s, NULL);
-                fprintf(stderr, "executing microspdy2http failed\n");
-    //killchildren();
-    _exit(1);
-        }
-
-        child_mhd2spdy = au_fork();
-        if (child_mhd2spdy == 0)
-        {
-    //run MHD2sdpy
-                pid_t devnull;
-    char *port_s;
-    char *url;
-
-                close(1);
-                devnull = open("/dev/null", O_WRONLY);
-                if (-1 == devnull)
-                  abort();
-                if (1 != devnull)
-                {
-                        dup2(devnull, 1);
-                        close(devnull);
-                }
-    asprintf(&url, "http://127.0.0.1:%i", spdy2http_port);
-    asprintf(&port_s, "%i", mhd2spdy_port);
-    sleep(2);
-                execlp ("../examples/mhd2spdy", "mhd2spdy", "-vosb", url, "-p", port_s, NULL);
-                fprintf(stderr, "executing mhd2spdy failed\n");
-    //killchildren();
-    _exit(1);
-        }
-
-        child_curl = au_fork();
-        if (child_curl == 0)
-        {
-    //run curl
-    FILE *p;
-                pid_t devnull;
-                char *cmd;
-    unsigned int i;
-    int retc;
-    char buf[strlen(EXPECTED_BODY) + 1];
-
-                close(1);
-                devnull = open("/dev/null", O_WRONLY);
-                if (-1 == devnull)
-                  abort ();
-                if (1 != devnull)
-                {
-                        dup2(devnull, 1);
-                        close(devnull);
-                }
-
-                asprintf (&cmd, "curl --proxy http://127.0.0.1:%i http://127.0.0.1:%i/", mhd2spdy_port, mhd_port);
-    sleep(3);
-    p = popen(cmd, "r");
-    if (p != NULL)
-    {
-      for (i = 0; i < strlen(EXPECTED_BODY) && !feof(p); i++)
-      {
-          retc = fgetc (p);
-          if (EOF == retc)
-            abort (); /* what did feof(p) do there!? */
-          buf[i] = (char) retc;
-      }
-
-      pclose(p);
-      buf[i] = 0;
-      _exit(strcmp(EXPECTED_BODY, buf));
-    }
-                fprintf(stderr, "executing curl failed\n");
-    //killchildren();
-    _exit(1);
-        }
-
-  do
-  {
-    wpid = waitpid(child_mhd,&childstatus,WNOHANG);
-    if(wpid == child_mhd)
-    {
-      fprintf(stderr, "mhd died unexpectedly\n");
-      killchildren();
-      return 1;
-    }
-
-    wpid = waitpid(child_spdy2http,&childstatus,WNOHANG);
-    if(wpid == child_spdy2http)
-    {
-      fprintf(stderr, "spdy2http died unexpectedly\n");
-      killchildren();
-      return 1;
-    }
-
-    wpid = waitpid(child_mhd2spdy,&childstatus,WNOHANG);
-    if(wpid == child_mhd2spdy)
-    {
-      fprintf(stderr, "mhd2spdy died unexpectedly\n");
-      killchildren();
-      return 1;
-    }
-
-    if(waitpid(child_curl,&childstatus,WNOHANG) == child_curl)
-    {
-      killchildren();
-      return WEXITSTATUS(childstatus);
-    }
-    sleep(1);
-  }
-        while(true);
-}
diff --git a/src/testspdy/test_request_response.c b/src/testspdy/test_request_response.c
deleted file mode 100644
index 36a85572..00000000
--- a/src/testspdy/test_request_response.c
+++ /dev/null
@@ -1,1029 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file test_request_response.c
- * @brief  tests receiving request and sending response. spdycli.c (spdylay)
- *                      code is reused here
- * @author Andrey Uzunov
- * @author Tatsuhiro Tsujikawa
- */
-
-#include "platform.h"
-#include "microspdy.h"
-#include <sys/wait.h>
-#include "common.h"
-
-#define RESPONSE_BODY "<html><body><b>Hi, this is libmicrospdy!</b></body></html>"
-
-#define CLS "anything"
-
-pid_t parent;
-pid_t child;
-char *rcvbuf;
-int rcvbuf_c = 0;
-
-int session_closed_called = 0;
-
-void
-killchild(int pid, char *message)
-{
-        printf("%s\n",message);
-        kill(pid, SIGKILL);
-        exit(1);
-}
-
-void
-killparent(int pid, char *message)
-{
-        printf("%s\n",message);
-        kill(pid, SIGKILL);
-        _exit(1);
-}
-
-
-/*****
- * start of code needed to utilize spdylay
- */
-
-#include <stdint.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <poll.h>
-#include <signal.h>
-#include <stdio.h>
-#include <assert.h>
-
-#include <spdylay/spdylay.h>
-
-#include <openssl/ssl.h>
-#include <openssl/err.h>
-
-enum {
-  IO_NONE,
-  WANT_READ,
-  WANT_WRITE
-};
-
-struct Connection {
-  SSL *ssl;
-  spdylay_session *session;
-  /* WANT_READ if SSL connection needs more input; or WANT_WRITE if it
-     needs more output; or IO_NONE. This is necessary because SSL/TLS
-     re-negotiation is possible at any time. Spdylay API offers
-     similar functions like spdylay_session_want_read() and
-     spdylay_session_want_write() but they do not take into account
-     SSL connection. */
-  int want_io;
-};
-
-struct Request {
-  char *host;
-  uint16_t port;
-  /* In this program, path contains query component as well. */
-  char *path;
-  /* This is the concatenation of host and port with ":" in
-     between. */
-  char *hostport;
-  /* Stream ID for this request. */
-  int32_t stream_id;
-  /* The gzip stream inflater for the compressed response. */
-  spdylay_gzip *inflater;
-};
-
-struct URI {
-  const char *host;
-  size_t hostlen;
-  uint16_t port;
-  /* In this program, path contains query component as well. */
-  const char *path;
-  size_t pathlen;
-  const char *hostport;
-  size_t hostportlen;
-};
-
-/*
- * Returns copy of string |s| with the length |len|. The returned
- * string is NULL-terminated.
- */
-static char* strcopy(const char *s, size_t len)
-{
-  char *dst;
-  dst = malloc(len+1);
-  if (NULL == dst)
-    abort ();
-  memcpy(dst, s, len);
-  dst[len] = '\0';
-  return dst;
-}
-
-/*
- * Prints error message |msg| and exit.
- */
-static void die(const char *msg)
-{
-  fprintf(stderr, "FATAL: %s\n", msg);
-  exit(EXIT_FAILURE);
-}
-
-/*
- * Prints error containing the function name |func| and message |msg|
- * and exit.
- */
-static void dief(const char *func, const char *msg)
-{
-  fprintf(stderr, "FATAL: %s: %s\n", func, msg);
-  exit(EXIT_FAILURE);
-}
-
-/*
- * Prints error containing the function name |func| and error code
- * |error_code| and exit.
- */
-static void diec(const char *func, int error_code)
-{
-  fprintf(stderr, "FATAL: %s: error_code=%d, msg=%s\n", func, error_code,
-          spdylay_strerror(error_code));
-  exit(EXIT_FAILURE);
-}
-
-/*
- * Check response is content-encoding: gzip. We need this because SPDY
- * client is required to support gzip.
- */
-static void check_gzip(struct Request *req, char **nv)
-{
-  int gzip = 0;
-  size_t i;
-  for(i = 0; nv[i]; i += 2) {
-    if(strcmp("content-encoding", nv[i]) == 0) {
-      gzip = strcmp("gzip", nv[i+1]) == 0;
-      break;
-    }
-  }
-  if(gzip) {
-    int rv;
-    if(req->inflater) {
-      return;
-    }
-    rv = spdylay_gzip_inflate_new(&req->inflater);
-    if(rv != 0) {
-      die("Can't allocate inflate stream.");
-    }
-  }
-}
-
-/*
- * The implementation of spdylay_send_callback type. Here we write
- * |data| with size |length| to the network and return the number of
- * bytes actually written. See the documentation of
- * spdylay_send_callback for the details.
- */
-static ssize_t send_callback(spdylay_session *session,
-                             const uint8_t *data, size_t length, int flags,
-                             void *user_data)
-{
-  (void)session;
-  (void)flags;
-
-  struct Connection *connection;
-  ssize_t rv;
-  connection = (struct Connection*)user_data;
-  connection->want_io = IO_NONE;
-  ERR_clear_error();
-  rv = SSL_write(connection->ssl, data, length);
-  if(rv < 0) {
-    int err = SSL_get_error(connection->ssl, rv);
-    if(err == SSL_ERROR_WANT_WRITE || err == SSL_ERROR_WANT_READ) {
-      connection->want_io = (err == SSL_ERROR_WANT_READ ?
-                             WANT_READ : WANT_WRITE);
-      rv = SPDYLAY_ERR_WOULDBLOCK;
-    } else {
-      rv = SPDYLAY_ERR_CALLBACK_FAILURE;
-    }
-  }
-  return rv;
-}
-
-/*
- * The implementation of spdylay_recv_callback type. Here we read data
- * from the network and write them in |buf|. The capacity of |buf| is
- * |length| bytes. Returns the number of bytes stored in |buf|. See
- * the documentation of spdylay_recv_callback for the details.
- */
-static ssize_t recv_callback(spdylay_session *session,
-                             uint8_t *buf, size_t length, int flags,
-                             void *user_data)
-{
-  (void)session;
-  (void)flags;
-
-  struct Connection *connection;
-  ssize_t rv;
-  connection = (struct Connection*)user_data;
-  connection->want_io = IO_NONE;
-  ERR_clear_error();
-  rv = SSL_read(connection->ssl, buf, length);
-  if(rv < 0) {
-    int err = SSL_get_error(connection->ssl, rv);
-    if(err == SSL_ERROR_WANT_WRITE || err == SSL_ERROR_WANT_READ) {
-      connection->want_io = (err == SSL_ERROR_WANT_READ ?
-                             WANT_READ : WANT_WRITE);
-      rv = SPDYLAY_ERR_WOULDBLOCK;
-    } else {
-      rv = SPDYLAY_ERR_CALLBACK_FAILURE;
-    }
-  } else if(rv == 0) {
-    rv = SPDYLAY_ERR_EOF;
-  }
-  return rv;
-}
-
-/*
- * The implementation of spdylay_before_ctrl_send_callback type.  We
- * use this function to get stream ID of the request. This is because
- * stream ID is not known when we submit the request
- * (spdylay_submit_request).
- */
-static void before_ctrl_send_callback(spdylay_session *session,
-                                      spdylay_frame_type type,
-                                      spdylay_frame *frame,
-                                      void *user_data)
-{
-  (void)user_data;
-
-  if(type == SPDYLAY_SYN_STREAM) {
-    struct Request *req;
-    int stream_id = frame->syn_stream.stream_id;
-    req = spdylay_session_get_stream_user_data(session, stream_id);
-    if(req && req->stream_id == -1) {
-      req->stream_id = stream_id;
-      printf("[INFO] Stream ID = %d\n", stream_id);
-    }
-  }
-}
-
-static void on_ctrl_send_callback(spdylay_session *session,
-                                  spdylay_frame_type type,
-                                  spdylay_frame *frame, void *user_data)
-{
-  (void)user_data;
-
-  char **nv;
-  const char *name = NULL;
-  int32_t stream_id;
-  size_t i;
-  switch(type) {
-  case SPDYLAY_SYN_STREAM:
-    nv = frame->syn_stream.nv;
-    name = "SYN_STREAM";
-    stream_id = frame->syn_stream.stream_id;
-    break;
-  default:
-    break;
-  }
-  if(name && spdylay_session_get_stream_user_data(session, stream_id)) {
-    printf("[INFO] C ----------------------------> S (%s)\n", name);
-    for(i = 0; nv[i]; i += 2) {
-      printf("       %s: %s\n", nv[i], nv[i+1]);
-    }
-  }
-}
-
-static void on_ctrl_recv_callback(spdylay_session *session,
-                                  spdylay_frame_type type,
-                                  spdylay_frame *frame, void *user_data)
-{
-  (void)user_data;
-
-  struct Request *req;
-  char **nv;
-  const char *name = NULL;
-  int32_t stream_id;
-  size_t i;
-  switch(type) {
-  case SPDYLAY_SYN_REPLY:
-    nv = frame->syn_reply.nv;
-    name = "SYN_REPLY";
-    stream_id = frame->syn_reply.stream_id;
-    break;
-  case SPDYLAY_HEADERS:
-    nv = frame->headers.nv;
-    name = "HEADERS";
-    stream_id = frame->headers.stream_id;
-    break;
-  default:
-    break;
-  }
-  if(!name) {
-    return;
-  }
-  req = spdylay_session_get_stream_user_data(session, stream_id);
-  if(req) {
-    check_gzip(req, nv);
-    printf("[INFO] C <---------------------------- S (%s)\n", name);
-    for(i = 0; nv[i]; i += 2) {
-      printf("       %s: %s\n", nv[i], nv[i+1]);
-    }
-  }
-}
-
-/*
- * The implementation of spdylay_on_stream_close_callback type. We use
- * this function to know the response is fully received. Since we just
- * fetch 1 resource in this program, after reception of the response,
- * we submit GOAWAY and close the session.
- */
-static void on_stream_close_callback(spdylay_session *session,
-                                     int32_t stream_id,
-                                     spdylay_status_code status_code,
-                                     void *user_data)
-{
-  (void)user_data;
-  (void)status_code;
-
-  struct Request *req;
-  req = spdylay_session_get_stream_user_data(session, stream_id);
-  if(req) {
-    int rv;
-    rv = spdylay_submit_goaway(session, SPDYLAY_GOAWAY_OK);
-    if(rv != 0) {
-      diec("spdylay_submit_goaway", rv);
-    }
-  }
-}
-
-#define MAX_OUTLEN 4096
-
-/*
- * The implementation of spdylay_on_data_chunk_recv_callback type. We
- * use this function to print the received response body.
- */
-static void on_data_chunk_recv_callback(spdylay_session *session, uint8_t flags,
-                                        int32_t stream_id,
-                                        const uint8_t *data, size_t len,
-                                        void *user_data)
-{
-  (void)user_data;
-  (void)flags;
-
-  struct Request *req;
-  req = spdylay_session_get_stream_user_data(session, stream_id);
-  if(req) {
-    printf("[INFO] C <---------------------------- S (DATA)\n");
-    printf("       %lu bytes\n", (unsigned long int)len);
-    if(req->inflater) {
-      while(len > 0) {
-        uint8_t out[MAX_OUTLEN];
-        size_t outlen = MAX_OUTLEN;
-        size_t tlen = len;
-        int rv;
-        rv = spdylay_gzip_inflate(req->inflater, out, &outlen, data, &tlen);
-        if(rv == -1) {
-          spdylay_submit_rst_stream(session, stream_id, SPDYLAY_INTERNAL_ERROR);
-          break;
-        }
-        fwrite(out, 1, outlen, stdout);
-        data += tlen;
-        len -= tlen;
-      }
-    } else {
-      /* TODO add support gzip */
-      fwrite(data, 1, len, stdout);
-
-      //check if the data is correct
-      //if(strcmp(RESPONSE_BODY, data) != 0)
-                //killparent(parent, "\nreceived data is not the same");
-      if(len + rcvbuf_c > strlen(RESPONSE_BODY))
-                killparent(parent, "\nreceived data is not the same");
-
-                strcpy(rcvbuf + rcvbuf_c,(char*)data);
-                rcvbuf_c+=len;
-    }
-    printf("\n");
-  }
-}
-
-/*
- * Setup callback functions. Spdylay API offers many callback
- * functions, but most of them are optional. The send_callback is
- * always required. Since we use spdylay_session_recv(), the
- * recv_callback is also required.
- */
-static void setup_spdylay_callbacks(spdylay_session_callbacks *callbacks)
-{
-  memset(callbacks, 0, sizeof(spdylay_session_callbacks));
-  callbacks->send_callback = send_callback;
-  callbacks->recv_callback = recv_callback;
-  callbacks->before_ctrl_send_callback = before_ctrl_send_callback;
-  callbacks->on_ctrl_send_callback = on_ctrl_send_callback;
-  callbacks->on_ctrl_recv_callback = on_ctrl_recv_callback;
-  callbacks->on_stream_close_callback = on_stream_close_callback;
-  callbacks->on_data_chunk_recv_callback = on_data_chunk_recv_callback;
-}
-
-/*
- * Callback function for SSL/TLS NPN. Since this program only supports
- * SPDY protocol, if server does not offer SPDY protocol the Spdylay
- * library supports, we terminate program.
- */
-static int select_next_proto_cb(SSL* ssl,
-                                unsigned char **out, unsigned char *outlen,
-                                const unsigned char *in, unsigned int inlen,
-                                void *arg)
-{
-  (void)ssl;
-
-  int rv;
-  uint16_t *spdy_proto_version;
-  /* spdylay_select_next_protocol() selects SPDY protocol version the
-     Spdylay library supports. */
-  rv = spdylay_select_next_protocol(out, outlen, in, inlen);
-  if(rv <= 0) {
-    die("Server did not advertise spdy/2 or spdy/3 protocol.");
-  }
-  spdy_proto_version = (uint16_t*)arg;
-  *spdy_proto_version = rv;
-  return SSL_TLSEXT_ERR_OK;
-}
-
-/*
- * Setup SSL context. We pass |spdy_proto_version| to get negotiated
- * SPDY protocol version in NPN callback.
- */
-static void init_ssl_ctx(SSL_CTX *ssl_ctx, uint16_t *spdy_proto_version)
-{
-  /* Disable SSLv2 and enable all workarounds for buggy servers */
-  SSL_CTX_set_options(ssl_ctx, SSL_OP_ALL|SSL_OP_NO_SSLv2);
-  SSL_CTX_set_mode(ssl_ctx, SSL_MODE_AUTO_RETRY);
-  SSL_CTX_set_mode(ssl_ctx, SSL_MODE_RELEASE_BUFFERS);
-  /* Set NPN callback */
-  SSL_CTX_set_next_proto_select_cb(ssl_ctx, select_next_proto_cb,
-                                   spdy_proto_version);
-}
-
-static void ssl_handshake(SSL *ssl, int fd)
-{
-  int rv;
-  if(SSL_set_fd(ssl, fd) == 0) {
-    dief("SSL_set_fd", ERR_error_string(ERR_get_error(), NULL));
-  }
-  ERR_clear_error();
-  rv = SSL_connect(ssl);
-  if(rv <= 0) {
-    dief("SSL_connect", ERR_error_string(ERR_get_error(), NULL));
-  }
-}
-
-/*
- * Connects to the host |host| and port |port|.  This function returns
- * the file descriptor of the client socket.
- */
-static int connect_to(const char *host, uint16_t port)
-{
-  struct addrinfo hints;
-  int fd = -1;
-  int rv;
-  char service[NI_MAXSERV];
-  struct addrinfo *res, *rp;
-  snprintf(service, sizeof(service), "%u", port);
-  memset(&hints, 0, sizeof(struct addrinfo));
-  hints.ai_family = AF_UNSPEC;
-  hints.ai_socktype = SOCK_STREAM;
-  rv = getaddrinfo(host, service, &hints, &res);
-  if(rv != 0) {
-    dief("getaddrinfo", gai_strerror(rv));
-  }
-  for(rp = res; rp; rp = rp->ai_next) {
-    fd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
-    if(fd == -1) {
-      continue;
-    }
-    while((rv = connect(fd, rp->ai_addr, rp->ai_addrlen)) == -1 &&
-          errno == EINTR);
-    if(rv == 0) {
-      break;
-    }
-    MHD_socket_close_(fd);
-    fd = -1;
-  }
-  freeaddrinfo(res);
-  return fd;
-}
-
-static void make_non_block(int fd)
-{
-  int flags, rv;
-  while((flags = fcntl(fd, F_GETFL, 0)) == -1 && errno == EINTR);
-  if(flags == -1) {
-    dief("fcntl", strerror(errno));
-  }
-  while((rv = fcntl(fd, F_SETFL, flags | O_NONBLOCK)) == -1 && errno == EINTR);
-  if(rv == -1) {
-    dief("fcntl", strerror(errno));
-  }
-}
-
-/*
- * Setting TCP_NODELAY is not mandatory for the SPDY protocol.
- */
-static void set_tcp_nodelay(int fd)
-{
-  int val = 1;
-  int rv;
-  rv = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, (socklen_t)sizeof(val));
-  if(rv == -1) {
-    dief("setsockopt", strerror(errno));
-  }
-}
-
-/*
- * Update |pollfd| based on the state of |connection|.
- */
-static void ctl_poll(struct pollfd *pollfd, struct Connection *connection)
-{
-  pollfd->events = 0;
-  if(spdylay_session_want_read(connection->session) ||
-     connection->want_io == WANT_READ) {
-    pollfd->events |= POLLIN;
-  }
-  if(spdylay_session_want_write(connection->session) ||
-     connection->want_io == WANT_WRITE) {
-    pollfd->events |= POLLOUT;
-  }
-}
-
-/*
- * Submits the request |req| to the connection |connection|.  This
- * function does not send packets; just append the request to the
- * internal queue in |connection->session|.
- */
-static void submit_request(struct Connection *connection, struct Request *req)
-{
-  int pri = 0;
-  int rv;
-  const char *nv[15];
-  /* We always use SPDY/3 style header even if the negotiated protocol
-     version is SPDY/2. The library translates the header name as
-     necessary. Make sure that the last item is NULL! */
-  nv[0] = ":method";     nv[1] = "GET";
-  nv[2] = ":path";       nv[3] = req->path;
-  nv[4] = ":version";    nv[5] = "HTTP/1.1";
-  nv[6] = ":scheme";     nv[7] = "https";
-  nv[8] = ":host";       nv[9] = req->hostport;
-  nv[10] = "accept";     nv[11] = "*/*";
-  nv[12] = "user-agent"; nv[13] = "spdylay/"SPDYLAY_VERSION;
-  nv[14] = NULL;
-  rv = spdylay_submit_request(connection->session, pri, nv, NULL, req);
-  if(rv != 0) {
-    diec("spdylay_submit_request", rv);
-  }
-}
-
-/*
- * Performs the network I/O.
- */
-static void exec_io(struct Connection *connection)
-{
-  int rv;
-  rv = spdylay_session_recv(connection->session);
-  if(rv != 0) {
-    diec("spdylay_session_recv", rv);
-  }
-  rv = spdylay_session_send(connection->session);
-  if(rv != 0) {
-    diec("spdylay_session_send", rv);
-  }
-}
-
-static void request_init(struct Request *req, const struct URI *uri)
-{
-  req->host = strcopy(uri->host, uri->hostlen);
-  req->port = uri->port;
-  req->path = strcopy(uri->path, uri->pathlen);
-  req->hostport = strcopy(uri->hostport, uri->hostportlen);
-  req->stream_id = -1;
-  req->inflater = NULL;
-}
-
-static void request_free(struct Request *req)
-{
-  free(req->host);
-  free(req->path);
-  free(req->hostport);
-  spdylay_gzip_inflate_del(req->inflater);
-}
-
-/*
- * Fetches the resource denoted by |uri|.
- */
-static void fetch_uri(const struct URI *uri)
-{
-  spdylay_session_callbacks callbacks;
-  int fd;
-  SSL_CTX *ssl_ctx;
-  SSL *ssl;
-  struct Request req;
-  struct Connection connection;
-  int rv;
-  nfds_t npollfds = 1;
-  struct pollfd pollfds[1];
-  uint16_t spdy_proto_version;
-
-  request_init(&req, uri);
-
-  setup_spdylay_callbacks(&callbacks);
-
-  /* Establish connection and setup SSL */
-  fd = connect_to(req.host, req.port);
-  if (-1 == fd)
-    abort ();
-  ssl_ctx = SSL_CTX_new(SSLv23_client_method());
-  if(ssl_ctx == NULL) {
-    dief("SSL_CTX_new", ERR_error_string(ERR_get_error(), NULL));
-  }
-  init_ssl_ctx(ssl_ctx, &spdy_proto_version);
-  ssl = SSL_new(ssl_ctx);
-  if(ssl == NULL) {
-    dief("SSL_new", ERR_error_string(ERR_get_error(), NULL));
-  }
-  /* To simplify the program, we perform SSL/TLS handshake in blocking
-     I/O. */
-  ssl_handshake(ssl, fd);
-
-  connection.ssl = ssl;
-  connection.want_io = IO_NONE;
-
-  /* Here make file descriptor non-block */
-  make_non_block(fd);
-  set_tcp_nodelay(fd);
-
-  printf("[INFO] SPDY protocol version = %d\n", spdy_proto_version);
-  rv = spdylay_session_client_new(&connection.session, spdy_proto_version,
-                                  &callbacks, &connection);
-  if(rv != 0) {
-    diec("spdylay_session_client_new", rv);
-  }
-
-  /* Submit the HTTP request to the outbound queue. */
-  submit_request(&connection, &req);
-
-  pollfds[0].fd = fd;
-  ctl_poll(pollfds, &connection);
-
-  /* Event loop */
-  while(spdylay_session_want_read(connection.session) ||
-        spdylay_session_want_write(connection.session)) {
-    int nfds = poll(pollfds, npollfds, -1);
-    if(nfds == -1) {
-      dief("poll", strerror(errno));
-    }
-    if(pollfds[0].revents & (POLLIN | POLLOUT)) {
-      exec_io(&connection);
-    }
-    if((pollfds[0].revents & POLLHUP) || (pollfds[0].revents & POLLERR)) {
-      die("Connection error");
-    }
-    ctl_poll(pollfds, &connection);
-  }
-
-  /* Resource cleanup */
-  spdylay_session_del(connection.session);
-  SSL_shutdown(ssl);
-  SSL_free(ssl);
-  SSL_CTX_free(ssl_ctx);
-  shutdown(fd, SHUT_WR);
-  MHD_socket_close_(fd);
-  request_free(&req);
-}
-
-static int parse_uri(struct URI *res, const char *uri)
-{
-  /* We only interested in https */
-  size_t len, i, offset;
-  memset(res, 0, sizeof(struct URI));
-  len = strlen(uri);
-  if(len < 9 || memcmp("https://", uri, 8) != 0) {
-    return -1;
-  }
-  offset = 8;
-  res->host = res->hostport = &uri[offset];
-  res->hostlen = 0;
-  if(uri[offset] == '[') {
-    /* IPv6 literal address */
-    ++offset;
-    ++res->host;
-    for(i = offset; i < len; ++i) {
-      if(uri[i] == ']') {
-        res->hostlen = i-offset;
-        offset = i+1;
-        break;
-      }
-    }
-  } else {
-    const char delims[] = ":/?#";
-    for(i = offset; i < len; ++i) {
-      if(strchr(delims, uri[i]) != NULL) {
-        break;
-      }
-    }
-    res->hostlen = i-offset;
-    offset = i;
-  }
-  if(res->hostlen == 0) {
-    return -1;
-  }
-  /* Assuming https */
-  res->port = 443;
-  if(offset < len) {
-    if(uri[offset] == ':') {
-      /* port */
-      const char delims[] = "/?#";
-      int port = 0;
-      ++offset;
-      for(i = offset; i < len; ++i) {
-        if(strchr(delims, uri[i]) != NULL) {
-          break;
-        }
-        if('0' <= uri[i] && uri[i] <= '9') {
-          port *= 10;
-          port += uri[i]-'0';
-          if(port > 65535) {
-            return -1;
-          }
-        } else {
-          return -1;
-        }
-      }
-      if(port == 0) {
-        return -1;
-      }
-      offset = i;
-      res->port = port;
-    }
-  }
-  res->hostportlen = uri+offset-res->host;
-  for(i = offset; i < len; ++i) {
-    if(uri[i] == '#') {
-      break;
-    }
-  }
-  if(i-offset == 0) {
-    res->path = "/";
-    res->pathlen = 1;
-  } else {
-    res->path = &uri[offset];
-    res->pathlen = i-offset;
-  }
-  return 0;
-}
-
-
-/*****
- * end of code needed to utilize spdylay
- */
-
-
-/*****
- * start of code needed to utilize microspdy
- */
-
-
-void
-standard_request_handler(void *cls,
-                                                struct SPDY_Request * request,
-                                                uint8_t priority,
-                        const char *method,
-                        const char *path,
-                        const char *version,
-                        const char *host,
-                        const char *scheme,
-                                                struct SPDY_NameValue * headers,
-            bool more)
-{
-        (void)cls;
-        (void)request;
-        (void)priority;
-        (void)host;
-        (void)scheme;
-        (void)headers;
-        (void)method;
-        (void)version;
-
-        struct SPDY_Response *response=NULL;
-
-        if(strcmp(CLS,cls)!=0)
-        {
-                killchild(child,"wrong cls");
-        }
-
-        if(false != more){
-                fprintf(stdout,"more has wrong value\n");
-                exit(5);
-        }
-
-        response = SPDY_build_response(200,NULL,SPDY_HTTP_VERSION_1_1,NULL,RESPONSE_BODY,strlen(RESPONSE_BODY));
-
-        if(NULL==response){
-                fprintf(stdout,"no response obj\n");
-                exit(3);
-        }
-
-        if(SPDY_queue_response(request,response,true,false,NULL,(void*)strdup(path))!=SPDY_YES)
-        {
-                fprintf(stdout,"queue\n");
-                exit(4);
-        }
-}
-
-void
-session_closed_handler (void *cls,
-                                                struct SPDY_Session * session,
-                                                int by_client)
-{
-        printf("session_closed_handler called\n");
-
-        if(strcmp(CLS,cls)!=0)
-        {
-                killchild(child,"wrong cls");
-        }
-
-        if(SPDY_YES != by_client)
-        {
-                //killchild(child,"wrong by_client");
-                printf("session closed by server\n");
-        }
-        else
-        {
-                printf("session closed by client\n");
-        }
-
-        if(NULL == session)
-        {
-                killchild(child,"session is NULL");
-        }
-
-        session_closed_called = 1;
-}
-
-
-/*****
- * end of code needed to utilize microspdy
- */
-
-//child process
-void
-childproc(int port)
-{
-  struct URI uri;
-  struct sigaction act;
-  int rv;
-  char *uristr;
-
-  memset(&act, 0, sizeof(struct sigaction));
-  act.sa_handler = SIG_IGN;
-  sigaction(SIGPIPE, &act, 0);
-
-        asprintf(&uristr, "https://127.0.0.1:%i/",port);
-        if(NULL == (rcvbuf = malloc(strlen(RESPONSE_BODY)+1)))
-                killparent(parent,"no memory");
-
-  SSL_load_error_strings();
-  SSL_library_init();
-
-  rv = parse_uri(&uri, uristr);
-  if(rv != 0) {
-    killparent(parent,"parse_uri failed");
-  }
-  fetch_uri(&uri);
-
-  if(strcmp(rcvbuf, RESPONSE_BODY))
-    killparent(parent,"received data is different");
-}
-
-//parent proc
-int
-parentproc( int port)
-{
-        int childstatus;
-        unsigned long long timeoutlong=0;
-        struct timeval timeout;
-        int ret;
-        fd_set read_fd_set;
-        fd_set write_fd_set;
-        fd_set except_fd_set;
-        int maxfd = -1;
-        struct SPDY_Daemon *daemon;
-
-        SPDY_init();
-
-        daemon = SPDY_start_daemon(port,
-                                                                DATA_DIR "cert-and-key.pem",
-                                                                DATA_DIR "cert-and-key.pem",
-                                                                NULL,&session_closed_handler,&standard_request_handler,NULL,CLS,SPDY_DAEMON_OPTION_END);
-
-        if(NULL==daemon){
-                printf("no daemon\n");
-                return 1;
-        }
-
-        do
-        {
-                FD_ZERO(&read_fd_set);
-                FD_ZERO(&write_fd_set);
-                FD_ZERO(&except_fd_set);
-
-                ret = SPDY_get_timeout(daemon, &timeoutlong);
-                if(SPDY_NO == ret || timeoutlong > 1000)
-                {
-                        timeout.tv_sec = 1;
-      timeout.tv_usec = 0;
-                }
-                else
-                {
-                        timeout.tv_sec = timeoutlong / 1000;
-                        timeout.tv_usec = (timeoutlong % 1000) * 1000;
-                }
-
-                maxfd = SPDY_get_fdset (daemon,
-                                                                &read_fd_set,
-                                                                &write_fd_set,
-                                                                &except_fd_set);
-
-                ret = select(maxfd+1, &read_fd_set, &write_fd_set, &except_fd_set, &timeout);
-
-                switch(ret) {
-                        case -1:
-                                printf("select error: %i\n", errno);
-                                killchild(child, "select error");
-                                break;
-                        case 0:
-
-                                break;
-                        default:
-                                SPDY_run(daemon);
-
-                        break;
-                }
-        }
-        while(waitpid(child,&childstatus,WNOHANG) != child);
-
-        //give chance to the client to close socket and handle this in run
-        usleep(100000);
-        SPDY_run(daemon);
-
-        SPDY_stop_daemon(daemon);
-
-        SPDY_deinit();
-
-        return WEXITSTATUS(childstatus);
-}
-
-int main()
-{
-        int port = get_port(12123);
-        parent = getpid();
-
-   child = fork();
-   if (child == -1)
-   {
-      fprintf(stderr, "can't fork, error %d\n", errno);
-      exit(EXIT_FAILURE);
-   }
-
-   if (child == 0)
-   {
-      childproc(port);
-      _exit(0);
-   }
-   else
-   {
-           int ret = parentproc(port);
-           if(1 == session_closed_called && 0 == ret)
-      exit(0);
-      else
-      exit(ret ? ret : 21);
-   }
-   return 1;
-}
diff --git a/src/testspdy/test_request_response_with_callback.c b/src/testspdy/test_request_response_with_callback.c
deleted file mode 100644
index 95fc263d..00000000
--- a/src/testspdy/test_request_response_with_callback.c
+++ /dev/null
@@ -1,320 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file request_response_with_callback.c
- * @brief  tests responses with callbacks
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include "microspdy.h"
-#include "stdio.h"
-#include <sys/wait.h>
-#include <ctype.h>
-#include "common.h"
-#include <sys/time.h>
-#include <sys/stat.h>
-
-int port;
-
-pid_t parent;
-pid_t child;
-
-int run = 1;
-int chunk_size=1;
-
-void
-killchild()
-{
-        kill(child, SIGKILL);
-        exit(1);
-}
-
-void
-killparent()
-{
-        kill(parent, SIGKILL);
-        _exit(1);
-}
-
-ssize_t
-response_callback (void *cls,
-                                                void *buffer,
-                                                size_t max,
-                                                bool *more)
-{
-        FILE *fd =(FILE*)cls;
-        
-        size_t n;
-        if(chunk_size % 2)
-                n = chunk_size;
-        else
-                n = max - chunk_size;
-        
-        if(n < 1) n = 1;
-        else if (n > max) n=max;
-        chunk_size++;
-        
-        int ret = fread(buffer,1,n,fd);
-        *more = feof(fd) == 0;
-        
-        //printf("more is %i\n",*more);
-        
-        if(!(*more))
-                fclose(fd);
-        
-        return ret;
-}
-
-
-void
-response_done_callback(void *cls,
-                                                                struct SPDY_Response * response,
-                                                                struct SPDY_Request * request,
-                                                                enum SPDY_RESPONSE_RESULT status,
-                                                bool streamopened)
-{
-  (void)status;
-  (void)streamopened;
-  
-        printf("answer for %s was sent\n", (char*)cls);
-        
-        SPDY_destroy_request(request);
-        SPDY_destroy_response(response);
-        free(cls);
-        
-        run = 0;
-}
-
-void
-standard_request_handler(void *cls,
-                                                struct SPDY_Request * request,
-                                                uint8_t priority,
-                        const char *method,
-                        const char *path,
-                        const char *version,
-                        const char *host,
-                        const char *scheme,
-                                                struct SPDY_NameValue * headers,
-            bool more)
-{
-        (void)cls;
-        (void)request;
-        (void)priority;
-        (void)host;
-        (void)scheme;
-        (void)headers;
-        (void)method;
-        (void)version;
-        (void)more;
-  
-        struct SPDY_Response *response=NULL;
-        struct SPDY_NameValue *resp_headers;
-        
-        printf("received request for '%s %s %s'\n", method, path, version);
-        
-                FILE *fd = fopen(DATA_DIR "spdy-draft.txt","r");
-                
-                if(NULL == (resp_headers = SPDY_name_value_create()))
-                {
-                        fprintf(stdout,"SPDY_name_value_create failed\n");
-                        killchild();
-                }
-                if(SPDY_YES != SPDY_name_value_add(resp_headers,SPDY_HTTP_HEADER_CONTENT_TYPE,"text/plain"))
-                {
-                        fprintf(stdout,"SPDY_name_value_add failed\n");
-                        killchild();
-                }
-                
-                response = SPDY_build_response_with_callback(200,NULL,
-                        SPDY_HTTP_VERSION_1_1,resp_headers,&response_callback,fd,SPDY_MAX_SUPPORTED_FRAME_SIZE);
-                SPDY_name_value_destroy(resp_headers);
-        
-        if(NULL==response){
-                fprintf(stdout,"no response obj\n");
-                        killchild();
-        }
-        
-        void *clspath = strdup(path);
-        
-        if(SPDY_queue_response(request,response,true,false,&response_done_callback,clspath)!=SPDY_YES)
-        {
-                fprintf(stdout,"queue\n");
-                        killchild();
-        }
-}
-
-int
-parentproc()
-{       
-        int childstatus;
-        unsigned long long timeoutlong=0;
-        struct timeval timeout;
-        int ret;
-        fd_set read_fd_set;
-        fd_set write_fd_set;
-        fd_set except_fd_set;
-        int maxfd = -1;
-        struct SPDY_Daemon *daemon;
-        
-        SPDY_init();
-        
-        daemon = SPDY_start_daemon(port,
-                                                                DATA_DIR "cert-and-key.pem",
-                                                                DATA_DIR "cert-and-key.pem",
-                                                                NULL,
-                                                                NULL,
-                                                                &standard_request_handler,
-                                                                NULL,
-                                                                NULL,
-                                                                SPDY_DAEMON_OPTION_SESSION_TIMEOUT,
-                                                                1800,
-                                                                SPDY_DAEMON_OPTION_END);
-        
-        if(NULL==daemon){
-                printf("no daemon\n");
-                return 1;
-        }
-
-        do
-        {
-                FD_ZERO(&read_fd_set);
-                FD_ZERO(&write_fd_set);
-                FD_ZERO(&except_fd_set);
-
-                ret = SPDY_get_timeout(daemon, &timeoutlong);
-                if(SPDY_NO == ret || timeoutlong > 1000)
-                {
-                        timeout.tv_sec = 1;
-      timeout.tv_usec = 0;
-                }
-                else
-                {
-                        timeout.tv_sec = timeoutlong / 1000;
-                        timeout.tv_usec = (timeoutlong % 1000) * 1000;
-                }
-                
-                maxfd = SPDY_get_fdset (daemon,
-                                                                &read_fd_set,
-                                                                &write_fd_set, 
-                                                                &except_fd_set);
-                                                                
-                ret = select(maxfd+1, &read_fd_set, &write_fd_set, &except_fd_set, &timeout);
-                
-                switch(ret) {
-                        case -1:
-                                printf("select error: %i\n", errno);
-                                break;
-                        case 0:
-
-                                break;
-                        default:
-                                SPDY_run(daemon);
-
-                        break;
-                }
-        }
-        while(waitpid(child,&childstatus,WNOHANG) != child);
-
-        SPDY_stop_daemon(daemon);
-        
-        SPDY_deinit();
-        
-        return WEXITSTATUS(childstatus);
-}
-
-#define MD5_LEN 32
-
-int
-md5(char *cmd, char *md5_sum)
-{
-    FILE *p = popen(cmd, "r");
-    if (p == NULL) return 0;
-
-    int i, ch;
-    for (i = 0; i < MD5_LEN && isxdigit(ch = fgetc(p)); i++) {
-        *md5_sum++ = ch;
-    }
-
-    *md5_sum = '\0';
-    pclose(p);
-    return i == MD5_LEN;
-}
-
-int
-childproc()
-{
-        char *cmd1;
-        char *cmd2;
-        char md5_sum1[33];
-        char md5_sum2[33];
-        int ret;
-        struct timeval tv1;
-        struct timeval tv2;
-        struct stat st;
-        //int secs;
-        uint64_t usecs;
-        
-        asprintf(&cmd1, "spdycat https://127.0.0.1:%i/ | md5sum",port);
-        asprintf(&cmd2, "md5sum " DATA_DIR "spdy-draft.txt");
-        
-        gettimeofday(&tv1, NULL);
-        md5(cmd1,md5_sum1);
-        gettimeofday(&tv2, NULL);
-        md5(cmd2,md5_sum2);
-        
-        printf("downloaded file md5: %s\n", md5_sum1);
-        printf("original   file md5: %s\n", md5_sum2);
-        ret = strcmp(md5_sum1, md5_sum2);
-        
-        if(0 == ret && 0 == stat(DATA_DIR "spdy-draft.txt", &st))
-        {
-                usecs = (uint64_t)1000000 * (uint64_t)(tv2.tv_sec - tv1.tv_sec) + tv2.tv_usec - tv1.tv_usec;
-                printf("%lld bytes read in %llu usecs\n", (long long)st.st_size, (long long unsigned )usecs);
-        }
-        
-        return ret;
-}
-
-
-int
-main()
-{
-        port = get_port(11123);
-        parent = getpid();
-
-        child = fork();
-        if (-1 == child)
-        {   
-                fprintf(stderr, "can't fork, error %d\n", errno);
-                exit(EXIT_FAILURE);
-        }
-
-        if (child == 0)
-        {
-                int ret = childproc();
-                _exit(ret);
-        }
-        else
-        { 
-                int ret = parentproc();
-                exit(ret);
-        }
-        return 1;
-}
diff --git a/src/testspdy/test_requests_with_assets.c b/src/testspdy/test_requests_with_assets.c
deleted file mode 100644
index 16d09214..00000000
--- a/src/testspdy/test_requests_with_assets.c
+++ /dev/null
@@ -1,302 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file requests_with_assets.c
- * @brief  tests several requests for an HTML and all its assets. For
- *                      client spdycat (from spdylay) is used. The latter uses
- *                      libxml2.
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include "microspdy.h"
-#include "common.h"
-#include <sys/wait.h>
-#include <stdio.h>   /* printf, stderr, fprintf */
-#include <sys/types.h> /* pid_t */
-#include <unistd.h>  /* _exit, fork */
-#include <stdlib.h>  /* exit */
-#include <errno.h>   /* errno */
-#include <sys/wait.h> /* pid_t */
-#include "common.h"
-
-#define HTML "<html>\
-<head>\
-<link href=\"file1.css\" rel=\"stylesheet\" type=\"text/css\" />\
-<link href=\"file2.css\" rel=\"stylesheet\" type=\"text/css\" />\
-<link href=\"file3.css\" rel=\"stylesheet\" type=\"text/css\" />\
-</head>\
-<body><b>Hi, this is libmicrospdy!</b>\
-</body></html>"
-
-#define CSS "@media all{body{font-family:verdana,arial;color:#333;background-color:#fff;margin:0;padding:0}#navcontainer ul{padding-left:0;background:#005cb9 url(http://cdn.computerhope.com/backbar.jpg) repeat-x left top;padding-bottom:0;padding-top:0;color:#fff;float:right;font-weight:700;width:100%;border-top:1px solid #333;border-bottom:1px solid #333;margin:0}#navcontainer ul li a{color:#fff;text-decoration:none;float:left;border-top:1px solid #fff;border-right:1px solid #333;border-left:1px solid #fff;border-bottom:1px solid #333;padding:.2em 1em}#navcontainer ul li a:hover{background:url(http://cdn.computerhope.com/backbar2.jpg) repeat-x left top;background-color:#9fcfff;color:#333;border-top:1px solid #333;border-right:1px solid #fff;border-left:1px solid #333;border-bottom:1px solid #fff}a:visited{color:#636}a{color:#2a70d0}#content a{text-decoration:none;border-bottom:1px solid #DBDBDB}#content a:hover,a:active,a:focus{color:#c33;border-bottom:1px solid #c33}img{border:0}#content-container1{float:left;width:100%;background:#fff url(http://cdn.computerhope.com/back.jpg) repeat-y 0}.print,.email,.edit,.share,.up,.down,.book,.folder,.issue,.driver,.history,.news,.btips,.tips,.warn,.phone,.forum,.question{background:url(chs.png) no-repeat top left}#container{padding-left:150px;padding-right:265px}#container .column{position:relative;float:left}#content{width:100%;padding:20px}#left-bar{width:150px;margin-left:-100%;left:225px;padding:10px}#container > #left-bar{left:-190px}#right-bar{width:205px;margin-right:-265px;padding:0 10px}#topad{background:#9fcfff;text-align:center;padding:35px 0 4px}#leftad{clear:both;background:inherit;height:auto;margin:15px 0 0}#content ul{position:relative;margin:10px 0 10px 10px;padding:0}#content ul li{list-style-type:none;background:url(http://cdn.computerhope.com/arrow.png) no-repeat top left;background-position:0 5px;line-height:1.5625;padding:0 0 8px 23px}ol li{margin-bottom:8px;line-height:1.5625}.print,.email,.edit,.share{padding-left:23px}.print{background-position:0 -868px;width:16px;height:16px}.email{background-position:0 -469px;width:16px;height:16px}.edit{background-position:0 -403px;width:16px;height:16px}.share{background-position:0 -1002px;width:16px;height:16px}#left-bar li.title{color:#005cb9;font-weight:700;margin:1em 0}#right-box{width:180px;border:1px solid #005cb9;border-radius:15px 15px 15px 15px;background:#ebebeb;margin:90px 0 0;padding:10px}#right-box ul.poll{margin-top:15px;font-weight:700;margin-bottom:10px}.up,.down{padding-left:20px;text-decoration:none;color:#333}.up{background-position:0 -1068px;width:16px;height:16px}.down{background-position:0 -269px;width:16px;height:16px}#right-box li.title{color:#333;font-weight:700;margin:1em 0 0}#header{background:#9fcfff}#containercol2{background-color:#d0e8ff;width:700px;overflow:hidden;margin:0 auto}#containercol2 ul.col2{width:700px;list-style:none;float:left;padding:0}#containercol2 ul.col2 li h2{border:1px solid #005cb9;background:url(http://cdn.computerhope.com/backbar.jpg) repeat-x left top;color:#fff;font-size:large;text-align:center}#containercol2 ul.col2 li{float:left;width:340px;padding:5px}#containercol2 ul li.headline{border-bottom:1px solid #327dac;background:gray}#bottomad{margin:14px 0 0}input.btn,input.bbtn{color:#333;background:#9fcfff;font-weight:700;border:1px solid #005cb9;border-top:1px solid #eee;border-left:1px solid #eee;cursor:pointer;margin:4px 0 0}input.sbar,input.bsbar{color:#333;width:110px;background:#fff}input.btn{width:115px;font-size:medium}input.sbar{font-size:medium}input.bbtn{width:110px;font-size:large}input.bsbar{width:350px;font-size:18px;margin-right:5px}h1{font-size:175%;margin-bottom:25px;border-bottom:1px solid #dadada;padding-bottom:.17em;letter-spacing:-.05em;font-weight:700}.ce{text-align:center}.tab{margin-left:40px}p{line-height:1.5625}.tabb{margin-left:40px;font-weight:700;line-height:1.4}.dtab{margin-left:80px}.dd{font-weight:700;margin-left:7px}.lb{margin-left:5px}.bld{font-weight:700}.bb{font-size:14pt;color:#005cb9;font-weight:700}.bbl{font-size:14pt;font-weight:700}.nb{color:#005cb9;font-weight:700}.rg{color:gray;font-weight:700}.sg{font-size:10pt;color:gray}.sm{font-size:small}.rb{color:#fff;font-weight:700;text-indent:.3cm}.wt{color:#fff;font-weight:700}.bwt{color:#fff;font-weight:700;font-size:14pt}.large{font-size:x-large}.red{color:red}table{clear:both}.mtable,.mtable2{border:0 solid silver;background-color:#e5e5e5;border-spacing:2px 1px;width:98%;margin-left:auto;margin-right:auto}table.mtable td,table.mtable2 td{border-spacing:5px 10px;padding:9px}table.mtable th,table.mtable2 th{background:#005cb9 url(http://cdn.computerhope.com/backbar.jpg) repeat-x left top;color:#fff;font-weight:700;padding:5px}table.mtable a{border-bottom:0!important}table.mtable tr:hover td{background-color:#eee;cursor:pointer}td{vertical-align:top}.tcb{background:#005cb9 url(http://cdn.computerhope.com/backbar.jpg) repeat-x left top}.tclb{background-color:#9fcfff}.tcllb{background-color:#d0e8ff}.tcw{background-color:#fff}.tcg{background-color:#ebebeb}.tcbl{background-color:#333}.tcy{border:1px solid #005cb9;background-color:#f1f5f9;overflow:auto;padding:15px}.icell{padding-left:15px;padding-bottom:3px}.mlb{background-color:#9fcfff;padding-left:15px;padding-bottom:3px;white-space:nowrap;width:120px;vertical-align:top}#footer{background:url(http://cdn.computerhope.com/footback.jpg) repeat-x left top;background-color:#d0e8ff;clear:both;padding:5px}#footer ul li{list-style-type:none;display:inline;background:inherit;margin:0}#footer li a{float:left;text-decoration:none;width:300px;border-bottom:1px dotted #327dac;padding:0 0 10px 10px}#footer li a:hover{background:#005cb9;color:#fff}#creditfooter{display:none}.legal{text-align:center;font-size:11px}.legal a{text-decoration:none;color:#333}.floatLeft{float:left;clear:left;margin-right:20px;margin-bottom:10px}.floatRight{float:right;margin-left:20px;margin-bottom:10px}.floatRightClear{float:right;clear:right;margin-left:20px}:first-child + html #container{overflow:hidden}.book,.folder,.issue,.driver,.history,.news,.btips,.tips,.warn,.phone,.forum,.question{padding-left:22px;font-weight:700}.book{background-position:0 0;width:17px;height:18px}.tips{background-position:0 -68px;width:17px;height:17px}.btips{background-position:0 -135px;width:17px;height:17px}.history{background-position:0 -202px;width:17px;height:17px}.driver{background-position:0 -335px;width:17px;height:18px}.folder{background-position:0 -535px;width:17px;height:16px}.issue{background-position:0 -601px;width:17px;height:18px}.news{background-position:0 -669px;width:17px;height:14px}.forum{background-position:0 -733px;width:17px;height:18px}.phone{background-position:0 -801px;width:17px;height:17px}.question{background-position:0 -934px;width:17px;height:18px}.warn{background-position:0 -1134px;width:16px;height:16px}textarea,input{border:1px solid #ccc;border-top:1px solid #8d8e90;border-left:1px solid #8d8e90}textarea:focus,input:focus{border:1px solid #005cb9}#left-bar ul,#right-box ul,#footer ul{margin:0;padding:0}#right-box li.poll,#navcontainer ul li{display:inline}#noprint{margin:1px 0 0}#left-bar ul li,#right-box ul li{margin-left:10px;list-style-type:none;padding:0}#right-box a,#left-bar a{color:#333}}@media print{#header,#navcontainer,#topad,#left-bar,#right-bar,#bottomad,#footer,#search,#buttons,#noprint{display:none!important}#content a{text-decoration:none;color:#000}#content,#container{font-family:\"Times New Roman\",Times;background:transparent!important;text-indent:0!important;width:100%!important;border:0!important;float:none!important;position:static!important;overflow:visible!important;line-height:1;margin:0!important;padding:0!important}h1{font-size:14pt;margin-bottom:5px;border-bottom:0;padding-bottom:0;letter-spacing:-.05em;font-weight:700}h2{font-size:13pt}.bb{font-size:13pt;color:#005cb9;font-weight:700}#content ul li:before{content:\"\00bb \0020\"}#content .nb,.bb{font-weight:700;color:#000}table{margin-top:30px;margin-bottom:30px;border-collapse:collapse}th,td{border:1px solid #333}}"
-
-#define JS "var _gaq = _gaq || [];\
-_gaq.push(['_setAccount', 'UA-222222222222222222222222-1']);\
-_gaq.push(['_trackPageview']);\
-(function() {\
-var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;\
-//ga.src = ('https:' == document.location.protocol ? 'ZZZhttps://ssl' : 'ZZZhttp://www') + '.google-analytics.com/ga.js';\
-var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);\
-})();"
-
-int port;
-
-#define NUM_CLIENTS 50
-
-pid_t parent;
-int html_req_count;
-int html_resp_count;
-
-int child_c;
-int children_pid[NUM_CLIENTS];
-int children_status[NUM_CLIENTS];
-
-int session_closed_called;
-
-void
-new_child(pid_t pid)
-{
-        //todo ids overflow
-        children_pid[child_c] = pid;
-        children_status[child_c++] = 1;
-}
-
-int
-alive_children()
-{
-  int i;
-  int dead;
-  int status;
-  int ret = 0;
-
-  for(i=NUM_CLIENTS-1;i>=0;--i)
-    {
-      if (1 != children_status[i])
-        continue;
-      dead = waitpid(children_pid[i], &status, WNOHANG);
-      if (0 == dead) 
-        {
-          ret = 1;
-          continue;
-        }
-      if (WEXITSTATUS(status) != 0)
-        {
-          for (i=NUM_CLIENTS-1;i>=0;--i)
-            if (1 == children_status[i])
-              kill (children_pid[i], SIGKILL);
-          exit (WEXITSTATUS(status));
-        }
-      children_status[i] = 2;
-    }
-  return ret;
-}
- 
-void
-killchild(int pid, char *message)
-{
-        printf("%s\nkilling %i\n",message,pid);
-        kill(pid, SIGKILL);
-        exit(1);
-}
-
-void
-killparent(int pid, const char *message)
-{
-        printf("%s\nkilling %i\n",message,pid);
-        kill(pid, SIGKILL);
-        _exit(1);
-}
-
-void
-standard_request_handler(void *cls,
-                                                struct SPDY_Request * request,
-                                                uint8_t priority,
-                        const char *method,
-                        const char *path,
-                        const char *version,
-                        const char *host,
-                        const char *scheme,
-                                                struct SPDY_NameValue * headers,
-            bool more)
-{
-        (void)cls;
-        (void)request;
-        (void)priority;
-        (void)host;
-        (void)scheme;
-        (void)headers;
-        (void)method;
-        (void)version;
-        (void)more;
-  
-        struct SPDY_Response *response;
-        
-        if(NULL != strstr(path,".css"))
-        {
-        response = SPDY_build_response(200,NULL,SPDY_HTTP_VERSION_1_1,NULL,CSS,strlen(CSS));
-        if(strcmp("/file3.css",path)==0)++html_resp_count;
-        }
-        /*else if(NULL != strstr(path,".js")) 
-        {
-        response = SPDY_build_response(200,NULL,SPDY_HTTP_VERSION_1_1,NULL,JS,strlen(JS));
-        }*/
-        else
-        {
-        response = SPDY_build_response(200,NULL,SPDY_HTTP_VERSION_1_1,NULL,HTML,strlen(HTML));
-        }
-        
-        if(NULL==response){
-                fprintf(stdout,"no response obj\n");
-                exit(3);
-        }
-        
-        if(SPDY_queue_response(request,response,true,false,NULL,(void*)strdup(path))!=SPDY_YES)
-        {
-                fprintf(stdout,"queue\n");
-                exit(4);
-        }
-        
-        
-}
- 
-void
-run_spdycat()
-{
-        pid_t child;
-        ++html_req_count;
-        child = fork();
-        if (child == -1)
-        {   
-                killparent(parent,"fork failed\n");
-        }
-
-        if (child == 0)
-        {
-                int devnull;
-
-                close(1);
-                devnull = open("/dev/null", O_WRONLY);
-                if (1 != devnull)
-                {
-                        dup2(devnull, 1);
-                        close(devnull);
-                }
-                char *uri;
-                asprintf (&uri, "https://127.0.0.1:%i/%i.html", port, html_req_count);
-                execlp ("spdycat", "spdycat", "-anv", uri, NULL);
-                killparent (parent, "executing spdycat failed");
-        }
-        else
-        {
-                new_child(child);
-        }
-}
-
-int
-parentproc()
-{
-        unsigned long long timeoutlong=0;
-        struct timeval timeout;
-        int ret;
-        fd_set read_fd_set;
-        fd_set write_fd_set;
-        fd_set except_fd_set;
-        int maxfd = -1;
-        struct SPDY_Daemon *daemon;
-        
-        SPDY_init();
-        
-        daemon = SPDY_start_daemon(port,
-                                                                DATA_DIR "cert-and-key.pem",
-                                                                DATA_DIR "cert-and-key.pem",
-                                                                NULL,
-                                                                NULL,
-                                                                &standard_request_handler,
-                                                                NULL,
-                                                                NULL,
-                                                                SPDY_DAEMON_OPTION_END);
-        
-        if(NULL==daemon){
-                printf("no daemon\n");
-                return 1;
-        }
-
-        do
-        {
-                if(NUM_CLIENTS > html_req_count)
-                {
-                        run_spdycat();
-                }
-                
-                FD_ZERO(&read_fd_set);
-                FD_ZERO(&write_fd_set);
-                FD_ZERO(&except_fd_set);
-    
-                ret = SPDY_get_timeout(daemon, &timeoutlong);
-                if(SPDY_NO == ret || timeoutlong > 1000)
-                {
-                        timeout.tv_sec = 1;
-      timeout.tv_usec = 0;
-                }
-                else
-                {
-                        timeout.tv_sec = timeoutlong / 1000;
-                        timeout.tv_usec = (timeoutlong % 1000) * 1000;
-                }
-                
-                maxfd = SPDY_get_fdset (daemon,
-                                                                &read_fd_set,
-                                                                &write_fd_set, 
-                                                                &except_fd_set);
-                                                                
-                ret = select(maxfd+1, &read_fd_set, &write_fd_set, &except_fd_set, &timeout);
-                
-                switch(ret) {
-                        case -1:
-                                printf("select error: %i\n", errno);
-                                break;
-                        case 0:
-
-                                break;
-                        default:
-                                SPDY_run(daemon);
-
-                        break;
-                }
-        }
-        while(alive_children());
-
-        SPDY_stop_daemon(daemon);
-        
-        SPDY_deinit();
-        
-        return html_resp_count != html_req_count;
-}
-
-int main()
-{
-        parent = getpid();
-        port = get_port(10123);
-
-        int ret = parentproc();
-        exit(ret);
-
-        return 1;
-}
diff --git a/src/testspdy/test_session_timeout.c b/src/testspdy/test_session_timeout.c
deleted file mode 100644
index ec1eced5..00000000
--- a/src/testspdy/test_session_timeout.c
+++ /dev/null
@@ -1,338 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2013 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file session_timeout.c
- * @brief  tests closing sessions after set timeout. Openssl is used for
- *                      client
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include "microspdy.h"
-#include "stdio.h"
-#include <sys/wait.h>
-#include <ctype.h>
-#include "common.h"
-#include <sys/time.h>
-#include <sys/stat.h>
-#include "../microspdy/internal.h"
-
-#define TIMEOUT 2
-#define SELECT_MS_TIMEOUT 20
-
-int port;
-
-pid_t parent;
-pid_t child;
-
-int run = 1;
-int chunk_size=1;
-int new_session;
-int closed_session;
-int do_sleep;
-
-
-
-static unsigned long long
-monotonic_time (void)
-{
-#ifdef HAVE_CLOCK_GETTIME
-#ifdef CLOCK_MONOTONIC
-  struct timespec ts;
-  if (0 == clock_gettime (CLOCK_MONOTONIC, &ts))
-    return ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
-#endif
-#endif
-  return time (NULL) * 1000;
-}
-
-
-static void
-killchild(char *msg)
-{
-        printf("%s\n",msg);
-        kill(child, SIGKILL);
-        exit(1);
-}
-
-
-static void
-killparent(char *msg)
-{
-        printf("%s\n",msg);
-        kill(parent, SIGKILL);
-        _exit(1);
-}
-
-
-static void
-new_session_cb (void *cls,
-                struct SPDY_Session * session)
-{
-  (void)cls;
-  (void)session;
-
-        if(!new_session)do_sleep = 1;
-        new_session = 1;
-        printf("new session\n");
-}
-
-
-static void
-closed_session_cb (void *cls,
-                   struct SPDY_Session * session,
-                   int by_client)
-{
-  (void)cls;
-  (void)session;
-
-        printf("closed_session_cb called\n");
-
-        if(SPDY_YES == by_client)
-        {
-                killchild("closed by the client");
-        }
-        if(closed_session)
-        {
-                killchild("closed_session_cb called twice");
-        }
-
-        closed_session = 1;
-}
-
-
-static int
-parentproc()
-{
-        int childstatus;
-        unsigned long long timeoutlong=0;
-        struct timeval timeout;
-        int ret;
-        fd_set read_fd_set;
-        fd_set write_fd_set;
-        fd_set except_fd_set;
-        int maxfd = -1;
-        struct SPDY_Daemon *daemon;
-  unsigned long long  beginning = 0;
-        unsigned long long now;
-
-        SPDY_init();
-
-        daemon = SPDY_start_daemon(port,
-                                                                DATA_DIR "cert-and-key.pem",
-                                                                DATA_DIR "cert-and-key.pem",
-                                                                &new_session_cb,
-                                                                &closed_session_cb,
-                                                                NULL,
-                                                                NULL,
-                                                                NULL,
-                                                                SPDY_DAEMON_OPTION_SESSION_TIMEOUT,
-                                                                TIMEOUT,
-                                                                SPDY_DAEMON_OPTION_END);
-
-        if(NULL==daemon){
-                printf("no daemon\n");
-                return 1;
-        }
-
-        do
-        {
-                do_sleep=0;
-                FD_ZERO(&read_fd_set);
-                FD_ZERO(&write_fd_set);
-                FD_ZERO(&except_fd_set);
-
-                ret = SPDY_get_timeout(daemon, &timeoutlong);
-
-                if(new_session && !closed_session)
-                {
-                        if(SPDY_NO == ret)
-                        {
-                                killchild("SPDY_get_timeout returned wrong SPDY_NO");
-                        }
-                        /*if(timeoutlong)
-                        {
-                                killchild("SPDY_get_timeout returned wrong timeout");
-                        }*/
-                        now = monotonic_time ();
-      if(now - beginning > TIMEOUT*1000 + SELECT_MS_TIMEOUT)
-      {
-        printf("Started at: %llums\n",beginning);
-        printf("Now is: %llums\n",now);
-        printf("Timeout is: %i\n",TIMEOUT);
-        printf("Select Timeout is: %ims\n",SELECT_MS_TIMEOUT);
-        printf("SPDY_get_timeout gave: %llums\n",timeoutlong);
-                                killchild("Timeout passed but session was not closed");
-      }
-      if(timeoutlong > beginning + TIMEOUT *1000)
-      {
-        printf("Started at: %llums\n",beginning);
-        printf("Now is: %llums\n",now);
-        printf("Timeout is: %i\n",TIMEOUT);
-        printf("Select Timeout is: %ims\n",SELECT_MS_TIMEOUT);
-        printf("SPDY_get_timeout gave: %llums\n",timeoutlong);
-                                killchild("SPDY_get_timeout returned wrong timeout");
-      }
-                }
-                else
-                {
-                        if(SPDY_YES == ret)
-                        {
-                                killchild("SPDY_get_timeout returned wrong SPDY_YES");
-                        }
-                }
-
-                if(SPDY_NO == ret || timeoutlong >= 1000)
-                {
-                        timeout.tv_sec = 1;
-      timeout.tv_usec = 0;
-                }
-                else
-                {
-                        timeout.tv_sec = timeoutlong / 1000;
-      timeout.tv_usec = (timeoutlong % 1000) * 1000;
-                }
-
-    //ignore values
-    timeout.tv_sec = 0;
-    timeout.tv_usec = SELECT_MS_TIMEOUT * 1000;
-
-                maxfd = SPDY_get_fdset (daemon,
-                                                                &read_fd_set,
-                                                                &write_fd_set,
-                                                                &except_fd_set);
-
-                ret = select(maxfd+1, &read_fd_set, &write_fd_set, &except_fd_set, &timeout);
-
-                switch(ret) {
-                        case -1:
-                                printf("select error: %i\n", errno);
-                                break;
-                        case 0:
-                                /*if(new_session)
-                                {
-                                        killchild("select returned wrong number");
-                                }*/
-                                break;
-                        default:
-                                SPDY_run(daemon);
-        if(0 == beginning)
-        {
-          beginning = monotonic_time ();
-        }
-                                /*if(do_sleep)
-                                {
-                                        sleep(TIMEOUT);
-                                        do_sleep = 0;
-                                }*/
-                        break;
-                }
-        }
-        while(waitpid(child,&childstatus,WNOHANG) != child);
-
-        if(!new_session || !closed_session)
-        {
-                killchild("child is dead, callback wasn't called");
-        }
-
-        ret = SPDY_get_timeout(daemon, &timeoutlong);
-
-        if(SPDY_YES == ret)
-        {
-                killchild("SPDY_get_timeout returned wrong SPDY_YES after child died");
-        }
-
-        SPDY_stop_daemon(daemon);
-
-        SPDY_deinit();
-
-        return 0;
-}
-
-
-static int
-childproc()
-{
-        pid_t devnull;
-        int out;
-
-        out=dup(1);
-        if (-1 == out)
-          abort();
-        //close(0);
-        close(1);
-        close(2);
-        /*devnull = open("/dev/null", O_RDONLY);
-        if (0 != devnull)
-        {
-                dup2(devnull, 0);
-                close(devnull);
-        }*/
-        devnull = open("/dev/null", O_WRONLY);
-        if (-1 == devnull)
-          abort ();
-        if (1 != devnull)
-        {
-                dup2(devnull, 1);
-                close(devnull);
-        }
-        devnull = open("/dev/null", O_WRONLY);
-        if (-1 == devnull)
-          abort ();
-        if (2 != devnull)
-        {
-                dup2(devnull, 2);
-                close(devnull);
-        }
-        char *uri;
-        asprintf (&uri, "127.0.0.1:%i", port);
-        execlp ("openssl", "openssl", "s_client", "-connect", uri, NULL);
-        close(1);
-        dup2(out,1);
-        close(out);
-        killparent ("executing openssl failed");
-        return 1;
-}
-
-
-int
-main()
-{
-        port = get_port(11123);
-        parent = getpid();
-
-        child = fork();
-        if (-1 == child)
-        {
-                fprintf(stderr, "can't fork, error %d\n", errno);
-                exit(EXIT_FAILURE);
-        }
-
-        if (child == 0)
-        {
-                int ret = childproc();
-                _exit(ret);
-        }
-        else
-        {
-                int ret = parentproc();
-                exit(ret);
-        }
-        return 1;
-}
diff --git a/src/testspdy/test_struct_namevalue.c b/src/testspdy/test_struct_namevalue.c
deleted file mode 100644
index 54e79349..00000000
--- a/src/testspdy/test_struct_namevalue.c
+++ /dev/null
@@ -1,346 +0,0 @@
-/*
-    This file is part of libmicrospdy
-    Copyright Copyright (C) 2012 Andrey Uzunov
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file struct_namevalue.c
- * @brief  tests all the API functions for handling struct SPDY_NameValue
- * @author Andrey Uzunov
- */
-
-#include "platform.h"
-#include "microspdy.h"
-#include "common.h"
-#include "../microspdy/structures.h"
-#include "../microspdy/alstructures.h"
-
-char *pairs[] = {"one","1","two","2","three","3","four","4","five","5"};
-char *pairs_with_dups[] = {"one","1","two","2","one","11","two","22","three","3","two","222","two","2222","four","","five","5"};//82
-char *pairs_with_empty[] = {"name","","name","value"};
-char *pairs_different[] = {"30","thirty","40","fouthy"};
-int size;
-int size2;
-int brake_at = 3;
-bool flag;
-
-
-int
-iterate_cb (void *cls, const char *name, const char * const * value, int num_values)
-{
-        int *c = (int*)cls;
-
-        if(*c < 0 || *c > size)
-                exit(11);
-
-        if(strcmp(name,pairs[*c]) != 0)
-        {
-                FAIL_TEST("name is wrong\n");
-        }
-
-        if(1 != num_values)
-        {
-                FAIL_TEST("num_values is wrong\n");
-        }
-
-        if(strcmp(value[0],pairs[(*c)+1]) != 0)
-        {
-                FAIL_TEST("value is wrong\n");
-        }
-
-        (*c)+=2;
-
-        return SPDY_YES;
-}
-
-int
-iterate_brake_cb (void *cls, const char *name, const char * const *value, int num_values)
-{
-  (void)name;
-  (void)value;
-  (void)num_values;
-
-        int *c = (int*)cls;
-
-        if(*c < 0 || *c >= brake_at)
-        {
-                FAIL_TEST("iteration was not interrupted\n");
-        }
-
-        (*c)++;
-
-        if(*c == brake_at) return SPDY_NO;
-
-        return SPDY_YES;
-}
-
-int
-main()
-{
-        SPDY_init();
-
-        const char *const*value;
-        const char *const*value2;
-        int i;
-        int j;
-        int cls = 0;
-        int ret;
-        int ret2;
-        void *ob1;
-        void *ob2;
-        void *ob3;
-        void *stream;
-        char data[] = "anything";
-        struct SPDY_NameValue *container;
-        struct SPDY_NameValue *container2;
-        struct SPDY_NameValue *container3;
-        struct SPDY_NameValue *container_arr[2];
-
-        size = sizeof(pairs)/sizeof(pairs[0]);
-
-        if(NULL == (container = SPDY_name_value_create ()))
-        {
-                FAIL_TEST("SPDY_name_value_create failed\n");
-        }
-
-        if(NULL != SPDY_name_value_lookup (container, "anything", &ret))
-        {
-                FAIL_TEST("SPDY_name_value_lookup failed\n");
-        }
-
-        if(SPDY_name_value_iterate (container, NULL, NULL) != 0)
-        {
-                FAIL_TEST("SPDY_name_value_iterate failed\n");
-        }
-
-        for(i=0;i<size; i+=2)
-        {
-                if(SPDY_YES != SPDY_name_value_add(container,pairs[i],pairs[i+1]))
-                {
-                        FAIL_TEST("SPDY_name_value_add failed\n");
-                }
-
-                if(SPDY_name_value_iterate (container, NULL, NULL) != ((i / 2) + 1))
-                {
-                        FAIL_TEST("SPDY_name_value_iterate failed\n");
-                }
-        }
-
-        if(NULL != SPDY_name_value_lookup (container, "anything", &ret))
-        {
-                FAIL_TEST("SPDY_name_value_lookup failed\n");
-        }
-
-        for(i=size - 2; i >= 0; i-=2)
-        {
-                value = SPDY_name_value_lookup(container,pairs[i], &ret);
-                if(NULL == value || 1 !=ret || strcmp(value[0], pairs[i+1]) != 0)
-                {
-                        printf("%p; %i; %i\n", value, ret,
-                               (NULL == value) ? -1 : strcmp(value[0], pairs[i+1]));
-                        FAIL_TEST("SPDY_name_value_lookup failed\n");
-                }
-        }
-
-        SPDY_name_value_iterate (container, &iterate_cb, &cls);
-
-        cls = 0;
-        if(SPDY_name_value_iterate (container, &iterate_brake_cb, &cls) != brake_at)
-        {
-                FAIL_TEST("SPDY_name_value_iterate with brake failed\n");
-        }
-
-        SPDY_name_value_destroy(container);
-
-        //check everything with NULL values
-        for(i=0; i<7; ++i)
-        {
-                printf("%i ",i);
-                ob1 = (i & 4) ? data : NULL;
-                ob2 = (i & 2) ? data : NULL;
-                ob3 = (i & 1) ? data : NULL;
-                if(SPDY_INPUT_ERROR != SPDY_name_value_add(ob1,ob2,ob3))
-                {
-                        FAIL_TEST("SPDY_name_value_add with NULLs failed\n");
-                }
-        }
-        printf("\n");
-        fflush(stdout);
-
-        if(SPDY_INPUT_ERROR != SPDY_name_value_iterate(NULL,NULL,NULL))
-        {
-                FAIL_TEST("SPDY_name_value_iterate with NULLs failed\n");
-        }
-
-        for(i=0; i<7; ++i)
-        {
-                printf("%i ",i);
-                ob1 = (i & 4) ? data : NULL;
-                ob2 = (i & 2) ? data : NULL;
-                ob3 = (i & 1) ? data : NULL;
-                if(NULL != SPDY_name_value_lookup(ob1,ob2,ob3))
-                {
-                        FAIL_TEST("SPDY_name_value_lookup with NULLs failed\n");
-                }
-        }
-        printf("\n");
-        SPDY_name_value_destroy(NULL);
-
-        if(NULL == (container = SPDY_name_value_create ()))
-        {
-                FAIL_TEST("SPDY_name_value_create failed\n");
-        }
-
-        size = sizeof(pairs_with_dups)/sizeof(pairs_with_dups[0]);
-
-        for(i=0;i<size; i+=2)
-        {
-                if(SPDY_YES != SPDY_name_value_add(container,pairs_with_dups[i],pairs_with_dups[i+1]))
-                {
-                        FAIL_TEST("SPDY_name_value_add failed\n");
-                }
-        }
-        if(SPDY_name_value_iterate (container, NULL, NULL) != atoi(pairs_with_dups[size - 1]))
-        {
-                FAIL_TEST("SPDY_name_value_iterate failed\n");
-        }
-        for(i=size - 2; i >= 0; i-=2)
-        {
-                value = SPDY_name_value_lookup(container,pairs_with_dups[i], &ret);
-                if(NULL == value)
-                {
-                        FAIL_TEST("SPDY_name_value_lookup failed\n");
-                }
-                flag = false;
-                for(j=0; j<ret; ++j)
-                        if(0 == strcmp(pairs_with_dups[i + 1], value[j]))
-                        {
-                                if(flag)
-                                        FAIL_TEST("SPDY_name_value_lookup failed\n");
-                                flag=true;
-                        }
-
-                if(!flag)
-                        FAIL_TEST("SPDY_name_value_lookup failed\n");
-        }
-        if(SPDY_NO != SPDY_name_value_add(container,pairs_with_dups[0],pairs_with_dups[1]))
-                FAIL_TEST("SPDY_name_value_add failed\n");
-
-        SPDY_name_value_destroy(container);
-
-        if(NULL == (container = SPDY_name_value_create ()))
-        {
-                FAIL_TEST("SPDY_name_value_create failed\n");
-        }
-
-        size = sizeof(pairs_with_empty)/sizeof(pairs_with_empty[0]);
-
-        for(i=0;i<size; i+=2)
-        {
-                if(SPDY_YES != SPDY_name_value_add(container,pairs_with_empty[i],pairs_with_empty[i+1]))
-                {
-                        FAIL_TEST("SPDY_name_value_add failed\n");
-                }
-                value = SPDY_name_value_lookup(container,pairs_with_empty[i], &ret);
-                if(NULL == value || 1 != ret)
-                {
-                        printf("%p; %i\n", value, ret);
-                        FAIL_TEST("SPDY_name_value_lookup failed\n");
-                }
-        }
-
-        ret = SPDY_name_value_iterate(container, NULL, NULL);
-        if(SPDY_INPUT_ERROR != SPDY_name_value_add(container, "capitalLeter","anything")
-                || SPDY_name_value_iterate(container, NULL, NULL) != ret)
-        {
-                FAIL_TEST("SPDY_name_value_add failed\n");
-        }
-
-        SPDY_name_value_destroy(container);
-
-        if(NULL == (container = SPDY_name_value_create ()))
-        {
-                FAIL_TEST("SPDY_name_value_create failed\n");
-        }
-
-        size = sizeof(pairs_with_dups)/sizeof(pairs_with_dups[0]);
-
-        for(i=0;i<size; i+=2)
-        {
-                if(SPDY_YES != SPDY_name_value_add(container,pairs_with_dups[i],pairs_with_dups[i+1]))
-                {
-                        FAIL_TEST("SPDY_name_value_add failed\n");
-                }
-        }
-
-        if(NULL == (container2 = SPDY_name_value_create ()))
-        {
-                FAIL_TEST("SPDY_name_value_create failed\n");
-        }
-
-        size2 = sizeof(pairs_different)/sizeof(pairs_different[0]);
-
-        for(i=0;i<size2; i+=2)
-        {
-                if(SPDY_YES != SPDY_name_value_add(container2,pairs_different[i],pairs_different[i+1]))
-                {
-                        FAIL_TEST("SPDY_name_value_add failed\n");
-                }
-        }
-
-        container_arr[0] = container;
-        container_arr[1] = container2;
-        if(0 > (ret = SPDYF_name_value_to_stream(container_arr, 2, &stream)) || NULL == stream)
-                FAIL_TEST("SPDYF_name_value_to_stream failed\n");
-        ret = SPDYF_name_value_from_stream(stream, ret, &container3);
-        if(SPDY_YES != ret)
-                FAIL_TEST("SPDYF_name_value_from_stream failed\n");
-
-        if(SPDY_name_value_iterate(container3, NULL, NULL)
-                != (SPDY_name_value_iterate(container, NULL, NULL) + SPDY_name_value_iterate(container2, NULL, NULL)))
-                FAIL_TEST("SPDYF_name_value_from_stream failed\n");
-
-        for(i=size - 2; i >= 0; i-=2)
-        {
-                value = SPDY_name_value_lookup(container,pairs_with_dups[i], &ret);
-                if(NULL == value)
-                        FAIL_TEST("SPDY_name_value_lookup failed\n");
-                value2 = SPDY_name_value_lookup(container3,pairs_with_dups[i], &ret2);
-                if(NULL == value2)
-                        FAIL_TEST("SPDY_name_value_lookup failed\n");
-
-                for(j=0; j<ret; ++j)
-                        if(0 != strcmp(value2[j], value[j]))
-                                FAIL_TEST("SPDY_name_value_lookup failed\n");
-        }
-        for(i=size2 - 2; i >= 0; i-=2)
-        {
-                value = SPDY_name_value_lookup(container2,pairs_different[i], &ret);
-                if(NULL == value)
-                        FAIL_TEST("SPDY_name_value_lookup failed\n");
-                value2 = SPDY_name_value_lookup(container3,pairs_different[i], &ret2);
-                if(NULL == value2)
-                        FAIL_TEST("SPDY_name_value_lookup failed\n");
-
-                for(j=0; j<ret; ++j)
-                        if(0 != strcmp(value2[j], value[j]))
-                                FAIL_TEST("SPDY_name_value_lookup failed\n");
-        }
-
-        SPDY_deinit();
-
-        return 0;
-}