488 lines
18 KiB
C
488 lines
18 KiB
C
/*
|
|
* 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_FRAME_H
|
|
#define SPDYLAY_FRAME_H
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
# include <config.h>
|
|
#endif /* HAVE_CONFIG_H */
|
|
|
|
#include <spdylay/spdylay.h>
|
|
#include "spdylay_zlib.h"
|
|
#include "spdylay_buffer.h"
|
|
|
|
#define SPDYLAY_STREAM_ID_MASK 0x7fffffff
|
|
#define SPDYLAY_LENGTH_MASK 0xffffff
|
|
#define SPDYLAY_VERSION_MASK 0x7fff
|
|
|
|
/* The length of DATA frame payload. */
|
|
#define SPDYLAY_DATA_PAYLOAD_LENGTH 4096
|
|
|
|
/* The number of bytes of frame header. */
|
|
#define SPDYLAY_FRAME_HEAD_LENGTH 8
|
|
|
|
/*
|
|
* Packs SYN_STREAM frame |frame| in wire format and store it in
|
|
* |*buf_ptr|. The capacity of |*buf_ptr| is |*buflen_ptr| bytes.
|
|
* The |*nvbuf_ptr| is used to store inflated name/value pairs in wire
|
|
* format temporarily. Its length is |*nvbuflen_ptr| bytes. This
|
|
* function expands |*buf_ptr| and |*nvbuf_ptr| as necessary to store
|
|
* frame and name/value pairs. When expansion occurred, memory
|
|
* previously pointed by |*buf_ptr| and |*nvbuf_ptr| is freed.
|
|
* |*buf_ptr|, |*buflen_ptr|, |*nvbuf_ptr| and |*nvbuflen_ptr| are
|
|
* updated accordingly.
|
|
*
|
|
* frame->hd.length is assigned after length is determined during
|
|
* packing process.
|
|
*
|
|
* This function returns the size of packed frame if it succeeds, or
|
|
* returns one of the following negative error codes:
|
|
*
|
|
* SPDYLAY_ERR_ZLIB
|
|
* The deflate operation failed.
|
|
* SPDYLAY_ERR_NOMEM
|
|
* Out of memory.
|
|
*/
|
|
ssize_t spdylay_frame_pack_syn_stream(uint8_t **buf_ptr,
|
|
size_t *buflen_ptr,
|
|
uint8_t **nvbuf_ptr,
|
|
size_t *nvbuflen_ptr,
|
|
spdylay_syn_stream *frame,
|
|
spdylay_zlib *deflater);
|
|
|
|
/*
|
|
* Unpacks SYN_STREAM frame byte sequence into |frame|. Header is
|
|
* given in head and headlen. In spdy/2 spec, headlen is 8
|
|
* bytes. |payload| is the data after length field of the header.
|
|
*
|
|
* |inflatebuf| is used to buffer name/value pairs while inflating
|
|
* them using |inflater|. The caller must reset |inflatebuf| before
|
|
* the call. |*nvbuf_ptr|, |*nvbuflen_ptr| is used to store temporal
|
|
* inflated name/value pairs. This function expands |*nvbuf_ptr| as
|
|
* necessary and updates these variables.
|
|
*
|
|
* This function returns 0 if it succeeds or one of the following
|
|
* negative error codes:
|
|
*
|
|
* SPDYLAY_ERR_INVALID_FRAME
|
|
* The input data are invalid.
|
|
* SPDYLAY_ERR_ZLIB
|
|
* The inflate operation failed.
|
|
* SPDYLAY_ERR_NOMEM
|
|
* Out of memory.
|
|
*/
|
|
int spdylay_frame_unpack_syn_stream(spdylay_syn_stream *frame,
|
|
spdylay_buffer *inflatebuf,
|
|
uint8_t **nvbuf_ptr,
|
|
size_t *nvbuflen_ptr,
|
|
const uint8_t *head, size_t headlen,
|
|
const uint8_t *payload, size_t payloadlen,
|
|
spdylay_zlib *inflater);
|
|
|
|
/*
|
|
* Packs SYN_REPLY frame |frame| in wire frame format and store it in
|
|
* |*buf_ptr|. The capacity of |*buf_ptr| is |*buflen_ptr| bytes.
|
|
* The |*nvbuf_ptr| is used to store inflated name/value pairs in wire
|
|
* format temporarily. Its length is |*nvbuflen_ptr| bytes. This
|
|
* function expands |*buf_ptr| and |*nvbuf_ptr| as necessary to store
|
|
* frame and name/value pairs. When expansion occurred, memory
|
|
* previously pointed by |*buf_ptr| and |*nvbuf_ptr| is freed.
|
|
* |*buf_ptr|, |*buflen_ptr|, |*nvbuf_ptr| and |*nvbuflen_ptr| are
|
|
* updated accordingly.
|
|
*
|
|
* frame->hd.length is assigned after length is determined during
|
|
* packing process.
|
|
*
|
|
* This function returns the size of packed frame if it succeeds, or
|
|
* returns one of the following negative error codes:
|
|
*
|
|
* SPDYLAY_ERR_ZLIB
|
|
* The deflate operation failed.
|
|
* SPDYLAY_ERR_NOMEM
|
|
* Out of memory.
|
|
*/
|
|
ssize_t spdylay_frame_pack_syn_reply(uint8_t **buf_ptr,
|
|
size_t *buflen_ptr,
|
|
uint8_t **nvbuf_ptr,
|
|
size_t *nvbuflen_ptr,
|
|
spdylay_syn_reply *frame,
|
|
spdylay_zlib *deflater);
|
|
|
|
/*
|
|
* Unpacks SYN_REPLY frame byte sequence into |frame|.
|
|
*
|
|
* |inflatebuf| is used to buffer name/value pairs while inflating
|
|
* them using |inflater|. The caller must reset |inflatebuf| before
|
|
* the call. |*nvbuf_ptr|, |*nvbuflen_ptr| is used to store temporal
|
|
* inflated name/value pairs. This function expands |*nvbuf_ptr| as
|
|
* necessary and updates these variables.
|
|
*
|
|
* This function returns 0 if it succeeds or one of the following
|
|
* negative error codes:
|
|
*
|
|
* SPDYLAY_ERR_INVALID_FRAME
|
|
* The input data are invalid.
|
|
* SPDYLAY_ERR_ZLIB
|
|
* The inflate operation failed.
|
|
* SPDYLAY_ERR_NOMEM
|
|
* Out of memory.
|
|
*/
|
|
int spdylay_frame_unpack_syn_reply(spdylay_syn_reply *frame,
|
|
spdylay_buffer *inflatebuf,
|
|
uint8_t **nvbuf_ptr,
|
|
size_t *nvbuflen_ptr,
|
|
const uint8_t *head, size_t headlen,
|
|
const uint8_t *payload, size_t payloadlen,
|
|
spdylay_zlib *inflater);
|
|
|
|
/*
|
|
* Packs PING frame |frame| in wire format and store it in
|
|
* |*buf_ptr|. The capacity of |*buf_ptr| is |*buflen_ptr|
|
|
* length. This function expands |*buf_ptr| as necessary to store
|
|
* given |frame|.
|
|
*
|
|
* This function returns 0 if it succeeds or one of the following
|
|
* negative error codes:
|
|
*
|
|
* SPDYLAY_ERR_NOMEM
|
|
* Out of memory.
|
|
*/
|
|
ssize_t spdylay_frame_pack_ping(uint8_t **buf_ptr, size_t *buflen_ptr,
|
|
spdylay_ping *frame);
|
|
|
|
/*
|
|
* Unpacks PING wire format into |frame|.
|
|
*
|
|
* This function returns 0 if it succeeds or one of the following
|
|
* negative error codes:
|
|
*
|
|
* SPDYLAY_ERR_INVALID_FRAME
|
|
* The input data are invalid.
|
|
*/
|
|
int spdylay_frame_unpack_ping(spdylay_ping *frame,
|
|
const uint8_t *head, size_t headlen,
|
|
const uint8_t *payload, size_t payloadlen);
|
|
|
|
/*
|
|
* Packs GOAWAY frame |frame | in wire format and store it in
|
|
* |*buf_ptr|. The capacity of |*buf_ptr| is |*buflen_ptr|
|
|
* length. This function expands |*buf_ptr| as necessary to store
|
|
* given |frame|.
|
|
*
|
|
* This function returns 0 if it succeeds or one of the following
|
|
* negative error codes:
|
|
*
|
|
* SPDYLAY_ERR_NOMEM
|
|
* Out of memory.
|
|
*/
|
|
ssize_t spdylay_frame_pack_goaway(uint8_t **buf_ptr, size_t *buflen_ptr,
|
|
spdylay_goaway *frame);
|
|
|
|
/*
|
|
* Unpacks GOAWAY wire format into |frame|.
|
|
*
|
|
* This function returns 0 if it succeeds or one of the following
|
|
* negative error codes:
|
|
*
|
|
* SPDYLAY_ERR_INVALID_FRAME
|
|
* The input data are invalid.
|
|
*/
|
|
int spdylay_frame_unpack_goaway(spdylay_goaway *frame,
|
|
const uint8_t *head, size_t headlen,
|
|
const uint8_t *payload, size_t payloadlen);
|
|
|
|
/*
|
|
* Packs HEADERS frame |frame| in wire format and store it in
|
|
* |*buf_ptr|. The capacity of |*buf_ptr| is |*buflen_ptr| bytes.
|
|
* The |*nvbuf_ptr| is used to store inflated name/value pairs in wire
|
|
* format temporarily. Its length is |*nvbuflen_ptr| bytes. This
|
|
* function expands |*buf_ptr| and |*nvbuf_ptr| as necessary to store
|
|
* frame and name/value pairs. When expansion occurred, memory
|
|
* previously pointed by |*buf_ptr| and |*nvbuf_ptr| is freed.
|
|
* |*buf_ptr|, |*buflen_ptr|, |*nvbuf_ptr| and |*nvbuflen_ptr| are
|
|
* updated accordingly.
|
|
*
|
|
* frame->hd.length is assigned after length is determined during
|
|
* packing process.
|
|
*
|
|
* This function returns the size of packed frame if it succeeds, or
|
|
* returns one of the following negative error codes:
|
|
*
|
|
* SPDYLAY_ERR_ZLIB
|
|
* The deflate operation failed.
|
|
* SPDYLAY_ERR_NOMEM
|
|
* Out of memory.
|
|
*/
|
|
ssize_t spdylay_frame_pack_headers(uint8_t **buf_ptr, size_t *buflen_ptr,
|
|
uint8_t **nvbuf_ptr, size_t *nvbuflen_ptr,
|
|
spdylay_headers *frame,
|
|
spdylay_zlib *deflater);
|
|
|
|
/*
|
|
* Unpacks HEADERS wire format into |frame|.
|
|
*
|
|
* |inflatebuf| is used to buffer name/value pairs while inflating
|
|
* them using |inflater|. The caller must reset |inflatebuf| before
|
|
* the call. |*nvbuf_ptr|, |*nvbuflen_ptr| is used to store temporal
|
|
* inflated name/value pairs. This function expands |*nvbuf_ptr| as
|
|
* necessary and updates these variables.
|
|
*
|
|
* This function returns 0 if it succeeds or one of the following
|
|
* negative error codes:
|
|
*
|
|
* SPDYLAY_ERR_INVALID_FRAME
|
|
* The input data are invalid.
|
|
* SPDYLAY_ERR_ZLIB
|
|
* The inflate operation failed.
|
|
* SPDYLAY_ERR_NOMEM
|
|
* Out of memory.
|
|
*/
|
|
int spdylay_frame_unpack_headers(spdylay_headers *frame,
|
|
spdylay_buffer *inflatebuf,
|
|
uint8_t **nvbuf_ptr,
|
|
size_t *nvbuflen_ptr,
|
|
const uint8_t *head, size_t headlen,
|
|
const uint8_t *payload, size_t payloadlen,
|
|
spdylay_zlib *inflater);
|
|
|
|
/*
|
|
* Packs RST_STREAM frame |frame| in wire frame format and store it in
|
|
* |*buf_ptr|. The capacity of |*buf_ptr| is |*buflen_ptr|
|
|
* length. This function expands |*buf_ptr| as necessary to store
|
|
* given |frame|. In spdy/2 spc, RST_STREAM wire format is always 16
|
|
* bytes long.
|
|
*
|
|
* This function returns the size of packed frame if it succeeds, or
|
|
* returns one of the following negative error codes:
|
|
*
|
|
* SPDYLAY_ERR_NOMEM
|
|
* Out of memory.
|
|
*/
|
|
ssize_t spdylay_frame_pack_rst_stream(uint8_t **buf_ptr, size_t *buflen_ptr,
|
|
spdylay_rst_stream *frame);
|
|
|
|
/*
|
|
* Unpacks RST_STREAM frame byte sequence into |frame|.
|
|
*
|
|
* This function returns 0 if it succeeds or one of the following
|
|
* negative error codes:
|
|
*
|
|
* SPDYLAY_ERR_INVALID_FRAME
|
|
* The input data are invalid.
|
|
*/
|
|
int spdylay_frame_unpack_rst_stream(spdylay_rst_stream *frame,
|
|
const uint8_t *head, size_t headlen,
|
|
const uint8_t *payload, size_t payloadlen);
|
|
|
|
/*
|
|
* Packs SETTINGS frame |frame| in wire format and store it in
|
|
* |*buf_ptr|. The capacity of |*buf_ptr| is |*buflen_ptr|
|
|
* length. This function expands |*buf_ptr| as necessary to store
|
|
* given |frame|.
|
|
*
|
|
* This function returns the size of packed frame if it succeeds, or
|
|
* returns one of the following negative error codes:
|
|
*
|
|
* SPDYLAY_ERR_NOMEM
|
|
* Out of memory.
|
|
*/
|
|
ssize_t spdylay_frame_pack_settings(uint8_t **buf_ptr, size_t *buflen_ptr,
|
|
spdylay_settings *frame);
|
|
|
|
/*
|
|
* Unpacks SETTINGS wire format into |frame|.
|
|
*
|
|
* This function returns 0 if it succeeds or one of the following
|
|
* negative error codes:
|
|
*
|
|
* SPDYLAY_ERR_INVALID_FRAME
|
|
* The input data are invalid.
|
|
* SPDYLAY_ERR_NOMEM
|
|
* Out of memory.
|
|
*/
|
|
int spdylay_frame_unpack_settings(spdylay_settings *frame,
|
|
const uint8_t *head, size_t headlen,
|
|
const uint8_t *payload, size_t payloadlen);
|
|
|
|
/*
|
|
* Returns number of bytes to pack name/value pairs |nv|. This
|
|
* function expects |nv| is sorted in ascending order of key.
|
|
* |len_size| is the number of bytes in length of name/value pair and
|
|
* it must be 2 or 4.
|
|
*
|
|
* This function can handles duplicate keys and concatenation of thier
|
|
* values with '\0'.
|
|
*/
|
|
size_t spdylay_frame_count_nv_space(char **nv, size_t len_size);
|
|
|
|
/*
|
|
* Packs name/value pairs in |nv| in |buf|. |buf| must have at least
|
|
* spdylay_frame_count_nv_space(nv) bytes. |len_size| is the number
|
|
* of bytes in length of name/value pair and it must be 2 or 4.
|
|
*/
|
|
ssize_t spdylay_frame_pack_nv(uint8_t *buf, char **nv, size_t len_size);
|
|
|
|
/*
|
|
* Counts number of name/value pair in |in| and computes length of
|
|
* buffers to store unpacked name/value pair and store them in
|
|
* |*num_nv_ptr| and |*buf_size_ptr| respectively. |len_size| is the
|
|
* number of bytes in length of name/value pair and it must be 2 or
|
|
* 4. We use folloing data structure in |*buf_size_ptr|. First part
|
|
* of the data is array of pointer to name/value pair. Supporse the
|
|
* buf pointer points to the data region and N is the number of
|
|
* name/value pair. First (N*2+1)*sizeof(char*) bytes contain array
|
|
* of pointer to name/value pair and terminating NULL. Each pointer
|
|
* to name/value pair points to the string in remaining data. For
|
|
* each name/value pair, the name is copied to the remaining data with
|
|
* terminating NULL character. The value is also copied to the
|
|
* position after the data with terminating NULL character. The
|
|
* corresponding index is assigned to these pointers. If the value
|
|
* contains multiple values (delimited by single NULL), for each such
|
|
* data, corresponding index is assigned to name/value pointers. In
|
|
* this case, the name string is reused.
|
|
*
|
|
* With the above stragety, |*buf_size_ptr| is calculated as
|
|
* (N*2+1)*sizeof(char*)+sum(strlen(name)+1+strlen(value)+1){for each
|
|
* name/value pair}.
|
|
*
|
|
* This function returns 0 if it succeeds, or one of the following
|
|
* negative error codes:
|
|
*
|
|
* SPDYLAY_ERR_INVALID_FRAME
|
|
* The input data are invalid.
|
|
*/
|
|
int spdylay_frame_count_unpack_nv_space
|
|
(size_t *num_nv_ptr, size_t *buf_size_ptr, const uint8_t *in, size_t inlen,
|
|
size_t len_size);
|
|
|
|
/*
|
|
* Unpacks name/value pairs in wire format |in| with length |inlen|
|
|
* and stores them in |*nv_ptr|. Thif function allocates enough
|
|
* memory to store name/value pairs in |*nv_ptr|. |len_size| is the
|
|
* number of bytes in length of name/value pair and it must be 2 or 4.
|
|
*
|
|
* This function returns 0 if it succeeds, or one of the following
|
|
* negative error codes:
|
|
*
|
|
* SPDYLAY_ERR_NOMEM
|
|
* Out of memory.
|
|
*/
|
|
int spdylay_frame_unpack_nv(char ***nv_ptr, const uint8_t *in, size_t inlen,
|
|
size_t len_size);
|
|
|
|
/*
|
|
* Initializes SYN_STREAM frame |frame| with given values. |frame|
|
|
* takes ownership of |nv|, so caller must not free it. If stream_id
|
|
* is not assigned yet, it must be 0.
|
|
*/
|
|
void spdylay_frame_syn_stream_init(spdylay_syn_stream *frame,
|
|
uint16_t version, uint8_t flags,
|
|
int32_t stream_id, int32_t assoc_stream_id,
|
|
uint8_t pri, char **nv);
|
|
|
|
void spdylay_frame_syn_stream_free(spdylay_syn_stream *frame);
|
|
|
|
void spdylay_frame_syn_reply_init(spdylay_syn_reply *frame,
|
|
uint16_t version, uint8_t flags,
|
|
int32_t stream_id, char **nv);
|
|
|
|
void spdylay_frame_syn_reply_free(spdylay_syn_reply *frame);
|
|
|
|
void spdylay_frame_ping_init(spdylay_ping *frame, uint16_t version,
|
|
uint32_t unique_id);
|
|
|
|
void spdylay_frame_ping_free(spdylay_ping *frame);
|
|
|
|
void spdylay_frame_goaway_init(spdylay_goaway *frame, uint16_t version,
|
|
int32_t last_good_stream_id);
|
|
|
|
void spdylay_frame_goaway_free(spdylay_goaway *frame);
|
|
|
|
void spdylay_frame_headers_init(spdylay_headers *frame, uint16_t version,
|
|
uint8_t flags,
|
|
int32_t stream_id, char **nv);
|
|
|
|
void spdylay_frame_headers_free(spdylay_headers *frame);
|
|
|
|
void spdylay_frame_rst_stream_init(spdylay_rst_stream *frame,
|
|
uint16_t version,
|
|
int32_t stream_id, uint32_t status_code);
|
|
|
|
void spdylay_frame_rst_stream_free(spdylay_rst_stream *frame);
|
|
|
|
/*
|
|
* Initializes SETTINGS frame |frame| with given values. |frame| takes
|
|
* ownership of |iv|, so caller must not free it.
|
|
*/
|
|
void spdylay_frame_settings_init(spdylay_settings *frame,
|
|
uint16_t version, uint8_t flags,
|
|
spdylay_settings_entry *iv, size_t niv);
|
|
|
|
void spdylay_frame_settings_free(spdylay_settings *frame);
|
|
|
|
void spdylay_frame_data_init(spdylay_data *frame, int32_t stream_id,
|
|
uint8_t flags,
|
|
const spdylay_data_provider *data_prd);
|
|
|
|
void spdylay_frame_data_free(spdylay_data *frame);
|
|
|
|
/*
|
|
* Returns 1 if the first byte of this frame indicates it is a control
|
|
* frame.
|
|
*/
|
|
int spdylay_frame_is_ctrl_frame(uint8_t first_byte);
|
|
|
|
/*
|
|
* Deallocates memory of name/value pair |nv|.
|
|
*/
|
|
void spdylay_frame_nv_del(char **nv);
|
|
|
|
/*
|
|
* Makes a deep copy of |nv| and returns the copy. This function
|
|
* returns the pointer to the copy if it succeeds, or NULL. To free
|
|
* allocated memory, use spdylay_frame_nv_del().
|
|
*/
|
|
char** spdylay_frame_nv_copy(const char **nv);
|
|
|
|
/*
|
|
* Sorts |nv| in the ascending order of name.
|
|
*/
|
|
void spdylay_frame_nv_sort(char **nv);
|
|
|
|
/*
|
|
* Makes names in |nv| lower cased.
|
|
*/
|
|
void spdylay_frame_nv_downcase(char **nv);
|
|
|
|
/*
|
|
* Makes copy of |iv| and return the copy. The |niv| is the number of
|
|
* entries in |iv|. This function returns the pointer to the copy if
|
|
* it succeeds, or NULL.
|
|
*/
|
|
spdylay_settings_entry* spdylay_frame_iv_copy(const spdylay_settings_entry *iv,
|
|
size_t niv);
|
|
|
|
#endif /* SPDYLAY_FRAME_H */
|