path: root/src/plugins/http/http.h

/*
 * Copyright (c) 2022 Cisco and/or its affiliates.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef SRC_PLUGINS_HTTP_HTTP_H_
#define SRC_PLUGINS_HTTP_HTTP_H_

#include <ctype.h>

#include <vnet/plugin/plugin.h>
#include <vpp/app/version.h>

#include <vppinfra/time_range.h>

#include <vnet/session/application_interface.h>
#include <vnet/session/application.h>
#include <http/http_buffer.h>

#define HTTP_DEBUG 0

#if HTTP_DEBUG
#define HTTP_DBG(_lvl, _fmt, _args...)                                        \
  if (_lvl <= HTTP_DEBUG)                                                     \
  clib_warning (_fmt, ##_args)
#else
#define HTTP_DBG(_lvl, _fmt, _args...)
#endif

typedef struct http_conn_id_
{
  union
  {
    session_handle_t app_session_handle;
    u32 parent_app_api_ctx;
  };
  session_handle_t tc_session_handle;
  u32 parent_app_wrk_index;
} http_conn_id_t;

STATIC_ASSERT (sizeof (http_conn_id_t) <= TRANSPORT_CONN_ID_LEN,
	       "ctx id must be less than TRANSPORT_CONN_ID_LEN");

typedef enum http_conn_state_
{
  HTTP_CONN_STATE_LISTEN,
  HTTP_CONN_STATE_CONNECTING,
  HTTP_CONN_STATE_ESTABLISHED,
  HTTP_CONN_STATE_TRANSPORT_CLOSED,
  HTTP_CONN_STATE_APP_CLOSED,
  HTTP_CONN_STATE_CLOSED
} http_conn_state_t;

typedef enum http_state_
{
  HTTP_STATE_IDLE = 0,
  HTTP_STATE_WAIT_APP_METHOD,
  HTTP_STATE_WAIT_CLIENT_METHOD,
  HTTP_STATE_WAIT_SERVER_REPLY,
  HTTP_STATE_WAIT_APP_REPLY,
  HTTP_STATE_CLIENT_IO_MORE_DATA,
  HTTP_STATE_APP_IO_MORE_DATA,
  HTTP_N_STATES,
} http_state_t;

typedef enum http_req_method_
{
  HTTP_REQ_GET = 0,
  HTTP_REQ_POST,
} http_req_method_t;

typedef enum http_msg_type_
{
  HTTP_MSG_REQUEST,
  HTTP_MSG_REPLY
} http_msg_type_t;

typedef enum http_target_form_
{
  HTTP_TARGET_ORIGIN_FORM,
  HTTP_TARGET_ABSOLUTE_FORM,
  HTTP_TARGET_AUTHORITY_FORM,
  HTTP_TARGET_ASTERISK_FORM
} http_target_form_t;

#define foreach_http_content_type                                             \
  _ (APP_7Z, ".7z", "application / x - 7z - compressed")                      \
  _ (APP_DOC, ".doc", "application / msword")                                 \
  _ (APP_DOCX, ".docx",                                                       \
     "application / vnd.openxmlformats - "                                    \
     "officedocument.wordprocessingml.document")                              \
  _ (APP_EPUB, ".epub", "application / epub + zip")                           \
  _ (APP_FONT, ".eot", "application / vnd.ms - fontobject")                   \
  _ (APP_JAR, ".jar", "application / java - archive")                         \
  _ (APP_JSON, ".json", "application / json")                                 \
  _ (APP_JSON_LD, ".jsonld", "application / ld + json")                       \
  _ (APP_MPKG, ".mpkg", "application / vnd.apple.installer + xml")            \
  _ (APP_ODP, ".odp", "application / vnd.oasis.opendocument.presentation")    \
  _ (APP_ODS, ".ods", "application / vnd.oasis.opendocument.spreadsheet")     \
  _ (APP_ODT, ".odt", "application / vnd.oasis.opendocument.text")            \
  _ (APP_OGX, ".ogx", "application / ogg")                                    \
  _ (APP_PDF, ".pdf", "application / pdf")                                    \
  _ (APP_PHP, ".php", "application / x - httpd - php")                        \
  _ (APP_PPT, ".ppt", "application / vnd.ms - powerpoint")                    \
  _ (APP_PPTX, ".pptx", "application / vnd.ms - powerpoint")                  \
  _ (APP_RAR, ".rar", "application / vnd.rar")                                \
  _ (APP_RTF, ".rtf", "application / rtf")                                    \
  _ (APP_SH, ".sh", "application / x - sh")                                   \
  _ (APP_TAR, ".tar", "application / x - tar")                                \
  _ (APP_VSD, ".vsd", "application / vnd.visio")                              \
  _ (APP_XHTML, ".xhtml", "application / xhtml + xml")                        \
  _ (APP_XLS, ".xls", "application / vnd.ms - excel")                         \
  _ (APP_XML, ".xml", "application / xml")                                    \
  _ (APP_XSLX, ".xlsx",                                                       \
     "application / vnd.openxmlformats - officedocument.spreadsheetml.sheet") \
  _ (APP_XUL, ".xul", "application / vnd.mozilla.xul + xml")                  \
  _ (APP_ZIP, ".zip", "application / zip")                                    \
  _ (AUDIO_AAC, ".aac", "audio / aac")                                        \
  _ (AUDIO_CD, ".cda", "application / x - cdf")                               \
  _ (AUDIO_WAV, ".wav", "audio / wav")                                        \
  _ (AUDIO_WEBA, ".weba", "audio / webm")                                     \
  _ (AUDO_MIDI, ".midi", "audio / midi")                                      \
  _ (AUDO_MID, ".mid", "audo / midi")                                         \
  _ (AUDO_MP3, ".mp3", "audio / mpeg")                                        \
  _ (AUDO_OGA, ".oga", "audio / ogg")                                         \
  _ (AUDO_OPUS, ".opus", "audio / opus")                                      \
  _ (APP_OCTET_STREAM, ".bin", "application / octet - stream")                \
  _ (BZIP2, ".bz2", "application / x - bzip2")                                \
  _ (BZIP, ".bz", "application / x - bzip")                                   \
  _ (FONT_OTF, ".otf", "font / otf")                                          \
  _ (FONT_TTF, ".ttf", "font / ttf")                                          \
  _ (FONT_WOFF2, ".woff2", "font / woff2")                                    \
  _ (FONT_WOFF, ".woff", "font / woff")                                       \
  _ (GZIP, ".gz", "application / gzip")                                       \
  _ (IMAGE_AVIF, ".avif", "image / avif")                                     \
  _ (IMAGE_BMP, ".bmp", "image / bmp")                                        \
  _ (IMAGE_GIF, ".gif", "image / gif")                                        \
  _ (IMAGE_ICON, ".ico", "image / vnd.microsoft.icon")                        \
  _ (IMAGE_JPEG, ".jpeg", "image / jpeg")                                     \
  _ (IMAGE_JPG, ".jpg", "image / jpeg")                                       \
  _ (IMAGE_PNG, ".png", "image / png")                                        \
  _ (IMAGE_SVG, ".svg", "image / svg + xml")                                  \
  _ (IMAGE_TIFF, ".tiff", "image / tiff")                                     \
  _ (IMAGE_TIF, ".tif", "image / tiff")                                       \
  _ (IMAGE_WEBP, ".webp", "image / webp")                                     \
  _ (SCRIPT_CSH, ".csh", "application / x - csh")                             \
  _ (TEXT_ABIWORD, ".abw", "application / x - abiword")                       \
  _ (TEXT_ARCHIVE, ".arc", "application / x - freearc")                       \
  _ (TEXT_AZW, ".azw", "application / vnd.amazon.ebook")                      \
  _ (TEXT_CALENDAR, ".ics", "text / calendar")                                \
  _ (TEXT_CSS, ".css", "text / css")                                          \
  _ (TEXT_CSV, ".csv", "text / csv")                                          \
  _ (TEXT_HTM, ".htm", "text / html")                                         \
  _ (TEXT_HTML, ".html", "text / html")                                       \
  _ (TEXT_JS, ".js", "text / javascript")                                     \
  _ (TEXT_MJS, ".mjs", "text / javascript")                                   \
  _ (TEXT_PLAIN, ".txt", "text / plain")                                      \
  _ (VIDEO_3GP2, ".3g2", "video / 3gpp2")                                     \
  _ (VIDEO_3GP, ".3gp", "video / 3gpp")                                       \
  _ (VIDEO_AVI, ".avi", "video / x - msvideo")                                \
  _ (VIDEO_MP4, ".mp4", "video / mp4")                                        \
  _ (VIDEO_MPEG, ".mpeg", "video / mpeg")                                     \
  _ (VIDEO_OGG, ".ogv", "video / ogg")                                        \
  _ (VIDEO_TS, ".ts", "video / mp2t")                                         \
  _ (VIDEO_WEBM, ".webm", "video / webm")

typedef enum http_content_type_
{
#define _(s, ext, str) HTTP_CONTENT_##s,
  foreach_http_content_type
#undef _
} http_content_type_t;

#define foreach_http_status_code                                              \
  _ (100, CONTINUE, "100 Continue")                                           \
  _ (101, SWITCHING_PROTOCOLS, "101 Switching Protocols")                     \
  _ (200, OK, "200 OK")                                                       \
  _ (201, CREATED, "201 Created")                                             \
  _ (202, ACCEPTED, "202 Accepted")                                           \
  _ (203, NON_UTHORITATIVE_INFORMATION, "203 Non-Authoritative Information")  \
  _ (204, NO_CONTENT, "204 No Content")                                       \
  _ (205, RESET_CONTENT, "205 Reset Content")                                 \
  _ (206, PARTIAL_CONTENT, "206 Partial Content")                             \
  _ (300, MULTIPLE_CHOICES, "300 Multiple Choices")                           \
  _ (301, MOVED, "301 Moved Permanently")                                     \
  _ (302, FOUND, "302 Found")                                                 \
  _ (303, SEE_OTHER, "303 See Other")                                         \
  _ (304, NOT_MODIFIED, "304 Not Modified")                                   \
  _ (305, USE_PROXY, "305 Use Proxy")                                         \
  _ (307, TEMPORARY_REDIRECT, "307 Temporary Redirect")                       \
  _ (308, PERMANENT_REDIRECT, "308 Permanent Redirect")                       \
  _ (400, BAD_REQUEST, "400 Bad Request")                                     \
  _ (401, UNAUTHORIZED, "401 Unauthorized")                                   \
  _ (402, PAYMENT_REQUIRED, "402 Payment Required")                           \
  _ (403, FORBIDDEN, "403 Forbidden")                                         \
  _ (404, NOT_FOUND, "404 Not Found")                                         \
  _ (405, METHOD_NOT_ALLOWED, "405 Method Not Allowed")                       \
  _ (406, NOT_ACCEPTABLE, "406 Not Acceptable")                               \
  _ (407, PROXY_AUTHENTICATION_REQUIRED, "407 Proxy Authentication Required") \
  _ (408, REQUEST_TIMEOUT, "408 Request Timeout")                             \
  _ (409, CONFLICT, "409 Conflict")                                           \
  _ (410, GONE, "410 Gone")                                                   \
  _ (411, LENGTH_REQUIRED, "411 Length Required")                             \
  _ (412, PRECONDITION_FAILED, "412 Precondition Failed")                     \
  _ (413, CONTENT_TOO_LARGE, "413 Content Too Large")                         \
  _ (414, URI_TOO_LONG, "414 URI Too Long")                                   \
  _ (415, UNSUPPORTED_MEDIA_TYPE, "415 Unsupported Media Type")               \
  _ (416, RANGE_NOT_SATISFIABLE, "416 Range Not Satisfiable")                 \
  _ (417, EXPECTATION_FAILED, "417 Expectation Failed")                       \
  _ (421, MISDIRECTED_REQUEST, "421 Misdirected Request")                     \
  _ (422, UNPROCESSABLE_CONTENT, "422 Unprocessable_Content")                 \
  _ (426, UPGRADE_REQUIRED, "426 Upgrade Required")                           \
  _ (500, INTERNAL_ERROR, "500 Internal Server Error")                        \
  _ (501, NOT_IMPLEMENTED, "501 Not Implemented")                             \
  _ (502, BAD_GATEWAY, "502 Bad Gateway")                                     \
  _ (503, SERVICE_UNAVAILABLE, "503 Service Unavailable")                     \
  _ (504, GATEWAY_TIMEOUT, "504 Gateway Timeout")                             \
  _ (505, HTTP_VERSION_NOT_SUPPORTED, "505 HTTP Version Not Supported")

typedef enum http_status_code_
{
#define _(c, s, str) HTTP_STATUS_##s,
  foreach_http_status_code
#undef _
    HTTP_N_STATUS
} http_status_code_t;

#define HTTP_HEADER_ACCEPT		      "Accept"
#define HTTP_HEADER_ACCEPT_CHARSET	      "Accept-Charset"
#define HTTP_HEADER_ACCEPT_ENCODING	      "Accept-Encoding"
#define HTTP_HEADER_ACCEPT_LANGUAGE	      "Accept-Language"
#define HTTP_HEADER_ACCEPT_RANGES	      "Accept-Ranges"
#define HTTP_HEADER_ALLOW		      "Allow"
#define HTTP_HEADER_AUTHENTICATION_INFO	      "Authentication-Info"
#define HTTP_HEADER_AUTHORIZATION	      "Authorization"
#define HTTP_HEADER_CLOSE		      "Close"
#define HTTP_HEADER_CONNECTION		      "Connection"
#define HTTP_HEADER_CONTENT_ENCODING	      "Content-Encoding"
#define HTTP_HEADER_CONTENT_LANGUAGE	      "Content-Language"
#define HTTP_HEADER_CONTENT_LENGTH	      "Content-Length"
#define HTTP_HEADER_CONTENT_LOCATION	      "Content-Location"
#define HTTP_HEADER_CONTENT_RANGE	      "Content-Range"
#define HTTP_HEADER_CONTENT_TYPE	      "Content-Type"
#define HTTP_HEADER_DATE		      "Date"
#define HTTP_HEADER_ETAG		      "ETag"
#define HTTP_HEADER_EXPECT		      "Expect"
#define HTTP_HEADER_FROM		      "From"
#define HTTP_HEADER_HOST		      "Host"
#define HTTP_HEADER_IF_MATCH		      "If-Match"
#define HTTP_HEADER_IF_MODIFIED_SINCE	      "If-Modified-Since"
#define HTTP_HEADER_IF_NONE_MATCH	      "If-None-Match"
#define HTTP_HEADER_IF_RANGE		      "If-Range"
#define HTTP_HEADER_IF_UNMODIFIED_SINCE	      "If-Unmodified-Since"
#define HTTP_HEADER_LAST_MODIFIED	      "Last-Modified"
#define HTTP_HEADER_LOCATION		      "Location"
#define HTTP_HEADER_MAX_FORWARDS	      "Max-Forwards"
#define HTTP_HEADER_PROXY_AUTHENTICATE	      "Proxy-Authenticate"
#define HTTP_HEADER_PROXY_AUTHENTICATION_INFO "Proxy-Authentication-Info"
#define HTTP_HEADER_PROXY_AUTHORIZATION	      "Proxy-Authorization"
#define HTTP_HEADER_RANGE		      "Range"
#define HTTP_HEADER_REFERER		      "Referer"
#define HTTP_HEADER_RETRY_AFTER		      "Retry-After"
#define HTTP_HEADER_SERVER		      "Server"
#define HTTP_HEADER_TE			      "TE"
#define HTTP_HEADER_TRAILER		      "Trailer"
#define HTTP_HEADER_TRANSFER_ENCODING	      "Transfer-Encoding"
#define HTTP_HEADER_UPGRADE		      "Upgrade"
#define HTTP_HEADER_USER_AGENT		      "User-Agent"
#define HTTP_HEADER_VARY		      "Vary"
#define HTTP_HEADER_VIA			      "Via"
#define HTTP_HEADER_WWW_AUTHENTICATE	      "WWW-Authenticate"

typedef enum http_msg_data_type_
{
  HTTP_MSG_DATA_INLINE,
  HTTP_MSG_DATA_PTR
} http_msg_data_type_t;

typedef struct http_msg_data_
{
  http_msg_data_type_t type;
  u64 len;
  http_target_form_t target_form;
  u32 target_path_offset;
  u32 target_path_len;
  u32 target_query_offset;
  u32 target_query_len;
  u32 headers_offset;
  u32 headers_len;
  u32 body_offset;
  u32 body_len;
  u8 data[0];
} http_msg_data_t;

typedef struct http_msg_
{
  http_msg_type_t type;
  union
  {
    http_req_method_t method_type;
    http_status_code_t code;
  };
  http_content_type_t content_type;
  http_msg_data_t data;
} http_msg_t;

typedef struct http_tc_
{
  union
  {
    transport_connection_t connection;
    http_conn_id_t c_http_conn_id;
  };
#define h_tc_session_handle c_http_conn_id.tc_session_handle
#define h_pa_wrk_index	    c_http_conn_id.parent_app_wrk_index
#define h_pa_session_handle c_http_conn_id.app_session_handle
#define h_pa_app_api_ctx    c_http_conn_id.parent_app_api_ctx
#define h_hc_index	    connection.c_index

  http_conn_state_t state;
  u32 timer_handle;
  u8 *app_name;

  /*
   * Current request
   */
  http_state_t http_state;
  http_req_method_t method;
  u8 *rx_buf;
  u32 rx_buf_offset;
  http_buffer_t tx_buf;
  u32 to_recv;
  u32 bytes_dequeued;
  http_target_form_t target_form;
  u32 target_path_offset;
  u32 target_path_len;
  u32 target_query_offset;
  u32 target_query_len;
  u32 headers_offset;
  u32 headers_len;
  u32 body_offset;
  u32 body_len;
} http_conn_t;

