/***************************************************************************

 *                                  _   _ ____  _

 *  Project                     ___| | | |  _ \| |

 *                             / __| | | | |_) | |

 *                            | (__| |_| |  _ <| |___

 *                             \___|\___/|_| \_\_____|

 *

 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.

 *

 * This software is licensed as described in the file COPYING, which

 * you should have received as part of this distribution. The terms

 * are also available at https://curl.se/docs/copyright.html.

 *

 * You may opt to use, copy, modify, merge, publish, distribute and/or sell

 * copies of the Software, and permit persons to whom the Software is

 * furnished to do so, under the terms of the COPYING file.

 *

 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY

 * KIND, either express or implied.

 *

 * SPDX-License-Identifier: curl

 *

 ***************************************************************************/

#include "curl_setup.h"

#include "dynhds.h"

#include "strcase.h"

/* The last 3 #include files should be in this order */

#ifdef USE_NGHTTP2

#include <stdint.h>

#include <nghttp2/nghttp2.h>

#endif /* USE_NGHTTP2 */

#include "curl_printf.h"

#include "curl_memory.h"

#include "memdebug.h"

static struct dynhds_entry *

entry_new(const char *name, size_t namelen,

          const char *value, size_t valuelen, int opts)

{

  struct dynhds_entry *e;

  char *p;

  DEBUGASSERT(name);

  DEBUGASSERT(value);

  e = calloc(1, sizeof(*e) + namelen + valuelen + 2);

  if(!e)

    return NULL;

  e->name = p = ((char *)e) + sizeof(*e);

  memcpy(p, name, namelen);

  e->namelen = namelen;

  e->value = p += namelen + 1; /* leave a \0 at the end of name */

  memcpy(p, value, valuelen);

  e->valuelen = valuelen;

  if(opts & DYNHDS_OPT_LOWERCASE)

    Curl_strntolower(e->name, e->name, e->namelen);

  return e;

}

static struct dynhds_entry *

entry_append(struct dynhds_entry *e,

             const char *value, size_t valuelen)

{

  struct dynhds_entry *e2;

  size_t valuelen2 = e->valuelen + 1 + valuelen;

  char *p;

  DEBUGASSERT(value);

  e2 = calloc(1, sizeof(*e) + e->namelen + valuelen2 + 2);

  if(!e2)

    return NULL;

  e2->name = p = ((char *)e2) + sizeof(*e2);

  memcpy(p, e->name, e->namelen);

  e2->namelen = e->namelen;

  e2->value = p += e->namelen + 1; /* leave a \0 at the end of name */

  memcpy(p, e->value, e->valuelen);

  p += e->valuelen;

  p[0] = ' ';

  memcpy(p + 1, value, valuelen);

  e2->valuelen = valuelen2;

  return e2;

}

static void entry_free(struct dynhds_entry *e)

{

  free(e);

}

void Curl_dynhds_init(struct dynhds *dynhds, size_t max_entries,

                      size_t max_strs_size)

{

  DEBUGASSERT(dynhds);

  DEBUGASSERT(max_strs_size);

  dynhds->hds = NULL;

  dynhds->hds_len = dynhds->hds_allc = dynhds->strs_len = 0;

  dynhds->max_entries = max_entries;

  dynhds->max_strs_size = max_strs_size;

  dynhds->opts = 0;

}

void Curl_dynhds_free(struct dynhds *dynhds)

{

  DEBUGASSERT(dynhds);

  if(dynhds->hds && dynhds->hds_len) {

    size_t i;

    DEBUGASSERT(dynhds->hds);

    for(i = 0; i < dynhds->hds_len; ++i) {

      entry_free(dynhds->hds[i]);

    }

  }

  Curl_safefree(dynhds->hds);

  dynhds->hds_len = dynhds->hds_allc = dynhds->strs_len = 0;

}

void Curl_dynhds_reset(struct dynhds *dynhds)

{

  DEBUGASSERT(dynhds);

  if(dynhds->hds_len) {

    size_t i;

    DEBUGASSERT(dynhds->hds);

    for(i = 0; i < dynhds->hds_len; ++i) {

      entry_free(dynhds->hds[i]);

      dynhds->hds[i] = NULL;

    }

  }

  dynhds->hds_len = dynhds->strs_len = 0;

}

size_t Curl_dynhds_count(struct dynhds *dynhds)

