Do not call spdylay_session_send(), spdylay_session_recv() or spdylay_session_mem_recv() from the spdylay callback functions directly or indirectly. It will lead to the crash. You can submit requests or frames in the callbacks then call spdylay_session_send(), spdylay_session_recv() or spdylay_session_mem_recv() outside of the callbacks.
Version number of the Spdylay library release
Default maximum concurrent streams.
Initial window size for both connection-level and stream-level flow control.
The SPDY protocol version.
(2) SPDY protocol version 2
(3) SPDY protocol version 3
(4) SPDY protocol version 3.1
Error codes used in the Spdylay library. The code range is [-999, -500], inclusive. The following values are defined:
(-501) Invalid argument passed.
(-502) Zlib error.
(-503) The specified protocol version is not supported.
(-504) Used as a return value from spdylay_send_callback and spdylay_recv_callback to indicate that the operation would block.
(-505) General protocol error
(-506) The frame is invalid.
(-507) The peer performed a shutdown on the connection.
(-508) Used as a return value from spdylay_data_source_read_callback() to indicate that data transfer is postponed. See spdylay_data_source_read_callback() for details.
(-509) Stream ID has reached the maximum value. Therefore no stream ID is available.
(-510) The stream is already closed; or the stream ID is invalid.
(-511) RST_STREAM has been added to the outbound queue. The stream is in closing state.
(-512) The transmission is not allowed for this stream (e.g., a frame with FLAG_FIN flag set has already sent).
(-513) The stream ID is invalid.
(-514) 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).
(-515) Another DATA frame has already been deferred.
(-516) SYN_STREAM is not allowed. (e.g., GOAWAY has been sent and/or received.
(-517) GOAWAY has already been sent.
(-518) 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).
(-519) Indicates that the context is not suitable to perform the requested operation.
(-520) The gzip error.
(-521) The user callback function failed due to the temporal error.
(-522) The length of the frame is too large.
(-900) The errors < SPDYLAY_ERR_FATAL mean that the library is under unexpected condition and cannot process any further data reliably (e.g., out of memory).
(-901) Out of memory. This is a fatal error.
(-902) The user callback function failed. This is a fatal error.
The control frame types in SPDY protocol.
(1) The SYN_STREAM control frame.
(2) The SYN_REPLY control frame.
(3) The RST_STREAM control frame.
(4) The SETTINGS control frame.
(5) The NOOP control frame. This was deprecated in SPDY/3.
(6) The PING control frame.
(7) The GOAWAY control frame.
(8) The HEADERS control frame.
(9) The WINDOW_UPDATE control frame. This first appeared in SPDY/3.
(10) The CREDENTIAL control frame. This first appeared in SPDY/3.
The flags for a control frame.
(0) No flag set.
(0x1) FLAG_FIN flag.
(0x2) FLAG_UNIDIRECTIONAL flag.
The flags for a DATA frame.
(0) No flag set.
(0x1) FLAG_FIN flag.
The flags for the SETTINGS control frame.
(0) No flag set.
(1) SETTINGS_CLEAR_SETTINGS flag.
The flags for SETTINGS ID/value pair.
(0) No flag set.
(1) FLAG_SETTINGS_PERSIST_VALUE flag.
(2) FLAG_SETTINGS_PERSISTED flag.
The SETTINGS ID.
(1) SETTINGS_UPLOAD_BANDWIDTH
(2) SETTINGS_DOWNLOAD_BANDWIDTH
(3) SETTINGS_ROUND_TRIP_TIME
(4) SETTINGS_MAX_CONCURRENT_STREAMS
(5) SETTINGS_CURRENT_CWND
(6) SETTINGS_DOWNLOAD_RETRANS_RATE
(7) SETTINGS_INITIAL_WINDOW_SIZE
(8) SETTINGS_CLIENT_CERTIFICATE_VECTOR_SIZE. This first appeared in SPDY/3.
(8) Maximum ID of spdylay_settings_id.
The status codes for the RST_STREAM control frame.
(0) SPDYLAY_OK is not valid status code for RST_STREAM. It is defined just for spdylay library use.
(1) PROTOCOL_ERROR
(2) INVALID_STREAM
(3) REFUSED_STREAM
(4) UNSUPPORTED_VERSION
(5) CANCEL
(6) INTERNAL_ERROR
(7) FLOW_CONTROL_ERROR
(8) STREAM_IN_USE
(9) STREAM_ALREADY_CLOSED
(10) INVALID_CREDENTIALS
(11) FRAME_TOO_LARGE
The status codes for GOAWAY, introduced in SPDY/3.
(0) OK. This indicates a normal session teardown.
(1) PROTOCOL_ERROR
(2) INTERNAL_ERROR
Configuration options for spdylay_session.
(1) 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().
(2) This option sets maximum receive buffer size for incoming control frame.
The primary structure to hold the resources needed for a SPDY session. The details of this structure are intentionally hidden from the public API.
The control frame header.
SPDY protocol version.
The type of this control frame.
The control frame flags.
The length field of this control frame.
The SYN_STREAM control frame. It has the following members:
The control frame header.
The stream ID.
The associated-to-stream ID. 0 if this frame has no associated-to-stream.
The priority of this frame. 0 is the highest priority value. Use spdylay_session_get_pri_lowest() to know the lowest priority value.
The index in server’s CREDENTIAL vector of the client certificate. This was introduced in SPDY/3.
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.
The SYN_REPLY control frame. It has the following members:
The control frame header.
The 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.
The HEADERS control frame. It has the following members:
The control frame header.
The 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.
The RST_STREAM control frame. It has the following members:
The control frame header.
The stream ID.
The status code. See spdylay_status_code.
The SETTINGS ID/Value pair. It has the following members:
The SETTINGS ID. See spdylay_settings_id.
The flags. See spdylay_settings_id_flag.
The value of this entry.
The SETTINGS control frame. It has the following members:
The control frame header.
The number of SETTINGS ID/Value pairs in iv.
The pointer to the array of SETTINGS ID/Value pair.
The PING control frame. It has the following members:
The control frame header.
The unique ID.
The GOAWAY control frame. It has the following members:
The control frame header.
The last-good-stream ID.
The status code. This first appeared in SPDY/3. See spdylay_goaway_status_code.
The WINDOW_UPDATE control frame. This first appeared in SPDY/3. It has the following members:
The control frame header.
The stream ID.
The delta-window-size.
The structure to hold chunk of memory.
The pointer to the data.
The length of the data.
The CREDENTIAL control frame. This first appeared in SPDY/3. It has the following members:
The control frame header.
The index in the client certificate vector.
Cryptographic proof that the client has possession of the private key associated with the certificate.
The certificate chain. The certs[0] is the leaf certificate.
The number of certificates in certs.
Convenient structure to inspect control frame header. It is useful to get the frame type.
The control frame header.
This union represents the some kind of data source passed to spdylay_data_source_read_callback.
The integer field, suitable for a file descriptor.
The pointer to an arbitrary object.
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 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 SPDYLAY_ERR_TEMPORAL_CALLBACK_FAILURE will close the stream by issuing RST_STREAM with SPDYLAY_INTERNAL_ERROR. Returning SPDYLAY_ERR_CALLBACK_FAILURE will signal the entire session failure.
This struct represents the data source and the way to read a chunk of data from it.
The data source.
The callback function to read a chunk of data from the source.
This union includes all control frames to pass them to various function calls as spdylay_frame type.
Convenient structure to inspect control frame header.
The SYN_STREAM control frame.
The SYN_REPLY control frame.
The RST_STREAM control frame.
The SETTINGS control frame.
The PING control frame.
The GOAWAY control frame.
The HEADERS control frame.
The WINDOW_UPDATE control frame.
The CREDENTIAL control frame.
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. The flags is currently not used and always 0. It must return the number of bytes sent if it succeeds. If it cannot send any single byte without blocking, it must return SPDYLAY_ERR_WOULDBLOCK. For other errors, it must return SPDYLAY_ERR_CALLBACK_FAILURE.
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. The flags is currently not used and always 0. 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 SPDYLAY_ERR_WOULDBLOCK. If it gets EOF before it reads any single byte, it must return SPDYLAY_ERR_EOF. For other errors, it must return SPDYLAY_ERR_CALLBACK_FAILURE.
Callback function invoked by spdylay_session_recv() when a control frame is received.
Callback function invoked by spdylay_session_recv() when an invalid control frame is received. The status_code is one of the spdylay_status_code and indicates the error. When this callback function is invoked, the library automatically submits either RST_STREAM or GOAWAY frame.
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 spdylay_on_data_recv_callback to know all data frames are received.
Callback function invoked when DATA frame is received. The actual data it contains are received by spdylay_on_data_chunk_recv_callback.
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.
Callback function invoked after the control frame frame of type type is sent.
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 spdylay_error.
Callback function invoked after DATA frame is sent.
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.
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.
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 spdylay_error and indicates the error.
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.
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.
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.
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, spdylay_get_credential_proof and spdylay_get_credential_cert callback functions will be used to get the cryptographic proof and certificate respectively.
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.
Callback functions.
Callback function invoked when the session wants to send data to the remote peer.
Callback function invoked when the session wants to receive data from the remote peer.
Callback function invoked by spdylay_session_recv() when a control frame is received.
Callback function invoked by spdylay_session_recv() when an invalid control frame is received.
Callback function invoked when a chunk of data in DATA frame is received.
Callback function invoked when DATA frame is received.
Callback function invoked before the control frame is sent.
Callback function invoked after the control frame is sent.
The callback function invoked when a control frame is not sent because of an error.
Callback function invoked after DATA frame is sent.
Callback function invoked when the stream is closed.
Callback function invoked when request from the remote peer is received.
Callback function invoked when the library needs the cryptographic proof that the client has possession of the private key associated with the certificate.
Callback function invoked when the library needs the length of the client certificate chain.
Callback function invoked when the library needs the client certificate.
Callback function invoked when the received control frame octets could not be parsed correctly.
Callback function invoked when the received control frame type is unknown.
This struct contains SPDY version information this library supports.
SPDY protocol version name which can be used as TLS NPN protocol string.
The length of proto member.
The corresponding SPDY version constant which can be passed to spdylay_session_client_new() and spdylay_session_server_new() as version argument.
The gzip stream to inflate data. The details of this structure are intentionally hidden from the public API.
Returns the scheme member of the origin.
Returns the host member of the origin.
Returns the port member of the origin.
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 spdylay_session_callbacks.send_callback must be specified. If the application code uses spdylay_session_recv(), the spdylay_session_callbacks.recv_callback must be specified. The other members of callbacks can be NULL. To use CREDENTIAL frame, specify SPDYLAY_PROTO_SPDY3 in version and specify spdylay_session_callbacks.get_credential_ncerts, spdylay_session_callbacks.get_credential_cert and 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:
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 spdylay_session_callbacks.send_callback must be specified. If the application code uses spdylay_session_recv(), the 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:
Frees any resources allocated for session. If session is NULL, this function does nothing.
Sets the configuration option for the session. The optname is one of 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:
This function returns 0 if it succeeds, or one of the following negative error codes:
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:
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.
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 spdylay_session_callbacks.send_callback returns 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:
This function returns 0 if it succeeds, or one of the following negative error codes:
Receives frames from the remote peer.
This function receives as many frames as possible until the user callback spdylay_session_callbacks.recv_callback returns 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:
- 2.1. spdylay_session_callbacks.recv_callback is invoked
- to receive DATA payload. For each chunk of data, spdylay_session_callbacks.on_data_chunk_recv_callback is invoked.
- 2.2. If one DATA frame is completely received,
- spdylay_session_callbacks.on_data_recv_callback is invoked. If the frame is the final frame of the request, spdylay_session_callbacks.on_request_recv_callback is invoked. If the reception of the frame triggers the closure of the stream, spdylay_session_callbacks.on_stream_close_callback is invoked.
- 3.1. spdylay_session_callbacks.recv_callback is invoked
- one or more times to receive whole frame.
- 3.2. If the received frame is valid,
- spdylay_session_callbacks.on_ctrl_recv_callback is invoked. If the frame is the final frame of the request, spdylay_session_callbacks.on_request_recv_callback is invoked. If the reception of the frame triggers the closure of the stream, spdylay_session_callbacks.on_stream_close_callback is invoked.
- 3.3. If the received frame is unpacked but is interpreted as
- invalid, spdylay_session_callbacks.on_invalid_ctrl_recv_callback is invoked.
- 3.4. If the received frame could not be unpacked correctly,
- spdylay_session_callbacks.on_ctrl_recv_parse_error_callback is invoked.
- 3.5. If the received frame type is unknown,
- 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:
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 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:
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:
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.
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.
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.
Returns the number of frames in the outbound queue. This does not include the deferred DATA frames.
Returns lowest priority value for the session.
Returns the number of DATA payload in bytes received without WINDOW_UPDATE transmission for the stream stream_id.
If the flow control is disabled by the protocol, this function returns 0.
This function returns -1 if it fails.
Returns the local (receive) window size for a stream. Because SPDY protocol always uses the initial window size as local window size, this function returns the current local settings of SETTINGS_INITIAL_WINDOW_SIZE.
This function returns -1 if it fails.
Returns the number of DATA payload in bytes received without WINDOW_UPDATE transmission for a connection.
If flow control is disabled by the protocol, this function returns 0.
This function returns -1 if it fails.
Returns the local (receive) window size for a connection. Because SPDY protocol always uses the initial window size as local window size, this fucntion always returns SPDYLAY_INITIAL_WINDOW_SIZE.
This function returns -1 if it fails.
Submits GOAWAY frame. The status code status_code is ignored if the protocol version is 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:
Returns string describing the error_code. The error_code must be one of the spdylay_error.
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:
If the session is initialized with the version 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 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:
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:
If the session is initialized with the version 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:
Submits SYN_STREAM frame. The flags is bitwise OR of the following values:
If flags includes 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:
Submits SYN_REPLY frame. The flags is bitwise OR of the following values:
If flags includes 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:
Submits HEADERS frame. The flags is bitwise OR of the following values:
If flags includes 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:
Submits one or more DATA frames to the stream stream_id. The data to be sent are provided by data_prd. If flags contains 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:
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:
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:
Submits GOAWAY frame. The status code status_code is ignored if the protocol version is SPDYLAY_PROTO_SPDY2.
This function returns 0 if it succeeds, or one of the following negative error codes:
Stores local settings and submits SETTINGS frame. The iv is the pointer to the array of spdylay_settings_entry. The niv indicates the number of spdylay_settings_entry. The flags is bitwise-OR of one or more values from 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:
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.
To send connection-level WINDOW_UPDATE, specify 0 to the stream_id if the negotiated protocol supports it.
This function returns 0 if it succeeds, or one of the following negative error codes:
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:
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);
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.
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, spdy/3 and spdy/3.1 are supported.
This function returns nonzero spdy version if it succeeds, or 0.
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:
Frees the inflate stream. The inflater may be NULL.
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:
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;
}
....
}