typedef struct http_worker_
{
  http_conn_t *conn_pool;
} http_worker_t;

typedef struct http_main_
{
  http_worker_t *wrk;
  http_conn_t *listener_pool;
  u32 app_index;

  clib_timebase_t timebase;

  /*
   * Runtime config
   */
  u8 debug_level;

  /*
   * Config
   */
  u64 first_seg_size;
  u64 add_seg_size;
  u32 fifo_size;
} http_main_t;

always_inline int
_validate_target_syntax (u8 *target, int is_query, int *is_encoded)
{
  int i, encoded = 0;

  static uword valid_chars[4] = {
    /* !$&'()*+,-./0123456789:;= */
    0x2fffffd200000000,
    /* @ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~ */
    0x47fffffe87ffffff,
    0x0000000000000000,
    0x0000000000000000,
  };

  for (i = 0; i < vec_len (target); i++)
    {
      if (clib_bitmap_get_no_check (valid_chars, target[i]))
	continue;
      /* target was already split after first question mark,
       * for query it is valid character */
      if (is_query && target[i] == '?')
	continue;
      /* pct-encoded = "%" HEXDIG HEXDIG */
      if (target[i] == '%')
	{
	  if ((i + 2) > vec_len (target))
	    return -1;
	  if (!isxdigit (target[i + 1]) || !isxdigit (target[i + 2]))
	    return -1;
	  i += 2;
	  encoded = 1;
	  continue;
	}
      clib_warning ("invalid character %d", target[i]);
      return -1;
    }
  if (is_encoded)
    *is_encoded = encoded;
  return 0;
}

