http2.h File Reference

Go to the source code of this file.

Data Structures
struct	http2_request_view_t
struct	http2_header

Typedefs
typedef struct http2_connection	http2_connection_t
typedef struct http2_header	http2_header_t
typedef asciichat_error_t(*	http2_request_fn) (http2_connection_t *connection, const http2_request_view_t *request, void *user_data)

Functions
asciichat_error_t	http2_connection_create (http2_connection_t **connection, http2_request_fn on_request, void *user_data, size_t max_request_body_length, size_t max_response_body_length)
void	http2_connection_destroy (http2_connection_t **connection)
asciichat_error_t	http2_connection_receive (http2_connection_t *connection, const void *data, size_t length)
asciichat_error_t	http2_connection_next_output (http2_connection_t *connection, const uint8_t **data, size_t *length)
asciichat_error_t	http2_connection_submit_response (http2_connection_t *connection, int32_t stream_id, unsigned status, const http_header_t *headers, size_t header_count, const void *body, size_t body_length)

Typedef Documentation

http2_connection_t

typedef struct http2_connection http2_connection_t

Definition at line 8 of file http2.h.

http2_header_t

typedef struct http2_header http2_header_t

http2_request_fn

typedef asciichat_error_t(* http2_request_fn) (http2_connection_t *connection, const http2_request_view_t *request, void *user_data)

Definition at line 23 of file http2.h.

Function Documentation

http2_connection_create()

asciichat_error_t http2_connection_create	(	http2_connection_t **	connection,
		http2_request_fn	on_request,
		void *	user_data,
		size_t	max_request_body_length,
		size_t	max_response_body_length )

