/src/CMake/Utilities/cmcurl/lib/dynhds.c

Source
/***************************************************************************
 *                                  _   _ ____  _
 *  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"

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 = curlx_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 void entry_free(struct dynhds_entry *e)
{
  curlx_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 &&
       curl_strnequal(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 = curlx_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;

  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 UNITTESTS
/* 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) &&
         curl_strnequal(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) &&
         curl_strnequal(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 = curlx_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 = curlx_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 */

Coverage Report

Created: 2026-04-29 07:01

Line	Count	Source
1		/***************************************************************************
2		* _ _ ____ _
3		* Project ___\| \| \| \| _ \\| \|
4		* / __\| \| \| \| \|_) \| \|
5		* \| (__\| \|_\| \| _ <\| \|___
6		* \___\|\___/\|_\| \_\_____\|
7		*
8		* Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
9		*
10		* This software is licensed as described in the file COPYING, which
11		* you should have received as part of this distribution. The terms
12		* are also available at https://curl.se/docs/copyright.html.
13		*
14		* You may opt to use, copy, modify, merge, publish, distribute and/or sell
15		* copies of the Software, and permit persons to whom the Software is
16		* furnished to do so, under the terms of the COPYING file.
17		*
18		* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19		* KIND, either express or implied.
20		*
21		* SPDX-License-Identifier: curl
22		*
23		***************************************************************************/
24		#include "curl_setup.h"
25
26		#include "dynhds.h"
27		#include "strcase.h"
28
29		static struct dynhds_entry entry_new(const char name, size_t namelen,
30		const char *value, size_t valuelen,
31		int opts)
32	0	{
33	0	struct dynhds_entry *e;
34	0	char *p;
35
36	0	DEBUGASSERT(name);
37	0	DEBUGASSERT(value);
38	0	e = curlx_calloc(1, sizeof(*e) + namelen + valuelen + 2);
39	0	if(!e)
40	0	return NULL;
41	0	e->name = p = (char )e + sizeof(e);
42	0	memcpy(p, name, namelen);
43	0	e->namelen = namelen;
44	0	e->value = p += namelen + 1; /* leave a \0 at the end of name */
45	0	memcpy(p, value, valuelen);
46	0	e->valuelen = valuelen;
47	0	if(opts & DYNHDS_OPT_LOWERCASE)
48	0	Curl_strntolower(e->name, e->name, e->namelen);
49	0	return e;
50	0	}
51
52		static void entry_free(struct dynhds_entry *e)
53	0	{
54	0	curlx_free(e);
55	0	}
56
57		void Curl_dynhds_init(struct dynhds *dynhds, size_t max_entries,
58		size_t max_strs_size)
59	0	{
60	0	DEBUGASSERT(dynhds);
61	0	DEBUGASSERT(max_strs_size);
62	0	dynhds->hds = NULL;
63	0	dynhds->hds_len = dynhds->hds_allc = dynhds->strs_len = 0;
64	0	dynhds->max_entries = max_entries;
65	0	dynhds->max_strs_size = max_strs_size;
66	0	dynhds->opts = 0;
67	0	}
68
69		void Curl_dynhds_free(struct dynhds *dynhds)
70	0	{
71	0	DEBUGASSERT(dynhds);
72	0	if(dynhds->hds && dynhds->hds_len) {
73	0	size_t i;
74	0	DEBUGASSERT(dynhds->hds);
75	0	for(i = 0; i < dynhds->hds_len; ++i) {
76	0	entry_free(dynhds->hds[i]);
77	0	}
78	0	}
79	0	Curl_safefree(dynhds->hds);
80	0	dynhds->hds_len = dynhds->hds_allc = dynhds->strs_len = 0;
81	0	}
82
83		void Curl_dynhds_reset(struct dynhds *dynhds)
84	0	{
85	0	DEBUGASSERT(dynhds);
86	0	if(dynhds->hds_len) {
87	0	size_t i;
88	0	DEBUGASSERT(dynhds->hds);
89	0	for(i = 0; i < dynhds->hds_len; ++i) {
90	0	entry_free(dynhds->hds[i]);
91	0	dynhds->hds[i] = NULL;
92	0	}
93	0	}
94	0	dynhds->hds_len = dynhds->strs_len = 0;
95	0	}
96
97		size_t Curl_dynhds_count(struct dynhds *dynhds)
98	0	{
99	0	return dynhds->hds_len;
100	0	}
101
102		void Curl_dynhds_set_opts(struct dynhds *dynhds, int opts)
103	0	{
104	0	dynhds->opts = opts;
105	0	}
106
107		struct dynhds_entry Curl_dynhds_getn(struct dynhds dynhds, size_t n)
108	0	{
109	0	DEBUGASSERT(dynhds);
110	0	return (n < dynhds->hds_len) ? dynhds->hds[n] : NULL;
111	0	}
112
113		struct dynhds_entry Curl_dynhds_get(struct dynhds dynhds, const char *name,
114		size_t namelen)
115	0	{
116	0	size_t i;
117	0	for(i = 0; i < dynhds->hds_len; ++i) {
118	0	if(dynhds->hds[i]->namelen == namelen &&
119	0	curl_strnequal(dynhds->hds[i]->name, name, namelen)) {
120	0	return dynhds->hds[i];
121	0	}
122	0	}
123	0	return NULL;
124	0	}
125
126		struct dynhds_entry Curl_dynhds_cget(struct dynhds dynhds, const char *name)
127	0	{
128	0	return Curl_dynhds_get(dynhds, name, strlen(name));
129	0	}
130
131		CURLcode Curl_dynhds_add(struct dynhds *dynhds,
132		const char *name, size_t namelen,
133		const char *value, size_t valuelen)
134	0	{
135	0	struct dynhds_entry *entry = NULL;
136	0	CURLcode result = CURLE_OUT_OF_MEMORY;
137
138	0	DEBUGASSERT(dynhds);
139	0	if(dynhds->max_entries && dynhds->hds_len >= dynhds->max_entries)
140	0	return CURLE_OUT_OF_MEMORY;
141	0	if(dynhds->strs_len + namelen + valuelen > dynhds->max_strs_size)
142	0	return CURLE_OUT_OF_MEMORY;
143
144	0	entry = entry_new(name, namelen, value, valuelen, dynhds->opts);
145	0	if(!entry)
146	0	goto out;
147
148	0	if(dynhds->hds_len + 1 >= dynhds->hds_allc) {
149	0	size_t nallc = dynhds->hds_len + 16;
150	0	struct dynhds_entry **nhds;
151
152	0	if(dynhds->max_entries && nallc > dynhds->max_entries)
153	0	nallc = dynhds->max_entries;
154
155	0	nhds = curlx_calloc(nallc, sizeof(struct dynhds_entry *));
156	0	if(!nhds)
157	0	goto out;
158	0	if(dynhds->hds) {
159	0	memcpy(nhds, dynhds->hds,
160	0	dynhds->hds_len * sizeof(struct dynhds_entry *));
161	0	Curl_safefree(dynhds->hds);
162	0	}
163	0	dynhds->hds = nhds;
164	0	dynhds->hds_allc = nallc;
165	0	}
166	0	dynhds->hds[dynhds->hds_len++] = entry;
167	0	entry = NULL;
168	0	dynhds->strs_len += namelen + valuelen;
169	0	result = CURLE_OK;
170
171	0	out:
172	0	if(entry)
173	0	entry_free(entry);
174	0	return result;
175	0	}
176
177		CURLcode Curl_dynhds_cadd(struct dynhds *dynhds,
178		const char name, const char value)
179	0	{
180	0	return Curl_dynhds_add(dynhds, name, strlen(name), value, strlen(value));
181	0	}
182
183		CURLcode Curl_dynhds_h1_add_line(struct dynhds *dynhds,
184		const char *line, size_t line_len)
185	0	{
186	0	const char *p;
187	0	const char *name;
188	0	size_t namelen;
189	0	const char *value;
190	0	size_t valuelen, i;
191
192	0	if(!line \|\| !line_len)
193	0	return CURLE_OK;
194
195	0	p = memchr(line, ':', line_len);
196	0	if(!p)
197	0	return CURLE_BAD_FUNCTION_ARGUMENT;
198	0	name = line;
199	0	namelen = p - line;
200	0	p++; /* move past the colon */
201	0	for(i = namelen + 1; i < line_len; ++i, ++p) {
202	0	if(!ISBLANK(*p))
203	0	break;
204	0	}
205	0	value = p;
206	0	valuelen = line_len - i;
207
208	0	p = memchr(value, '\r', valuelen);
209	0	if(!p)
210	0	p = memchr(value, '\n', valuelen);
211	0	if(p)
212	0	valuelen = (size_t)(p - value);
213
214	0	return Curl_dynhds_add(dynhds, name, namelen, value, valuelen);
215	0	}
216
217		CURLcode Curl_dynhds_h1_cadd_line(struct dynhds dynhds, const char line)
218	0	{
219	0	return Curl_dynhds_h1_add_line(dynhds, line, line ? strlen(line) : 0);
220	0	}
221
222		#ifdef UNITTESTS
223		/* used by unit2602.c */
224
225		bool Curl_dynhds_contains(struct dynhds *dynhds,
226		const char *name, size_t namelen)
227		{
228		return !!Curl_dynhds_get(dynhds, name, namelen);
229		}
230
231		bool Curl_dynhds_ccontains(struct dynhds dynhds, const char name)
232		{
233		return Curl_dynhds_contains(dynhds, name, strlen(name));
234		}
235
236		size_t Curl_dynhds_count_name(struct dynhds *dynhds,
237		const char *name, size_t namelen)
238		{
239		size_t n = 0;
240		if(dynhds->hds_len) {
241		size_t i;
242		for(i = 0; i < dynhds->hds_len; ++i) {
243		if((namelen == dynhds->hds[i]->namelen) &&
244		curl_strnequal(name, dynhds->hds[i]->name, namelen))
245		++n;
246		}
247		}
248		return n;
249		}
250
251		size_t Curl_dynhds_ccount_name(struct dynhds dynhds, const char name)
252		{
253		return Curl_dynhds_count_name(dynhds, name, strlen(name));
254		}
255
256		CURLcode Curl_dynhds_set(struct dynhds *dynhds,
257		const char *name, size_t namelen,
258		const char *value, size_t valuelen)
259		{
260		Curl_dynhds_remove(dynhds, name, namelen);
261		return Curl_dynhds_add(dynhds, name, namelen, value, valuelen);
262		}
263
264		size_t Curl_dynhds_remove(struct dynhds *dynhds,
265		const char *name, size_t namelen)
266		{
267		size_t n = 0;
268		if(dynhds->hds_len) {
269		size_t i, len;
270		for(i = 0; i < dynhds->hds_len; ++i) {
271		if((namelen == dynhds->hds[i]->namelen) &&
272		curl_strnequal(name, dynhds->hds[i]->name, namelen)) {
273		++n;
274		--dynhds->hds_len;
275		dynhds->strs_len -= (dynhds->hds[i]->namelen +
276		dynhds->hds[i]->valuelen);
277		entry_free(dynhds->hds[i]);
278		len = dynhds->hds_len - i; /* remaining entries */
279		if(len) {
280		memmove(&dynhds->hds[i], &dynhds->hds[i + 1],
281		len * sizeof(dynhds->hds[i]));
282		}
283		--i; /* do this index again */
284		}
285		}
286		}
287		return n;
288		}
289
290		size_t Curl_dynhds_cremove(struct dynhds dynhds, const char name)
291		{
292		return Curl_dynhds_remove(dynhds, name, strlen(name));
293		}
294
295		#endif
296
297		CURLcode Curl_dynhds_h1_dprint(struct dynhds dynhds, struct dynbuf dbuf)
298	0	{
299	0	CURLcode result = CURLE_OK;
300	0	size_t i;
301
302	0	if(!dynhds->hds_len)
303	0	return result;
304
305	0	for(i = 0; i < dynhds->hds_len; ++i) {
306	0	result = curlx_dyn_addf(dbuf, "%.s: %.s\r\n",
307	0	(int)dynhds->hds[i]->namelen, dynhds->hds[i]->name,
308	0	(int)dynhds->hds[i]->valuelen,
309	0	dynhds->hds[i]->value);
310	0	if(result)
311	0	break;
312	0	}
313
314	0	return result;
315	0	}
316
317		#ifdef USE_NGHTTP2
318
319		nghttp2_nv Curl_dynhds_to_nva(struct dynhds dynhds, size_t *pcount)
320	0	{
321	0	nghttp2_nv nva = curlx_calloc(1, sizeof(nghttp2_nv) dynhds->hds_len);
322	0	size_t i;
323
324	0	*pcount = 0;
325	0	if(!nva)
326	0	return NULL;
327
328	0	for(i = 0; i < dynhds->hds_len; ++i) {
329	0	struct dynhds_entry *e = dynhds->hds[i];
330	0	DEBUGASSERT(e);
331	0	nva[i].name = (unsigned char *)e->name;
332	0	nva[i].namelen = e->namelen;
333	0	nva[i].value = (unsigned char *)e->value;
334	0	nva[i].valuelen = e->valuelen;
335	0	nva[i].flags = NGHTTP2_NV_FLAG_NONE;
336	0	}
337	0	*pcount = dynhds->hds_len;
338	0	return nva;
339	0	}
340
341		#endif /* USE_NGHTTP2 */