/**
 * An "absolute-path" rule validation (RFC9110 section 4.1).
 *
 * @param path       Target path to validate.
 * @param is_encoded Return flag that indicates if percent-encoded (optional).
 *
 * @return @c 0 on success.
 */
always_inline int
http_validate_abs_path_syntax (u8 *path, int *is_encoded)
{
  return _validate_target_syntax (path, 0, is_encoded);
}

/**
 * A "query" rule validation (RFC3986 section 2.1).
 *
 * @param query      Target query to validate.
 * @param is_encoded Return flag that indicates if percent-encoded (optional).
 *
 * @return @c 0 on success.
 */
always_inline int
http_validate_query_syntax (u8 *query, int *is_encoded)
{
  return _validate_target_syntax (query, 1, is_encoded);
}

#define htoi(x) (isdigit (x) ? (x - '0') : (tolower (x) - 'a' + 10))

/**
 * Decode percent-encoded data.
 *
 * @param src Data to decode.
 *
 * @return New vector with decoded data.
 *
 * The caller is always responsible to free the returned vector.
 */
always_inline u8 *
http_percent_decode (u8 *src)
{
  int i;
  u8 *decoded_uri = 0;

  for (i = 0; i < vec_len (src); i++)
    {
      if (src[i] == '%')
	{
	  u8 c = (htoi (src[i + 1]) << 4) | htoi (src[i + 2]);
	  vec_add1 (decoded_uri, c);
	  i += 2;
	}
      else
	vec_add1 (decoded_uri, src[i]);
    }
  return decoded_uri;
}