{

  return dynhds->hds_len;

}

void Curl_dynhds_set_opts(struct dynhds *dynhds, int opts)

{

  dynhds->opts = opts;

}

struct dynhds_entry *Curl_dynhds_getn(struct dynhds *dynhds, size_t n)

{

  DEBUGASSERT(dynhds);

  return (n < dynhds->hds_len)? dynhds->hds[n] : NULL;

}

struct dynhds_entry *Curl_dynhds_get(struct dynhds *dynhds, const char *name,

                                     size_t namelen)

{

  size_t i;

  for(i = 0; i < dynhds->hds_len; ++i) {

    if(dynhds->hds[i]->namelen == namelen &&

       strncasecompare(dynhds->hds[i]->name, name, namelen)) {

      return dynhds->hds[i];

    }

  }

  return NULL;

}

struct dynhds_entry *Curl_dynhds_cget(struct dynhds *dynhds, const char *name)

{

  return Curl_dynhds_get(dynhds, name, strlen(name));

}

CURLcode Curl_dynhds_add(struct dynhds *dynhds,

                         const char *name, size_t namelen,

                         const char *value, size_t valuelen)

{

  struct dynhds_entry *entry = NULL;

  CURLcode result = CURLE_OUT_OF_MEMORY;

  DEBUGASSERT(dynhds);

  if(dynhds->max_entries && dynhds->hds_len >= dynhds->max_entries)

    return CURLE_OUT_OF_MEMORY;

  if(dynhds->strs_len + namelen + valuelen > dynhds->max_strs_size)

    return CURLE_OUT_OF_MEMORY;

entry = entry_new(name, namelen, value, valuelen, dynhds->opts);

  if(!entry)

    goto out;

  if(dynhds->hds_len + 1 >= dynhds->hds_allc) {

    size_t nallc = dynhds->hds_len + 16;

    struct dynhds_entry **nhds;

    if(dynhds->max_entries && nallc > dynhds->max_entries)

      nallc = dynhds->max_entries;

    nhds = calloc(nallc, sizeof(struct dynhds_entry *));

    if(!nhds)

      goto out;

    if(dynhds->hds) {

      memcpy(nhds, dynhds->hds,

             dynhds->hds_len * sizeof(struct dynhds_entry *));

      Curl_safefree(dynhds->hds);

    }

    dynhds->hds = nhds;

    dynhds->hds_allc = nallc;

  }

  dynhds->hds[dynhds->hds_len++] = entry;

  entry = NULL;

  dynhds->strs_len += namelen + valuelen;

  result = CURLE_OK;

out:

  if(entry)

    entry_free(entry);

  return result;

}

CURLcode Curl_dynhds_cadd(struct dynhds *dynhds,

                          const char *name, const char *value)

{

  return Curl_dynhds_add(dynhds, name, strlen(name), value, strlen(value));

}

CURLcode Curl_dynhds_h1_add_line(struct dynhds *dynhds,

                                 const char *line, size_t line_len)

{

  const char *p;

  const char *name;

  size_t namelen;

  const char *value;

  size_t valuelen, i;

  if(!line || !line_len)

    return CURLE_OK;

  if((line[0] == ' ') || (line[0] == '\t')) {

    struct dynhds_entry *e, *e2;

    /* header continuation, yikes! */

    if(!dynhds->hds_len)

      return CURLE_BAD_FUNCTION_ARGUMENT;

    while(line_len && ISBLANK(line[0])) {

      ++line;

      --line_len;

    }

    if(!line_len)

      return CURLE_BAD_FUNCTION_ARGUMENT;

    e = dynhds->hds[dynhds->hds_len-1];

    e2 = entry_append(e, line, line_len);

    if(!e2)

      return CURLE_OUT_OF_MEMORY;

    dynhds->hds[dynhds->hds_len-1] = e2;

    entry_free(e);

    return CURLE_OK;

  }

  else {

    p = memchr(line, ':', line_len);

    if(!p)

      return CURLE_BAD_FUNCTION_ARGUMENT;

    name = line;

    namelen = p - line;

    p++; /* move past the colon */

    for(i = namelen + 1; i < line_len; ++i, ++p) {

      if(!ISBLANK(*p))

        break;

    }

    value = p;

    valuelen = line_len - i;

    p = memchr(value, '\r', valuelen);

    if(!p)

      p = memchr(value, '\n', valuelen);

    if(p)

      valuelen = (size_t)(p - value);

    return Curl_dynhds_add(dynhds, name, namelen, value, valuelen);

  }

}

