2002-09-03 15:52:59 +04:00
|
|
|
/***************************************************************************
|
2004-06-24 11:43:48 +04:00
|
|
|
* _ _ ____ _
|
|
|
|
* Project ___| | | | _ \| |
|
|
|
|
* / __| | | | |_) | |
|
|
|
|
* | (__| |_| | _ <| |___
|
2002-01-03 13:22:59 +03:00
|
|
|
* \___|\___/|_| \_\_____|
|
|
|
|
*
|
2023-01-02 15:51:48 +03:00
|
|
|
* Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
|
2002-01-03 13:22:59 +03:00
|
|
|
*
|
2002-09-03 15:52:59 +04:00
|
|
|
* This software is licensed as described in the file COPYING, which
|
|
|
|
* you should have received as part of this distribution. The terms
|
2020-11-04 16:02:01 +03:00
|
|
|
* are also available at https://curl.se/docs/copyright.html.
|
2004-06-24 11:43:48 +04:00
|
|
|
*
|
2002-01-03 13:22:59 +03:00
|
|
|
* 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
|
2002-09-03 15:52:59 +04:00
|
|
|
* furnished to do so, under the terms of the COPYING file.
|
2002-01-03 13:22:59 +03:00
|
|
|
*
|
|
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
|
|
* KIND, either express or implied.
|
|
|
|
*
|
2002-09-03 15:52:59 +04:00
|
|
|
* SPDX-License-Identifier: curl
|
2022-05-17 12:16:50 +03:00
|
|
|
*
|
2002-09-03 15:52:59 +04:00
|
|
|
***************************************************************************/
|
2002-01-03 13:22:59 +03:00
|
|
|
|
2013-01-06 22:06:49 +04:00
|
|
|
#include "curl_setup.h"
|
2002-01-03 13:22:59 +03:00
|
|
|
|
2016-04-01 15:21:12 +03:00
|
|
|
#include <curl/curl.h>
|
|
|
|
|
2013-01-04 05:50:28 +04:00
|
|
|
#include "llist.h"
|
2009-04-21 15:46:16 +04:00
|
|
|
#include "curl_memory.h"
|
2002-01-03 13:22:59 +03:00
|
|
|
|
|
|
|
/* this must be the last include file */
|
2013-01-04 05:50:28 +04:00
|
|
|
#include "memdebug.h"
|
2004-05-11 15:30:23 +04:00
|
|
|
|
2024-08-11 00:27:25 +03:00
|
|
|
#define LLISTINIT 0x100cc001 /* random pattern */
|
|
|
|
#define NODEINIT 0x12344321 /* random pattern */
|
|
|
|
#define NODEREM 0x54321012 /* random pattern */
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef DEBUGBUILD
|
|
|
|
#define VERIFYNODE(x) verifynode(x)
|
|
|
|
static struct Curl_llist_node *verifynode(struct Curl_llist_node *n)
|
|
|
|
{
|
|
|
|
DEBUGASSERT(!n || (n->_init == NODEINIT));
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define VERIFYNODE(x) x
|
|
|
|
#endif
|
2011-06-19 04:27:22 +04:00
|
|
|
/*
|
|
|
|
* @unittest: 1300
|
|
|
|
*/
|
2017-04-03 11:32:43 +03:00
|
|
|
void
|
2020-09-02 13:06:20 +03:00
|
|
|
Curl_llist_init(struct Curl_llist *l, Curl_llist_dtor dtor)
|
2002-01-03 13:22:59 +03:00
|
|
|
{
|
2024-08-11 00:27:25 +03:00
|
|
|
l->_size = 0;
|
|
|
|
l->_dtor = dtor;
|
|
|
|
l->_head = NULL;
|
|
|
|
l->_tail = NULL;
|
|
|
|
#ifdef DEBUGBUILD
|
|
|
|
l->_init = LLISTINIT;
|
|
|
|
#endif
|
2002-01-03 13:22:59 +03:00
|
|
|
}
|
|
|
|
|
2004-05-10 12:57:37 +04:00
|
|
|
/*
|
2010-08-10 12:52:26 +04:00
|
|
|
* Curl_llist_insert_next()
|
|
|
|
*
|
|
|
|
* Inserts a new list element after the given one 'e'. If the given existing
|
|
|
|
* entry is NULL and the list already has elements, the new one will be
|
|
|
|
* inserted first in the list.
|
|
|
|
*
|
2017-04-20 16:10:04 +03:00
|
|
|
* The 'ne' argument should be a pointer into the object to store.
|
|
|
|
*
|
2011-06-10 16:40:46 +04:00
|
|
|
* @unittest: 1300
|
2004-05-10 12:57:37 +04:00
|
|
|
*/
|
2017-04-20 16:10:04 +03:00
|
|
|
void
|
2024-08-11 00:27:25 +03:00
|
|
|
Curl_llist_insert_next(struct Curl_llist *list,
|
|
|
|
struct Curl_llist_node *e, /* may be NULL */
|
2017-04-20 16:10:04 +03:00
|
|
|
const void *p,
|
2024-08-11 00:27:25 +03:00
|
|
|
struct Curl_llist_node *ne)
|
2002-01-03 13:22:59 +03:00
|
|
|
{
|
2024-08-11 00:27:25 +03:00
|
|
|
DEBUGASSERT(list);
|
|
|
|
DEBUGASSERT(list->_init == LLISTINIT);
|
|
|
|
DEBUGASSERT(ne);
|
|
|
|
|
|
|
|
#ifdef DEBUGBUILD
|
|
|
|
ne->_init = NODEINIT;
|
|
|
|
#endif
|
|
|
|
ne->_ptr = (void *) p;
|
|
|
|
ne->_list = list;
|
|
|
|
if(list->_size == 0) {
|
|
|
|
list->_head = ne;
|
|
|
|
list->_head->_prev = NULL;
|
|
|
|
list->_head->_next = NULL;
|
|
|
|
list->_tail = ne;
|
2004-05-10 12:57:37 +04:00
|
|
|
}
|
|
|
|
else {
|
2010-08-10 12:52:26 +04:00
|
|
|
/* if 'e' is NULL here, we insert the new element first in the list */
|
2024-08-11 00:27:25 +03:00
|
|
|
ne->_next = e?e->_next:list->_head;
|
|
|
|
ne->_prev = e;
|
2010-08-10 12:52:26 +04:00
|
|
|
if(!e) {
|
2024-08-11 00:27:25 +03:00
|
|
|
list->_head->_prev = ne;
|
|
|
|
list->_head = ne;
|
2010-08-10 12:52:26 +04:00
|
|
|
}
|
2024-08-11 00:27:25 +03:00
|
|
|
else if(e->_next) {
|
|
|
|
e->_next->_prev = ne;
|
2004-05-10 12:57:37 +04:00
|
|
|
}
|
|
|
|
else {
|
2024-08-11 00:27:25 +03:00
|
|
|
list->_tail = ne;
|
2002-01-03 13:22:59 +03:00
|
|
|
}
|
2010-08-10 12:52:26 +04:00
|
|
|
if(e)
|
2024-08-11 00:27:25 +03:00
|
|
|
e->_next = ne;
|
2002-01-03 13:22:59 +03:00
|
|
|
}
|
|
|
|
|
2024-08-11 00:27:25 +03:00
|
|
|
++list->_size;
|
2002-01-03 13:22:59 +03:00
|
|
|
}
|
|
|
|
|
2024-04-10 12:51:08 +03:00
|
|
|
/*
|
|
|
|
* Curl_llist_append()
|
|
|
|
*
|
|
|
|
* Adds a new list element to the end of the list.
|
|
|
|
*
|
|
|
|
* The 'ne' argument should be a pointer into the object to store.
|
|
|
|
*
|
|
|
|
* @unittest: 1300
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
Curl_llist_append(struct Curl_llist *list, const void *p,
|
2024-08-11 00:27:25 +03:00
|
|
|
struct Curl_llist_node *ne)
|
2024-04-10 12:51:08 +03:00
|
|
|
{
|
2024-08-11 00:27:25 +03:00
|
|
|
DEBUGASSERT(list);
|
|
|
|
DEBUGASSERT(list->_init == LLISTINIT);
|
|
|
|
DEBUGASSERT(ne);
|
|
|
|
Curl_llist_insert_next(list, list->_tail, p, ne);
|
2024-04-10 12:51:08 +03:00
|
|
|
}
|
|
|
|
|
2011-06-10 16:40:46 +04:00
|
|
|
/*
|
|
|
|
* @unittest: 1300
|
|
|
|
*/
|
2017-04-20 16:10:04 +03:00
|
|
|
void
|
2024-08-11 00:27:25 +03:00
|
|
|
Curl_node_uremove(struct Curl_llist_node *e, void *user)
|
2002-01-03 13:22:59 +03:00
|
|
|
{
|
2017-04-20 16:10:04 +03:00
|
|
|
void *ptr;
|
2024-08-11 00:27:25 +03:00
|
|
|
struct Curl_llist *list;
|
|
|
|
if(!e)
|
2017-04-20 16:10:04 +03:00
|
|
|
return;
|
2002-01-03 13:22:59 +03:00
|
|
|
|
2024-08-11 00:27:25 +03:00
|
|
|
list = e->_list;
|
|
|
|
DEBUGASSERT(list);
|
|
|
|
DEBUGASSERT(list->_init == LLISTINIT);
|
|
|
|
DEBUGASSERT(list->_size);
|
|
|
|
DEBUGASSERT(e->_init == NODEINIT);
|
|
|
|
if(e == list->_head) {
|
|
|
|
list->_head = e->_next;
|
2002-01-03 13:22:59 +03:00
|
|
|
|
2024-08-11 00:27:25 +03:00
|
|
|
if(!list->_head)
|
|
|
|
list->_tail = NULL;
|
2002-01-03 13:22:59 +03:00
|
|
|
else
|
2024-08-11 00:27:25 +03:00
|
|
|
e->_next->_prev = NULL;
|
2011-04-20 17:17:42 +04:00
|
|
|
}
|
|
|
|
else {
|
2024-08-11 00:27:25 +03:00
|
|
|
if(e->_prev)
|
|
|
|
e->_prev->_next = e->_next;
|
2017-11-21 00:59:19 +03:00
|
|
|
|
2024-08-11 00:27:25 +03:00
|
|
|
if(!e->_next)
|
|
|
|
list->_tail = e->_prev;
|
2002-01-03 13:22:59 +03:00
|
|
|
else
|
2024-08-11 00:27:25 +03:00
|
|
|
e->_next->_prev = e->_prev;
|
2002-01-03 13:22:59 +03:00
|
|
|
}
|
|
|
|
|
2024-08-11 00:27:25 +03:00
|
|
|
ptr = e->_ptr;
|
2008-10-20 00:17:16 +04:00
|
|
|
|
2024-08-11 00:27:25 +03:00
|
|
|
e->_ptr = NULL;
|
|
|
|
e->_prev = NULL;
|
|
|
|
e->_next = NULL;
|
|
|
|
#ifdef DEBUGBUILD
|
|
|
|
e->_init = NODEREM; /* specific pattern on remove - not zero */
|
|
|
|
#endif
|
2011-10-07 22:50:57 +04:00
|
|
|
|
2024-08-11 00:27:25 +03:00
|
|
|
--list->_size;
|
2002-01-03 13:22:59 +03:00
|
|
|
|
2017-04-20 16:10:04 +03:00
|
|
|
/* call the dtor() last for when it actually frees the 'e' memory itself */
|
2024-08-11 00:27:25 +03:00
|
|
|
if(list->_dtor)
|
|
|
|
list->_dtor(user, ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Curl_node_remove(struct Curl_llist_node *e)
|
|
|
|
{
|
|
|
|
Curl_node_uremove(e, NULL);
|
2002-01-03 13:22:59 +03:00
|
|
|
}
|
|
|
|
|
2004-06-24 11:43:48 +04:00
|
|
|
void
|
2020-09-02 13:06:20 +03:00
|
|
|
Curl_llist_destroy(struct Curl_llist *list, void *user)
|
2002-01-03 13:22:59 +03:00
|
|
|
{
|
2003-08-14 19:06:08 +04:00
|
|
|
if(list) {
|
2024-08-11 00:27:25 +03:00
|
|
|
DEBUGASSERT(list->_init == LLISTINIT);
|
|
|
|
while(list->_size > 0)
|
|
|
|
Curl_node_uremove(list->_tail, user);
|
2003-08-14 19:06:08 +04:00
|
|
|
}
|
2002-01-03 13:22:59 +03:00
|
|
|
}
|
2006-09-08 01:49:20 +04:00
|
|
|
|
2024-08-11 00:27:25 +03:00
|
|
|
/* Curl_llist_head() returns the first 'struct Curl_llist_node *', which
|
|
|
|
might be NULL */
|
|
|
|
struct Curl_llist_node *Curl_llist_head(struct Curl_llist *list)
|
|
|
|
{
|
|
|
|
DEBUGASSERT(list);
|
|
|
|
DEBUGASSERT(list->_init == LLISTINIT);
|
|
|
|
return VERIFYNODE(list->_head);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Curl_llist_tail() returns the last 'struct Curl_llist_node *', which
|
|
|
|
might be NULL */
|
|
|
|
struct Curl_llist_node *Curl_llist_tail(struct Curl_llist *list)
|
2006-09-08 01:49:20 +04:00
|
|
|
{
|
2024-08-11 00:27:25 +03:00
|
|
|
DEBUGASSERT(list);
|
|
|
|
DEBUGASSERT(list->_init == LLISTINIT);
|
|
|
|
return VERIFYNODE(list->_tail);
|
2006-09-08 01:49:20 +04:00
|
|
|
}
|
2024-08-11 00:27:25 +03:00
|
|
|
|
|
|
|
/* Curl_llist_count() returns a size_t the number of nodes in the list */
|
|
|
|
size_t Curl_llist_count(struct Curl_llist *list)
|
|
|
|
{
|
|
|
|
DEBUGASSERT(list);
|
|
|
|
DEBUGASSERT(list->_init == LLISTINIT);
|
|
|
|
return list->_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Curl_node_elem() returns the custom data from a Curl_llist_node */
|
|
|
|
void *Curl_node_elem(struct Curl_llist_node *n)
|
|
|
|
{
|
|
|
|
DEBUGASSERT(n);
|
|
|
|
DEBUGASSERT(n->_init == NODEINIT);
|
|
|
|
return n->_ptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Curl_node_next() returns the next element in a list from a given
|
|
|
|
Curl_llist_node */
|
|
|
|
struct Curl_llist_node *Curl_node_next(struct Curl_llist_node *n)
|
|
|
|
{
|
|
|
|
DEBUGASSERT(n);
|
|
|
|
DEBUGASSERT(n->_init == NODEINIT);
|
|
|
|
return VERIFYNODE(n->_next);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef UNITTEST
|
|
|
|
|
|
|
|
/* Curl_node_prev() returns the previous element in a list from a given
|
|
|
|
Curl_llist_node */
|
|
|
|
struct Curl_llist_node *Curl_node_prev(struct Curl_llist_node *n)
|
|
|
|
{
|
|
|
|
DEBUGASSERT(n);
|
|
|
|
DEBUGASSERT(n->_init == NODEINIT);
|
|
|
|
return VERIFYNODE(n->_prev);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|