2012-01-17 18:10:22 +01:00
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
|
2012-01-18 13:36:29 +01:00
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
2012-01-17 18:10:22 +01:00
|
|
|
#include <stdlib.h>
|
2012-01-19 17:04:13 +01:00
|
|
|
#include <stdint.h>
|
2012-01-31 02:11:14 +01:00
|
|
|
#include <sys/types.h>
|
2012-01-17 18:10:22 +01:00
|
|
|
|
2012-02-07 13:19:23 +01:00
|
|
|
#include <spdylay/spdylayver.h>
|
|
|
|
|
2012-01-26 17:17:40 +01:00
|
|
|
struct spdylay_session;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @struct
|
|
|
|
*
|
|
|
|
* The primary structure to hold the resources needed for a SPDY
|
2012-03-15 14:39:26 +01:00
|
|
|
* session. The details of this structure are intentionally hidden
|
|
|
|
* from the public API.
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-01-26 17:17:40 +01:00
|
|
|
typedef struct spdylay_session spdylay_session;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
2012-03-27 11:23:05 +02:00
|
|
|
* @enum
|
2012-03-13 16:32:52 +01:00
|
|
|
*
|
2012-03-27 11:23:05 +02:00
|
|
|
* The SPDY protocol version.
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-03-27 11:23:05 +02:00
|
|
|
typedef enum {
|
|
|
|
/**
|
|
|
|
* SPDY protocol version 2
|
|
|
|
*/
|
|
|
|
SPDYLAY_PROTO_SPDY2 = 2,
|
|
|
|
/**
|
|
|
|
* SPDY protocol version 3
|
|
|
|
*/
|
|
|
|
SPDYLAY_PROTO_SPDY3 = 3
|
|
|
|
} spdylay_proto_version;
|
2012-01-27 10:28:29 +01:00
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @enum
|
|
|
|
*
|
|
|
|
* Error codes used in the Spdylay library. The following values are
|
|
|
|
* defined:
|
|
|
|
*/
|
2012-01-24 14:02:24 +01:00
|
|
|
typedef enum {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* Invalid argument passed.
|
|
|
|
*/
|
2012-01-24 14:02:24 +01:00
|
|
|
SPDYLAY_ERR_INVALID_ARGUMENT = -501,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* Zlib error.
|
|
|
|
*/
|
2012-02-18 13:55:40 +01:00
|
|
|
SPDYLAY_ERR_ZLIB = -502,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The specified protocol version is not supported.
|
|
|
|
*/
|
2012-02-24 17:17:03 +01:00
|
|
|
SPDYLAY_ERR_UNSUPPORTED_VERSION = -503,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* Used as a return value from :type:`spdylay_send_callback` and
|
|
|
|
* :type:`spdylay_recv_callback` to indicate that the operation
|
|
|
|
* would block.
|
|
|
|
*/
|
2012-01-24 14:02:24 +01:00
|
|
|
SPDYLAY_ERR_WOULDBLOCK = -504,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* General protocol error
|
|
|
|
*/
|
2012-01-24 14:02:24 +01:00
|
|
|
SPDYLAY_ERR_PROTO = -505,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The frame is invalid.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
SPDYLAY_ERR_INVALID_FRAME = -506,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The peer performed a shutdown on the connection.
|
|
|
|
*/
|
2012-01-29 08:46:18 +01:00
|
|
|
SPDYLAY_ERR_EOF = -507,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2012-02-19 15:42:25 +01:00
|
|
|
SPDYLAY_ERR_DEFERRED = -508,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
2012-03-15 14:39:26 +01:00
|
|
|
* Stream ID has reached the maximum value. Therefore no stream ID
|
|
|
|
* is available.
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-03-07 16:18:18 +01:00
|
|
|
SPDYLAY_ERR_STREAM_ID_NOT_AVAILABLE = -509,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The stream is already closed; or the stream ID is invalid.
|
|
|
|
*/
|
2012-03-07 16:37:18 +01:00
|
|
|
SPDYLAY_ERR_STREAM_CLOSED = -510,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
2012-03-15 14:39:26 +01:00
|
|
|
* RST_STREAM has been added to the outbound queue. The stream is in
|
2012-03-13 16:32:52 +01:00
|
|
|
* closing state.
|
|
|
|
*/
|
2012-03-07 16:18:18 +01:00
|
|
|
SPDYLAY_ERR_STREAM_CLOSING = -511,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The transmission is not allowed for this stream (e.g., a frame
|
2012-03-15 14:39:26 +01:00
|
|
|
* with FLAG_FIN flag set has already sent).
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-03-07 16:18:18 +01:00
|
|
|
SPDYLAY_ERR_STREAM_SHUT_WR = -512,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The stream ID is invalid.
|
|
|
|
*/
|
2012-03-07 16:18:18 +01:00
|
|
|
SPDYLAY_ERR_INVALID_STREAM_ID = -513,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The state of the stream is not valid (e.g., SYN_REPLY cannot be
|
2012-03-15 14:39:26 +01:00
|
|
|
* sent to the stream if SYN_REPLY has already been sent).
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-03-07 16:18:18 +01:00
|
|
|
SPDYLAY_ERR_INVALID_STREAM_STATE = -514,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* Another DATA frame has already been deferred.
|
|
|
|
*/
|
2012-03-07 16:18:18 +01:00
|
|
|
SPDYLAY_ERR_DEFERRED_DATA_EXIST = -515,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* SYN_STREAM is not allowed. (e.g., GOAWAY has been sent and/or
|
|
|
|
* received.
|
|
|
|
*/
|
2012-03-07 16:18:18 +01:00
|
|
|
SPDYLAY_ERR_SYN_STREAM_NOT_ALLOWED = -516,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
2012-03-15 14:39:26 +01:00
|
|
|
* GOAWAY has already been sent.
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-03-07 16:18:18 +01:00
|
|
|
SPDYLAY_ERR_GOAWAY_ALREADY_SENT = -517,
|
2012-03-26 16:19:58 +02:00
|
|
|
/**
|
|
|
|
* 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,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The errors < :enum:`SPDYLAY_ERR_FATAL` mean that the library is
|
2012-03-15 14:39:26 +01:00
|
|
|
* under unexpected condition and cannot process any further data
|
|
|
|
* reliably (e.g., out of memory).
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-01-25 15:46:07 +01:00
|
|
|
SPDYLAY_ERR_FATAL = -900,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* Out of memory. This is a fatal error.
|
|
|
|
*/
|
2012-01-25 15:46:07 +01:00
|
|
|
SPDYLAY_ERR_NOMEM = -901,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The user callback function failed. This is a fatal error.
|
|
|
|
*/
|
2012-03-22 18:17:48 +01:00
|
|
|
SPDYLAY_ERR_CALLBACK_FAILURE = -902
|
2012-01-24 14:02:24 +01:00
|
|
|
} spdylay_error;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
SPDYLAY_MSG_MORE
|
|
|
|
} spdylay_io_flag;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @enum
|
2012-03-29 16:59:51 +02:00
|
|
|
* The control frame types in SPDY protocol.
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
typedef enum {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The SYN_STREAM control frame.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
SPDYLAY_SYN_STREAM = 1,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The SYN_REPLY control frame.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
SPDYLAY_SYN_REPLY = 2,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The RST_STREAM control frame.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
SPDYLAY_RST_STREAM = 3,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The SETTINGS control frame.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
SPDYLAY_SETTINGS = 4,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
2012-03-15 14:39:26 +01:00
|
|
|
* The NOOP control frame. This was deprecated in SPDY/3.
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
SPDYLAY_NOOP = 5,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The PING control frame.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
SPDYLAY_PING = 6,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The GOAWAY control frame.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
SPDYLAY_GOAWAY = 7,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The HEADERS control frame.
|
|
|
|
*/
|
2012-01-27 10:21:14 +01:00
|
|
|
SPDYLAY_HEADERS = 8,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
2012-03-15 14:39:26 +01:00
|
|
|
* The WINDOW_UPDATE control frame. This first appeared in SPDY/3.
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-03-29 16:59:51 +02:00
|
|
|
SPDYLAY_WINDOW_UPDATE = 9
|
2012-01-25 13:31:28 +01:00
|
|
|
} spdylay_frame_type;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @enum
|
|
|
|
*
|
|
|
|
* The flags for a control frame.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
typedef enum {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* No flag set.
|
|
|
|
*/
|
2012-02-24 13:40:13 +01:00
|
|
|
SPDYLAY_CTRL_FLAG_NONE = 0,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* FLAG_FIN flag.
|
|
|
|
*/
|
2012-02-24 13:40:13 +01:00
|
|
|
SPDYLAY_CTRL_FLAG_FIN = 0x1,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* FLAG_UNIDIRECTIONAL flag.
|
|
|
|
*/
|
2012-02-24 13:40:13 +01:00
|
|
|
SPDYLAY_CTRL_FLAG_UNIDIRECTIONAL = 0x2
|
|
|
|
} spdylay_ctrl_flag;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @enum
|
|
|
|
* The flags for a DATA frame.
|
|
|
|
*/
|
2012-02-24 13:40:13 +01:00
|
|
|
typedef enum {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* No flag set.
|
|
|
|
*/
|
2012-02-24 13:40:13 +01:00
|
|
|
SPDYLAY_DATA_FLAG_NONE = 0,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* FLAG_FIN flag.
|
|
|
|
*/
|
2012-02-24 13:40:13 +01:00
|
|
|
SPDYLAY_DATA_FLAG_FIN = 0x1
|
|
|
|
} spdylay_data_flag;
|
2012-01-25 13:31:28 +01:00
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @enum
|
|
|
|
* The flags for the SETTINGS control frame.
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
typedef enum {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* No flag set.
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
SPDYLAY_FLAG_SETTINGS_NONE = 0,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* SETTINGS_CLEAR_SETTINGS flag.
|
|
|
|
*/
|
2012-03-09 13:34:50 +01:00
|
|
|
SPDYLAY_FLAG_SETTINGS_CLEAR_SETTINGS = 1
|
2012-01-31 16:26:26 +01:00
|
|
|
} spdylay_settings_flag;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @enum
|
|
|
|
* The flags for SETTINGS ID/value pair.
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
typedef enum {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* No flag set.
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
SPDYLAY_ID_FLAG_SETTINGS_NONE = 0,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* FLAG_SETTINGS_PERSIST_VALUE flag.
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
SPDYLAY_ID_FLAG_SETTINGS_PERSIST_VALUE = 1,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* FLAG_SETTINGS_PERSISTED flag.
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
SPDYLAY_ID_FLAG_SETTINGS_PERSISTED = 2
|
|
|
|
} spdylay_settings_id_flag;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @enum
|
|
|
|
* The SETTINGS ID.
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
typedef enum {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* SETTINGS_UPLOAD_BANDWIDTH
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
SPDYLAY_SETTINGS_UPLOAD_BANDWIDTH = 1,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* SETTINGS_DOWNLOAD_BANDWIDTH
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
SPDYLAY_SETTINGS_DOWNLOAD_BANDWIDTH = 2,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* SETTINGS_ROUND_TRIP_TIME
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
SPDYLAY_SETTINGS_ROUND_TRIP_TIME = 3,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* SETTINGS_MAX_CONCURRENT_STREAMS
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
SPDYLAY_SETTINGS_MAX_CONCURRENT_STREAMS = 4,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* SETTINGS_CURRENT_CWND
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
SPDYLAY_SETTINGS_CURRENT_CWND = 5,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* SETTINGS_DOWNLOAD_RETRANS_RATE
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
SPDYLAY_SETTINGS_DOWNLOAD_RETRANS_RATE = 6,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* SETTINGS_INITIAL_WINDOW_SIZE
|
|
|
|
*/
|
2012-03-09 13:34:50 +01:00
|
|
|
SPDYLAY_SETTINGS_INITIAL_WINDOW_SIZE = 7,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
2012-03-15 14:39:26 +01:00
|
|
|
* SETTINGS_CLIENT_CERTIFICATE_VECTOR_SIZE. This first appeared in
|
|
|
|
* SPDY/3.
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-03-09 13:34:50 +01:00
|
|
|
SPDYLAY_SETTINGS_CLIENT_CERTIFICATE_VECTOR_SIZE = 8
|
2012-01-31 16:26:26 +01:00
|
|
|
} spdylay_settings_id;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @macro
|
|
|
|
* Maximum ID of :type:`spdylay_settings_id`.
|
|
|
|
*/
|
2012-03-09 13:34:50 +01:00
|
|
|
#define SPDYLAY_SETTINGS_MAX 8
|
2012-02-05 16:14:19 +01:00
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @macro
|
|
|
|
* Default maximum concurrent streams.
|
|
|
|
*/
|
2012-03-10 10:49:25 +01:00
|
|
|
#define SPDYLAY_INITIAL_MAX_CONCURRENT_STREAMS 100
|
2012-02-05 16:14:19 +01:00
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @enum
|
2012-03-15 14:39:26 +01:00
|
|
|
* The status codes for the RST_STREAM control frame.
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
typedef enum {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* SPDYLAY_OK is not valid status code for RST_STREAM. It is defined
|
|
|
|
* just for spdylay library use.
|
|
|
|
*/
|
2012-01-29 15:00:33 +01:00
|
|
|
SPDYLAY_OK = 0,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* PROTOCOL_ERROR
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
SPDYLAY_PROTOCOL_ERROR = 1,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* INVALID_STREAM
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
SPDYLAY_INVALID_STREAM = 2,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* REFUSED_STREAM
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
SPDYLAY_REFUSED_STREAM = 3,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* UNSUPPORTED_VERSION
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
SPDYLAY_UNSUPPORTED_VERSION = 4,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* CANCEL
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
SPDYLAY_CANCEL = 5,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* INTERNAL_ERROR
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
SPDYLAY_INTERNAL_ERROR = 6,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* FLOW_CONTROL_ERROR
|
|
|
|
*/
|
2012-02-26 08:26:38 +01:00
|
|
|
SPDYLAY_FLOW_CONTROL_ERROR = 7,
|
|
|
|
/* Following status codes were introduced in SPDY/3 */
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* STREAM_IN_USE
|
|
|
|
*/
|
2012-02-26 08:26:38 +01:00
|
|
|
SPDYLAY_STREAM_IN_USE = 8,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* STREAM_ALREADY_CLOSED
|
|
|
|
*/
|
2012-02-26 08:26:38 +01:00
|
|
|
SPDYLAY_STREAM_ALREADY_CLOSED = 9,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* SPDYLAY_INVALID_CREDENTIALS
|
|
|
|
*/
|
2012-02-26 08:26:38 +01:00
|
|
|
SPDYLAY_INVALID_CREDENTIALS = 10,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* FRAME_TOO_LARGE
|
|
|
|
*/
|
2012-02-26 08:26:38 +01:00
|
|
|
FRAME_TOO_LARGE = 11
|
2012-01-25 13:31:28 +01:00
|
|
|
} spdylay_status_code;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @enum
|
2012-03-15 14:39:26 +01:00
|
|
|
* The status codes for GOAWAY, introduced in SPDY/3.
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-02-26 08:26:38 +01:00
|
|
|
typedef enum {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* OK. This indicates a normal session teardown.
|
|
|
|
*/
|
2012-02-26 08:26:38 +01:00
|
|
|
SPDYLAY_GOAWAY_OK = 0,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* PROTOCOL_ERROR
|
|
|
|
*/
|
2012-02-26 08:26:38 +01:00
|
|
|
SPDYLAY_GOAWAY_PROTOCOL_ERROR = 1,
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* INTERNAL_ERROR
|
|
|
|
*/
|
2012-02-26 08:26:38 +01:00
|
|
|
SPDYLAY_GOAWAY_INTERNAL_ERROR = 11
|
|
|
|
} spdylay_goaway_status_code;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @struct
|
|
|
|
* The control frame header.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
typedef struct {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* SPDY protocol version.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
uint16_t version;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The type of this control frame.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
uint16_t type;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The control frame flags.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
uint8_t flags;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The length field of this control frame.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
int32_t length;
|
|
|
|
} spdylay_ctrl_hd;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @struct
|
|
|
|
* The SYN_STREAM control frame. It has the following members:
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
typedef struct {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The control frame header.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
spdylay_ctrl_hd hd;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The stream ID.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
int32_t stream_id;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The associated-to-stream ID. 0 if this frame has no
|
|
|
|
* associated-to-stream.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
int32_t assoc_stream_id;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
2012-03-26 16:35:20 +02:00
|
|
|
* The priority of this frame. 0 is the highest priority value. Use
|
|
|
|
* `spdylay_session_get_pri_lowest()` to know the lowest priority
|
|
|
|
* value.
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
uint8_t pri;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The index in server's CREDENTIAL vector of the client certificate.
|
|
|
|
* This was introduced in SPDY/3.
|
|
|
|
*/
|
2012-02-24 15:33:06 +01:00
|
|
|
uint8_t slot;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* 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``.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
char **nv;
|
|
|
|
} spdylay_syn_stream;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @struct
|
|
|
|
* The SYN_REPLY control frame. It has the following members:
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
typedef struct {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The control frame header.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
spdylay_ctrl_hd hd;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The stream ID.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
int32_t stream_id;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* 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``.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
char **nv;
|
|
|
|
} spdylay_syn_reply;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @struct
|
|
|
|
* The HEADERS control frame. It has the following members:
|
|
|
|
*/
|
2012-01-27 10:21:14 +01:00
|
|
|
typedef struct {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The control frame header.
|
|
|
|
*/
|
2012-01-27 10:21:14 +01:00
|
|
|
spdylay_ctrl_hd hd;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The stream ID.
|
|
|
|
*/
|
2012-01-27 10:21:14 +01:00
|
|
|
int32_t stream_id;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* 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``.
|
|
|
|
*/
|
2012-01-27 10:21:14 +01:00
|
|
|
char **nv;
|
|
|
|
} spdylay_headers;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @struct
|
|
|
|
* The RST_STREAM control frame. It has the following members:
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
typedef struct {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The control frame header.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
spdylay_ctrl_hd hd;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The stream ID.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
int32_t stream_id;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The status code. See :type:`spdylay_status_code`.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
uint32_t status_code;
|
|
|
|
} spdylay_rst_stream;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @struct
|
|
|
|
* The SETTINGS ID/Value pair. It has the following members:
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
typedef struct {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The SETTINGS ID. See :type:`spdylay_settings_id`.
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
int32_t settings_id;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The flags. See :type:`spdylay_settings_id_flag`.
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
uint8_t flags;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The value of this entry.
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
uint32_t value;
|
|
|
|
} spdylay_settings_entry;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @struct
|
|
|
|
* The SETTINGS control frame. It has the following members:
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
typedef struct {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The control frame header.
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
spdylay_ctrl_hd hd;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The number of SETTINGS ID/Value pairs in |iv|.
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
size_t niv;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The pointer to the array of SETTINGS ID/Value pair.
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
spdylay_settings_entry *iv;
|
|
|
|
} spdylay_settings;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @struct
|
|
|
|
* The PING control frame. It has the following members:
|
|
|
|
*/
|
2012-01-27 11:35:05 +01:00
|
|
|
typedef struct {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The control frame header.
|
|
|
|
*/
|
2012-01-27 11:35:05 +01:00
|
|
|
spdylay_ctrl_hd hd;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The unique ID.
|
|
|
|
*/
|
2012-01-27 11:35:05 +01:00
|
|
|
uint32_t unique_id;
|
|
|
|
} spdylay_ping;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @struct
|
|
|
|
* The GOAWAY control frame. It has the following members:
|
|
|
|
*/
|
2012-01-28 11:22:38 +01:00
|
|
|
typedef struct {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The control frame header.
|
|
|
|
*/
|
2012-01-28 11:22:38 +01:00
|
|
|
spdylay_ctrl_hd hd;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The last-good-stream ID.
|
|
|
|
*/
|
2012-01-28 11:22:38 +01:00
|
|
|
int32_t last_good_stream_id;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
2012-03-15 14:39:26 +01:00
|
|
|
* The status code. This first appeared in SPDY/3. See
|
2012-03-13 16:32:52 +01:00
|
|
|
* :type:`spdylay_goaway_status_code`.
|
|
|
|
*/
|
2012-01-28 11:22:38 +01:00
|
|
|
uint32_t status_code;
|
|
|
|
} spdylay_goaway;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @struct
|
|
|
|
*
|
2012-03-15 14:39:26 +01:00
|
|
|
* The WINDOW_UPDATE control frame. This first appeared in SPDY/3. It
|
2012-03-13 16:32:52 +01:00
|
|
|
* has the following members:
|
|
|
|
*/
|
2012-02-24 17:47:37 +01:00
|
|
|
typedef struct {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The control frame header.
|
|
|
|
*/
|
2012-02-24 17:47:37 +01:00
|
|
|
spdylay_ctrl_hd hd;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The stream ID.
|
|
|
|
*/
|
2012-02-24 17:47:37 +01:00
|
|
|
int32_t stream_id;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The delta-window-size.
|
|
|
|
*/
|
2012-02-24 17:47:37 +01:00
|
|
|
int32_t delta_window_size;
|
|
|
|
} spdylay_window_update;
|
|
|
|
|
2012-03-29 16:59:51 +02:00
|
|
|
/**
|
|
|
|
* @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;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @union
|
|
|
|
*
|
|
|
|
* This union represents the some kind of data source passed to
|
|
|
|
* :type:`spdylay_data_source_read_callback`.
|
|
|
|
*/
|
2012-01-26 17:17:40 +01:00
|
|
|
typedef union {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The integer field, suitable for a file descriptor.
|
|
|
|
*/
|
2012-01-26 17:17:40 +01:00
|
|
|
int fd;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The pointer to an arbitrary object.
|
|
|
|
*/
|
2012-01-26 17:17:40 +01:00
|
|
|
void *ptr;
|
|
|
|
} spdylay_data_source;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @functypedef
|
|
|
|
*
|
2012-02-08 15:51:52 +01:00
|
|
|
* Callback function invoked when the library wants to read data from
|
2012-03-15 14:39:26 +01:00
|
|
|
* the |source|. The read data is sent in the stream |stream_id|. The
|
2012-02-19 15:48:39 +01:00
|
|
|
* 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
|
2012-03-13 16:32:52 +01:00
|
|
|
* 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, return :enum:`SPDYLAY_ERR_CALLBACK_FAILURE`,
|
|
|
|
* which leads to session failure.
|
2012-02-08 15:51:52 +01:00
|
|
|
*/
|
2012-01-26 17:17:40 +01:00
|
|
|
typedef ssize_t (*spdylay_data_source_read_callback)
|
2012-02-19 15:48:39 +01:00
|
|
|
(spdylay_session *session, int32_t stream_id,
|
|
|
|
uint8_t *buf, size_t length, int *eof,
|
2012-01-26 17:17:40 +01:00
|
|
|
spdylay_data_source *source, void *user_data);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @struct
|
|
|
|
*
|
|
|
|
* This struct represents the data source and the way to read a chunk
|
|
|
|
* of data from it.
|
|
|
|
*/
|
2012-01-26 17:17:40 +01:00
|
|
|
typedef struct {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The data source.
|
|
|
|
*/
|
2012-01-26 17:17:40 +01:00
|
|
|
spdylay_data_source source;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
2012-03-15 14:39:26 +01:00
|
|
|
* The callback function to read a chunk of data from the |source|.
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-01-26 17:17:40 +01:00
|
|
|
spdylay_data_source_read_callback read_callback;
|
|
|
|
} spdylay_data_provider;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @union
|
|
|
|
*
|
2012-03-29 16:59:51 +02:00
|
|
|
* This union includes all control frames to pass them
|
2012-03-13 16:32:52 +01:00
|
|
|
* to various function calls as spdylay_frame type.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
typedef union {
|
2012-03-29 16:59:51 +02:00
|
|
|
/**
|
|
|
|
* Convenient structure to inspect control frame header.
|
|
|
|
*/
|
2012-03-29 17:07:27 +02:00
|
|
|
spdylay_ctrl_frame ctrl;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The SYN_STREAM control frame.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
spdylay_syn_stream syn_stream;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The SYN_REPLY control frame.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
spdylay_syn_reply syn_reply;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The RST_STREAM control frame.
|
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
spdylay_rst_stream rst_stream;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The SETTINGS control frame.
|
|
|
|
*/
|
2012-01-31 16:26:26 +01:00
|
|
|
spdylay_settings settings;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The PING control frame.
|
|
|
|
*/
|
2012-01-27 11:35:05 +01:00
|
|
|
spdylay_ping ping;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The GOAWAY control frame.
|
|
|
|
*/
|
2012-01-28 11:22:38 +01:00
|
|
|
spdylay_goaway goaway;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The HEADERS control frame.
|
|
|
|
*/
|
2012-01-27 10:21:14 +01:00
|
|
|
spdylay_headers headers;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The WINDOW_UPDATE control frame.
|
|
|
|
*/
|
2012-02-24 17:47:37 +01:00
|
|
|
spdylay_window_update window_update;
|
2012-01-25 13:31:28 +01:00
|
|
|
} spdylay_frame;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @functypedef
|
|
|
|
*
|
|
|
|
* Callback function invoked when |session| wants to send data to the
|
2012-01-29 09:06:26 +01:00
|
|
|
* 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
|
2012-03-13 16:32:52 +01:00
|
|
|
* without blocking, it must return
|
|
|
|
* :enum:`SPDYLAY_ERR_WOULDBLOCK`. For other errors, it must return
|
|
|
|
* :enum:`SPDYLAY_ERR_CALLBACK_FAILURE`.
|
2012-01-29 09:06:26 +01:00
|
|
|
*/
|
2012-01-24 14:02:24 +01:00
|
|
|
typedef ssize_t (*spdylay_send_callback)
|
2012-01-24 14:56:26 +01:00
|
|
|
(spdylay_session *session,
|
|
|
|
const uint8_t *data, size_t length, int flags, void *user_data);
|
2012-01-24 14:02:24 +01:00
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @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`.
|
2012-01-29 08:46:18 +01:00
|
|
|
*/
|
2012-01-24 14:02:24 +01:00
|
|
|
typedef ssize_t (*spdylay_recv_callback)
|
2012-01-24 14:56:26 +01:00
|
|
|
(spdylay_session *session,
|
|
|
|
uint8_t *buf, size_t length, int flags, void *user_data);
|
2012-01-24 14:02:24 +01:00
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @functypedef
|
|
|
|
*
|
|
|
|
* Callback function invoked by `spdylay_session_recv()` when a
|
2012-03-15 14:39:26 +01:00
|
|
|
* control frame is received.
|
2012-01-25 13:31:28 +01:00
|
|
|
*/
|
|
|
|
typedef void (*spdylay_on_ctrl_recv_callback)
|
|
|
|
(spdylay_session *session, spdylay_frame_type type, spdylay_frame *frame,
|
|
|
|
void *user_data);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @functypedef
|
|
|
|
*
|
|
|
|
* Callback function invoked by `spdylay_session_recv()` when an
|
2012-03-15 14:39:26 +01:00
|
|
|
* invalid control frame is received. When this callback function is
|
2012-03-13 16:32:52 +01:00
|
|
|
* invoked, either RST_STREAM or GOAWAY will be sent.
|
2012-01-25 13:31:28 +01:00
|
|
|
*/
|
|
|
|
typedef void (*spdylay_on_invalid_ctrl_recv_callback)
|
|
|
|
(spdylay_session *session, spdylay_frame_type type, spdylay_frame *frame,
|
|
|
|
void *user_data);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @functypedef
|
|
|
|
*
|
|
|
|
* Callback function invoked when a chunk of data in DATA frame is
|
2012-03-15 14:39:26 +01:00
|
|
|
* 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
|
2012-03-13 16:32:52 +01:00
|
|
|
* stream. You should use :type:`spdylay_on_data_recv_callback` to
|
|
|
|
* know all data frames are received.
|
2012-01-27 19:54:53 +01:00
|
|
|
*/
|
|
|
|
typedef void (*spdylay_on_data_chunk_recv_callback)
|
2012-01-27 20:20:19 +01:00
|
|
|
(spdylay_session *session, uint8_t flags, int32_t stream_id,
|
2012-01-27 19:54:53 +01:00
|
|
|
const uint8_t *data, size_t len, void *user_data);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @functypedef
|
|
|
|
*
|
2012-01-27 19:54:53 +01:00
|
|
|
* Callback function invoked when DATA frame is received. The actual
|
2012-03-13 16:32:52 +01:00
|
|
|
* data it contains are received by
|
|
|
|
* :type:`spdylay_on_data_chunk_recv_callback`.
|
2012-01-27 19:54:53 +01:00
|
|
|
*/
|
|
|
|
typedef void (*spdylay_on_data_recv_callback)
|
2012-01-27 20:20:19 +01:00
|
|
|
(spdylay_session *session, uint8_t flags, int32_t stream_id, int32_t length,
|
2012-01-27 19:54:53 +01:00
|
|
|
void *user_data);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @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.
|
2012-01-27 20:28:39 +01:00
|
|
|
*/
|
|
|
|
typedef void (*spdylay_on_ctrl_send_callback)
|
|
|
|
(spdylay_session *session, spdylay_frame_type type, spdylay_frame *frame,
|
|
|
|
void *user_data);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @functypedef
|
|
|
|
*
|
2012-03-07 16:18:18 +01:00
|
|
|
* Callback function invoked after the control frame |frame| of type
|
|
|
|
* |type| is not sent because of the error. The error is indicated by
|
2012-03-13 16:32:52 +01:00
|
|
|
* the |error|, which is one of the values defined in
|
|
|
|
* :type:`spdylay_error`.
|
2012-03-07 16:18:18 +01:00
|
|
|
*/
|
|
|
|
typedef void (*spdylay_on_ctrl_not_send_callback)
|
|
|
|
(spdylay_session *session, spdylay_frame_type type, spdylay_frame *frame,
|
|
|
|
int error, void *user_data);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @functypedef
|
|
|
|
*
|
2012-01-27 20:28:39 +01:00
|
|
|
* 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);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @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.
|
2012-01-29 15:00:33 +01:00
|
|
|
*/
|
|
|
|
typedef void (*spdylay_on_stream_close_callback)
|
|
|
|
(spdylay_session *session, int32_t stream_id, spdylay_status_code status_code,
|
|
|
|
void *user_data);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @functypedef
|
|
|
|
*
|
2012-03-15 14:39:26 +01:00
|
|
|
* Callback function invoked when the request from the remote peer is
|
2012-03-13 16:32:52 +01:00
|
|
|
* received. In other words, the frame with FIN flag set is received.
|
|
|
|
* In HTTP, this means HTTP request, including request body, is fully
|
2012-02-07 16:10:23 +01:00
|
|
|
* received.
|
|
|
|
*/
|
|
|
|
typedef void (*spdylay_on_request_recv_callback)
|
|
|
|
(spdylay_session *session, int32_t stream_id, void *user_data);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @struct
|
|
|
|
*
|
|
|
|
* Callback functions.
|
|
|
|
*/
|
2012-01-24 14:02:24 +01:00
|
|
|
typedef struct {
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
2012-03-15 14:39:26 +01:00
|
|
|
* Callback function invoked when the |session| wants to send data
|
|
|
|
* to the remote peer.
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-01-24 14:02:24 +01:00
|
|
|
spdylay_send_callback send_callback;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
2012-03-15 14:39:26 +01:00
|
|
|
* Callback function invoked when the |session| wants to receive
|
|
|
|
* data from the remote peer.
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-01-24 14:02:24 +01:00
|
|
|
spdylay_recv_callback recv_callback;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* Callback function invoked by `spdylay_session_recv()` when a
|
2012-03-15 14:39:26 +01:00
|
|
|
* control frame is received.
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
spdylay_on_ctrl_recv_callback on_ctrl_recv_callback;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* Callback function invoked by `spdylay_session_recv()` when an
|
2012-03-15 14:39:26 +01:00
|
|
|
* invalid control frame is received.
|
2012-03-13 16:32:52 +01:00
|
|
|
*/
|
2012-01-25 13:31:28 +01:00
|
|
|
spdylay_on_invalid_ctrl_recv_callback on_invalid_ctrl_recv_callback;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* Callback function invoked when a chunk of data in DATA frame is
|
|
|
|
* received.
|
|
|
|
*/
|
2012-01-27 19:54:53 +01:00
|
|
|
spdylay_on_data_chunk_recv_callback on_data_chunk_recv_callback;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* Callback function invoked when DATA frame is received.
|
|
|
|
*/
|
2012-01-27 19:54:53 +01:00
|
|
|
spdylay_on_data_recv_callback on_data_recv_callback;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* Callback function invoked before the control frame is sent.
|
|
|
|
*/
|
2012-01-28 09:25:14 +01:00
|
|
|
spdylay_before_ctrl_send_callback before_ctrl_send_callback;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* Callback function invoked after the control frame is sent.
|
|
|
|
*/
|
2012-01-27 20:28:39 +01:00
|
|
|
spdylay_on_ctrl_send_callback on_ctrl_send_callback;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* The callback function invoked when a control frame is not sent
|
|
|
|
* because of an error.
|
|
|
|
*/
|
2012-03-07 16:18:18 +01:00
|
|
|
spdylay_on_ctrl_not_send_callback on_ctrl_not_send_callback;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* Callback function invoked after DATA frame is sent.
|
|
|
|
*/
|
2012-01-27 20:28:39 +01:00
|
|
|
spdylay_on_data_send_callback on_data_send_callback;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* Callback function invoked when the stream is closed.
|
|
|
|
*/
|
2012-01-29 15:00:33 +01:00
|
|
|
spdylay_on_stream_close_callback on_stream_close_callback;
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* Callback function invoked when request from the remote peer is
|
|
|
|
* received.
|
|
|
|
*/
|
2012-02-07 16:10:23 +01:00
|
|
|
spdylay_on_request_recv_callback on_request_recv_callback;
|
2012-01-24 14:02:24 +01:00
|
|
|
} spdylay_session_callbacks;
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
2012-02-25 16:12:32 +01:00
|
|
|
* 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.
|
2012-02-23 14:49:08 +01:00
|
|
|
*
|
2012-03-18 16:47:15 +01:00
|
|
|
* 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``.
|
2012-03-13 16:36:53 +01:00
|
|
|
*
|
2012-02-23 14:49:08 +01:00
|
|
|
* This function returns 0 if it succeeds, or one of the following
|
|
|
|
* negative error codes:
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_NOMEM`
|
2012-02-23 14:49:08 +01:00
|
|
|
* Out of memory.
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_ZLIB`
|
2012-02-24 17:17:03 +01:00
|
|
|
* The z_stream initialization failed.
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_UNSUPPORTED_VERSION`
|
2012-02-24 17:17:03 +01:00
|
|
|
* The version is not supported.
|
2012-01-29 09:06:26 +01:00
|
|
|
*/
|
2012-01-24 14:56:26 +01:00
|
|
|
int spdylay_session_client_new(spdylay_session **session_ptr,
|
2012-02-25 16:12:32 +01:00
|
|
|
uint16_t version,
|
2012-01-24 14:56:26 +01:00
|
|
|
const spdylay_session_callbacks *callbacks,
|
2012-02-01 16:19:31 +01:00
|
|
|
void *user_data);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
2012-02-25 16:12:32 +01:00
|
|
|
* 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.
|
2012-02-23 14:49:08 +01:00
|
|
|
*
|
2012-03-18 16:47:15 +01:00
|
|
|
* 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``.
|
2012-03-13 16:36:53 +01:00
|
|
|
*
|
2012-02-23 14:49:08 +01:00
|
|
|
* This function returns 0 if it succeeds, or one of the following
|
|
|
|
* negative error codes:
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_NOMEM`
|
2012-02-23 14:49:08 +01:00
|
|
|
* Out of memory.
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_ZLIB`
|
2012-02-24 17:17:03 +01:00
|
|
|
* The z_stream initialization failed.
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_UNSUPPORTED_VERSION`
|
2012-02-24 17:17:03 +01:00
|
|
|
* The version is not supported.
|
2012-02-01 16:19:31 +01:00
|
|
|
*/
|
|
|
|
int spdylay_session_server_new(spdylay_session **session_ptr,
|
2012-02-25 16:12:32 +01:00
|
|
|
uint16_t version,
|
2012-02-01 16:19:31 +01:00
|
|
|
const spdylay_session_callbacks *callbacks,
|
2012-01-24 14:56:26 +01:00
|
|
|
void *user_data);
|
2012-01-24 14:02:24 +01:00
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
|
|
|
* Frees any resources allocated for |session|. If |session| is
|
|
|
|
* ``NULL``, this function does nothing.
|
2012-01-29 09:06:26 +01:00
|
|
|
*/
|
2012-01-24 14:56:26 +01:00
|
|
|
void spdylay_session_del(spdylay_session *session);
|
2012-01-24 14:02:24 +01:00
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
2012-02-23 14:49:08 +01:00
|
|
|
* Sends pending frames to the remote peer.
|
|
|
|
*
|
2012-03-06 15:00:17 +01:00
|
|
|
* This function retrieves the highest prioritized frame from the
|
|
|
|
* outbound queue and sends it to the remote peer. It does this as
|
2012-03-13 16:32:52 +01:00
|
|
|
* 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:
|
2012-03-06 15:00:17 +01:00
|
|
|
*
|
|
|
|
* 1. Get the next frame to send from outbound queue.
|
|
|
|
* 2. Prepare transmission of the frame.
|
2012-03-08 14:02:48 +01:00
|
|
|
* 3. If the control frame cannot be sent because some preconditions
|
|
|
|
* are not met (e.g., SYN_STREAM cannot be sent after GOAWAY),
|
2012-03-13 16:32:52 +01:00
|
|
|
* :member:`spdylay_session_callbacks.on_ctrl_not_send_callback` is
|
2012-03-15 14:39:26 +01:00
|
|
|
* invoked. Abort the following steps.
|
2012-03-08 14:02:48 +01:00
|
|
|
* 4. If the frame is SYN_STREAM, the stream is opened here.
|
2012-03-13 16:32:52 +01:00
|
|
|
* 5. :member:`spdylay_session_callbacks.before_ctrl_send_callback` is
|
|
|
|
* invoked.
|
|
|
|
* 6. :member:`spdylay_session_callbacks.send_callback` is invoked one
|
2012-03-15 14:39:26 +01:00
|
|
|
* or more times to send the frame.
|
2012-03-13 16:32:52 +01:00
|
|
|
* 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.
|
2012-03-08 14:02:48 +01:00
|
|
|
* 9. If the transmission of the frame triggers closure of the stream,
|
2012-03-13 16:32:52 +01:00
|
|
|
* the stream is closed and
|
|
|
|
* :member:`spdylay_session_callbacks.on_stream_close_callback` is
|
|
|
|
* invoked.
|
2012-03-06 15:00:17 +01:00
|
|
|
*
|
2012-02-23 14:49:08 +01:00
|
|
|
* This function returns 0 if it succeeds, or one of the following
|
|
|
|
* negative error codes:
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_NOMEM`
|
2012-02-23 14:49:08 +01:00
|
|
|
* Out of memory.
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_CALLBACK_FAILURE`
|
2012-02-23 14:49:08 +01:00
|
|
|
* The callback function failed.
|
2012-01-29 09:06:26 +01:00
|
|
|
*/
|
2012-01-24 14:02:24 +01:00
|
|
|
int spdylay_session_send(spdylay_session *session);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
2012-02-23 14:49:08 +01:00
|
|
|
* Receives frames from the remote peer.
|
|
|
|
*
|
2012-03-06 15:00:17 +01:00
|
|
|
* This function receives as many frames as possible until the user
|
2012-03-13 16:32:52 +01:00
|
|
|
* 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.
|
2012-03-06 15:00:17 +01:00
|
|
|
* 2. If the frame is DATA frame:
|
2012-03-13 16:32:52 +01:00
|
|
|
*
|
|
|
|
* 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`
|
2012-03-06 15:00:17 +01:00
|
|
|
* is invoked.
|
2012-03-13 16:32:52 +01:00
|
|
|
*
|
2012-03-06 15:00:17 +01:00
|
|
|
* 3. If the frame is the control frame:
|
2012-03-13 16:32:52 +01:00
|
|
|
*
|
|
|
|
* 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.
|
2012-03-06 15:00:17 +01:00
|
|
|
*
|
2012-02-23 14:49:08 +01:00
|
|
|
* This function returns 0 if it succeeds, or one of the following
|
|
|
|
* negative error codes:
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_EOF`
|
2012-02-23 14:49:08 +01:00
|
|
|
* The remote peer did shutdown on the connection.
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_NOMEM`
|
2012-02-23 14:49:08 +01:00
|
|
|
* Out of memory.
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_CALLBACK_FAILURE`
|
2012-02-23 14:49:08 +01:00
|
|
|
* The callback function failed.
|
2012-01-29 09:06:26 +01:00
|
|
|
*/
|
2012-01-24 14:02:24 +01:00
|
|
|
int spdylay_session_recv(spdylay_session *session);
|
|
|
|
|
2012-03-17 15:39:38 +01:00
|
|
|
/**
|
2012-03-17 15:44:49 +01:00
|
|
|
* @function
|
|
|
|
*
|
2012-03-17 15:39:38 +01:00
|
|
|
* 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);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
|
|
|
* Puts back previously deferred DATA frame in the stream |stream_id|
|
|
|
|
* to the outbound queue.
|
2012-02-28 13:42:31 +01:00
|
|
|
*
|
|
|
|
* This function returns 0 if it succeeds, or one of the following
|
|
|
|
* negative error codes:
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_INVALID_ARGUMENT`
|
2012-02-28 13:42:31 +01:00
|
|
|
* The stream does not exist or no deferred data exist.
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_NOMEM`
|
2012-02-28 13:42:31 +01:00
|
|
|
* Out of memory.
|
|
|
|
*/
|
|
|
|
int spdylay_session_resume_data(spdylay_session *session, int32_t stream_id);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
|
|
|
* Returns nonzero value if |session| wants to receive data from the
|
2012-02-23 14:49:08 +01:00
|
|
|
* remote peer.
|
2012-02-18 13:55:40 +01:00
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* If both `spdylay_session_want_read()` and
|
|
|
|
* `spdylay_session_want_write()` return 0, the application should
|
|
|
|
* drop the connection.
|
2012-01-29 09:06:26 +01:00
|
|
|
*/
|
2012-01-24 14:02:24 +01:00
|
|
|
int spdylay_session_want_read(spdylay_session *session);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
|
|
|
* Returns nonzero value if |session| wants to send data to the remote
|
|
|
|
* peer.
|
2012-02-18 13:55:40 +01:00
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* If both `spdylay_session_want_read()` and
|
|
|
|
* `spdylay_session_want_write()` return 0, the application should
|
|
|
|
* drop the connection.
|
2012-01-29 09:06:26 +01:00
|
|
|
*/
|
2012-01-24 14:02:24 +01:00
|
|
|
int spdylay_session_want_write(spdylay_session *session);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
2012-02-03 17:37:21 +01:00
|
|
|
* Returns stream_user_data for the stream |stream_id|. The
|
2012-03-13 16:32:52 +01:00
|
|
|
* 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``.
|
2012-02-03 17:37:21 +01:00
|
|
|
*/
|
|
|
|
void* spdylay_session_get_stream_user_data(spdylay_session *session,
|
|
|
|
int32_t stream_id);
|
|
|
|
|
2012-03-15 15:06:28 +01:00
|
|
|
/**
|
|
|
|
* @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);
|
|
|
|
|
2012-03-26 16:35:20 +02:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
|
|
|
* Returns lowest priority value for the |session|.
|
|
|
|
*/
|
|
|
|
uint8_t spdylay_session_get_pri_lowest(spdylay_session *session);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
2012-02-15 15:54:42 +01:00
|
|
|
* Submits SYN_STREAM frame and optionally one or more DATA
|
2012-02-28 15:14:32 +01:00
|
|
|
* frames.
|
2012-01-27 15:43:04 +01:00
|
|
|
*
|
2012-03-15 14:39:26 +01:00
|
|
|
* The |pri| is priority of this request. 0 is the highest priority
|
2012-03-26 16:35:20 +02:00
|
|
|
* value. Use `spdylay_session_get_pri_lowest()` to know the lowest
|
|
|
|
* priority value for this |session|.
|
2012-03-13 16:32:52 +01:00
|
|
|
*
|
|
|
|
* 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``.
|
2012-01-27 15:43:04 +01:00
|
|
|
*
|
2012-03-06 15:43:45 +01:00
|
|
|
* The |nv| must include following name/value pairs:
|
2012-02-28 15:14:32 +01:00
|
|
|
*
|
|
|
|
* ":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.
|
2012-02-12 09:43:50 +01:00
|
|
|
*
|
2012-03-06 15:43:45 +01:00
|
|
|
* If the |session| is initialized with the version
|
2012-03-13 16:32:52 +01:00
|
|
|
* :macro:`SPDYLAY_PROTO_SPDY2`, the above names are translated to
|
|
|
|
* "method", "scheme", "url", "version" and "host" respectively.
|
2012-03-06 15:43:45 +01:00
|
|
|
*
|
2012-02-15 15:54:42 +01:00
|
|
|
* This function creates copies of all name/value pairs in |nv|. It
|
|
|
|
* also lower-cases all names in |nv|.
|
2012-01-27 15:43:04 +01:00
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* 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
|
2012-02-16 15:48:12 +01:00
|
|
|
* (http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9) must
|
|
|
|
* be specified with "method" key in |nv| (e.g. POST). If |data_prd|
|
2012-03-15 14:39:26 +01:00
|
|
|
* 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
|
2012-03-13 16:32:52 +01:00
|
|
|
* `spdylay_session_get_stream_user_data()`.
|
2012-03-06 15:00:17 +01:00
|
|
|
*
|
|
|
|
* 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
|
2012-03-13 16:32:52 +01:00
|
|
|
* :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
|
2012-03-06 15:00:17 +01:00
|
|
|
* |stream_user_data| to identify which SYN_STREAM we are processing.
|
2012-01-29 11:07:31 +01:00
|
|
|
*
|
2012-02-23 14:49:08 +01:00
|
|
|
* This function returns 0 if it succeeds, or one of the following
|
|
|
|
* negative error codes:
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_INVALID_ARGUMENT`
|
2012-03-11 10:52:42 +01:00
|
|
|
* The |pri| is invalid; or the Associated-To-Stream-ID is
|
|
|
|
* invalid.
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_NOMEM`
|
2012-02-23 14:49:08 +01:00
|
|
|
* Out of memory.
|
2012-01-27 15:43:04 +01:00
|
|
|
*/
|
2012-01-27 15:35:23 +01:00
|
|
|
int spdylay_submit_request(spdylay_session *session, uint8_t pri,
|
2012-01-29 11:07:31 +01:00
|
|
|
const char **nv,
|
2012-02-23 15:22:58 +01:00
|
|
|
const spdylay_data_provider *data_prd,
|
2012-02-03 17:37:21 +01:00
|
|
|
void *stream_user_data);
|
2012-01-29 11:07:31 +01:00
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
2012-02-15 15:54:42 +01:00
|
|
|
* Submits SYN_REPLY frame and optionally one or more DATA frames
|
2012-03-13 16:32:52 +01:00
|
|
|
* 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``.
|
2012-02-28 15:14:32 +01:00
|
|
|
*
|
2012-03-06 15:43:45 +01:00
|
|
|
* The |nv| must include following name/value pairs:
|
2012-01-29 09:06:26 +01:00
|
|
|
*
|
2012-02-28 15:14:32 +01:00
|
|
|
* ":status"
|
|
|
|
* HTTP status code (e.g., "200" or "200 OK")
|
|
|
|
* ":version"
|
|
|
|
* HTTP response version (e.g., "HTTP/1.1")
|
2012-01-29 09:06:26 +01:00
|
|
|
*
|
2012-03-06 15:43:45 +01:00
|
|
|
* If the |session| is initialized with the version
|
2012-03-13 16:32:52 +01:00
|
|
|
* :macro:`SPDYLAY_PROTO_SPDY2`, the above names are translated to
|
|
|
|
* "status" and "version" respectively.
|
2012-03-06 15:43:45 +01:00
|
|
|
*
|
2012-02-15 15:54:42 +01:00
|
|
|
* This function creates copies of all name/value pairs in |nv|. It
|
|
|
|
* also lower-cases all names in |nv|.
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* If |data_prd| is not ``NULL``, it provides data which will be sent
|
|
|
|
* in subsequent DATA frames. If |data_prd| is ``NULL``, SYN_REPLY
|
2012-03-15 14:39:26 +01:00
|
|
|
* will have FLAG_FIN set.
|
2012-01-29 09:06:26 +01:00
|
|
|
*
|
2012-02-23 14:49:08 +01:00
|
|
|
* This function returns 0 if it succeeds, or one of the following
|
|
|
|
* negative error codes:
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_NOMEM`
|
2012-02-23 14:49:08 +01:00
|
|
|
* Out of memory.
|
2012-01-26 17:17:40 +01:00
|
|
|
*/
|
2012-01-27 15:35:23 +01:00
|
|
|
int spdylay_submit_response(spdylay_session *session,
|
|
|
|
int32_t stream_id, const char **nv,
|
2012-02-23 15:22:58 +01:00
|
|
|
const spdylay_data_provider *data_prd);
|
2012-01-26 17:17:40 +01:00
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
2012-02-23 15:20:05 +01:00
|
|
|
* Submits SYN_STREAM frame. The |flags| is bitwise OR of the
|
|
|
|
* following values:
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* * :enum:`SPDYLAY_CTRL_FLAG_FIN`
|
|
|
|
* * :enum:`SPDYLAY_CTRL_FLAG_UNIDIRECTIONAL`
|
2012-02-23 15:20:05 +01:00
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* If |flags| includes :enum:`SPDYLAY_CTRL_FLAG_FIN`, this frame has
|
2012-03-15 14:39:26 +01:00
|
|
|
* FLAG_FIN flag set.
|
2012-02-23 16:05:45 +01:00
|
|
|
*
|
2012-02-23 15:20:05 +01:00
|
|
|
* The |assoc_stream_id| is used for server-push. If |session| is
|
2012-03-15 14:39:26 +01:00
|
|
|
* initialized for client use, |assoc_stream_id| is ignored.
|
2012-03-26 16:35:20 +02:00
|
|
|
*
|
2012-03-15 14:39:26 +01:00
|
|
|
* The |pri| is priority of this request. 0 is the highest priority
|
2012-03-26 16:35:20 +02:00
|
|
|
* value. Use `spdylay_session_get_pri_lowest()` to know the lowest
|
|
|
|
* priority value for this |session|.
|
2012-02-23 15:20:05 +01:00
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* 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``.
|
|
|
|
*
|
2012-03-15 14:39:26 +01:00
|
|
|
* The |stream_user_data| is a pointer to an arbitrary
|
|
|
|
* data which is associated to the stream this frame will open.
|
|
|
|
*
|
2012-02-23 15:20:05 +01:00
|
|
|
* This function is low-level in a sense that the application code can
|
2012-03-11 10:52:42 +01:00
|
|
|
* specify flags and the Associated-To-Stream-ID directly. For usual
|
2012-03-13 16:32:52 +01:00
|
|
|
* HTTP request, `spdylay_submit_request()` is useful.
|
2012-02-23 15:20:05 +01:00
|
|
|
*
|
|
|
|
* This function returns 0 if it succeeds, or one of the following
|
|
|
|
* negative error codes:
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_INVALID_ARGUMENT`
|
2012-03-11 10:52:42 +01:00
|
|
|
* The |pri| is invalid; or the Associated-To-Stream-ID is
|
|
|
|
* invalid.
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_NOMEM`
|
2012-02-23 15:20:05 +01:00
|
|
|
* Out of memory.
|
|
|
|
*/
|
|
|
|
int spdylay_submit_syn_stream(spdylay_session *session, uint8_t flags,
|
2012-02-23 15:28:46 +01:00
|
|
|
int32_t assoc_stream_id, uint8_t pri,
|
2012-02-23 15:20:05 +01:00
|
|
|
const char **nv, void *stream_user_data);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
2012-02-28 15:27:10 +01:00
|
|
|
* Submits SYN_REPLY frame. The |flags| is bitwise OR of the following
|
|
|
|
* values:
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* * :enum:`SPDYLAY_CTRL_FLAG_FIN`
|
2012-02-28 15:27:10 +01:00
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* If |flags| includes :enum:`SPDYLAY_CTRL_FLAG_FIN`, this frame has
|
2012-03-15 14:39:26 +01:00
|
|
|
* FLAG_FIN flag set.
|
2012-03-13 16:32:52 +01:00
|
|
|
*
|
|
|
|
* The stream which this frame belongs to is given in the
|
|
|
|
* |stream_id|. The |nv| is the name/value pairs in this frame.
|
2012-02-28 15:27:10 +01:00
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* 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``.
|
2012-02-28 15:27:10 +01:00
|
|
|
*
|
|
|
|
* This function returns 0 if it succeeds, or one of the following
|
|
|
|
* negative error codes:
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_NOMEM`
|
2012-02-28 15:27:10 +01:00
|
|
|
* Out of memory.
|
|
|
|
*/
|
|
|
|
int spdylay_submit_syn_reply(spdylay_session *session, uint8_t flags,
|
|
|
|
int32_t stream_id, const char **nv);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
2012-02-23 16:02:29 +01:00
|
|
|
* Submits HEADERS frame. The |flags| is bitwise OR of the following
|
|
|
|
* values:
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* * :enum:`SPDYLAY_CTRL_FLAG_FIN`
|
2012-02-23 16:02:29 +01:00
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* If |flags| includes :enum:`SPDYLAY_CTRL_FLAG_FIN`, this frame has
|
2012-03-15 14:39:26 +01:00
|
|
|
* FLAG_FIN flag set.
|
2012-02-23 16:02:29 +01:00
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* The stream which this frame belongs to is given in the
|
|
|
|
* |stream_id|. The |nv| is the name/value pairs in this frame.
|
2012-02-23 16:02:29 +01:00
|
|
|
*
|
2012-03-15 14:39:26 +01:00
|
|
|
* 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``.
|
|
|
|
*
|
2012-02-23 16:02:29 +01:00
|
|
|
* This function returns 0 if it succeeds, or one of the following
|
|
|
|
* negative error codes:
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_NOMEM`
|
2012-02-23 16:02:29 +01:00
|
|
|
* Out of memory.
|
|
|
|
*/
|
|
|
|
int spdylay_submit_headers(spdylay_session *session, uint8_t flags,
|
|
|
|
int32_t stream_id, const char **nv);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @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.
|
2012-02-15 15:02:51 +01:00
|
|
|
*
|
2012-02-23 14:49:08 +01:00
|
|
|
* This function returns 0 if it succeeds, or one of the following
|
|
|
|
* negative error codes:
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_NOMEM`
|
2012-02-23 14:49:08 +01:00
|
|
|
* Out of memory.
|
2012-02-15 15:02:51 +01:00
|
|
|
*/
|
|
|
|
int spdylay_submit_data(spdylay_session *session, int32_t stream_id,
|
2012-02-23 15:22:58 +01:00
|
|
|
uint8_t flags, const spdylay_data_provider *data_prd);
|
2012-02-15 15:02:51 +01:00
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
|
|
|
* Submits RST_STREAM frame to cancel/reject the stream |stream_id|
|
|
|
|
* with the status code |status_code|.
|
2012-02-23 14:49:08 +01:00
|
|
|
*
|
|
|
|
* This function returns 0 if it succeeds, or one of the following
|
|
|
|
* negative error codes:
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_NOMEM`
|
2012-02-23 14:49:08 +01:00
|
|
|
* Out of memory.
|
2012-02-06 13:20:35 +01:00
|
|
|
*/
|
2012-02-15 15:15:48 +01:00
|
|
|
int spdylay_submit_rst_stream(spdylay_session *session, int32_t stream_id,
|
|
|
|
uint32_t status_code);
|
2012-02-06 13:20:35 +01:00
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
2012-02-23 14:49:08 +01:00
|
|
|
* Submits PING frame.
|
|
|
|
*
|
|
|
|
* This function returns 0 if it succeeds, or one of the following
|
|
|
|
* negative error codes:
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_NOMEM`
|
2012-02-23 14:49:08 +01:00
|
|
|
* Out of memory.
|
2012-01-29 09:06:26 +01:00
|
|
|
*/
|
2012-01-27 15:05:29 +01:00
|
|
|
int spdylay_submit_ping(spdylay_session *session);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
2012-02-26 08:26:38 +01:00
|
|
|
* Submits GOAWAY frame. The status code |status_code| is ignored if
|
2012-03-13 16:32:52 +01:00
|
|
|
* the protocol version is :macro:`SPDYLAY_PROTO_SPDY2`.
|
2012-02-23 14:49:08 +01:00
|
|
|
*
|
|
|
|
* This function returns 0 if it succeeds, or one of the following
|
|
|
|
* negative error codes:
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_NOMEM`
|
2012-02-23 14:49:08 +01:00
|
|
|
* Out of memory.
|
2012-01-29 09:06:26 +01:00
|
|
|
*/
|
2012-02-26 08:26:38 +01:00
|
|
|
int spdylay_submit_goaway(spdylay_session *session, uint32_t status_code);
|
2012-01-28 11:35:51 +01:00
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
2012-03-10 10:41:01 +01:00
|
|
|
* Stores local settings and submits SETTINGS frame. The |iv| is the
|
2012-03-13 16:32:52 +01:00
|
|
|
* 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`.
|
2012-03-10 10:41:01 +01:00
|
|
|
*
|
|
|
|
* This function returns 0 if it succeeds, or one of the following
|
|
|
|
* negative error codes:
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_INVALID_ARGUMENT`
|
2012-03-10 10:41:01 +01:00
|
|
|
* The |iv| contains duplicate settings ID or invalid value.
|
2012-03-13 16:32:52 +01:00
|
|
|
* :enum:`SPDYLAY_ERR_NOMEM`
|
2012-03-10 10:41:01 +01:00
|
|
|
* Out of memory.
|
|
|
|
*/
|
|
|
|
int spdylay_submit_settings(spdylay_session *session, uint8_t flags,
|
|
|
|
const spdylay_settings_entry *iv, size_t niv);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @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"
|
|
|
|
* are "http/1.1" stored in |in| like this::
|
2012-02-08 13:20:50 +01:00
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* in[0] = 6
|
|
|
|
* in[1..6] = "spdy/2"
|
|
|
|
* in[7] = 8
|
|
|
|
* in[8..15] = "http/1.1"
|
|
|
|
* inlen = 16
|
2012-02-08 13:20:50 +01:00
|
|
|
*
|
|
|
|
* The selection algorithm is as follows:
|
|
|
|
*
|
2012-03-02 14:52:01 +01:00
|
|
|
* 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
|
2012-03-13 16:32:52 +01:00
|
|
|
* `spdylay_session_client_new()` and
|
|
|
|
* `spdylay_session_server_new()` . The following steps are not
|
|
|
|
* taken.
|
2012-02-08 13:20:50 +01:00
|
|
|
*
|
|
|
|
* 2. If server's list contains "http/1.1", this function selects
|
|
|
|
* "http/1.1" and returns 0. The following step is not taken.
|
|
|
|
*
|
2012-02-09 14:46:26 +01:00
|
|
|
* 3. This function selects nothing and returns -1. (So called
|
|
|
|
* non-overlap case). In this case, |out| and |outlen| are left
|
|
|
|
* untouched.
|
2012-02-08 13:20:50 +01:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
2012-02-05 13:48:20 +01:00
|
|
|
* Selecting "spdy/2" means that "spdy/2" is written into |*out| and
|
|
|
|
* length of "spdy/2" (which is 6) is assigned to |*outlen|.
|
|
|
|
*
|
2012-02-09 14:46:26 +01:00
|
|
|
* See http://technotes.googlecode.com/git/nextprotoneg.html for more
|
|
|
|
* details about NPN.
|
|
|
|
*
|
2012-03-13 16:32:52 +01:00
|
|
|
* 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);
|
2012-02-03 01:31:11 +01:00
|
|
|
*/
|
|
|
|
int spdylay_select_next_protocol(unsigned char **out, unsigned char *outlen,
|
|
|
|
const unsigned char *in, unsigned int inlen);
|
|
|
|
|
2012-03-13 16:32:52 +01:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*
|
2012-03-15 14:39:26 +01:00
|
|
|
* Returns spdy version which spdylay library supports from the given
|
2012-02-25 17:30:41 +01:00
|
|
|
* 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);
|
|
|
|
|
2012-01-18 13:36:29 +01:00
|
|
|
#ifdef __cplusplus
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-01-17 18:10:22 +01:00
|
|
|
#endif /* SPDYLAY_H */
|