/**
 * Remove dot segments from path (RFC3986 section 5.2.4)
 *
 * @param path Path to sanitize.
 *
 * @return New vector with sanitized path.
 *
 * The caller is always responsible to free the returned vector.
 */
always_inline u8 *
http_path_remove_dot_segments (u8 *path)
{
  u32 *segments = 0, *segments_len = 0, segment_len;
  u8 *new_path = 0;
  int i, ii;

  if (!path)
    return vec_new (u8, 0);

  segments = vec_new (u32, 1);
  /* first segment */
  segments[0] = 0;
  /* find all segments */
  for (i = 1; i < (vec_len (path) - 1); i++)
    {
      if (path[i] == '/')
	vec_add1 (segments, i + 1);
    }
  /* dummy tail */
  vec_add1 (segments, vec_len (path));

  /* scan all segments for "." and ".." */
  segments_len = vec_new (u32, vec_len (segments) - 1);
  for (i = 0; i < vec_len (segments_len); i++)
    {
      segment_len = segments[i + 1] - segments[i];
      if (segment_len == 2 && path[segments[i]] == '.')
	segment_len = 0;
      else if (segment_len == 3 && path[segments[i]] == '.' &&
	       path[segments[i] + 1] == '.')
	{
	  segment_len = 0;
	  /* remove parent (if any) */
	  for (ii = i - 1; ii >= 0; ii--)
	    {
	      if (segments_len[ii])
		{
		  segments_len[ii] = 0;
		  break;
		}
	    }
	}
      segments_len[i] = segment_len;
    }

  /* we might end with empty path, so return at least empty vector */
  new_path = vec_new (u8, 0);
  /* append all valid segments */
  for (i = 0; i < vec_len (segments_len); i++)
    {
      if (segments_len[i])
	vec_add (new_path, path + segments[i], segments_len[i]);
    }
  vec_free (segments);
  vec_free (segments_len);
  return new_path;
}

