/* * Spdylay - SPDY Library * * 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. */ #ifndef SPDYLAY_H #define SPDYLAY_H #ifdef __cplusplus extern "C" { #endif #include #include #include #include struct spdylay_session; /** * @struct * * The primary structure to hold the resources needed for a SPDY * session. The details of this structure are intentionally hidden * from the public API. */ typedef struct spdylay_session spdylay_session; /** * @enum * * The SPDY protocol version. */ typedef enum { /** * SPDY protocol version 2 */ SPDYLAY_PROTO_SPDY2 = 2, /** * SPDY protocol version 3 */ SPDYLAY_PROTO_SPDY3 = 3 } spdylay_proto_version; /** * @enum * * Error codes used in the Spdylay library. The code range is [-999, * -500], inclusive. The following values are defined: */ typedef enum { /** * Invalid argument passed. */ SPDYLAY_ERR_INVALID_ARGUMENT = -501, /** * Zlib error. */ SPDYLAY_ERR_ZLIB = -502, /** * The specified protocol version is not supported. */ SPDYLAY_ERR_UNSUPPORTED_VERSION = -503, /** * Used as a return value from :type:`spdylay_send_callback` and * :type:`spdylay_recv_callback` to indicate that the operation * would block. */ SPDYLAY_ERR_WOULDBLOCK = -504, /** * General protocol error */ SPDYLAY_ERR_PROTO = -505, /** * The frame is invalid. */ SPDYLAY_ERR_INVALID_FRAME = -506, /** * The peer performed a shutdown on the connection. */ SPDYLAY_ERR_EOF = -507, /** * Used as a return value from * :func:`spdylay_data_source_read_callback` to indicate that data * transfer is postponed. See * :func:`spdylay_data_source_read_callback` for details. */ SPDYLAY_ERR_DEFERRED = -508, /** * Stream ID has reached the maximum value. Therefore no stream ID * is available. */ SPDYLAY_ERR_STREAM_ID_NOT_AVAILABLE = -509, /** * The stream is already closed; or the stream ID is invalid. */ SPDYLAY_ERR_STREAM_CLOSED = -510, /** * RST_STREAM has been added to the outbound queue. The stream is in * closing state. */ SPDYLAY_ERR_STREAM_CLOSING = -511, /** * The transmission is not allowed for this stream (e.g., a frame * with FLAG_FIN flag set has already sent). */ SPDYLAY_ERR_STREAM_SHUT_WR = -512, /** * The stream ID is invalid. */ SPDYLAY_ERR_INVALID_STREAM_ID = -513, /** * The state of the stream is not valid (e.g., SYN_REPLY cannot be * sent to the stream if SYN_REPLY has already been sent). */ SPDYLAY_ERR_INVALID_STREAM_STATE = -514, /** * Another DATA frame has already been deferred. */ SPDYLAY_ERR_DEFERRED_DATA_EXIST = -515, /** * SYN_STREAM is not allowed. (e.g., GOAWAY has been sent and/or * received. */ SPDYLAY_ERR_SYN_STREAM_NOT_ALLOWED = -516, /** * GOAWAY has already been sent. */ SPDYLAY_ERR_GOAWAY_ALREADY_SENT = -517, /** * The received frame contains the invalid header block. (e.g., * There are duplicate header names; or the header names are not * encoded in US-ASCII character set and not lower cased; or the * header name is zero-length string; or the header value contains * multiple in-sequence NUL bytes). */ SPDYLAY_ERR_INVALID_HEADER_BLOCK = -518, /** * Indicates that the context is not suitable to perform the * requested operation. */ SPDYLAY_ERR_INVALID_STATE = -519, /** * The gzip error. */ SPDYLAY_ERR_GZIP = -520, /** * The user callback function failed due to the temporal error. */ SPDYLAY_ERR_TEMPORAL_CALLBACK_FAILURE = -521, /** * The length of the frame is too large. */ SPDYLAY_ERR_FRAME_TOO_LARGE = -522, /** * The errors < :enum:`SPDYLAY_ERR_FATAL` mean that the library is * under unexpected condition and cannot process any further data * reliably (e.g., out of memory). */ SPDYLAY_ERR_FATAL = -900, /** * Out of memory. This is a fatal error. */ SPDYLAY_ERR_NOMEM = -901, /** * The user callback function failed. This is a fatal error. */ SPDYLAY_ERR_CALLBACK_FAILURE = -902 } spdylay_error; typedef enum { SPDYLAY_MSG_MORE } spdylay_io_flag; /** * @enum * The control frame types in SPDY protocol. */ typedef enum { /** * The SYN_STREAM control frame. */ SPDYLAY_SYN_STREAM = 1, /** * The SYN_REPLY control frame. */ SPDYLAY_SYN_REPLY = 2, /** * The RST_STREAM control frame. */ SPDYLAY_RST_STREAM = 3, /** * The SETTINGS control frame. */ SPDYLAY_SETTINGS = 4, /** * The NOOP control frame. This was deprecated in SPDY/3. */ SPDYLAY_NOOP = 5, /** * The PING control frame. */ SPDYLAY_PING = 6, /** * The GOAWAY control frame. */ SPDYLAY_GOAWAY = 7, /** * The HEADERS control frame. */ SPDYLAY_HEADERS = 8, /** * The WINDOW_UPDATE control frame. This first appeared in SPDY/3. */ SPDYLAY_WINDOW_UPDATE = 9, /** * The CREDENTIAL control frame. This first appeared in SPDY/3. */ SPDYLAY_CREDENTIAL = 10 } spdylay_frame_type; /** * @enum * * The flags for a control frame. */ typedef enum { /** * No flag set. */ SPDYLAY_CTRL_FLAG_NONE = 0, /** * FLAG_FIN flag. */ SPDYLAY_CTRL_FLAG_FIN = 0x1, /** * FLAG_UNIDIRECTIONAL flag. */ SPDYLAY_CTRL_FLAG_UNIDIRECTIONAL = 0x2 } spdylay_ctrl_flag; /** * @enum * The flags for a DATA frame. */ typedef enum { /** * No flag set. */ SPDYLAY_DATA_FLAG_NONE = 0, /** * FLAG_FIN flag. */ SPDYLAY_DATA_FLAG_FIN = 0x1 } spdylay_data_flag; /** * @enum * The flags for the SETTINGS control frame. */ typedef enum { /** * No flag set. */ SPDYLAY_FLAG_SETTINGS_NONE = 0, /** * SETTINGS_CLEAR_SETTINGS flag. */ SPDYLAY_FLAG_SETTINGS_CLEAR_SETTINGS = 1 } spdylay_settings_flag; /** * @enum * The flags for SETTINGS ID/value pair. */ typedef enum { /** * No flag set. */ SPDYLAY_ID_FLAG_SETTINGS_NONE = 0, /** * FLAG_SETTINGS_PERSIST_VALUE flag. */ SPDYLAY_ID_FLAG_SETTINGS_PERSIST_VALUE = 1, /** * FLAG_SETTINGS_PERSISTED flag. */ SPDYLAY_ID_FLAG_SETTINGS_PERSISTED = 2 } spdylay_settings_id_flag; /** * @enum * The SETTINGS ID. */ typedef enum { /** * SETTINGS_UPLOAD_BANDWIDTH */ SPDYLAY_SETTINGS_UPLOAD_BANDWIDTH = 1, /** * SETTINGS_DOWNLOAD_BANDWIDTH */ SPDYLAY_SETTINGS_DOWNLOAD_BANDWIDTH = 2, /** * SETTINGS_ROUND_TRIP_TIME */ SPDYLAY_SETTINGS_ROUND_TRIP_TIME = 3, /** * SETTINGS_MAX_CONCURRENT_STREAMS */ SPDYLAY_SETTINGS_MAX_CONCURRENT_STREAMS = 4, /** * SETTINGS_CURRENT_CWND */ SPDYLAY_SETTINGS_CURRENT_CWND = 5, /** * SETTINGS_DOWNLOAD_RETRANS_RATE */ SPDYLAY_SETTINGS_DOWNLOAD_RETRANS_RATE = 6, /** * SETTINGS_INITIAL_WINDOW_SIZE */ SPDYLAY_SETTINGS_INITIAL_WINDOW_SIZE = 7, /** * SETTINGS_CLIENT_CERTIFICATE_VECTOR_SIZE. This first appeared in * SPDY/3. */ SPDYLAY_SETTINGS_CLIENT_CERTIFICATE_VECTOR_SIZE = 8, /** * Maximum ID of :type:`spdylay_settings_id`. */ SPDYLAY_SETTINGS_MAX = 8 } spdylay_settings_id; /** * @macro * Default maximum concurrent streams. */ #define SPDYLAY_INITIAL_MAX_CONCURRENT_STREAMS 100 /** * @enum * The status codes for the RST_STREAM control frame. */ typedef enum { /** * SPDYLAY_OK is not valid status code for RST_STREAM. It is defined * just for spdylay library use. */ SPDYLAY_OK = 0, /** * PROTOCOL_ERROR */ SPDYLAY_PROTOCOL_ERROR = 1, /** * INVALID_STREAM */ SPDYLAY_INVALID_STREAM = 2, /** * REFUSED_STREAM */ SPDYLAY_REFUSED_STREAM = 3, /** * UNSUPPORTED_VERSION */ SPDYLAY_UNSUPPORTED_VERSION = 4, /** * CANCEL */ SPDYLAY_CANCEL = 5, /** * INTERNAL_ERROR */ SPDYLAY_INTERNAL_ERROR = 6, /** * FLOW_CONTROL_ERROR */ SPDYLAY_FLOW_CONTROL_ERROR = 7, /* Following status codes were introduced in SPDY/3 */ /** * STREAM_IN_USE */ SPDYLAY_STREAM_IN_USE = 8, /** * STREAM_ALREADY_CLOSED */ SPDYLAY_STREAM_ALREADY_CLOSED = 9, /** * INVALID_CREDENTIALS */ SPDYLAY_INVALID_CREDENTIALS = 10, /** * FRAME_TOO_LARGE */ SPDYLAY_FRAME_TOO_LARGE = 11 } spdylay_status_code; /** * @enum * The status codes for GOAWAY, introduced in SPDY/3. */ typedef enum { /** * OK. This indicates a normal session teardown. */ SPDYLAY_GOAWAY_OK = 0, /** * PROTOCOL_ERROR */ SPDYLAY_GOAWAY_PROTOCOL_ERROR = 1, /** * INTERNAL_ERROR */ SPDYLAY_GOAWAY_INTERNAL_ERROR = 11 } spdylay_goaway_status_code; /** * @struct * The control frame header. */ typedef struct { /** * SPDY protocol version. */ uint16_t version; /** * The type of this control frame. */ uint16_t type; /** * The control frame flags. */ uint8_t flags; /** * The length field of this control frame. */ int32_t length; } spdylay_ctrl_hd; /** * @struct * The SYN_STREAM control frame. It has the following members: */ typedef struct { /** * The control frame header. */ spdylay_ctrl_hd hd; /** * The stream ID. */ int32_t stream_id; /** * The associated-to-stream ID. 0 if this frame has no * associated-to-stream. */ int32_t assoc_stream_id; /** * The priority of this frame. 0 is the highest priority value. Use * `spdylay_session_get_pri_lowest()` to know the lowest priority * value. */ uint8_t pri; /** * The index in server's CREDENTIAL vector of the client certificate. * This was introduced in SPDY/3. */ uint8_t slot; /** * The name/value pairs. For i >= 0, ``nv[2*i]`` contains a pointer * to the name string and ``nv[2*i+1]`` contains a pointer to the * value string. The one beyond last value must be ``NULL``. That * is, if the |nv| contains N name/value pairs, ``nv[2*N]`` must be * ``NULL``. This member may be ``NULL``. */ char **nv; } spdylay_syn_stream; /** * @struct * The SYN_REPLY control frame. It has the following members: */ typedef struct { /** * The control frame header. */ spdylay_ctrl_hd hd; /** * The stream ID. */ int32_t stream_id; /** * The name/value pairs. For i >= 0, ``nv[2*i]`` contains a pointer * to the name string and ``nv[2*i+1]`` contains a pointer to the * value string. The one beyond last value must be ``NULL``. That * is, if the |nv| contains N name/value pairs, ``nv[2*N]`` must be * ``NULL``. This member may be ``NULL``. */ char **nv; } spdylay_syn_reply; /** * @struct * The HEADERS control frame. It has the following members: */ typedef struct { /** * The control frame header. */ spdylay_ctrl_hd hd; /** * The stream ID. */ int32_t stream_id; /** * The name/value pairs. For i >= 0, ``nv[2*i]`` contains a pointer * to the name string and ``nv[2*i+1]`` contains a pointer to the * value string. The one beyond last value must be ``NULL``. That * is, if the |nv| contains N name/value pairs, ``nv[2*N]`` must be * ``NULL``. This member may be ``NULL``. */ char **nv; } spdylay_headers; /** * @struct * The RST_STREAM control frame. It has the following members: */ typedef struct { /** * The control frame header. */ spdylay_ctrl_hd hd; /** * The stream ID. */ int32_t stream_id; /** * The status code. See :type:`spdylay_status_code`. */ uint32_t status_code; } spdylay_rst_stream; /** * @struct * The SETTINGS ID/Value pair. It has the following members: */ typedef struct { /** * The SETTINGS ID. See :type:`spdylay_settings_id`. */ int32_t settings_id; /** * The flags. See :type:`spdylay_settings_id_flag`. */ uint8_t flags; /** * The value of this entry. */ uint32_t value; } spdylay_settings_entry; /** * @struct * The SETTINGS control frame. It has the following members: */ typedef struct { /** * The control frame header. */ spdylay_ctrl_hd hd; /** * The number of SETTINGS ID/Value pairs in |iv|. */ size_t niv; /** * The pointer to the array of SETTINGS ID/Value pair. */ spdylay_settings_entry *iv; } spdylay_settings; /** * @struct * The PING control frame. It has the following members: */ typedef struct { /** * The control frame header. */ spdylay_ctrl_hd hd; /** * The unique ID. */ uint32_t unique_id; } spdylay_ping; /** * @struct * The GOAWAY control frame. It has the following members: */ typedef struct { /** * The control frame header. */ spdylay_ctrl_hd hd; /** * The last-good-stream ID. */ int32_t last_good_stream_id; /** * The status code. This first appeared in SPDY/3. See * :type:`spdylay_goaway_status_code`. */ uint32_t status_code; } spdylay_goaway; /** * @struct * * The WINDOW_UPDATE control frame. This first appeared in SPDY/3. It * has the following members: */ typedef struct { /** * The control frame header. */ spdylay_ctrl_hd hd; /** * The stream ID. */ int32_t stream_id; /** * The delta-window-size. */ int32_t delta_window_size; } spdylay_window_update; /** * @struct * * The structure to hold chunk of memory. */ typedef struct { /** * The pointer to the data. */ uint8_t *data; /** * The length of the data. */ size_t length; } spdylay_mem_chunk; /** * @struct * * The CREDENTIAL control frame. This first appeared in SPDY/3. It has * the following members: */ typedef struct { /** * The control frame header. */ spdylay_ctrl_hd hd; /** * The index in the client certificate vector. */ uint16_t slot; /** * Cryptographic proof that the client has possession of the private * key associated with the certificate. */ spdylay_mem_chunk proof; /** * The certificate chain. The certs[0] is the leaf certificate. */ spdylay_mem_chunk *certs; /** * The number of certificates in |certs|. */ size_t ncerts; } spdylay_credential; /** * @struct * * Convenient structure to inspect control frame header. It is useful * to get the frame type. */ typedef struct { /** * The control frame header. */ spdylay_ctrl_hd hd; } spdylay_ctrl_frame; /** * @union * * This union represents the some kind of data source passed to * :type:`spdylay_data_source_read_callback`. */ typedef union { /** * The integer field, suitable for a file descriptor. */ int fd; /** * The pointer to an arbitrary object. */ void *ptr; } spdylay_data_source; /** * @functypedef * * Callback function invoked when the library wants to read data from * the |source|. The read data is sent in the stream |stream_id|. The * implementation of this function must read at most |length| bytes of * data from |source| (or possibly other places) and store them in * |buf| and return number of data stored in |buf|. If EOF is reached, * set |*eof| to 1. If the application wants to postpone DATA frames, * (e.g., asynchronous I/O, or reading data blocks for long time), it * is achieved by returning :enum:`SPDYLAY_ERR_DEFERRED` without * reading any data in this invocation. The library removes DATA * frame from the outgoing queue temporarily. To move back deferred * DATA frame to outgoing queue, call `spdylay_session_resume_data()`. * In case of error, there are 2 choices. Returning * :enum:`SPDYLAY_ERR_TEMPORAL_CALLBACK_FAILURE` will close the stream * by issuing RST_STREAM with :enum:`SPDYLAY_INTERNAL_ERROR`. * Returning :enum:`SPDYLAY_ERR_CALLBACK_FAILURE` will signal the * entire session failure. */ typedef ssize_t (*spdylay_data_source_read_callback) (spdylay_session *session, int32_t stream_id, uint8_t *buf, size_t length, int *eof, spdylay_data_source *source, void *user_data); /** * @struct * * This struct represents the data source and the way to read a chunk * of data from it. */ typedef struct { /** * The data source. */ spdylay_data_source source; /** * The callback function to read a chunk of data from the |source|. */ spdylay_data_source_read_callback read_callback; } spdylay_data_provider; /** * @union * * This union includes all control frames to pass them * to various function calls as spdylay_frame type. */ typedef union { /** * Convenient structure to inspect control frame header. */ spdylay_ctrl_frame ctrl; /** * The SYN_STREAM control frame. */ spdylay_syn_stream syn_stream; /** * The SYN_REPLY control frame. */ spdylay_syn_reply syn_reply; /** * The RST_STREAM control frame. */ spdylay_rst_stream rst_stream; /** * The SETTINGS control frame. */ spdylay_settings settings; /** * The PING control frame. */ spdylay_ping ping; /** * The GOAWAY control frame. */ spdylay_goaway goaway; /** * The HEADERS control frame. */ spdylay_headers headers; /** * The WINDOW_UPDATE control frame. */ spdylay_window_update window_update; /** * The CREDENTIAL control frame. */ spdylay_credential credential; } spdylay_frame; /** * @functypedef * * Callback function invoked when |session| wants to send data to the * remote peer. The implementation of this function must send at most * |length| bytes of data stored in |data|. It must return the number * of bytes sent if it succeeds. If it cannot send any single byte * without blocking, it must return * :enum:`SPDYLAY_ERR_WOULDBLOCK`. For other errors, it must return * :enum:`SPDYLAY_ERR_CALLBACK_FAILURE`. */ typedef ssize_t (*spdylay_send_callback) (spdylay_session *session, const uint8_t *data, size_t length, int flags, void *user_data); /** * @functypedef * * Callback function invoked when |session| wants to receive data from * the remote peer. The implementation of this function must read at * most |length| bytes of data and store it in |buf|. It must return * the number of bytes written in |buf| if it succeeds. If it cannot * read any single byte without blocking, it must return * :enum:`SPDYLAY_ERR_WOULDBLOCK`. If it gets EOF before it reads any * single byte, it must return :enum:`SPDYLAY_ERR_EOF`. For other * errors, it must return :enum:`SPDYLAY_ERR_CALLBACK_FAILURE`. */ typedef ssize_t (*spdylay_recv_callback) (spdylay_session *session, uint8_t *buf, size_t length, int flags, void *user_data); /** * @functypedef * * Callback function invoked by `spdylay_session_recv()` when a * control frame is received. */ typedef void (*spdylay_on_ctrl_recv_callback) (spdylay_session *session, spdylay_frame_type type, spdylay_frame *frame, void *user_data); /** * @functypedef * * Callback function invoked by `spdylay_session_recv()` when an * invalid control frame is received. The |status_code| is one of the * :enum:`spdylay_status_code` and indicates the error. When this * callback function is invoked, the library automatically submits * either RST_STREAM or GOAWAY frame. */ typedef void (*spdylay_on_invalid_ctrl_recv_callback) (spdylay_session *session, spdylay_frame_type type, spdylay_frame *frame, uint32_t status_code, void *user_data); /** * @functypedef * * Callback function invoked when a chunk of data in DATA frame is * received. The |stream_id| is the stream ID this DATA frame belongs * to. The |flags| is the flags of DATA frame which this data chunk is * contained. ``(flags & SPDYLAY_DATA_FLAG_FIN) != 0`` does not * necessarily mean this chunk of data is the last one in the * stream. You should use :type:`spdylay_on_data_recv_callback` to * know all data frames are received. */ typedef void (*spdylay_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); /** * @functypedef * * Callback function invoked when DATA frame is received. The actual * data it contains are received by * :type:`spdylay_on_data_chunk_recv_callback`. */ typedef void (*spdylay_on_data_recv_callback) (spdylay_session *session, uint8_t flags, int32_t stream_id, int32_t length, void *user_data); /** * @functypedef * * Callback function invoked before the control frame |frame| of type * |type| is sent. This may be useful, for example, to know the stream * ID of SYN_STREAM frame (see also * `spdylay_session_get_stream_user_data()`), which is not assigned * when it was queued. */ typedef void (*spdylay_before_ctrl_send_callback) (spdylay_session *session, spdylay_frame_type type, spdylay_frame *frame, void *user_data); /** * @functypedef * * Callback function invoked after the control frame |frame| of type * |type| is sent. */ typedef void (*spdylay_on_ctrl_send_callback) (spdylay_session *session, spdylay_frame_type type, spdylay_frame *frame, void *user_data); /** * @functypedef * * Callback function invoked after the control frame |frame| of type * |type| is not sent because of the error. The error is indicated by * the |error_code|, which is one of the values defined in * :type:`spdylay_error`. */ typedef void (*spdylay_on_ctrl_not_send_callback) (spdylay_session *session, spdylay_frame_type type, spdylay_frame *frame, int error_code, void *user_data); /** * @functypedef * * Callback function invoked after DATA frame is sent. */ typedef void (*spdylay_on_data_send_callback) (spdylay_session *session, uint8_t flags, int32_t stream_id, int32_t length, void *user_data); /** * @functypedef * * Callback function invoked when the stream |stream_id| is * closed. The reason of closure is indicated by the * |status_code|. The stream_user_data, which was specified in * `spdylay_submit_request()` or `spdylay_submit_syn_stream()`, is * still available in this function. */ typedef void (*spdylay_on_stream_close_callback) (spdylay_session *session, int32_t stream_id, spdylay_status_code status_code, void *user_data); /** * @functypedef * * Callback function invoked when the request from the remote peer is * received. In other words, the frame with FIN flag set is received. * In HTTP, this means HTTP request, including request body, is fully * received. */ typedef void (*spdylay_on_request_recv_callback) (spdylay_session *session, int32_t stream_id, void *user_data); /** * @functypedef * * Callback function invoked when the received control frame octets * could not be parsed correctly. The |type| indicates the type of * received control frame. The |head| is the pointer to the header of * the received frame. The |headlen| is the length of the * |head|. According to the SPDY spec, the |headlen| is always 8. In * other words, the |head| is the first 8 bytes of the received frame. * The |payload| is the pointer to the data portion of the received * frame. The |payloadlen| is the length of the |payload|. This is * the data after the length field. The |error_code| is one of the * error code defined in :enum:`spdylay_error` and indicates the * error. */ typedef void (*spdylay_on_ctrl_recv_parse_error_callback) (spdylay_session *session, spdylay_frame_type type, const uint8_t *head, size_t headlen, const uint8_t *payload, size_t payloadlen, int error_code, void *user_data); /** * @functypedef * * Callback function invoked when the received control frame type is * unknown. The |head| is the pointer to the header of the received * frame. The |headlen| is the length of the |head|. According to the * SPDY spec, the |headlen| is always 8. In other words, the |head| is * the first 8 bytes of the received frame. The |payload| is the * pointer to the data portion of the received frame. The * |payloadlen| is the length of the |payload|. This is the data after * the length field. */ typedef void (*spdylay_on_unknown_ctrl_recv_callback) (spdylay_session *session, const uint8_t *head, size_t headlen, const uint8_t *payload, size_t payloadlen, void *user_data); #define SPDYLAY_MAX_SCHEME 255 #define SPDYLAY_MAX_HOSTNAME 255 struct spdylay_origin; /** * @struct * * The Web origin structure. The origin is the tuple (scheme, host, * port). The details of this structure is intentionally hidden. To * access these members, use accessor functions below. */ typedef struct spdylay_origin spdylay_origin; /** * @function * * Returns the scheme member of the |origin|. */ const char* spdylay_origin_get_scheme(const spdylay_origin *origin); /** * @function * * Returns the host member of the |origin|. */ const char* spdylay_origin_get_host(const spdylay_origin *origin); /** * @function * * Returns the port member of the |origin|. */ uint16_t spdylay_origin_get_port(const spdylay_origin *origin); /** * @functypedef * * Callback function invoked when the library needs the cryptographic * proof that the client has possession of the private key associated * with the certificate for the given |origin|. If called with * |prooflen| == 0, the implementation of this function must return * the length of the proof in bytes. If called with |prooflen| > 0, * write proof into |proof| exactly |prooflen| bytes and return 0. * * Because the client certificate vector has limited number of slots, * the application code may be required to pass the same proof more * than once. */ typedef ssize_t (*spdylay_get_credential_proof) (spdylay_session *session, const spdylay_origin *origin, uint8_t *proof, size_t prooflen, void *user_data); /** * @functypedef * * Callback function invoked when the library needs the length of the * client certificate chain for the given |origin|. The * implementation of this function must return the length of the * client certificate chain. If no client certificate is required for * the given |origin|, return 0. If positive integer is returned, * :type:`spdylay_get_credential_proof` and * :type:`spdylay_get_credential_cert` callback functions will be used * to get the cryptographic proof and certificate respectively. */ typedef ssize_t (*spdylay_get_credential_ncerts) (spdylay_session *session, const spdylay_origin *origin, void *user_data); /** * @functypedef * * Callback function invoked when the library needs the client * certificate for the given |origin|. The |idx| is the index of the * certificate chain and 0 means the leaf certificate of the chain. * If called with |certlen| == 0, the implementation of this function * must return the length of the certificate in bytes. If called with * |certlen| > 0, write certificate into |cert| exactly |certlen| * bytes and return 0. */ typedef ssize_t (*spdylay_get_credential_cert) (spdylay_session *session, const spdylay_origin *origin, size_t idx, uint8_t *cert, size_t certlen, void *user_data); /** * @struct * * Callback functions. */ typedef struct { /** * Callback function invoked when the |session| wants to send data * to the remote peer. */ spdylay_send_callback send_callback; /** * Callback function invoked when the |session| wants to receive * data from the remote peer. */ spdylay_recv_callback recv_callback; /** * Callback function invoked by `spdylay_session_recv()` when a * control frame is received. */ spdylay_on_ctrl_recv_callback on_ctrl_recv_callback; /** * Callback function invoked by `spdylay_session_recv()` when an * invalid control frame is received. */ spdylay_on_invalid_ctrl_recv_callback on_invalid_ctrl_recv_callback; /** * Callback function invoked when a chunk of data in DATA frame is * received. */ spdylay_on_data_chunk_recv_callback on_data_chunk_recv_callback; /** * Callback function invoked when DATA frame is received. */ spdylay_on_data_recv_callback on_data_recv_callback; /** * Callback function invoked before the control frame is sent. */ spdylay_before_ctrl_send_callback before_ctrl_send_callback; /** * Callback function invoked after the control frame is sent. */ spdylay_on_ctrl_send_callback on_ctrl_send_callback; /** * The callback function invoked when a control frame is not sent * because of an error. */ spdylay_on_ctrl_not_send_callback on_ctrl_not_send_callback; /** * Callback function invoked after DATA frame is sent. */ spdylay_on_data_send_callback on_data_send_callback; /** * Callback function invoked when the stream is closed. */ spdylay_on_stream_close_callback on_stream_close_callback; /** * Callback function invoked when request from the remote peer is * received. */ spdylay_on_request_recv_callback on_request_recv_callback; /** * Callback function invoked when the library needs the * cryptographic proof that the client has possession of the private * key associated with the certificate. */ spdylay_get_credential_proof get_credential_proof; /** * Callback function invoked when the library needs the length of the * client certificate chain. */ spdylay_get_credential_ncerts get_credential_ncerts; /** * Callback function invoked when the library needs the client * certificate. */ spdylay_get_credential_cert get_credential_cert; /** * Callback function invoked when the received control frame octets * could not be parsed correctly. */ spdylay_on_ctrl_recv_parse_error_callback on_ctrl_recv_parse_error_callback; /** * Callback function invoked when the received control frame type is * unknown. */ spdylay_on_unknown_ctrl_recv_callback on_unknown_ctrl_recv_callback; } spdylay_session_callbacks; /** * @function * * Initializes |*session_ptr| for client use, using the protocol * version |version|. The all members of |callbacks| are copied to * |*session_ptr|. Therefore |*session_ptr| does not store * |callbacks|. |user_data| is an arbitrary user supplied data, which * will be passed to the callback functions. * * The :member:`spdylay_session_callbacks.send_callback` must be * specified. If the application code uses `spdylay_session_recv()`, * the :member:`spdylay_session_callbacks.recv_callback` must be * specified. The other members of |callbacks| can be ``NULL``. To * use CREDENTIAL frame, specify :macro:`SPDYLAY_PROTO_SPDY3` in * |version| and specify * :member:`spdylay_session_callbacks.get_credential_ncerts`, * :member:`spdylay_session_callbacks.get_credential_cert` and * :member:`spdylay_session_callbacks.get_credential_proof`. See also * `spdylay_session_set_initial_client_cert_origin()`. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. * :enum:`SPDYLAY_ERR_ZLIB` * The z_stream initialization failed. * :enum:`SPDYLAY_ERR_UNSUPPORTED_VERSION` * The version is not supported. */ int spdylay_session_client_new(spdylay_session **session_ptr, uint16_t version, const spdylay_session_callbacks *callbacks, void *user_data); /** * @function * * Initializes |*session_ptr| for server use, using the protocol * version |version|. The all members of |callbacks| are copied to * |*session_ptr|. Therefore |*session_ptr| does not store * |callbacks|. |user_data| is an arbitrary user supplied data, which * will be passed to the callback functions. * * The :member:`spdylay_session_callbacks.send_callback` must be * specified. If the application code uses `spdylay_session_recv()`, * the :member:`spdylay_session_callbacks.recv_callback` must be * specified. The other members of |callbacks| can be ``NULL``. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. * :enum:`SPDYLAY_ERR_ZLIB` * The z_stream initialization failed. * :enum:`SPDYLAY_ERR_UNSUPPORTED_VERSION` * The version is not supported. */ int spdylay_session_server_new(spdylay_session **session_ptr, uint16_t version, const spdylay_session_callbacks *callbacks, void *user_data); /** * @function * * Frees any resources allocated for |session|. If |session| is * ``NULL``, this function does nothing. */ void spdylay_session_del(spdylay_session *session); /** * @enum * * Configuration options for :type:`spdylay_session`. */ typedef enum { /** * This option prevents the library from sending WINDOW_UPDATE * automatically. If this option is set, the application is * responsible for sending WINDOW_UPDATE using * `spdylay_submit_window_update`. */ SPDYLAY_OPT_NO_AUTO_WINDOW_UPDATE = 1, /** * This option sets maximum receive buffer size for incoming control * frame. */ SPDYLAY_OPT_MAX_RECV_CTRL_FRAME_BUFFER = 2 } spdylay_opt; /** * @function * * Sets the configuration option for the |session|. The |optname| is * one of :type:`spdylay_opt`. The |optval| is the pointer to the * option value and the |optlen| is the size of |*optval|. The * required type of |optval| varies depending on the |optname|. See * below. * * The following |optname| are supported: * * :enum:`SPDYLAY_OPT_NO_AUTO_WINDOW_UPDATE` * The |optval| must be a pointer to ``int``. If the |*optval| is * nonzero, the library will not send WINDOW_UPDATE automatically. * Therefore, the application is responsible for sending * WINDOW_UPDATE using `spdylay_submit_window_update`. This option * defaults to 0. * * :enum:`SPDYLAY_OPT_MAX_RECV_CTRL_FRAME_BUFFER` * The |optval| must be a pointer to ``uint32_t``. The |*optval| * must be in the range [(1 << 13), (1 << 24)-1], inclusive. This * option defaults to (1 << 24)-1. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_INVALID_ARGUMENT` * The |optname| is not supported; or the |optval| and/or the * |optlen| are invalid. */ int spdylay_session_set_option(spdylay_session *session, int optname, void *optval, size_t optlen); /** * @function * * Sets the origin tuple (|scheme|, |host| and |port|) that the * connection is made to and the client certificate is sent in the * first TLS handshake. This function must be called before any call * of `spdylay_session_send()` and `spdylay_session_recv()` and be * called only once per session. This function must not be called if * the |session| is initialized for server use. If the client did not * provide the client certificate in the first TLS handshake, this * function must not be called. * * This function stores the given origin at the slot 1 in the client * certificate vector. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory * :enum:`SPDYLAY_ERR_INVALID_STATE` * The |session| is initialized for server use; or the client * certificate vector size is 0. */ int spdylay_session_set_initial_client_cert_origin(spdylay_session *session, const char *scheme, const char *host, uint16_t port); /** * @function * * Returns the origin at the index |slot| in the client certificate * vector. If there is no origin at the given |slot|, this function * returns ``NULL``. * * This function must not be called if the |session| is initialized * for server use. */ const spdylay_origin* spdylay_session_get_client_cert_origin (spdylay_session *session, size_t slot); /** * @function * * Sends pending frames to the remote peer. * * This function retrieves the highest prioritized frame from the * outbound queue and sends it to the remote peer. It does this as * many as possible until the user callback * :member:`spdylay_session_callbacks.send_callback` returns * :enum:`SPDYLAY_ERR_WOULDBLOCK` or the outbound queue becomes empty. * This function calls several callback functions which are passed * when initializing the |session|. Here is the simple time chart * which tells when each callback is invoked: * * 1. Get the next frame to send from outbound queue. * 2. Prepare transmission of the frame. * 3. If the control frame cannot be sent because some preconditions * are not met (e.g., SYN_STREAM cannot be sent after GOAWAY), * :member:`spdylay_session_callbacks.on_ctrl_not_send_callback` is * invoked. Abort the following steps. * 4. If the frame is SYN_STREAM, the stream is opened here. * If the |session| is initialized for client use and the protocol * version is :macro:`SPDYLAY_PROTO_SPDY3` and the library needs * the client certificate for the origin, * :member:`spdylay_session_callbacks.get_credential_ncerts` is * invoked. If the result is more than zero, * :member:`spdylay_session_callbacks.get_credential_proof` and * :member:`spdylay_session_callbacks.get_credential_cert` are also * invoked. * 5. :member:`spdylay_session_callbacks.before_ctrl_send_callback` is * invoked. * 6. :member:`spdylay_session_callbacks.send_callback` is invoked one * or more times to send the frame. * 7. If the frame is a control frame, * :member:`spdylay_session_callbacks.on_ctrl_send_callback` is * invoked. * 8. If the frame is a DATA frame, * :member:`spdylay_session_callbacks.on_data_send_callback` is * invoked. * 9. If the transmission of the frame triggers closure of the stream, * the stream is closed and * :member:`spdylay_session_callbacks.on_stream_close_callback` is * invoked. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. * :enum:`SPDYLAY_ERR_CALLBACK_FAILURE` * The callback function failed. */ int spdylay_session_send(spdylay_session *session); /** * @function * * Receives frames from the remote peer. * * This function receives as many frames as possible until the user * callback :member:`spdylay_session_callbacks.recv_callback` returns * :enum:`SPDYLAY_ERR_WOULDBLOCK`. This function calls several * callback functions which are passed when initializing the * |session|. Here is the simple time chart which tells when each * callback is invoked: * * 1. :member:`spdylay_session_callbacks.recv_callback` is invoked one * or more times to receive frame header. * 2. If the frame is DATA frame: * * 2.1. :member:`spdylay_session_callbacks.recv_callback` is invoked * to receive DATA payload. For each chunk of data, * :member:`spdylay_session_callbacks.on_data_chunk_recv_callback` * is invoked. * 2.2. If one DATA frame is completely received, * :member:`spdylay_session_callbacks.on_data_recv_callback` is * invoked. If the frame is the final frame of the request, * :member:`spdylay_session_callbacks.on_request_recv_callback` * is invoked. If the reception of the frame triggers the * closure of the stream, * :member:`spdylay_session_callbacks.on_stream_close_callback` * is invoked. * * 3. If the frame is the control frame: * * 3.1. :member:`spdylay_session_callbacks.recv_callback` is invoked * one or more times to receive whole frame. * 3.2. If the received frame is valid, * :member:`spdylay_session_callbacks.on_ctrl_recv_callback` is * invoked. If the frame is the final frame of the request, * :member:`spdylay_session_callbacks.on_request_recv_callback` * is invoked. If the reception of the frame triggers the * closure of the stream, * :member:`spdylay_session_callbacks.on_stream_close_callback` * is invoked. * 3.3. If the received frame is unpacked but is interpreted as * invalid, * :member:`spdylay_session_callbacks.on_invalid_ctrl_recv_callback` * is invoked. * 3.4. If the received frame could not be unpacked correctly, * :member:`spdylay_session_callbacks.on_ctrl_recv_parse_error_callback` * is invoked. * 3.5. If the received frame type is unknown, * :member:`spdylay_session_callbacks.on_unknown_ctrl_recv_callback` * is invoked. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_EOF` * The remote peer did shutdown on the connection. * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. * :enum:`SPDYLAY_ERR_CALLBACK_FAILURE` * The callback function failed. */ int spdylay_session_recv(spdylay_session *session); /** * @function * * Processes data |in| as an input from the remote endpoint. The * |inlen| indicates the number of bytes in the |in|. * * This function behaves like `spdylay_session_recv()` except that it * does not use :member:`spdylay_session_callbacks.recv_callback` to * receive data; the |in| is the only data for the invocation of this * function. If all bytes are processed, this function returns. The * other callbacks are called in the same way as they are in * `spdylay_session_recv()`. * * In the current implementation, this function always tries to * processes all input data unless an error occurs. * * This function returns the number of processed bytes, or one of the * following negative error codes: * * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. */ ssize_t spdylay_session_mem_recv(spdylay_session *session, const uint8_t *in, size_t inlen); /** * @function * * Puts back previously deferred DATA frame in the stream |stream_id| * to the outbound queue. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_INVALID_ARGUMENT` * The stream does not exist or no deferred data exist. * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. */ int spdylay_session_resume_data(spdylay_session *session, int32_t stream_id); /** * @function * * Returns nonzero value if |session| wants to receive data from the * remote peer. * * If both `spdylay_session_want_read()` and * `spdylay_session_want_write()` return 0, the application should * drop the connection. */ int spdylay_session_want_read(spdylay_session *session); /** * @function * * Returns nonzero value if |session| wants to send data to the remote * peer. * * If both `spdylay_session_want_read()` and * `spdylay_session_want_write()` return 0, the application should * drop the connection. */ int spdylay_session_want_write(spdylay_session *session); /** * @function * * Returns stream_user_data for the stream |stream_id|. The * stream_user_data is provided by `spdylay_submit_request()` or * `spdylay_submit_syn_stream()`. If the stream is initiated by the * remote endpoint, stream_user_data is always ``NULL``. If the stream * is initiated by the local endpoint and ``NULL`` is given in * `spdylay_submit_request()` or `spdylay_submit_syn_stream()`, then * this function returns ``NULL``. If the stream does not exist, this * function returns ``NULL``. */ void* spdylay_session_get_stream_user_data(spdylay_session *session, int32_t stream_id); /** * @function * * Returns the number of frames in the outbound queue. This does not * include the deferred DATA frames. */ size_t spdylay_session_get_outbound_queue_size(spdylay_session *session); /** * @function * * Returns lowest priority value for the |session|. */ uint8_t spdylay_session_get_pri_lowest(spdylay_session *session); /** * @function * * Submits GOAWAY frame. The status code |status_code| is ignored if * the protocol version is :macro:`SPDYLAY_PROTO_SPDY2`. * * This function should be called when the connection should be * terminated after sending GOAWAY. If the remaining streams should be * processed after GOAWAY, use `spdylay_submit_goaway()` instead. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. */ int spdylay_session_fail_session(spdylay_session *session, uint32_t status_code); /** * @function * * Returns string describing the |error_code|. The |error_code| must * be one of the :enum:`spdylay_error`. */ const char* spdylay_strerror(int error_code); /** * @function * * Submits SYN_STREAM frame and optionally one or more DATA * frames. * * The |pri| is priority of this request. 0 is the highest priority * value. Use `spdylay_session_get_pri_lowest()` to know the lowest * priority value for this |session|. * * The |nv| contains the name/value pairs. For i >= 0, ``nv[2*i]`` * contains a pointer to the name string and ``nv[2*i+1]`` contains a * pointer to the value string. The one beyond last value must be * ``NULL``. That is, if the |nv| contains N name/value pairs, * ``nv[2*N]`` must be ``NULL``. * * The |nv| must include following name/value pairs: * * ``:method`` * HTTP method (e.g., ``GET``, ``POST``, ``HEAD``, etc) * ``:scheme`` * URI scheme (e.g., ``https``) * ``:path`` * Absolute path and parameters of this request (e.g., ``/foo``, * ``/foo;bar;haz?h=j&y=123``) * ``:version`` * HTTP version (e.g., ``HTTP/1.1``) * ``:host`` * The hostport portion of the URI for this request (e.g., * ``example.org:443``). This is the same as the HTTP "Host" header * field. * * If the |session| is initialized with the version * :macro:`SPDYLAY_PROTO_SPDY2`, the above names are translated to * ``method``, ``scheme``, ``url``, ``version`` and ``host`` * respectively. * * This function creates copies of all name/value pairs in |nv|. It * also lower-cases all names in |nv|. * * If |data_prd| is not ``NULL``, it provides data which will be sent * in subsequent DATA frames. In this case, a method that allows * request message bodies * (http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9) must * be specified with ``:method`` key in |nv| (e.g. ``POST``). This * function does not take ownership of the |data_prd|. The function * copies the members of the |data_prd|. If |data_prd| is ``NULL``, * SYN_STREAM have FLAG_FIN set. The |stream_user_data| is data * associated to the stream opened by this request and can be an * arbitrary pointer, which can be retrieved later by * `spdylay_session_get_stream_user_data()`. * * Since the library reorders the frames and tries to send the highest * prioritized one first and the SPDY specification requires the * stream ID must be strictly increasing, the stream ID of this * request cannot be known until it is about to sent. To know the * stream ID of the request, the application can use * :member:`spdylay_session_callbacks.before_ctrl_send_callback`. This * callback is called just before the frame is sent. For SYN_STREAM * frame, the argument frame has the stream ID assigned. Also since * the stream is already opened, * `spdylay_session_get_stream_user_data()` can be used to get * |stream_user_data| to identify which SYN_STREAM we are processing. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_INVALID_ARGUMENT` * The |pri| is invalid; or the |nv| includes empty name or NULL * value. * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. */ int spdylay_submit_request(spdylay_session *session, uint8_t pri, const char **nv, const spdylay_data_provider *data_prd, void *stream_user_data); /** * @function * * Submits SYN_REPLY frame and optionally one or more DATA frames * against the stream |stream_id|. * * The |nv| contains the name/value pairs. For i >= 0, ``nv[2*i]`` * contains a pointer to the name string and ``nv[2*i+1]`` contains a * pointer to the value string. The one beyond last value must be * ``NULL``. That is, if the |nv| contains N name/value pairs, * ``nv[2*N]`` must be ``NULL``. * * The |nv| must include following name/value pairs: * * ``:status`` * HTTP status code (e.g., ``200`` or ``200 OK``) * ``:version`` * HTTP response version (e.g., ``HTTP/1.1``) * * If the |session| is initialized with the version * :macro:`SPDYLAY_PROTO_SPDY2`, the above names are translated to * ``status`` and ``version`` respectively. * * This function creates copies of all name/value pairs in |nv|. It * also lower-cases all names in |nv|. * * If |data_prd| is not ``NULL``, it provides data which will be sent * in subsequent DATA frames. This function does not take ownership * of the |data_prd|. The function copies the members of the * |data_prd|. If |data_prd| is ``NULL``, SYN_REPLY will have * FLAG_FIN set. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_INVALID_ARGUMENT` * The |nv| includes empty name or NULL value. * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. */ int spdylay_submit_response(spdylay_session *session, int32_t stream_id, const char **nv, const spdylay_data_provider *data_prd); /** * @function * * Submits SYN_STREAM frame. The |flags| is bitwise OR of the * following values: * * * :enum:`SPDYLAY_CTRL_FLAG_FIN` * * :enum:`SPDYLAY_CTRL_FLAG_UNIDIRECTIONAL` * * If |flags| includes :enum:`SPDYLAY_CTRL_FLAG_FIN`, this frame has * FLAG_FIN flag set. * * The |assoc_stream_id| is used for server-push. Specify 0 if this * stream is not server-push. If |session| is initialized for client * use, |assoc_stream_id| is ignored. * * The |pri| is priority of this request. 0 is the highest priority * value. Use `spdylay_session_get_pri_lowest()` to know the lowest * priority value for this |session|. * * The |nv| contains the name/value pairs. For i >= 0, ``nv[2*i]`` * contains a pointer to the name string and ``nv[2*i+1]`` contains a * pointer to the value string. The one beyond last value must be * ``NULL``. That is, if the |nv| contains N name/value pairs, * ``nv[2*N]`` must be ``NULL``. * * This function creates copies of all name/value pairs in |nv|. It * also lower-cases all names in |nv|. * * The |stream_user_data| is a pointer to an arbitrary * data which is associated to the stream this frame will open. * * This function is low-level in a sense that the application code can * specify flags and the Associated-To-Stream-ID directly. For usual * HTTP request, `spdylay_submit_request()` is useful. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_INVALID_ARGUMENT` * The |pri| is invalid; or the |assoc_stream_id| is invalid; or * the |nv| includes empty name or NULL value. * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. */ int spdylay_submit_syn_stream(spdylay_session *session, uint8_t flags, int32_t assoc_stream_id, uint8_t pri, const char **nv, void *stream_user_data); /** * @function * * Submits SYN_REPLY frame. The |flags| is bitwise OR of the following * values: * * * :enum:`SPDYLAY_CTRL_FLAG_FIN` * * If |flags| includes :enum:`SPDYLAY_CTRL_FLAG_FIN`, this frame has * FLAG_FIN flag set. * * The stream which this frame belongs to is given in the * |stream_id|. The |nv| is the name/value pairs in this frame. * * The |nv| contains the name/value pairs. For i >= 0, ``nv[2*i]`` * contains a pointer to the name string and ``nv[2*i+1]`` contains a * pointer to the value string. The one beyond last value must be * ``NULL``. That is, if the |nv| contains N name/value pairs, * ``nv[2*N]`` must be ``NULL``. * * This function creates copies of all name/value pairs in |nv|. It * also lower-cases all names in |nv|. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_INVALID_ARGUMENT` * The |nv| includes empty name or NULL value. * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. */ int spdylay_submit_syn_reply(spdylay_session *session, uint8_t flags, int32_t stream_id, const char **nv); /** * @function * * Submits HEADERS frame. The |flags| is bitwise OR of the following * values: * * * :enum:`SPDYLAY_CTRL_FLAG_FIN` * * If |flags| includes :enum:`SPDYLAY_CTRL_FLAG_FIN`, this frame has * FLAG_FIN flag set. * * The stream which this frame belongs to is given in the * |stream_id|. The |nv| is the name/value pairs in this frame. * * The |nv| contains the name/value pairs. For i >= 0, ``nv[2*i]`` * contains a pointer to the name string and ``nv[2*i+1]`` contains a * pointer to the value string. The one beyond last value must be * ``NULL``. That is, if the |nv| contains N name/value pairs, * ``nv[2*N]`` must be ``NULL``. * * This function creates copies of all name/value pairs in |nv|. It * also lower-cases all names in |nv|. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_INVALID_ARGUMENT` * The |nv| includes empty name or NULL value. * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. */ int spdylay_submit_headers(spdylay_session *session, uint8_t flags, int32_t stream_id, const char **nv); /** * @function * * Submits one or more DATA frames to the stream |stream_id|. The * data to be sent are provided by |data_prd|. If |flags| contains * :enum:`SPDYLAY_DATA_FLAG_FIN`, the last DATA frame has FLAG_FIN * set. * * This function does not take ownership of the |data_prd|. The * function copies the members of the |data_prd|. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. */ int spdylay_submit_data(spdylay_session *session, int32_t stream_id, uint8_t flags, const spdylay_data_provider *data_prd); /** * @function * * Submits RST_STREAM frame to cancel/reject the stream |stream_id| * with the status code |status_code|. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. */ int spdylay_submit_rst_stream(spdylay_session *session, int32_t stream_id, uint32_t status_code); /** * @function * * Submits PING frame. You don't have to send PING back when you * received PING frame. The library automatically submits PING frame * in this case. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. */ int spdylay_submit_ping(spdylay_session *session); /** * @function * * Submits GOAWAY frame. The status code |status_code| is ignored if * the protocol version is :macro:`SPDYLAY_PROTO_SPDY2`. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. */ int spdylay_submit_goaway(spdylay_session *session, uint32_t status_code); /** * @function * * Stores local settings and submits SETTINGS frame. The |iv| is the * pointer to the array of :type:`spdylay_settings_entry`. The |niv| * indicates the number of :type:`spdylay_settings_entry`. The |flags| * is bitwise-OR of one or more values from * :type:`spdylay_settings_flag`. * * This function does not take ownership of the |iv|. This function * copies all the elements in the |iv|. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_INVALID_ARGUMENT` * The |iv| contains duplicate settings ID or invalid value. * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. */ int spdylay_submit_settings(spdylay_session *session, uint8_t flags, const spdylay_settings_entry *iv, size_t niv); /** * @function * * Submits WINDOW_UPDATE frame. The effective range of the * |delta_window_size| is [1, (1 << 31)-1], inclusive. But the * application must be responsible to keep the resulting window size * <= (1 << 31)-1. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_INVALID_ARGUMENT` * The |delta_window_size| is 0 or negative. * :enum:`SPDYLAY_ERR_STREAM_CLOSED` * The stream is already closed or does not exist. * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. */ int spdylay_submit_window_update(spdylay_session *session, int32_t stream_id, int32_t delta_window_size); /** * @function * * A helper function for dealing with NPN in client side. The |in| * contains server's protocol in preferable order. The format of |in| * is length-prefixed and not null-terminated. For example, * ``spdy/2`` and ``http/1.1`` stored in |in| like this:: * * in[0] = 6 * in[1..6] = "spdy/2" * in[7] = 8 * in[8..15] = "http/1.1" * inlen = 16 * * The selection algorithm is as follows: * * 1. If server's list contains SPDY versions the spdylay library * supports, this function selects one of them and returns its SPDY * protocol version which can be used directly with * `spdylay_session_client_new()` and * `spdylay_session_server_new()` . The following steps are not * taken. * * 2. If server's list contains ``http/1.1``, this function selects * ``http/1.1`` and returns 0. The following step is not taken. * * 3. This function selects nothing and returns -1. (So called * non-overlap case). In this case, |out| and |outlen| are left * untouched. * * When spdylay supports updated version of SPDY in the future, this * function may select updated protocol and application code which * relies on spdylay for SPDY stuff needs not be modified. * * Selecting ``spdy/2`` means that ``spdy/2`` is written into |*out| * and length of ``spdy/2`` (which is 6) is assigned to |*outlen|. * * See http://technotes.googlecode.com/git/nextprotoneg.html for more * details about NPN. * * To use this method you should do something like:: * * static int select_next_proto_cb(SSL* ssl, * unsigned char **out, * unsigned char *outlen, * const unsigned char *in, * unsigned int inlen, * void *arg) * { * int version; * version = spdylay_select_next_protocol(out, outlen, in, inlen); * if(version > 0) { * ((MyType*)arg)->spdy_version = version; * } * return SSL_TLSEXT_ERR_OK; * } * ... * SSL_CTX_set_next_proto_select_cb(ssl_ctx, select_next_proto_cb, my_obj); */ int spdylay_select_next_protocol(unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen); /** * @struct * * This struct contains SPDY version information this library * supports. */ typedef struct { /** * SPDY protocol version name which can be used as TLS NPN protocol * string. */ const unsigned char *proto; /** * The length of proto member. */ uint8_t len; /** * The corresponding SPDY version constant which can be passed to * `spdylay_session_client_new()` and `spdylay_session_server_new()` * as version argument. */ uint16_t version; } spdylay_npn_proto; /** * @function * * Returns a pointer to the supported SPDY version list. The number of * elements in the list will be assigned to the |*len_ptr|. It * contains all SPDY version information this library supports. The * application can use this information to configure NPN protocol * offerings/selection. */ const spdylay_npn_proto* spdylay_npn_get_proto_list(size_t *len_ptr); /** * @function * * Returns spdy version which spdylay library supports from the given * protocol name. The |proto| is the pointer to the protocol name and * |protolen| is its length. Currently, ``spdy/2`` and ``spdy/3`` are * supported. * * This function returns nonzero spdy version if it succeeds, or 0. */ uint16_t spdylay_npn_get_version(const unsigned char *proto, size_t protolen); struct spdylay_gzip; /** * @struct * * The gzip stream to inflate data. The details of this structure are * intentionally hidden from the public API. */ typedef struct spdylay_gzip spdylay_gzip; /** * @function * * A helper function to set up a per request gzip stream to inflate data. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_GZIP` * The initialization of gzip stream failed. * :enum:`SPDYLAY_ERR_NOMEM` * Out of memory. */ int spdylay_gzip_inflate_new(spdylay_gzip **inflater_ptr); /** * @function * * Frees the inflate stream. The |inflater| may be ``NULL``. */ void spdylay_gzip_inflate_del(spdylay_gzip *inflater); /** * @function * * Inflates data in |in| with the length |*inlen_ptr| and stores the * inflated data to |out| which has allocated size at least * |*outlen_ptr|. On return, |*outlen_ptr| is updated to represent * the number of data written in |out|. Similarly, |*inlen_ptr| is * updated to represent the number of input bytes processed. * * This function returns 0 if it succeeds, or one of the following * negative error codes: * * :enum:`SPDYLAY_ERR_GZIP` * The inflation of gzip stream failed. * * The example follows:: * * 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) * { * ... * req = spdylay_session_get_stream_user_data(session, stream_id); * spdylay_gzip *inflater = 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(inflater, out, &outlen, data, &tlen); * if(rv != 0) { * spdylay_submit_rst_stream(session, stream_id, * SPDYLAY_INTERNAL_ERROR); * break; * } * ... Do stuff ... * data += tlen; * len -= tlen; * } * .... * } */ int spdylay_gzip_inflate(spdylay_gzip *inflater, uint8_t *out, size_t *outlen_ptr, const uint8_t *in, size_t *inlen_ptr); #ifdef __cplusplus } #endif #endif /* SPDYLAY_H */