CURLcode Curl_dynhds_h1_cadd_line(struct dynhds *dynhds, const char *line)

{

  return Curl_dynhds_h1_add_line(dynhds, line, line? strlen(line) : 0);

}

#ifdef DEBUGBUILD

/* used by unit2602.c */

bool Curl_dynhds_contains(struct dynhds *dynhds,

                          const char *name, size_t namelen)

{

  return !!Curl_dynhds_get(dynhds, name, namelen);

}

bool Curl_dynhds_ccontains(struct dynhds *dynhds, const char *name)

{

  return Curl_dynhds_contains(dynhds, name, strlen(name));

}

size_t Curl_dynhds_count_name(struct dynhds *dynhds,

                              const char *name, size_t namelen)

{

  size_t n = 0;

  if(dynhds->hds_len) {

    size_t i;

    for(i = 0; i < dynhds->hds_len; ++i) {

      if((namelen == dynhds->hds[i]->namelen) &&

         strncasecompare(name, dynhds->hds[i]->name, namelen))

        ++n;

    }

  }

  return n;

}

size_t Curl_dynhds_ccount_name(struct dynhds *dynhds, const char *name)

{

  return Curl_dynhds_count_name(dynhds, name, strlen(name));

}

CURLcode Curl_dynhds_set(struct dynhds *dynhds,

                         const char *name, size_t namelen,

                         const char *value, size_t valuelen)

{

  Curl_dynhds_remove(dynhds, name, namelen);

  return Curl_dynhds_add(dynhds, name, namelen, value, valuelen);

}

size_t Curl_dynhds_remove(struct dynhds *dynhds,

                          const char *name, size_t namelen)

{

  size_t n = 0;

  if(dynhds->hds_len) {

    size_t i, len;

    for(i = 0; i < dynhds->hds_len; ++i) {

      if((namelen == dynhds->hds[i]->namelen) &&

         strncasecompare(name, dynhds->hds[i]->name, namelen)) {

        ++n;

        --dynhds->hds_len;

        dynhds->strs_len -= (dynhds->hds[i]->namelen +

                             dynhds->hds[i]->valuelen);

        entry_free(dynhds->hds[i]);

        len = dynhds->hds_len - i; /* remaining entries */

        if(len) {

          memmove(&dynhds->hds[i], &dynhds->hds[i + 1],

                  len * sizeof(dynhds->hds[i]));

        }

        --i; /* do this index again */

      }

    }

  }

  return n;

}

size_t Curl_dynhds_cremove(struct dynhds *dynhds, const char *name)

{

  return Curl_dynhds_remove(dynhds, name, strlen(name));

}

#endif

CURLcode Curl_dynhds_h1_dprint(struct dynhds *dynhds, struct dynbuf *dbuf)

{

  CURLcode result = CURLE_OK;

  size_t i;

  if(!dynhds->hds_len)

    return result;

  for(i = 0; i < dynhds->hds_len; ++i) {

    result = Curl_dyn_addf(dbuf, "%.*s: %.*s\r\n",

               (int)dynhds->hds[i]->namelen, dynhds->hds[i]->name,

               (int)dynhds->hds[i]->valuelen, dynhds->hds[i]->value);

    if(result)

      break;

  }

  return result;

}

#ifdef USE_NGHTTP2

nghttp2_nv *Curl_dynhds_to_nva(struct dynhds *dynhds, size_t *pcount)

{

  nghttp2_nv *nva = calloc(1, sizeof(nghttp2_nv) * dynhds->hds_len);

  size_t i;

  *pcount = 0;

  if(!nva)

    return NULL;

  for(i = 0; i < dynhds->hds_len; ++i) {

    struct dynhds_entry *e = dynhds->hds[i];

    DEBUGASSERT(e);

    nva[i].name = (unsigned char *)e->name;

    nva[i].namelen = e->namelen;

    nva[i].value = (unsigned char *)e->value;

    nva[i].valuelen = e->valuelen;

    nva[i].flags = NGHTTP2_NV_FLAG_NONE;

  }

  *pcount = dynhds->hds_len;

  return nva;

}

#endif /* USE_NGHTTP2 */