always_inline int
_parse_field_name (u8 **pos, u8 *end, u8 **field_name_start,
		   u32 *field_name_len)
{
  u32 name_len = 0;
  u8 *p;

  static uword tchar[4] = {
    /* !#$%'*+-.0123456789 */
    0x03ff6cba00000000,
    /* ABCDEFGHIJKLMNOPQRSTUVWXYZ^_`abcdefghijklmnopqrstuvwxyz|~ */
    0x57ffffffc7fffffe,
    0x0000000000000000,
    0x0000000000000000,
  };

  p = *pos;

  *field_name_start = p;
  while (p != end)
    {
      if (clib_bitmap_get_no_check (tchar, *p))
	{
	  name_len++;
	  p++;
	}
      else if (*p == ':')
	{
	  if (name_len == 0)
	    {
	      clib_warning ("empty field name");
	      return -1;
	    }
	  *field_name_len = name_len;
	  p++;
	  *pos = p;
	  return 0;
	}
      else
	{
	  clib_warning ("invalid character %d", *p);
	  return -1;
	}
    }
  clib_warning ("field name end not found");
  return -1;
}

always_inline int
_parse_field_value (u8 **pos, u8 *end, u8 **field_value_start,
		    u32 *field_value_len)
{
  u32 value_len = 0;
  u8 *p;

  p = *pos;

  /* skip leading whitespace */
  while (1)
    {
      if (p == end)
	{
	  clib_warning ("field value not found");
	  return -1;
	}
      else if (*p != ' ' && *p != '\t')
	{
	  break;
	}
      p++;
    }

  *field_value_start = p;
  while (p != end)
    {
      if (*p == '\r')
	{
	  if ((end - p) < 1)
	    {
	      clib_warning ("incorrect field line end");
	      return -1;
	    }
	  p++;
	  if (*p == '\n')
	    {
	      if (value_len == 0)
		{
		  clib_warning ("empty field value");
		  return -1;
		}
	      p++;
	      *pos = p;
	      /* skip trailing whitespace */
	      p = *field_value_start + value_len - 1;
	      while (*p == ' ' || *p == '\t')
		{
		  p--;
		  value_len--;
		}
	      *field_value_len = value_len;
	      return 0;
	    }
	  clib_warning ("CR without LF");
	  return -1;
	}
      if (*p < ' ' && *p != '\t')
	{
	  clib_warning ("invalid character %d", *p);
	  return -1;
	}
      p++;
      value_len++;
    }

  clib_warning ("field value end not found");
  return -1;
}