Definition at line 189 of file http2.c.

                                                                                                           {
  if (!out || !on_request || max_request_body_length == 0 || max_response_body_length == 0)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing HTTP/2 request callback");
  http2_connection_t *connection = SAFE_CALLOC(1, sizeof(*connection), http2_connection_t *);
  nghttp2_session_callbacks *callbacks = NULL;
  nghttp2_option *options = NULL;
  if (nghttp2_session_callbacks_new(&callbacks) != 0 || nghttp2_option_new(&options) != 0) {
    nghttp2_session_callbacks_del(callbacks);
    nghttp2_option_del(options);
    SAFE_FREE(connection);
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Cannot initialize HTTP/2 callbacks");
  }
  nghttp2_session_callbacks_set_on_begin_headers_callback(callbacks, on_begin_headers);
  nghttp2_session_callbacks_set_on_header_callback(callbacks, on_header);
  nghttp2_session_callbacks_set_on_data_chunk_recv_callback(callbacks, on_data);
  nghttp2_session_callbacks_set_on_frame_recv_callback(callbacks, on_frame_recv);
  nghttp2_session_callbacks_set_on_stream_close_callback(callbacks, on_stream_close);
  if (nghttp2_session_server_new2(&connection->session, callbacks, connection, options) != 0) {
    nghttp2_session_callbacks_del(callbacks);
    nghttp2_option_del(options);
    SAFE_FREE(connection);
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Cannot initialize HTTP/2 session");
  }
  nghttp2_session_callbacks_del(callbacks);
  nghttp2_option_del(options);
  nghttp2_settings_entry settings = {NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS, HTTP2_MAX_CONCURRENT_STREAMS};
  if (nghttp2_submit_settings(connection->session, NGHTTP2_FLAG_NONE, &settings, 1) != 0) {
    nghttp2_session_del(connection->session);
    SAFE_FREE(connection);
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Cannot configure HTTP/2 stream limit");
  }
  connection->on_request = on_request;
  connection->user_data = user_data;
  connection->max_body_length = max_request_body_length;
  connection->max_response_body_length = max_response_body_length;
  *out = connection;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_NETWORK_PROTOCOL, HTTP2_MAX_CONCURRENT_STREAMS, http2_connection::max_body_length, http2_connection::max_response_body_length, http2_connection::on_request, out, SAFE_CALLOC, SAFE_FREE, http2_connection::session, SET_ERRNO, and http2_connection::user_data.

http2_connection_destroy()

void http2_connection_destroy

(

http2_connection_t **

connection

)

Definition at line 229 of file http2.c.

                                                               {
  if (!connection || !*connection)
    return;
  nghttp2_session_del((*connection)->session);
  SAFE_FREE(*connection);
  *connection = NULL;
}

References SAFE_FREE.

http2_connection_next_output()

asciichat_error_t http2_connection_next_output	(	http2_connection_t *	connection,
		const uint8_t **	data,
		size_t *	length )

Definition at line 245 of file http2.c.

                                                                                                                     {
  if (!connection || !data || !length)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid HTTP/2 output request");
  ssize_t output_length = nghttp2_session_mem_send(connection->session, &connection->output);
  if (output_length < 0)
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Cannot serialize HTTP/2 output");
  connection->output_length = (size_t)output_length;
  *data = connection->output;
  *length = connection->output_length;
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_NETWORK_PROTOCOL, http2_connection::output, http2_connection::output_length, http2_connection::session, and SET_ERRNO.

http2_connection_receive()

asciichat_error_t http2_connection_receive	(	http2_connection_t *	connection,
		const void *	data,
		size_t	length )

Definition at line 237 of file http2.c.

                                                                                                            {
  if (!connection || (!data && length))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid HTTP/2 input");
  if (nghttp2_session_mem_recv(connection->session, data, length) < 0)
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Invalid HTTP/2 frame sequence");
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_NETWORK_PROTOCOL, http2_connection::session, and SET_ERRNO.

http2_connection_submit_response()

asciichat_error_t http2_connection_submit_response	(	http2_connection_t *	connection,
		int32_t	stream_id,
		unsigned	status,
		const http_header_t *	headers,
		size_t	header_count,
		const void *	body,
		size_t	body_length )

Definition at line 257 of file http2.c.

                                                                       {
  if (!connection || status < 100 || status > 599 || body_length > connection->max_response_body_length ||
      (!body && body_length))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid HTTP/2 response");
  if (header_count > HTTP2_MAX_HEADERS || (header_count && !headers))
    return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid HTTP/2 response headers");
  char *status_text = SAFE_MALLOC(4, char *);
  if (!status_text)
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate HTTP/2 response status");
  safe_snprintf(status_text, 4, "%u", status);
  response_state_t *response = SAFE_CALLOC(1, sizeof(*response), response_state_t *);
  if (!response) {
    SAFE_FREE(status_text);
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate HTTP/2 response state");
  }
  response->length = body_length;
  if (body_length) {
    response->data = SAFE_MALLOC(body_length, char *);
    if (!response->data) {
      SAFE_FREE(response);
      return SET_ERRNO(ERROR_MEMORY, "Cannot allocate HTTP/2 response body");
    }
    memcpy(response->data, body, body_length);
  }
  nghttp2_nv *fields = SAFE_CALLOC(header_count + 1, sizeof(*fields), nghttp2_nv *);
  if (!fields) {
    SAFE_FREE(status_text);
    SAFE_FREE(response->data);
    SAFE_FREE(response);
    return SET_ERRNO(ERROR_MEMORY, "Cannot allocate HTTP/2 response headers");
  }
  fields[0] = (nghttp2_nv){(uint8_t *)":status", (uint8_t *)status_text, 7, strlen(status_text), NGHTTP2_NV_FLAG_NONE};
  for (size_t i = 0; i < header_count; ++i) {
    if (!headers[i].name || !headers[i].value) {
      SAFE_FREE(fields);
      SAFE_FREE(status_text);
      SAFE_FREE(response->data);
      SAFE_FREE(response);
      return SET_ERRNO(ERROR_INVALID_PARAM, "Invalid HTTP/2 response header");
    }
    fields[i + 1] = (nghttp2_nv){(uint8_t *)headers[i].name, (uint8_t *)headers[i].value, strlen(headers[i].name),
                                 strlen(headers[i].value), NGHTTP2_NV_FLAG_NONE};
  }
  nghttp2_data_provider provider = {.source = {.ptr = response}, .read_callback = read_response};
  int result =
      nghttp2_submit_response(connection->session, stream_id, fields, header_count + 1, body_length ? &provider : NULL);
  SAFE_FREE(fields);
  SAFE_FREE(status_text);
  if (!body_length)
    SAFE_FREE(response);
  if (result != 0) {
    if (body_length) {
      SAFE_FREE(response->data);
      SAFE_FREE(response);
    }
    return SET_ERRNO(ERROR_NETWORK_PROTOCOL, "Cannot submit HTTP/2 response");
  }
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, response_state_t::data, ERROR_INVALID_PARAM, ERROR_MEMORY, ERROR_NETWORK_PROTOCOL, HTTP2_MAX_HEADERS, response_state_t::length, http2_connection::max_response_body_length, SAFE_CALLOC, SAFE_FREE, SAFE_MALLOC, safe_snprintf(), http2_connection::session, SET_ERRNO, and http_header_t::value.

Referenced by http_response_finish().