typedef struct
{
  u8 *name;
  u8 *value;
} http_header_t;

typedef struct
{
  http_header_t *headers;
  uword *value_by_name;
} http_header_table_t;

/**
 * Free header table's memory.
 *
 * @param ht Header table to free.
 */
always_inline void
http_free_header_table (http_header_table_t *ht)
{
  http_header_t *header;
  vec_foreach (header, ht->headers)
    {
      vec_free (header->name);
      vec_free (header->value);
    }
  vec_free (ht->headers);
  hash_free (ht->value_by_name);
  clib_mem_free (ht);
}

/**
 * Parse headers in given vector.
 *
 * @param headers Vector to parse.
 * @param [out] header_table Parsed headers in case of success.
 *
 * @return @c 0 on success.
 *
 * The caller is responsible to free the returned @c header_table
 * using @c http_free_header_table .
 */
always_inline int
http_parse_headers (u8 *headers, http_header_table_t **header_table)
{
  u8 *pos, *end, *name_start, *value_start, *name;
  u32 name_len, value_len;
  int rv;
  http_header_t *header;
  http_header_table_t *ht;
  uword *p;

  end = headers + vec_len (headers);
  pos = headers;

  ht = clib_mem_alloc (sizeof (*ht));
  ht->value_by_name = hash_create_string (0, sizeof (uword));
  ht->headers = 0;
  do
    {
      rv = _parse_field_name (&pos, end, &name_start, &name_len);
      if (rv != 0)
	{
	  http_free_header_table (ht);
	  return rv;
	}
      rv = _parse_field_value (&pos, end, &value_start, &value_len);
      if (rv != 0)
	{
	  http_free_header_table (ht);
	  return rv;
	}
      name = vec_new (u8, name_len);
      clib_memcpy (name, name_start, name_len);
      vec_terminate_c_string (name);
      /* check if header is repeated */
      p = hash_get_mem (ht->value_by_name, name);
      if (p)
	{
	  /* if yes combine values */
	  header = vec_elt_at_index (ht->headers, p[0]);
	  vec_pop (header->value); /* drop null byte */
	  header->value = format (header->value, ", %U%c", format_ascii_bytes,
				  value_start, value_len, 0);
	  vec_free (name);
	  continue;
	}
      /* or create new record */
      vec_add2 (ht->headers, header, sizeof (*header));
      header->name = name;
      header->value = vec_new (u8, value_len);
      clib_memcpy (header->value, value_start, value_len);
      vec_terminate_c_string (header->value);
      hash_set_mem (ht->value_by_name, header->name, header - ht->headers);
    }
  while (pos != end);

  *header_table = ht;

  return 0;
}

/**
 * Try to find given header name in header table.
 *
 * @param header_table Header table to search.
 * @param name Header name to match.
 *
 * @return Header's value in case of success, @c 0 otherwise.
 */
always_inline const char *
http_get_header (http_header_table_t *header_table, const char *name)
{
  uword *p;
  http_header_t *header;

  p = hash_get_mem (header_table->value_by_name, name);
  if (p)
    {
      header = vec_elt_at_index (header_table->headers, p[0]);
      return (const char *) header->value;
    }

  return 0;
}

#endif /* SRC_PLUGINS_HTTP_HTTP_H_ */

/*
 * fd.io coding-style-patch-verification: ON
 *
 * Local Variables:
 * eval: (c-set-style "gnu")
 * End:
 */