+ LicenseRef-scancode-mit-no-advert-export-control \

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__buf.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__htable.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__htable_asvp.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__htable_stvp.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__llist.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__slist.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__buf.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__htable.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__htable_asvp.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__htable_stvp.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__llist.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__slist.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__buf.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__htable.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__htable_asvp.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__htable_stvp.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__llist.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__slist.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__buf.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__htable.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__htable_asvp.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__htable_stvp.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__llist.c

+ ${CMAKE_SOURCE_DIR}/contrib/libs/c-ares/src/lib/ares__slist.c

+Reading and comprehension of the following Microsoft Learn article

+is a must for any Windows developer. Especially

+ - [Use the C Run-Time](https://learn.microsoft.com/en-us/troubleshoot/developer/visualstudio/cpp/libraries/use-c-run-time)

+WATCOM

+=====

+

+To build c-ares with OpenWatcom, you need to have at least version 1.9 of OpenWatcom. You can get the latest version from [http://openwatcom.org/ftp/install/](http://openwatcom.org/ftp/install/). Install the version that corresponds to your current host platform.

+

+After installing OpenWatcom, open a new command prompt and execute the following commands:

+

+```

+ cd \path\to\cmake\source

+ buildconf.bat

+ wmake -u -f Makefile.Watcom

+```

+

+After running wmake, you should get adig.exe, ahost.exe, and the static and dynamic versions of libcares.

+

+MIT License

+

+

+Copyright (c) 1998 Massachusetts Institute of Technology

+Copyright (c) 2007 - 2023 Daniel Stenberg with many contributors, see AUTHORS

+Permission is hereby granted, free of charge, to any person obtaining a copy of

+this software and associated documentation files (the "Software"), to deal in

+the Software without restriction, including without limitation the rights to

+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+the Software, and to permit persons to whom the Software is furnished to do so,

+subject to the following conditions:

+

+The above copyright notice and this permission notice (including the next

+paragraph) shall be included in all copies or substantial portions of the

+Software.

+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+SOFTWARE.

+c-ares is distributed the MIT license.

+ 'ahost', and 'adig'. The 'cares' folder is the one that

+c-ares version 1.20.1

+This release resolves a significant issue in the 1.20.0 release.

+Bug fixes:

+ o Resolve use-after-free issue when TCP connection is terminated before a

+ response is returned [17]

+ o Reduce number of queries for a load test case to prevent overloading some

+ build systems

+ o Fix fuzz test build target [18]

+

+

+c-ares 1.20.0 notes below:

+

+This is a feature and bugfix release with some significant internal changes.

+Changes:

+ o Update from 1989 MIT license text to modern MIT license text [1]

+ o Remove acountry from built tools as nerd.dk is gone [3]

+ o Add new ARES_OPT_UDP_MAX_QUERIES configuration option to limit the number of

+ queries that can be made from a single ephemeral port [7]

+ o Default per-query timeout has been reduced to 2s with a 3x retry count [8]

+ o Modernization: start implementing some common data structures that are easy

+ to use and hard to misuse. This will make code refactoring easier and remove

+ some varied implementations in use. This change also makes ares_timeout()

+ more efficient [9]

+ o Use SPDX identifiers and a REUSE CI job to verify [12]

+ o rand: add support for getrandom() [14]

+ o TCP back to back queries were broken [2]

+ o Ensure queries for ares_getaddrinfo() are not requeued during destruction [4]

+ o ares_getaddrinfo() should not retry other address classes if one address

+ class has already been returned [5]

+ o Avoid production ill-formed result when qualifying a name with the root

+ domain [6]

+ o Fix missing prefix for CMake generated libcares.pc [10]

+ o DNS server ports will now be read from system configuration instead of

+ defaulting to port 53 [11]

+ o Remove some unreachable code [13]

+ o Replace usages of sprintf with snprintf [15]

+ o Fix Watcom instructions and update Windows URLs [16]

+ Alexey A Tikhonov (@alexey-tikhonov)

+ Ben Noordhuis (@bnoordhuis)

+ Jérôme Duval (@korli)

+ Sam Morris (@yrro)

+ Tim Wojtulewicz (@timwoj)

+ [1] = https://github.com/c-ares/c-ares/pull/556

+ [2] = https://github.com/c-ares/c-ares/pull/552

+ [3] = https://github.com/c-ares/c-ares/pull/554

+ [4] = https://github.com/c-ares/c-ares/pull/553

+ [5] = https://github.com/c-ares/c-ares/pull/551

+ [6] = https://github.com/c-ares/c-ares/pull/546

+ [7] = https://github.com/c-ares/c-ares/pull/549

+ [8] = https://github.com/c-ares/c-ares/pull/542

+ [9] = https://github.com/c-ares/c-ares/pull/540

+ [10] = https://github.com/c-ares/c-ares/pull/530

+ [11] = https://github.com/c-ares/c-ares/pull/534

+ [12] = https://github.com/c-ares/c-ares/commit/c1b00c41

+ [13] = https://github.com/c-ares/c-ares/pull/527

+ [14] = https://github.com/c-ares/c-ares/pull/526

+ [15] = https://github.com/c-ares/c-ares/pull/525

+ [16] = https://github.com/c-ares/c-ares/pull/524

+ [17] = https://github.com/c-ares/c-ares/pull/562

+ [18] = https://github.com/c-ares/c-ares/pull/559

+- edit `include/ares_version.h` and set `ARES_VERSION_*` definitions to reflect

+ the current version.

+

+/* MIT License

+ *

+ * Copyright (c) Massachusetts Institute of Technology

+ * Copyright (c) Daniel Stenberg

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * SPDX-License-Identifier: MIT

+#define ARES_OPT_FLAGS (1 << 0)

+#define ARES_OPT_TIMEOUT (1 << 1)

+#define ARES_OPT_TRIES (1 << 2)

+#define ARES_OPT_NDOTS (1 << 3)

+#define ARES_OPT_UDP_PORT (1 << 4)

+#define ARES_OPT_TCP_PORT (1 << 5)

+#define ARES_OPT_SERVERS (1 << 6)

+#define ARES_OPT_DOMAINS (1 << 7)

+#define ARES_OPT_LOOKUPS (1 << 8)

+#define ARES_OPT_SOCK_STATE_CB (1 << 9)

+#define ARES_OPT_SORTLIST (1 << 10)

+#define ARES_OPT_SOCK_SNDBUF (1 << 11)

+#define ARES_OPT_SOCK_RCVBUF (1 << 12)

+#define ARES_OPT_TIMEOUTMS (1 << 13)

+#define ARES_OPT_ROTATE (1 << 14)

+#define ARES_OPT_EDNSPSZ (1 << 15)

+#define ARES_OPT_NOROTATE (1 << 16)

+#define ARES_OPT_RESOLVCONF (1 << 17)

+#define ARES_OPT_HOSTS_FILE (1 << 18)

+#define ARES_OPT_UDP_MAX_QUERIES (1 << 19)

+#define ARES_OPT_MAXTIMEOUTMS (1 << 20)

+#define ARES_OPT_JITTER (1 << 21)

+ int udp_max_queries;

+#ifndef __CARES_BUILD_H

+#define __CARES_BUILD_H

+/*

+ * Copyright (C) The c-ares project and its contributors

+ * SPDX-License-Identifier: MIT

+ */

+

+#define CARES_TYPEOF_ARES_SOCKLEN_T socklen_t

+#define CARES_TYPEOF_ARES_SSIZE_T ssize_t

+

+/* Prefix names with CARES_ to make sure they don't conflict with other config.h

+ * files. We need to include some dependent headers that may be system specific

+ * for C-Ares */

+#define CARES_HAVE_SYS_TYPES_H

+/* #undef CARES_HAVE_SYS_RANDOM_H */

+#define CARES_HAVE_SYS_SOCKET_H

+/* #undef CARES_HAVE_WINDOWS_H */

+/* #undef CARES_HAVE_WS2TCPIP_H */

+/* #undef CARES_HAVE_WINSOCK2_H */

+/* #undef CARES_HAVE_WINDOWS_H */

+#define CARES_HAVE_ARPA_NAMESER_H

+#define CARES_HAVE_ARPA_NAMESER_COMPAT_H

+

+#ifdef CARES_HAVE_SYS_TYPES_H

+# include <sys/types.h>

+#endif

+

+#ifdef CARES_HAVE_SYS_RANDOM_H

+# include <sys/random.h>

+#endif

+

+#ifdef CARES_HAVE_SYS_SOCKET_H

+# include <sys/socket.h>

+#endif

+

+#ifdef CARES_HAVE_WINSOCK2_H

+# include <winsock2.h>

+#endif

+

+#ifdef CARES_HAVE_WS2TCPIP_H

+# include <ws2tcpip.h>

+#endif

+

+#ifdef CARES_HAVE_WINDOWS_H

+# include <windows.h>

+#endif

+

+

+typedef CARES_TYPEOF_ARES_SOCKLEN_T ares_socklen_t;

+typedef CARES_TYPEOF_ARES_SSIZE_T ares_ssize_t;

+

+#endif /* __CARES_BUILD_H */

+/*

+ * Copyright (C) The c-ares project and its contributors

+ * SPDX-License-Identifier: MIT

+ */

+#define CARES_HAVE_SYS_RANDOM_H

+#ifdef CARES_HAVE_SYS_RANDOM_H

+# include <sys/random.h>

+#endif

+

+#if defined(__IOS__)

+# include "ares_build-ios.h"

+#elif defined(_MSC_VER) && (defined(__x86_64__) || defined(_M_X64))

+/* MIT License

+ *

+ * Copyright (c) Massachusetts Institute of Technology

+ * Copyright (c) The c-ares project and its contributors

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+#ifndef HEADER_CARES_DNS_H

+#define HEADER_CARES_DNS_H

+/* MIT License

+ *

+ * Copyright (c) Massachusetts Institute of Technology

+ * Copyright (c) Daniel Stenberg

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+ */

+/* MIT License

+ *

+ * Copyright (c) 2009 Daniel Stenberg

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+#ifndef __CARES_RULES_H

+#define __CARES_RULES_H

+/* MIT License

+ *

+ * Copyright (c) Daniel Stenberg

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+ */

+#define ARES_COPYRIGHT "2004 - 2023 Daniel Stenberg, <daniel@haxx.se>."

+#define ARES_VERSION_MINOR 20

+#define ARES_VERSION_PATCH 1

+#define ARES_VERSION_STR "1.20.1"

+/* MIT License

+ * Copyright (c) 1998 Massachusetts Institute of Technology

+ * Copyright (c) 2005 Dominick Meglio

+ * Copyright (c) 2019 Andrew Selivanov

+ * Copyright (c) 2021 Brad House

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+/* MIT License

+ * Copyright (c) Massachusetts Institute of Technology

+ * Copyright (c) Daniel Stenberg

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+/* MIT License

+ *

+ * Copyright (c) 2023 Brad House

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+ */

+#include "ares_setup.h"

+#include "ares.h"

+#include "ares_private.h"

+#include "ares__buf.h"

+#include <limits.h>

+#ifdef HAVE_STDINT_H

+# include <stdint.h>

+#endif

+

+struct ares__buf {

+ const unsigned char *data; /*!< pointer to start of data buffer */

+ size_t data_len; /*!< total size of data in buffer */

+

+ unsigned char *alloc_buf; /*!< Pointer to allocated data buffer,

+ * not used for const buffers */

+ size_t alloc_buf_len; /*!< Size of allocated data buffer */

+

+ size_t offset; /*!< Current working offset in buffer */

+ size_t tag_offset; /*!< Tagged offset in buffer. Uses

+ * SIZE_MAX if not set. */

+};

+

+ares__buf_t *ares__buf_create(void)

+{

+ ares__buf_t *buf = ares_malloc(sizeof(*buf));

+ if (buf == NULL)

+ return NULL;

+

+ memset(buf, 0, sizeof(*buf));

+ buf->tag_offset = SIZE_MAX;

+ return buf;

+}

+

+

+ares__buf_t *ares__buf_create_const(const unsigned char *data, size_t data_len)

+{

+ ares__buf_t *buf;

+

+ if (data == NULL || data_len == 0)

+ return NULL;

+

+ buf = ares__buf_create();

+ if (buf == NULL)

+ return NULL;

+

+ buf->data = data;

+ buf->data_len = data_len;

+

+ return buf;

+}

+

+

+void ares__buf_destroy(ares__buf_t *buf)

+{

+ if (buf == NULL)

+ return;

+ ares_free(buf->alloc_buf);

+ ares_free(buf);

+}

+

+

+static int ares__buf_is_const(const ares__buf_t *buf)

+{

+ if (buf == NULL)

+ return 0;

+

+ if (buf->data != NULL && buf->alloc_buf == NULL)

+ return 1;

+

+ return 0;

+}

+

+

+static void ares__buf_reclaim(ares__buf_t *buf)

+{

+ size_t prefix_size;

+ size_t data_size;

+

+ if (buf == NULL)

+ return;

+

+ if (ares__buf_is_const(buf))

+ return;

+

+ if (buf->tag_offset != SIZE_MAX) {

+ prefix_size = buf->tag_offset;

+ } else {

+ prefix_size = buf->offset;

+ }

+

+ if (prefix_size == 0)

+ return;

+

+ data_size = buf->data_len - prefix_size;

+

+ memmove(buf->alloc_buf, buf->alloc_buf + prefix_size, data_size);

+ buf->data = buf->alloc_buf;

+ buf->data_len = data_size;

+ buf->offset -= prefix_size;

+ if (buf->tag_offset != SIZE_MAX)

+ buf->tag_offset -= prefix_size;

+

+ return;

+}

+

+

+static int ares__buf_ensure_space(ares__buf_t *buf, size_t needed_size)

+{

+ size_t remaining_size;

+ size_t alloc_size;

+ unsigned char *ptr;

+

+ if (buf == NULL)

+ return ARES_EFORMERR;

+

+ if (ares__buf_is_const(buf))

+ return ARES_EFORMERR;

+

+ /* When calling ares__buf_finish_str() we end up adding a null terminator,

+ * so we want to ensure the size is always sufficient for this as we don't

+ * want an ARES_ENOMEM at that point */

+ needed_size++;

+

+ /* No need to do an expensive move operation, we have enough to just append */

+ remaining_size = buf->alloc_buf_len - buf->data_len;

+ if (remaining_size >= needed_size)

+ return ARES_SUCCESS;

+

+ /* See if just moving consumed data frees up enough space */

+ ares__buf_reclaim(buf);

+

+ remaining_size = buf->alloc_buf_len - buf->data_len;

+ if (remaining_size >= needed_size)

+ return ARES_SUCCESS;

+

+ alloc_size = buf->alloc_buf_len;

+

+ /* Not yet started */

+ if (alloc_size == 0)

+ alloc_size = 16; /* Always shifts 1, so ends up being 32 minimum */

+

+ /* Increase allocation by powers of 2 */

+ do {

+ alloc_size <<= 1;

+ remaining_size = alloc_size - buf->data_len;

+ } while (remaining_size < needed_size);

+

+ ptr = ares_realloc(buf->alloc_buf, alloc_size);

+ if (ptr == NULL)

+ return ARES_ENOMEM;

+

+ buf->alloc_buf = ptr;

+ buf->alloc_buf_len = alloc_size;

+ buf->data = ptr;

+

+ return ARES_SUCCESS;

+}

+

+

+int ares__buf_append(ares__buf_t *buf, const unsigned char *data,

+ size_t data_len)

+{

+ int status;

+

+ if (data == NULL || data_len == 0)

+ return ARES_EFORMERR;

+

+ status = ares__buf_ensure_space(buf, data_len);

+ if (status != ARES_SUCCESS)

+ return status;

+

+ memcpy(buf->alloc_buf + buf->data_len, data, data_len);

+ buf->data_len += data_len;

+ return ARES_SUCCESS;

+}

+

+

+unsigned char *ares__buf_append_start(ares__buf_t *buf, size_t *len)

+{

+ int status;

+

+ if (len == NULL || *len == 0)

+ return NULL;

+

+ status = ares__buf_ensure_space(buf, *len);

+ if (status != ARES_SUCCESS)

+ return NULL;

+

+ *len = buf->alloc_buf_len - buf->data_len;

+ return buf->alloc_buf + buf->data_len;

+}

+

+

+void ares__buf_append_finish(ares__buf_t *buf, size_t len)

+{

+ if (buf == NULL)

+ return;

+

+ buf->data_len += len;

+}

+

+

+unsigned char *ares__buf_finish_bin(ares__buf_t *buf, size_t *len)

+{

+ unsigned char *ptr = NULL;

+ if (buf == NULL || len == NULL || ares__buf_is_const(buf))

+ return NULL;

+

+ ares__buf_reclaim(buf);

+ ptr = buf->alloc_buf;

+ *len = buf->data_len;

+ ares_free(buf);

+ return ptr;

+}

+

+

+char *ares__buf_finish_str(ares__buf_t *buf, size_t *len)

+{

+ char *ptr;

+ size_t mylen;

+

+ ptr = (char *)ares__buf_finish_bin(buf, &mylen);

+ if (ptr == NULL)

+ return NULL;

+

+ if (len != NULL)

+ *len = mylen;

+

+ /* NOTE: ensured via ares__buf_ensure_space() that there is always at least

+ * 1 extra byte available for this specific use-case */

+ ptr[mylen] = 0;

+

+ return ptr;

+}

+

+

+void ares__buf_tag(ares__buf_t *buf)

+{

+ if (buf == NULL)

+ return;

+

+ buf->tag_offset = buf->offset;

+}

+

+

+int ares__buf_tag_rollback(ares__buf_t *buf)

+{

+ if (buf == NULL || buf->tag_offset == SIZE_MAX)

+ return ARES_EFORMERR;

+

+ buf->offset = buf->tag_offset;

+ buf->tag_offset = SIZE_MAX;

+ return ARES_SUCCESS;

+}

+

+

+int ares__buf_tag_clear(ares__buf_t *buf)

+{

+ if (buf == NULL || buf->tag_offset == SIZE_MAX)

+ return ARES_EFORMERR;

+

+ buf->tag_offset = SIZE_MAX;

+ return ARES_SUCCESS;

+}

+

+

+const unsigned char *ares__buf_tag_fetch(const ares__buf_t *buf, size_t *len)

+{

+ if (buf == NULL || buf->tag_offset == SIZE_MAX || len == NULL)

+ return NULL;

+

+ *len = buf->offset - buf->tag_offset;

+ return buf->data + buf->tag_offset;

+}

+

+

+static const unsigned char *ares__buf_fetch(const ares__buf_t *buf, size_t *len)

+{

+ if (len != NULL)

+ *len = 0;

+

+ if (buf == NULL || len == NULL || buf->data == NULL)

+ return NULL;

+

+ *len = buf->data_len - buf->offset;

+ return buf->data + buf->offset;

+}

+

+

+int ares__buf_consume(ares__buf_t *buf, size_t len)

+{

+ size_t remaining_len;

+

+ ares__buf_fetch(buf, &remaining_len);

+

+ if (remaining_len < len)

+ return ARES_EBADRESP;

+

+ buf->offset += len;

+ return ARES_SUCCESS;

+}

+

+

+int ares__buf_fetch_be16(ares__buf_t *buf, unsigned short *u16)

+{

+ size_t remaining_len;

+ const unsigned char *ptr = ares__buf_fetch(buf, &remaining_len);

+

+ if (buf == NULL || u16 == NULL || remaining_len < sizeof(*u16))

+ return ARES_EBADRESP;

+

+ *u16 = (unsigned short)((unsigned short)(ptr[0]) << 8 | (unsigned short)ptr[1]);

+

+ return ares__buf_consume(buf, sizeof(*u16));

+}

+

+

+int ares__buf_fetch_bytes(ares__buf_t *buf, unsigned char *bytes,

+ size_t len)

+{

+ size_t remaining_len;

+ const unsigned char *ptr = ares__buf_fetch(buf, &remaining_len);

+

+ if (buf == NULL || bytes == NULL || len == 0 || remaining_len < len)

+ return ARES_EBADRESP;

+

+ memcpy(bytes, ptr, len);

+ return ares__buf_consume(buf, len);

+}

+

+

+size_t ares__buf_consume_whitespace(ares__buf_t *buf, int include_linefeed)

+{

+ size_t remaining_len = 0;

+ const unsigned char *ptr = ares__buf_fetch(buf, &remaining_len);

+ size_t i;

+

+ if (ptr == NULL)

+ return 0;

+

+ for (i=0; i<remaining_len; i++) {

+ switch(ptr[i]) {

+ case '\r':

+ case '\t':

+ case ' ':

+ case '\v':

+ case '\f':

+ break;

+ case '\n':

+ if (!include_linefeed)

+ goto done;

+ break;

+ default:

+ goto done;

+ }

+ }

+

+done:

+ if (i > 0)

+ ares__buf_consume(buf, i);

+ return i;

+}

+

+size_t ares__buf_consume_nonwhitespace(ares__buf_t *buf)

+{

+ size_t remaining_len = 0;

+ const unsigned char *ptr = ares__buf_fetch(buf, &remaining_len);

+ size_t i;

+

+ if (ptr == NULL)

+ return 0;

+

+ for (i=0; i<remaining_len; i++) {

+ switch(ptr[i]) {

+ case '\r':

+ case '\t':

+ case ' ':

+ case '\v':

+ case '\f':

+ case '\n':

+ goto done;

+ default:

+ break;

+ }

+ }

+

+done:

+ if (i > 0)

+ ares__buf_consume(buf, i);

+ return i;

+}

+

+size_t ares__buf_consume_line(ares__buf_t *buf, int include_linefeed)

+{

+ size_t remaining_len = 0;

+ const unsigned char *ptr = ares__buf_fetch(buf, &remaining_len);

+ size_t i;

+

+ if (ptr == NULL)

+ return 0;

+

+ for (i=0; i<remaining_len; i++) {

+ switch(ptr[i]) {

+ case '\n':

+ if (include_linefeed)

+ i++;

+ goto done;

+ default:

+ break;

+ }

+ }

+

+done:

+ if (i > 0)

+ ares__buf_consume(buf, i);

+ return i;

+}

+

+

+int ares__buf_begins_with(ares__buf_t *buf, const unsigned char *data,

+ size_t data_len)

+{

+ size_t remaining_len = 0;

+ const unsigned char *ptr = ares__buf_fetch(buf, &remaining_len);

+

+ if (ptr == NULL || data == NULL || data_len == 0)

+ return ARES_EFORMERR;

+

+ if (data_len > remaining_len)

+ return ARES_EBADRESP;

+

+ if (memcmp(ptr, data, data_len) == 0)

+ return ARES_EBADRESP;

+

+ return ARES_SUCCESS;

+}

+

+

+size_t ares__buf_len(const ares__buf_t *buf)

+{

+ size_t len = 0;

+ ares__buf_fetch(buf, &len);

+ return len;

+}

+

+

+const unsigned char *ares__buf_peek(const ares__buf_t *buf, size_t *len)

+{

+ return ares__buf_fetch(buf, len);

+}

+

+/* MIT License

+ *

+ * Copyright (c) 2023 Brad House

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+ */

+#ifndef __ARES__BUF_H

+#define __ARES__BUF_H

+

+/*! \addtogroup ares__buf Safe Data Builder and buffer

+ *

+ * This is a buffer building and parsing framework with a focus on security over

+ * performance. All data to be read from the buffer will perform explicit length

+ * validation and return a success/fail result. There are also various helpers

+ * for writing data to the buffer which dynamically grows.

+ *

+ * The helpers for this object are meant to be added as needed. If you can't

+ * find it, write it!

+ *

+ * @{

+ */

+struct ares__buf;

+

+/*! Opaque data type for generic hash table implementation */

+typedef struct ares__buf ares__buf_t;

+

+/*! Create a new buffer object that dynamically allocates buffers for data.

+ *

+ * \return initialized buffer object or NULL if out of memory.

+ */

+ares__buf_t *ares__buf_create(void);

+

+/*! Create a new buffer object that uses a user-provided data pointer. The

+ * data provided will not be manipulated, and cannot be appended to. This

+ * is strictly used for parsing.

+ *

+ * \param[in] data Data to provide to buffer, must not be NULL.

+ * \param[in] data_len Size of buffer provided, must be > 0

+ *

+ * \return initialized buffer object or NULL if out of memory or misuse.

+ */

+ares__buf_t *ares__buf_create_const(const unsigned char *data, size_t data_len);

+

+/*! Destroy an initialized buffer object.

+ *

+ * \param[in] buf Initialized buf object

+ */

+void ares__buf_destroy(ares__buf_t *buf);

+

+/*! Append to a dynamic buffer object

+ *

+ * \param[in] buf Initialized buffer object

+ * \param[in] data Data to copy to buffer object

+ * \param[in] data_len Length of data to copy to buffer object.

+ * \return ARES_SUCCESS or one of the c-ares error codes

+ */

+int ares__buf_append(ares__buf_t *buf, const unsigned char *data,

+ size_t data_len);

+

+

+/*! Start a dynamic append operation that returns a buffer suitable for

+ * writing. A desired minimum length is passed in, and the actual allocated

+ * buffer size is returned which may be greater than the requested size.

+ * No operation other than ares__buf_append_finish() is allowed on the

+ * buffer after this request.

+ *

+ * \param[in] buf Initialized buffer object

+ * \param[in,out] len Desired non-zero length passed in, actual buffer size

+ * returned.

+ * \return Pointer to writable buffer or NULL on failure (usage, out of mem)

+ */

+unsigned char *ares__buf_append_start(ares__buf_t *buf, size_t *len);

+

+/*! Finish a dynamic append operation. Called after

+ * ares__buf_append_start() once desired data is written.

+ *

+ * \param[in] buf Initialized buffer object.

+ * \param[in] len Length of data written. May be zero to terminate

+ * operation. Must not be greater than returned from

+ * ares__buf_append_start().

+ */

+void ares__buf_append_finish(ares__buf_t *buf, size_t len);

+

+/*! Clean up ares__buf_t and return allocated pointer to unprocessed data. It

+ * is the responsibility of the caller to ares_free() the returned buffer.

+ * The passed in buf parameter is invalidated by this call.

+ *

+ * \param[in] buf Initialized buffer object. Can not be a "const" buffer.

+ * \param[out] len Length of data returned

+ * \return pointer to unprocessed data or NULL on error.

+ */

+unsigned char *ares__buf_finish_bin(ares__buf_t *buf, size_t *len);

+

+/*! Clean up ares__buf_t and return allocated pointer to unprocessed data and

+ * return it as a string (null terminated). It is the responsibility of the

+ * caller to ares_free() the returned buffer. The passed in buf parameter is

+ * invalidated by this call.

+ *

+ * This function in no way validates the data in this buffer is actually

+ * a string, that characters are printable, or that there aren't multiple

+ * NULL terminators. It is assumed that the caller will either validate that

+ * themselves or has built this buffer with only a valid character set.

+ *

+ * \param[in] buf Initialized buffer object. Can not be a "const" buffer.

+ * \param[out] len Optional. Length of data returned, or NULL if not needed.

+ * \return pointer to unprocessed data or NULL on error.

+ */

+char *ares__buf_finish_str(ares__buf_t *buf, size_t *len);

+

+/*! Tag a position to save in the buffer in case parsing needs to rollback,

+ * such as if insufficient data is available, but more data may be added in

+ * the future. Only a single tag can be set per buffer object. Setting a

+ * tag will override any pre-existing tag.

+ *

+ * \param[in] buf Initialized buffer object

+ */

+void ares__buf_tag(ares__buf_t *buf);

+

+/*! Rollback to a tagged position. Will automatically clear the tag.

+ *

+ * \param[in] buf Initialized buffer object

+ * \return ARES_SUCCESS or one of the c-ares error codes

+ */

+int ares__buf_tag_rollback(ares__buf_t *buf);

+

+/*! Clear the tagged position without rolling back. You should do this any

+ * time a tag is no longer needed as future append operations can reclaim

+ * buffer space.

+ *

+ * \param[in] buf Initialized buffer object

+ * \return ARES_SUCCESS or one of the c-ares error codes

+ */

+int ares__buf_tag_clear(ares__buf_t *buf);

+

+/*! Fetch the buffer and length of data starting from the tagged position up

+ * to the _current_ position. It will not unset the tagged position. The

+ * data may be invalidated by any future ares__buf_*() calls.

+ *

+ * \param[in] buf Initialized buffer object

+ * \param[out] len Length between tag and current offset in buffer

+ * \return NULL on failure (such as no tag), otherwise pointer to start of

+ * buffer

+ */

+const unsigned char *ares__buf_tag_fetch(const ares__buf_t *buf, size_t *len);

+

+/*! Consume the given number of bytes without reading them.

+ *

+ * \param[in] buf Initialized buffer object

+ * \param[in] len Length to consume

+ * \return ARES_SUCCESS or one of the c-ares error codes

+ */

+int ares__buf_consume(ares__buf_t *buf, size_t len);

+

+/*! Fetch a 16bit Big Endian number from the buffer.

+ *

+ * \param[in] buf Initialized buffer object

+ * \param[out] u16 Buffer to hold 16bit integer

+ * \return ARES_SUCCESS or one of the c-ares error codes

+ */

+int ares__buf_fetch_be16(ares__buf_t *buf, unsigned short *u16);

+

+/*! Fetch the requested number of bytes into the provided buffer

+ *

+ * \param[in] buf Initialized buffer object

+ * \param[out] bytes Buffer to hold data

+ * \param[in] len Requested number of bytes (must be > 0)

+ * \return ARES_SUCCESS or one of the c-ares error codes

+ */

+int ares__buf_fetch_bytes(ares__buf_t *buf, unsigned char *bytes,

+ size_t len);

+

+/*! Consume whitespace characters (0x09, 0x0B, 0x0C, 0x0D, 0x20, and optionally

+ * 0x0A).

+ *

+ * \param[in] buf Initialized buffer object

+ * \param[in] include_linefeed 1 to include consuming 0x0A, 0 otherwise.

+ * \return number of whitespace characters consumed

+ */

+size_t ares__buf_consume_whitespace(ares__buf_t *buf, int include_linefeed);

+

+

+/*! Consume any non-whitespace character (anything other than 0x09, 0x0B, 0x0C,

+ * 0x0D, 0x20, and 0x0A).

+ *

+ * \param[in] buf Initialized buffer object

+ * \return number of characters consumed

+ */

+size_t ares__buf_consume_nonwhitespace(ares__buf_t *buf);

+

+/*! Consume from the current position until the end of the line, and optionally

+ * the end of line character (0x0A) itself.

+ *

+ * \param[in] buf Initialized buffer object

+ * \param[in] include_linefeed 1 to include consuming 0x0A, 0 otherwise.

+ * \return number of characters consumed

+ */

+size_t ares__buf_consume_line(ares__buf_t *buf, int include_linefeed);

+

+

+/*! Check the unprocessed buffer to see if it begins with the sequence of

+ * characters provided.

+ *

+ * \param[in] buf Initialized buffer object

+ * \param[in] data Bytes of data to compare.

+ * \param[in] data_len Length of data to compare.

+ * \return ARES_SUCCESS or one of the c-ares error codes

+ */

+int ares__buf_begins_with(ares__buf_t *buf, const unsigned char *data,

+ size_t data_len);

+

+

+/*! Size of unprocessed remaining data length

+ *

+ * \param[in] buf Initialized buffer object

+ * \return length remaining

+ */

+size_t ares__buf_len(const ares__buf_t *buf);

+

+/*! Retrieve a pointer to the currently unprocessed data. Generally this isn't

+ * recommended to be used in practice. The returned pointer may be invalidated

+ * by any future ares__buf_*() calls.

+ *

+ * \param[in] buf Initialized buffer object

+ * \param[out] len Length of available data

+ * \return Pointer to buffer of unprocessed data

+ */

+const unsigned char *ares__buf_peek(const ares__buf_t *buf,

+ size_t *len);

+

+

+/*! @} */

+

+#endif /* __ARES__BUF_H */

+/* MIT License

+ *

+ * Copyright (c) 1998 Massachusetts Institute of Technology

+ * Copyright (c) The c-ares project and its contributors

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+#include <assert.h>

+

+void ares__close_connection(struct server_connection *conn)

+ struct server_state *server = conn->server;

+ ares_channel channel = server->channel;

+

+ if (conn->is_tcp) {

+ /* Reset any existing input and output buffer. */

+ ares__buf_consume(server->tcp_parser, ares__buf_len(server->tcp_parser));

+ ares__buf_consume(server->tcp_send, ares__buf_len(server->tcp_send));

+ server->tcp_connection_generation = ++channel->tcp_connection_generation;

+ server->tcp_conn = NULL;

+ }

+

+

+ SOCK_STATE_CALLBACK(channel, conn->fd, 0, 0);

+ ares__close_socket(channel, conn->fd);

+ ares__llist_node_claim(

+ ares__htable_asvp_get_direct(channel->connnode_by_socket, conn->fd)

+ );

+ ares__htable_asvp_remove(channel->connnode_by_socket, conn->fd);

+

+#ifndef NDEBUG

+ assert(ares__llist_len(conn->queries_to_conn) == 0);

+#endif

+ ares__llist_destroy(conn->queries_to_conn);

+ ares_free(conn);

+}

+

+void ares__close_sockets(struct server_state *server)

+{

+ ares__llist_node_t *node;

+

+ while ((node = ares__llist_node_first(server->connections)) != NULL) {

+ struct server_connection *conn = ares__llist_node_val(node);

+ ares__close_connection(conn);

+ }

+}

+

+void ares__check_cleanup_conn(ares_channel channel, ares_socket_t fd)

+{

+ ares__llist_node_t *node;

+ struct server_connection *conn;

+ int do_cleanup = 0;

+

+ node = ares__htable_asvp_get_direct(channel->connnode_by_socket, fd);

+ if (node == NULL) {

+ return;

+ }

+

+ conn = ares__llist_node_val(node);

+

+ if (ares__llist_len(conn->queries_to_conn)) {

+ return;

+ }

+

+ /* If we are configured not to stay open, close it out */

+ if (!(channel->flags & ARES_FLAG_STAYOPEN)) {

+ do_cleanup = 1;

+ }

+

+ /* If the udp connection hit its max queries, always close it */

+ if (!conn->is_tcp && channel->udp_max_queries > 0 &&

+ conn->total_queries >= (size_t)channel->udp_max_queries) {

+ do_cleanup = 1;

+ }

+

+ if (do_cleanup) {

+ ares__close_connection(conn);

+ }

+/* MIT License

+ *

+ * Copyright (c) 1998, 2011 Massachusetts Institute of Technology

+ * Copyright (c) The c-ares project and its contributors

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * SPDX-License-Identifier: MIT

+/* MIT License

+ *

+ * Copyright (c) 2023 Brad House

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+ */

+#include "ares_setup.h"

+#include "ares.h"

+#include "ares_private.h"

+#include "ares__llist.h"

+#include "ares__htable.h"

+

+#define ARES__HTABLE_MAX_BUCKETS (1U<<24)

+#define ARES__HTABLE_MIN_BUCKETS (1U<<4)

+#define ARES__HTABLE_EXPAND_PERCENT 75

+

+struct ares__htable {

+ ares__htable_hashfunc_t hash;

+ ares__htable_bucket_key_t bucket_key;

+ ares__htable_bucket_free_t bucket_free;

+ ares__htable_key_eq_t key_eq;

+ unsigned int seed;

+ unsigned int size;

+ size_t num_keys;

+ /* NOTE: if we converted buckets into ares__slist_t we could guarantee on

+ * hash collisions we would have O(log n) worst case insert and search

+ * performance. (We'd also need to make key_eq into a key_cmp to

+ * support sort). That said, risk with a random hash seed is near zero,

+ * and ares__slist_t is heavier weight so I think using ares__llist_t is

+ * is an overall win. */

+ ares__llist_t **buckets;

+};

+

+

+static unsigned int ares__htable_generate_seed(ares__htable_t *htable)

+{

+ unsigned int seed = 0;

+

+ /* Mix stack address, heap address, and time to generate a random seed, it

+ * doesn't have to be super secure, just quick. Likelihood of a hash

+ * collision attack is very low with a small amount of effort */

+ seed |= (unsigned int)((size_t)htable & 0xFFFFFFFF);

+ seed |= (unsigned int)((size_t)&seed & 0xFFFFFFFF);

+ seed |= (unsigned int)time(NULL) & 0xFFFFFFFF;

+ return seed;

+}

+

+static void ares__htable_buckets_destroy(ares__llist_t **buckets,

+ unsigned int size,

+ unsigned char destroy_vals)

+{

+ unsigned int i;

+

+ if (buckets == NULL)

+ return;

+

+ for (i=0; i<size; i++) {

+ if (buckets[i] == NULL)

+ continue;

+

+ if (!destroy_vals)

+ ares__llist_replace_destructor(buckets[i], NULL);

+

+ ares__llist_destroy(buckets[i]);

+ }

+

+ ares_free(buckets);

+}

+

+

+void ares__htable_destroy(ares__htable_t *htable)

+{

+ if (htable == NULL)

+ return;

+ ares__htable_buckets_destroy(htable->buckets, htable->size, 1);

+ ares_free(htable);

+}

+

+

+ares__htable_t *ares__htable_create(ares__htable_hashfunc_t hash_func,

+ ares__htable_bucket_key_t bucket_key,

+ ares__htable_bucket_free_t bucket_free,

+ ares__htable_key_eq_t key_eq)

+{

+ ares__htable_t *htable = NULL;

+

+ if (hash_func == NULL || bucket_key == NULL || bucket_free == NULL ||

+ key_eq == NULL) {

+ goto fail;

+ }

+

+ htable = ares_malloc(sizeof(*htable));

+ if (htable == NULL)

+ goto fail;

+

+ memset(htable, 0, sizeof(*htable));

+

+ htable->hash = hash_func;

+ htable->bucket_key = bucket_key;

+ htable->bucket_free = bucket_free;

+ htable->key_eq = key_eq;

+ htable->seed = ares__htable_generate_seed(htable);

+ htable->size = ARES__HTABLE_MIN_BUCKETS;

+ htable->buckets = ares_malloc(sizeof(*htable->buckets) * htable->size);

+

+ if (htable->buckets == NULL)

+ goto fail;

+

+ memset(htable->buckets, 0, sizeof(*htable->buckets) * htable->size);

+

+ return htable;

+

+fail:

+ ares__htable_destroy(htable);

+ return NULL;

+}

+

+

+/*! Grabs the Hashtable index from the key and length. The h index is

+ * the hash of the function reduced to the size of the bucket list.

+ * We are doing "hash & (size - 1)" since we are guaranteeing a power of

+ * 2 for size. This is equivalent to "hash % size", but should be more

+ * efficient */

+#define HASH_IDX(h, key) h->hash(key, h->seed) & (h->size - 1)

+

+static ares__llist_node_t *ares__htable_find(ares__htable_t *htable,

+ unsigned int idx,

+ const void *key)

+{

+ ares__llist_node_t *node = NULL;

+

+ for (node = ares__llist_node_first(htable->buckets[idx]);

+ node != NULL;

+ node = ares__llist_node_next(node)) {

+

+ if (htable->key_eq(key, htable->bucket_key(ares__llist_node_val(node))))

+ break;

+ }

+

+ return node;

+}

+

+

+static unsigned int ares__htable_expand(ares__htable_t *htable)

+{

+ ares__llist_t **buckets = NULL;

+ unsigned int old_size = htable->size;

+ size_t i;

+

+ /* Not a failure, just won't expand */

+ if (old_size == ARES__HTABLE_MAX_BUCKETS)

+ return 1;

+

+ htable->size <<= 1;

+

+ /* We must do this in 2 passes as we want it to be non-destructive in case

+ * there is a memory allocation failure. So we will actually use more

+ * memory doing it this way, but at least we might be able to gracefully

+ * recover */

+ buckets = ares_malloc(sizeof(*buckets) * htable->size);

+ if (buckets == NULL)

+ goto fail;

+

+ memset(buckets, 0, sizeof(*buckets) * htable->size);

+

+ for (i=0; i<old_size; i++) {

+ ares__llist_node_t *node;

+ for (node = ares__llist_node_first(htable->buckets[i]);

+ node != NULL;

+ node = ares__llist_node_next(node)) {

+

+ void *val = ares__llist_node_val(node);

+ size_t idx = HASH_IDX(htable, htable->bucket_key(val));

+

+ if (buckets[idx] == NULL) {

+ buckets[idx] = ares__llist_create(htable->bucket_free);

+ if (buckets[idx] == NULL)

+ goto fail;

+ }

+

+ if (ares__llist_insert_first(buckets[idx], val) == NULL) {

+ goto fail;

+ }

+

+ }

+ }

+

+ /* Swap out buckets */

+ ares__htable_buckets_destroy(htable->buckets, old_size, 0);

+ htable->buckets = buckets;

+ return 1;

+

+fail:

+ ares__htable_buckets_destroy(buckets, htable->size, 0);

+ htable->size = old_size;

+

+ return 0;

+}

+

+

+unsigned int ares__htable_insert(ares__htable_t *htable, void *bucket)

+{

+ unsigned int idx = 0;

+ ares__llist_node_t *node = NULL;

+ const void *key = NULL;

+

+ if (htable == NULL || bucket == NULL)

+ return 0;

+

+

+ key = htable->bucket_key(bucket);

+ idx = HASH_IDX(htable, key);

+

+ /* See if we have a matching bucket already, if so, replace it */

+ node = ares__htable_find(htable, idx, key);

+ if (node != NULL) {

+ ares__llist_node_replace(node, bucket);

+ return 1;

+ }

+

+ /* Check to see if we should rehash because likelihood of collisions has

+ * increased beyond our threshold */

+ if (htable->num_keys+1 > (htable->size * ARES__HTABLE_EXPAND_PERCENT) / 100) {

+ if (!ares__htable_expand(htable)) {

+ return 0;

+ }

+ /* If we expanded, need to calculate a new index */

+ idx = HASH_IDX(htable, key);

+ }

+

+ /* We lazily allocate the linked list */

+ if (htable->buckets[idx] == NULL) {

+ htable->buckets[idx] = ares__llist_create(htable->bucket_free);

+ if (htable->buckets[idx] == NULL)

+ return 0;

+ }

+

+ node = ares__llist_insert_first(htable->buckets[idx], bucket);

+ if (node == NULL)

+ return 0;

+

+ htable->num_keys++;

+

+ return 1;

+}

+

+

+void *ares__htable_get(ares__htable_t *htable, const void *key)

+{

+ unsigned int idx;

+

+ if (htable == NULL || key == NULL)

+ return NULL;

+

+ idx = HASH_IDX(htable, key);

+

+ return ares__llist_node_val(ares__htable_find(htable, idx, key));

+}

+

+

+unsigned int ares__htable_remove(ares__htable_t *htable, const void *key)

+{

+ ares__llist_node_t *node;

+ unsigned int idx;

+

+ if (htable == NULL || key == NULL)

+ return 0;

+

+ idx = HASH_IDX(htable, key);

+ node = ares__htable_find(htable, idx, key);

+ if (node == NULL)

+ return 0;

+

+ htable->num_keys--;

+ ares__llist_node_destroy(node);

+ return 1;

+}

+

+size_t ares__htable_num_keys(ares__htable_t *htable)

+{

+ if (htable == NULL)

+ return 0;

+ return htable->num_keys;

+}

+

+unsigned int ares__htable_hash_FNV1a(const unsigned char *key, size_t key_len,

+ unsigned int seed)

+{

+ /* recommended seed is 2166136261U, but we don't want collisions */

+ unsigned int hv = seed;

+ size_t i;

+

+ for (i = 0; i < key_len; i++) {

+ hv ^= (unsigned int)key[i];

+ /* hv *= 0x01000193 */

+ hv += (hv<<1) + (hv<<4) + (hv<<7) + (hv<<8) + (hv<<24);

+ }

+

+ return hv;

+}

+

+/* tolower() is locale-specific. Use a lookup table fast conversion that only

+ * operates on ASCII */

+static const unsigned char ares__tolower_lookup[] = {

+ 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,

+ 0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,

+ 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,

+ 0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,

+ 0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,

+ 0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,

+ 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,

+ 0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,

+ 0x40,0x61,0x62,0x63,0x64,0x65,0x66,0x67,

+ 0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,

+ 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,

+ 0x78,0x79,0x7A,0x5B,0x5C,0x5D,0x5E,0x5F,

+ 0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,

+ 0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,

+ 0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,

+ 0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,

+ 0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,

+ 0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,

+ 0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,

+ 0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,

+ 0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,

+ 0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,

+ 0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,

+ 0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,

+ 0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,

+ 0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,

+ 0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,

+ 0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,

+ 0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,

+ 0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,

+ 0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,

+ 0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF

+};

+

+

+/* Case insensitive version, meant for ASCII strings */

+unsigned int ares__htable_hash_FNV1a_casecmp(const unsigned char *key, size_t key_len,

+ unsigned int seed)

+{

+ /* recommended seed is 2166136261U, but we don't want collisions */

+ unsigned int hv = seed;

+ size_t i;

+

+ for (i = 0; i < key_len; i++) {

+ hv ^= (unsigned int)ares__tolower_lookup[key[i]];

+ /* hv *= 0x01000193 */

+ hv += (hv<<1) + (hv<<4) + (hv<<7) + (hv<<8) + (hv<<24);

+ }

+

+ return hv;

+}

+/* MIT License

+ *

+ * Copyright (c) 2023 Brad House

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+ */

+#ifndef __ARES__HTABLE_H

+#define __ARES__HTABLE_H

+

+

+/*! \addtogroup ares__htable Base HashTable Data Structure

+ *

+ * This is a basic hashtable data structure that is meant to be wrapped

+ * by a higher level implementation. This data structure is designed to

+ * be callback-based in order to facilitate wrapping without needing to

+ * worry about any underlying complexities of the hashtable implementation.

+ *

+ * This implementation supports automatic growing by powers of 2 when reaching

+ * 75% capacity. A rehash will be performed on the expanded bucket list.

+ *

+ * Average time complexity:

+ * - Insert: O(1)

+ * - Search: O(1)

+ * - Delete: O(1)

+ *

+ * @{

+ */

+

+struct ares__htable_t;

+

+/*! Opaque data type for generic hash table implementation */

+typedef struct ares__htable ares__htable_t;

+

+/*! Callback for generating a hash of the key.

+ *

+ * \param[in] key pointer to key to be hashed

+ * \param[in] seed randomly generated seed used by hash function.

+ * value is specific to the hashtable instance

+ * but otherwise will not change between calls.

+ * \return hash

+ */

+typedef unsigned int (*ares__htable_hashfunc_t)(const void *key,

+ unsigned int seed);

+

+/*! Callback to free the bucket

+ *

+ * \param[in] bucket user provided bucket

+ */

+typedef void (*ares__htable_bucket_free_t)(void *bucket);

+

+/*! Callback to extract the key from the user-provided bucket

+ *

+ * \param[in] bucket user provided bucket

+ * \return pointer to key held in bucket

+ */

+typedef const void *(*ares__htable_bucket_key_t)(const void *bucket);

+

+/*! Callback to compare two keys for equality

+ *

+ * \param[in] key1 first key

+ * \param[in] key2 second key

+ * \return 1 if equal, 0 if not

+ */

+typedef unsigned int (*ares__htable_key_eq_t)(const void *key1,

+ const void *key2);

+

+

+/*! Destroy the initialized hashtable

+ *

+ * \param[in] initialized hashtable

+ */

+void ares__htable_destroy(ares__htable_t *htable);

+

+/*! Create a new hashtable

+ *

+ * \param[in] hash_func Required. Callback for Hash function.

+ * \param[in] bucket_key Required. Callback to extract key from bucket.

+ * \param[in] bucket_free Required. Callback to free bucket.

+ * \param[in] key_eq Required. Callback to check for key equality.

+ * \return initialized hashtable. NULL if out of memory or misuse.

+ */

+ares__htable_t *ares__htable_create(ares__htable_hashfunc_t hash_func,

+ ares__htable_bucket_key_t bucket_key,

+ ares__htable_bucket_free_t bucket_free,

+ ares__htable_key_eq_t key_eq);

+

+/*! Count of keys from initialized hashtable

+ *

+ * \param[in] htable Initialized hashtable.

+ * \return count of keys

+ */

+size_t ares__htable_num_keys(ares__htable_t *htable);

+

+/*! Insert bucket into hashtable

+ *

+ * \param[in] htable Initialized hashtable.

+ * \param[in] bucket User-provided bucket to insert. Takes "ownership". Not

+ * allowed to be NULL.

+ * \return 1 on success, 0 if out of memory

+ */

+unsigned int ares__htable_insert(ares__htable_t *htable, void *bucket);

+

+/*! Retrieve bucket from hashtable based on key.

+ *

+ * \param[in] htable Initialized hashtable

+ * \param[in] key Pointer to key to use for comparison.

+ * \return matching bucket, or NULL if not found.

+ */

+void *ares__htable_get(ares__htable_t *htable, const void *key);

+

+/*! Remove bucket from hashtable by key

+ *

+ * \param[in] htable Initialized hashtable

+ * \param[in] key Pointer to key to use for comparison

+ * \return 1 if found, 0 if not found

+ */

+unsigned int ares__htable_remove(ares__htable_t *htable, const void *key);

+

+/*! FNV1a hash algorithm. Can be used as underlying primitive for building

+ * a wrapper hashtable.

+ *

+ * \param[in] key pointer to key

+ * \param[in] key_len Length of key

+ * \param[in] seed Seed for generating hash

+ * \return hash value

+ */

+unsigned int ares__htable_hash_FNV1a(const unsigned char *key, size_t key_len,

+ unsigned int seed);

+

+/*! FNV1a hash algorithm, but converts all characters to lowercase before

+ * hashing to make the hash case-insensitive. Can be used as underlying

+ * primitive for building a wrapper hashtable. Used on string-based keys.

+ *

+ * \param[in] key pointer to key

+ * \param[in] key_len Length of key

+ * \param[in] seed Seed for generating hash

+ * \return hash value

+ */

+unsigned int ares__htable_hash_FNV1a_casecmp(const unsigned char *key,

+ size_t key_len,

+ unsigned int seed);

+

+/*! @} */

+

+#endif /* __ARES__HTABLE_H */

+/* MIT License

+ *

+ * Copyright (c) 2023 Brad House

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+ */

+#include "ares_setup.h"

+#include "ares.h"

+#include "ares_private.h"

+#include "ares__htable.h"

+#include "ares__htable_asvp.h"

+

+

+struct ares__htable_asvp {

+ ares__htable_asvp_val_free_t free_val;

+ ares__htable_t *hash;

+};

+

+

+typedef struct {

+ ares_socket_t key;

+ void *val;

+ ares__htable_asvp_t *parent;

+} ares__htable_asvp_bucket_t;

+

+

+void ares__htable_asvp_destroy(ares__htable_asvp_t *htable)

+{

+ if (htable == NULL)

+ return;

+

+ ares__htable_destroy(htable->hash);

+ ares_free(htable);

+}

+

+

+static unsigned int hash_func(const void *key, unsigned int seed)

+{

+ const ares_socket_t *arg = key;

+ return ares__htable_hash_FNV1a((const unsigned char *)arg, sizeof(*arg),

+ seed);

+}

+

+

+static const void *bucket_key(const void *bucket)

+{

+ const ares__htable_asvp_bucket_t *arg = bucket;

+ return &arg->key;

+}

+

+

+static void bucket_free(void *bucket)

+{

+ ares__htable_asvp_bucket_t *arg = bucket;

+

+ if (arg->parent->free_val)

+ arg->parent->free_val(arg->val);

+

+ ares_free(arg);

+}

+

+

+static unsigned int key_eq(const void *key1, const void *key2)

+{

+ const ares_socket_t *k1 = key1;

+ const ares_socket_t *k2 = key2;

+

+ if (*k1 == *k2)

+ return 1;

+

+ return 0;

+}

+

+

+ares__htable_asvp_t *ares__htable_asvp_create(

+ ares__htable_asvp_val_free_t val_free)

+{

+ ares__htable_asvp_t *htable = ares_malloc(sizeof(*htable));

+ if (htable == NULL)

+ goto fail;

+

+ htable->hash = ares__htable_create(hash_func,

+ bucket_key,

+ bucket_free,

+ key_eq);

+ if (htable->hash == NULL)

+ goto fail;

+

+ htable->free_val = val_free;

+

+ return htable;

+

+fail:

+ if (htable) {

+ ares__htable_destroy(htable->hash);

+ ares_free(htable);

+ }

+ return NULL;

+}

+

+

+unsigned int ares__htable_asvp_insert(ares__htable_asvp_t *htable,

+ ares_socket_t key, void *val)

+{

+ ares__htable_asvp_bucket_t *bucket = NULL;

+

+ if (htable == NULL)

+ goto fail;

+

+ bucket = ares_malloc(sizeof(*bucket));

+ if (bucket == NULL)

+ goto fail;

+

+ bucket->parent = htable;

+ bucket->key = key;

+ bucket->val = val;

+

+ if (!ares__htable_insert(htable->hash, bucket))

+ goto fail;

+

+ return 1;

+

+fail:

+ if (bucket) {

+ ares_free(bucket);

+ }

+ return 0;

+}

+

+

+unsigned int ares__htable_asvp_get(ares__htable_asvp_t *htable,

+ ares_socket_t key, void **val)

+{

+ ares__htable_asvp_bucket_t *bucket = NULL;

+

+ if (val)

+ *val = NULL;

+

+ if (htable == NULL)

+ return 0;

+

+ bucket = ares__htable_get(htable->hash, &key);

+ if (bucket == NULL)

+ return 0;

+

+ if (val)

+ *val = bucket->val;

+ return 1;

+}

+

+

+void *ares__htable_asvp_get_direct(ares__htable_asvp_t *htable,

+ ares_socket_t key)

+{

+ void *val = NULL;

+ ares__htable_asvp_get(htable, key, &val);

+ return val;

+}

+

+

+unsigned int ares__htable_asvp_remove(ares__htable_asvp_t *htable,

+ ares_socket_t key)

+{

+ if (htable == NULL)

+ return 0;

+

+ return ares__htable_remove(htable->hash, &key);

+}

+

+

+size_t ares__htable_asvp_num_keys(ares__htable_asvp_t *htable)

+{

+ if (htable == NULL)

+ return 0;

+ return ares__htable_num_keys(htable->hash);

+}

+/* MIT License

+ *

+ * Copyright (c) 2023 Brad House

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+ */

+#ifndef __ARES__HTABLE_ASVP_H

+#define __ARES__HTABLE_ASVP_H

+

+/*! \addtogroup ares__htable_asvp HashTable with ares_socket_t Key and

+ * void pointer Value

+ *

+ * This data structure wraps the base ares__htable data structure in order to

+ * split the key and value data types as ares_socket_t and void pointer,

+ * respectively.

+ *

+ * Average time complexity:

+ * - Insert: O(1)

+ * - Search: O(1)

+ * - Delete: O(1)

+ *

+ * @{

+ */

+

+struct ares__htable_asvp;

+

+/*! Opaque data type for ares_socket_t key, void pointer hash table

+ * implementation */

+typedef struct ares__htable_asvp ares__htable_asvp_t;

+

+/*! Callback to free value stored in hashtable

+ *

+ * \param[in] val user-supplied value

+ */

+typedef void (*ares__htable_asvp_val_free_t)(void *val);

+

+/*! Destroy hashtable

+ *

+ * \param[in] htable Initialized hashtable

+ */

+void ares__htable_asvp_destroy(ares__htable_asvp_t *htable);

+

+/*! Create size_t key, void pointer value hash table

+ *

+ * \param[in] val_free Optional. Call back to free user-supplied value. If

+ * NULL it is expected the caller will clean up any user

+ * supplied values.

+ */

+ares__htable_asvp_t *ares__htable_asvp_create(

+ ares__htable_asvp_val_free_t val_free);

+

+/*! Insert key/value into hash table

+ *

+ * \param[in] htable Initialized hash table

+ * \param[in] key key to associate with value

+ * \param[in] val value to store (takes ownership). May be NULL.

+ * \return 1 on success, 0 on out of memory or misuse

+ */

+unsigned int ares__htable_asvp_insert(ares__htable_asvp_t *htable,

+ ares_socket_t key, void *val);

+

+/*! Retrieve value from hashtable based on key

+ *

+ * \param[in] htable Initialized hash table

+ * \param[in] key key to use to search

+ * \param[out] val Optional. Pointer to store value.

+ * \return 1 on success, 0 on failure

+ */

+unsigned int ares__htable_asvp_get(ares__htable_asvp_t *htable,

+ ares_socket_t key, void **val);

+

+/*! Retrieve value from hashtable directly as return value. Caveat to this

+ * function over ares__htable_asvp_get() is that if a NULL value is stored

+ * you cannot determine if the key is not found or the value is NULL.

+ *

+ * \param[in] htable Initialized hash table

+ * \param[in] key key to use to search

+ * \return value associated with key in hashtable or NULL

+ */

+void *ares__htable_asvp_get_direct(ares__htable_asvp_t *htable,

+ ares_socket_t key);

+

+/*! Remove a value from the hashtable by key

+ *

+ * \param[in] htable Initialized hash table

+ * \param[in] key key to use to search

+ * \return 1 if found, 0 if not

+ */

+unsigned int ares__htable_asvp_remove(ares__htable_asvp_t *htable,

+ ares_socket_t key);

+

+/*! Retrieve the number of keys stored in the hash table

+ *

+ * \param[in] htable Initialized hash table

+ * \return count

+ */

+size_t ares__htable_asvp_num_keys(ares__htable_asvp_t *htable);

+

+/*! @} */

+

+#endif /* __ARES__HTABLE_ASVP_H */

+/* MIT License

+ *

+ * Copyright (c) 2023 Brad House

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+ */

+#include "ares_setup.h"

+#include "ares.h"

+#include "ares_private.h"

+#include "ares__htable.h"

+#include "ares__htable_stvp.h"

+

+

+struct ares__htable_stvp {

+ ares__htable_stvp_val_free_t free_val;

+ ares__htable_t *hash;

+};

+

+

+typedef struct {

+ size_t key;

+ void *val;

+ ares__htable_stvp_t *parent;

+} ares__htable_stvp_bucket_t;

+

+

+void ares__htable_stvp_destroy(ares__htable_stvp_t *htable)

+{

+ if (htable == NULL)

+ return;

+

+ ares__htable_destroy(htable->hash);

+ ares_free(htable);

+}

+

+

+static unsigned int hash_func(const void *key, unsigned int seed)

+{

+ const size_t *arg = key;

+ return ares__htable_hash_FNV1a((const unsigned char *)arg, sizeof(*arg),

+ seed);

+}

+

+

+static const void *bucket_key(const void *bucket)

+{

+ const ares__htable_stvp_bucket_t *arg = bucket;

+ return &arg->key;

+}

+

+

+static void bucket_free(void *bucket)

+{

+ ares__htable_stvp_bucket_t *arg = bucket;

+

+ if (arg->parent->free_val)

+ arg->parent->free_val(arg->val);

+

+ ares_free(arg);

+}

+

+

+static unsigned int key_eq(const void *key1, const void *key2)

+{

+ const size_t *k1 = key1;

+ const size_t *k2 = key2;

+

+ if (*k1 == *k2)

+ return 1;

+

+ return 0;

+}

+

+

+ares__htable_stvp_t *ares__htable_stvp_create(

+ ares__htable_stvp_val_free_t val_free)

+{

+ ares__htable_stvp_t *htable = ares_malloc(sizeof(*htable));

+ if (htable == NULL)

+ goto fail;

+

+ htable->hash = ares__htable_create(hash_func,

+ bucket_key,

+ bucket_free,

+ key_eq);

+ if (htable->hash == NULL)

+ goto fail;

+

+ htable->free_val = val_free;

+

+ return htable;

+

+fail:

+ if (htable) {

+ ares__htable_destroy(htable->hash);

+ ares_free(htable);

+ }

+ return NULL;

+}

+

+

+unsigned int ares__htable_stvp_insert(ares__htable_stvp_t *htable, size_t key,

+ void *val)

+{

+ ares__htable_stvp_bucket_t *bucket = NULL;

+

+ if (htable == NULL)

+ goto fail;

+

+ bucket = ares_malloc(sizeof(*bucket));

+ if (bucket == NULL)

+ goto fail;

+

+ bucket->parent = htable;

+ bucket->key = key;

+ bucket->val = val;

+

+ if (!ares__htable_insert(htable->hash, bucket))

+ goto fail;

+

+ return 1;

+

+fail:

+ if (bucket) {

+ ares_free(bucket);

+ }

+ return 0;

+}

+

+

+unsigned int ares__htable_stvp_get(ares__htable_stvp_t *htable, size_t key,

+ void **val)

+{

+ ares__htable_stvp_bucket_t *bucket = NULL;

+

+ if (val)

+ *val = NULL;

+

+ if (htable == NULL)

+ return 0;

+

+ bucket = ares__htable_get(htable->hash, &key);

+ if (bucket == NULL)

+ return 0;

+

+ if (val)

+ *val = bucket->val;

+ return 1;

+}

+

+

+void *ares__htable_stvp_get_direct(ares__htable_stvp_t *htable, size_t key)

+{

+ void *val = NULL;

+ ares__htable_stvp_get(htable, key, &val);

+ return val;

+}

+

+

+unsigned int ares__htable_stvp_remove(ares__htable_stvp_t *htable, size_t key)

+{

+ if (htable == NULL)

+ return 0;

+

+ return ares__htable_remove(htable->hash, &key);

+}

+

+

+size_t ares__htable_stvp_num_keys(ares__htable_stvp_t *htable)

+{

+ if (htable == NULL)

+ return 0;

+ return ares__htable_num_keys(htable->hash);

+}

+/* MIT License

+ *

+ * Copyright (c) 2023 Brad House

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+ */

+#ifndef __ARES__HTABLE_STVP_H

+#define __ARES__HTABLE_STVP_H

+

+/*! \addtogroup ares__htable_stvp HashTable with size_t Key and void pointer Value

+ *

+ * This data structure wraps the base ares__htable data structure in order to

+ * split the key and value data types as size_t and void pointer, respectively.

+ *

+ * Average time complexity:

+ * - Insert: O(1)

+ * - Search: O(1)

+ * - Delete: O(1)

+ *

+ * @{

+ */

+

+struct ares__htable_stvp;

+

+/*! Opaque data type for size_t key, void pointer hash table implementation */

+typedef struct ares__htable_stvp ares__htable_stvp_t;

+

+/*! Callback to free value stored in hashtable

+ *

+ * \param[in] val user-supplied value

+ */

+typedef void (*ares__htable_stvp_val_free_t)(void *val);

+

+/*! Destroy hashtable

+ *

+ * \param[in] htable Initialized hashtable

+ */

+void ares__htable_stvp_destroy(ares__htable_stvp_t *htable);

+

+/*! Create size_t key, void pointer value hash table

+ *

+ * \param[in] val_free Optional. Call back to free user-supplied value. If

+ * NULL it is expected the caller will clean up any user

+ * supplied values.

+ */

+ares__htable_stvp_t *ares__htable_stvp_create(

+ ares__htable_stvp_val_free_t val_free);

+

+/*! Insert key/value into hash table

+ *

+ * \param[in] htable Initialized hash table

+ * \param[in] key key to associate with value

+ * \param[in] val value to store (takes ownership). May be NULL.

+ * \return 1 on success, 0 on out of memory or misuse

+ */

+unsigned int ares__htable_stvp_insert(ares__htable_stvp_t *htable, size_t key,

+ void *val);

+

+/*! Retrieve value from hashtable based on key

+ *

+ * \param[in] htable Initialized hash table

+ * \param[in] key key to use to search

+ * \param[out] val Optional. Pointer to store value.

+ * \return 1 on success, 0 on failure

+ */

+unsigned int ares__htable_stvp_get(ares__htable_stvp_t *htable, size_t key,

+ void **val);

+

+/*! Retrieve value from hashtable directly as return value. Caveat to this

+ * function over ares__htable_stvp_get() is that if a NULL value is stored

+ * you cannot determine if the key is not found or the value is NULL.

+ *

+ * \param[in] htable Initialized hash table

+ * \param[in] key key to use to search

+ * \return value associated with key in hashtable or NULL

+ */

+void *ares__htable_stvp_get_direct(ares__htable_stvp_t *htable, size_t key);

+

+/*! Remove a value from the hashtable by key

+ *

+ * \param[in] htable Initialized hash table

+ * \param[in] key key to use to search

+ * \return 1 if found, 0 if not

+ */

+unsigned int ares__htable_stvp_remove(ares__htable_stvp_t *htable, size_t key);

+

+/*! Retrieve the number of keys stored in the hash table

+ *

+ * \param[in] htable Initialized hash table

+ * \return count

+ */

+size_t ares__htable_stvp_num_keys(ares__htable_stvp_t *htable);

+

+/*! @} */

+

+#endif /* __ARES__HTABLE_STVP_H */

+/* MIT License

+ *

+ * Copyright (c) 2023 Brad House

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+ */

+#include "ares_setup.h"

+#include "ares.h"

+#include "ares_private.h"

+#include "ares__llist.h"

+

+struct ares__llist {

+ ares__llist_node_t *head;

+ ares__llist_node_t *tail;

+ ares__llist_destructor_t destruct;

+ size_t cnt;

+};

+

+

+struct ares__llist_node {

+ void *data;

+ ares__llist_node_t *prev;

+ ares__llist_node_t *next;

+ ares__llist_t *parent;

+};

+

+

+ares__llist_t *ares__llist_create(ares__llist_destructor_t destruct)

+{

+ ares__llist_t *list = ares_malloc(sizeof(*list));

+

+ if (list == NULL)

+ return NULL;

+

+ memset(list, 0, sizeof(*list));

+

+ list->destruct = destruct;

+

+ return list;

+}

+

+

+void ares__llist_replace_destructor(ares__llist_t *list,

+ ares__llist_destructor_t destruct)

+{

+ if (list == NULL)

+ return;

+

+ list->destruct = destruct;

+}

+

+

+typedef enum {

+ ARES__LLIST_INSERT_HEAD,

+ ARES__LLIST_INSERT_TAIL,

+ ARES__LLIST_INSERT_BEFORE

+} ares__llist_insert_type_t;

+

+

+static ares__llist_node_t *ares__llist_insert_at(ares__llist_t *list,

+ ares__llist_insert_type_t type,

+ ares__llist_node_t *at,

+ void *val)

+{

+ ares__llist_node_t *node = NULL;

+

+ if (list == NULL || val == NULL)

+ return NULL;

+

+ node = ares_malloc(sizeof(*node));

+

+ if (node == NULL)

+ return NULL;

+

+ memset(node, 0, sizeof(*node));

+ node->data = val;

+ node->parent = list;

+

+ if (type == ARES__LLIST_INSERT_BEFORE && (at == list->head || at == NULL)) {

+ type = ARES__LLIST_INSERT_HEAD;

+ }

+

+ switch (type) {

+ case ARES__LLIST_INSERT_HEAD:

+ node->next = list->head;

+ node->prev = NULL;

+ if (list->head)

+ list->head->prev = node;

+ list->head = node;

+ break;

+ case ARES__LLIST_INSERT_TAIL:

+ node->next = NULL;

+ node->prev = list->tail;

+ if (list->tail)

+ list->tail->next = node;

+ list->tail = node;

+ break;

+ case ARES__LLIST_INSERT_BEFORE:

+ node->next = at;

+ node->prev = at->prev;

+ at->prev = node;

+ break;

+ }

+ if (list->tail == NULL)

+ list->tail = node;

+ if (list->head == NULL)

+ list->head = node;

+

+ list->cnt++;

+

+ return node;

+}

+

+

+ares__llist_node_t *ares__llist_insert_first(ares__llist_t *list, void *val)

+{

+ return ares__llist_insert_at(list, ARES__LLIST_INSERT_HEAD, NULL, val);

+}

+

+

+ares__llist_node_t *ares__llist_insert_last(ares__llist_t *list, void *val)

+{

+ return ares__llist_insert_at(list, ARES__LLIST_INSERT_TAIL, NULL, val);

+}

+

+

+ares__llist_node_t *ares__llist_insert_before(ares__llist_node_t *node,

+ void *val)

+{

+ if (node == NULL)

+ return NULL;

+

+ return ares__llist_insert_at(node->parent, ARES__LLIST_INSERT_BEFORE, node,

+ val);

+}

+

+

+ares__llist_node_t *ares__llist_insert_after(ares__llist_node_t *node,

+ void *val)

+{

+ if (node == NULL)

+ return NULL;

+

+ if (node->next == NULL)

+ return ares__llist_insert_last(node->parent, val);

+

+ return ares__llist_insert_at(node->parent, ARES__LLIST_INSERT_BEFORE,

+ node->next, val);

+}

+

+

+ares__llist_node_t *ares__llist_node_first(ares__llist_t *list)

+{

+ if (list == NULL)

+ return NULL;

+ return list->head;

+}

+

+

+ares__llist_node_t *ares__llist_node_last(ares__llist_t *list)

+{

+ if (list == NULL)

+ return NULL;

+ return list->tail;

+}

+

+

+ares__llist_node_t *ares__llist_node_next(ares__llist_node_t *node)

+{

+ if (node == NULL)

+ return NULL;

+ return node->next;

+}

+

+

+ares__llist_node_t *ares__llist_node_prev(ares__llist_node_t *node)

+{

+ if (node == NULL)

+ return NULL;

+ return node->prev;

+}

+

+

+void *ares__llist_node_val(ares__llist_node_t *node)

+{

+ if (node == NULL)

+ return NULL;

+

+ return node->data;

+}

+

+

+size_t ares__llist_len(ares__llist_t *list)

+{

+ if (list == NULL)

+ return 0;

+ return list->cnt;

+}

+

+

+ares__llist_t *ares__llist_node_parent(ares__llist_node_t *node)

+{

+ if (node == NULL)

+ return NULL;

+ return node->parent;

+}

+

+

+void *ares__llist_first_val(ares__llist_t *list)

+{

+ return ares__llist_node_val(ares__llist_node_first(list));

+}

+

+

+void *ares__llist_last_val(ares__llist_t *list)

+{

+ return ares__llist_node_val(ares__llist_node_last(list));

+}

+

+

+void *ares__llist_node_claim(ares__llist_node_t *node)

+{

+ void *val;

+ ares__llist_t *list;

+

+ if (node == NULL)

+ return NULL;

+

+ list = node->parent;

+ val = node->data;

+

+ if (node->prev) {

+ node->prev->next = node->next;

+ }

+

+ if (node->next) {

+ node->next->prev = node->prev;

+ }

+

+ if (node == list->head) {

+ list->head = node->next;

+ }

+

+ if (node == list->tail) {

+ list->tail = node->prev;

+ }

+ ares_free(node);

+

+ list->cnt--;

+

+ return val;

+}

+

+

+void ares__llist_node_destroy(ares__llist_node_t *node)

+{

+ ares__llist_destructor_t destruct;

+ void *val;

+

+ if (node == NULL)

+ return;

+

+ destruct = node->parent->destruct;

+

+ val = ares__llist_node_claim(node);

+ if (val != NULL && destruct != NULL)

+ destruct(val);

+}

+

+

+void ares__llist_node_replace(ares__llist_node_t *node, void *val)

+{

+ ares__llist_destructor_t destruct;

+

+ if (node == NULL)

+ return;

+

+ destruct = node->parent->destruct;

+ if (destruct != NULL)

+ destruct(node->data);

+

+ node->data = val;

+}

+

+

+void ares__llist_destroy(ares__llist_t *list)

+{

+ ares__llist_node_t *node;

+

+ if (list == NULL)

+ return;

+

+ while ((node = ares__llist_node_first(list)) != NULL) {

+ ares__llist_node_destroy(node);

+ }

+ ares_free(list);

+}

+/* MIT License

+ *

+ * Copyright (c) 2023 Brad House

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+ */

+#ifndef __ARES__LLIST_H

+#define __ARES__LLIST_H

+

+/*! \addtogroup ares__llist LinkedList Data Structure

+ *

+ * This is a doubly-linked list data structure.

+ *

+ * Average time complexity:

+ * - Insert: O(1) -- head or tail

+ * - Search: O(n)

+ * - Delete: O(1) -- delete assumes you hold a node pointer

+ *

+ * @{

+ */

+

+struct ares__llist;

+

+/*! Opaque data structure for linked list */

+typedef struct ares__llist ares__llist_t;

+

+struct ares__llist_node;

+

+/*! Opaque data structure for a node in a linked list */

+typedef struct ares__llist_node ares__llist_node_t;

+

+/*! Callback to free user-defined node data

+ *

+ * \param[in] data user supplied data

+ */

+typedef void (*ares__llist_destructor_t)(void *data);

+

+/*! Create a linked list object

+ *

+ * \param[in] destruct Optional. Destructor to call on all removed nodes

+ * \return linked list object or NULL on out of memory

+ */

+ares__llist_t *ares__llist_create(ares__llist_destructor_t destruct);

+

+/*! Replace destructor for linked list nodes. Typically this is used

+ * when wanting to disable the destructor by using NULL.

+ *

+ * \param[in] list Initialized linked list object

+ * \param[in] destruct replacement destructor, NULL is allowed

+ */

+void ares__llist_replace_destructor(ares__llist_t *list,

+ ares__llist_destructor_t destruct);

+

+/*! Insert value as the first node in the linked list

+ *

+ * \param[in] list Initialized linked list object

+ * \param[in] val user-supplied value.

+ * \return node object referencing place in list, or null if out of memory or

+ * misuse

+ */

+ares__llist_node_t *ares__llist_insert_first(ares__llist_t *list, void *val);

+

+/*! Insert value as the last node in the linked list

+ *

+ * \param[in] list Initialized linked list object

+ * \param[in] val user-supplied value.

+ * \return node object referencing place in list, or null if out of memory or

+ * misuse

+ */

+ares__llist_node_t *ares__llist_insert_last(ares__llist_t *list, void *val);

+

+/*! Insert value before specified node in the linked list

+ *

+ * \param[in] node node referenced to insert before

+ * \param[in] val user-supplied value.

+ * \return node object referencing place in list, or null if out of memory or

+ * misuse

+ */

+ares__llist_node_t *ares__llist_insert_before(ares__llist_node_t *node,

+ void *val);

+

+/*! Insert value after specified node in the linked list

+ *

+ * \param[in] node node referenced to insert after

+ * \param[in] val user-supplied value.

+ * \return node object referencing place in list, or null if out of memory or

+ * misuse

+ */

+ares__llist_node_t *ares__llist_insert_after(ares__llist_node_t *node,

+ void *val);

+

+/*! Obtain first node in list

+ *

+ * \param[in] list Initialized list object

+ * \return first node in list or NULL if none

+ */

+ares__llist_node_t *ares__llist_node_first(ares__llist_t *list);

+

+/*! Obtain last node in list

+ *

+ * \param[in] list Initialized list object

+ * \return last node in list or NULL if none

+ */

+ares__llist_node_t *ares__llist_node_last(ares__llist_t *list);

+

+/*! Obtain next node in respect to specified node

+ *

+ * \param[in] node Node referenced

+ * \return node or NULL if none

+ */

+ares__llist_node_t *ares__llist_node_next(ares__llist_node_t *node);

+

+/*! Obtain previous node in respect to specified node

+ *

+ * \param[in] node Node referenced

+ * \return node or NULL if none

+ */

+ares__llist_node_t *ares__llist_node_prev(ares__llist_node_t *node);

+

+/*! Obtain value from node

+ *

+ * \param[in] node Node referenced

+ * \return user provided value from node

+ */

+void *ares__llist_node_val(ares__llist_node_t *node);

+

+/*! Obtain the number of entries in the list

+ *

+ * \param[in] list Initialized list object

+ * \return count

+ */

+size_t ares__llist_len(ares__llist_t *list);

+

+/*! Obtain list object from referenced node

+ *

+ * \param[in] node Node referenced

+ * \return list object node belongs to

+ */

+ares__llist_t *ares__llist_node_parent(ares__llist_node_t *node);

+

+/*! Obtain the first user-supplied value in the list

+ *

+ * \param[in] list Initialized list object

+ * \return first user supplied value or NULL if none

+ */

+void *ares__llist_first_val(ares__llist_t *list);

+

+/*! Obtain the last user-supplied value in the list

+ *

+ * \param[in] list Initialized list object

+ * \return last user supplied value or NULL if none

+ */

+void *ares__llist_last_val(ares__llist_t *list);

+

+/*! Take ownership of user-supplied value in list without calling destructor.

+ * Will unchain entry from list.

+ *

+ * \param[in] node Node referenced

+ * \return user supplied value

+ */

+void *ares__llist_node_claim(ares__llist_node_t *node);

+

+/*! Replace user-supplied value for node

+ *

+ * \param[in] node Node referenced

+ * \param[in] val new user-supplied value

+ */

+void ares__llist_node_replace(ares__llist_node_t *node, void *val);

+

+/*! Destroy the node, removing it from the list and calling destructor.

+ *

+ * \param[in] node Node referenced

+ */

+void ares__llist_node_destroy(ares__llist_node_t *node);

+

+/*! Destroy the list object and all nodes in the list.

+ *

+ * \param[in] list Initialized list object

+ */

+void ares__llist_destroy(ares__llist_t *list);

+

+/*! @} */

+

+#endif /* __ARES__LLIST_H */

+/* MIT License

+ * Copyright (c) 2019 Andrew Selivanov

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+/* MIT License

+ *

+ * Copyright (c) 1998 Massachusetts Institute of Technology

+ * Copyright (c) The c-ares project and its contributors

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * SPDX-License-Identifier: MIT

+/* MIT License

+ * Copyright (c) 2019 Andrew Selivanov

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+/* MIT License

+ *

+ * Copyright (c) 2023 Brad House

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+ */

+#include "ares_setup.h"

+#include "ares.h"

+#include "ares_private.h"

+#include "ares__slist.h"

+

+/* SkipList implementation */

+

+#define ARES__SLIST_START_LEVELS 4

+

+

+struct ares__slist {

+ ares_rand_state *rand_state;

+ unsigned char rand_data[8];

+ size_t rand_bits;

+

+ ares__slist_node_t **head;

+ size_t levels;

+ ares__slist_node_t *tail;

+

+ ares__slist_cmp_t cmp;

+ ares__slist_destructor_t destruct;

+ size_t cnt;

+};

+

+

+struct ares__slist_node {

+ void *data;

+ ares__slist_node_t **prev;

+ ares__slist_node_t **next;

+ size_t levels;

+ ares__slist_t *parent;

+};

+

+

+ares__slist_t *ares__slist_create(ares_rand_state *rand_state,

+ ares__slist_cmp_t cmp,

+ ares__slist_destructor_t destruct)

+{

+ ares__slist_t *list;

+

+ if (rand_state == NULL || cmp == NULL)

+ return NULL;

+

+ list = ares_malloc(sizeof(*list));

+

+ if (list == NULL)

+ return NULL;

+

+ memset(list, 0, sizeof(*list));

+

+ list->rand_state = rand_state;

+ list->cmp = cmp;

+ list->destruct = destruct;

+

+ list->levels = ARES__SLIST_START_LEVELS;

+ list->head = ares_malloc(sizeof(*list->head) * list->levels);

+ if (list->head == NULL) {

+ ares_free(list);

+ return NULL;

+ }

+

+ memset(list->head, 0, sizeof(*list->head) * list->levels);

+

+ return list;

+}

+

+

+static unsigned int ares__slist_coin_flip(ares__slist_t *list)

+{

+ size_t total_bits = sizeof(list->rand_data) * 8;

+ size_t bit;

+

+ /* Refill random data used for coin flips. We pull this in 8 byte chunks.

+ * ares__rand_bytes() has some built-in caching of its own so we don't need

+ * to be excessive in caching ourselves. Prefer to require less memory per

+ * skiplist */

+ if (list->rand_bits == 0) {

+ ares__rand_bytes(list->rand_state, list->rand_data,

+ sizeof(list->rand_data));

+ list->rand_bits = total_bits;

+ }

+

+ bit = total_bits - list->rand_bits;

+ list->rand_bits--;

+

+ return (list->rand_data[bit / 8] & (1 << (bit % 8)))?1:0;

+}

+

+

+void ares__slist_replace_destructor(ares__slist_t *list,

+ ares__slist_destructor_t destruct)

+{

+ if (list == NULL)

+ return;

+

+ list->destruct = destruct;

+}

+

+/* Uses public domain code snipets from http://graphics.stanford.edu/~seander/bithacks.html */

+

+static size_t ares__round_up_pow2(size_t n)

+{

+ n--;

+ n |= n >> 1;

+ n |= n >> 2;

+ n |= n >> 4;

+ n |= n >> 8;

+ n |= n >> 16;

+ if (sizeof(size_t) > 4)

+ n |= n >> 32;

+ n++;

+ return n;

+}

+

+

+static size_t ares__log2(size_t n)

+{

+ static const unsigned char tab32[32] = {

+ 0, 1, 28, 2, 29, 14, 24, 3,

+ 30, 22, 20, 15, 25, 17, 4, 8,

+ 31, 27, 13, 23, 21, 19, 16, 7,

+ 26, 12, 18, 6, 11, 5, 10, 9

+ };

+ static const unsigned char tab64[64] = {

+ 63, 0, 58, 1, 59, 47, 53, 2,

+ 60, 39, 48, 27, 54, 33, 42, 3,

+ 61, 51, 37, 40, 49, 18, 28, 20,

+ 55, 30, 34, 11, 43, 14, 22, 4,

+ 62, 57, 46, 52, 38, 26, 32, 41,

+ 50, 36, 17, 19, 29, 10, 13, 21,

+ 56, 45, 25, 31, 35, 16, 9, 12,

+ 44, 24, 15, 8, 23, 7, 6, 5

+ };

+

+ if (sizeof(size_t) == 4)

+ return tab32[(size_t)(n*0x077CB531) >> 27];

+

+ return tab64[((size_t)(n*0x07EDD5E59A4E28C2)) >> 58];

+}

+

+

+static size_t ares__slist_max_level(ares__slist_t *list)

+{

+ size_t max_level = 0;

+

+ if (list->cnt+1 <= (1 << ARES__SLIST_START_LEVELS)) {

+ max_level = ARES__SLIST_START_LEVELS;

+ } else {

+ max_level = ares__log2(ares__round_up_pow2(list->cnt+1));

+ }

+

+ if (list->levels > max_level)

+ max_level = list->levels;

+

+ return max_level;

+}

+

+

+static size_t ares__slist_calc_level(ares__slist_t *list)

+{

+ size_t max_level = ares__slist_max_level(list);

+ size_t level;

+

+ for (level=1; ares__slist_coin_flip(list) && level < max_level; level++)

+ ;

+

+ return level;

+}

+

+

+ares__slist_node_t *ares__slist_insert(ares__slist_t *list, void *val)

+{

+ ares__slist_node_t *node = NULL;

+ ares__slist_node_t *left = NULL;

+ size_t i;

+

+ if (list == NULL || val == NULL)

+ return NULL;

+

+ node = ares_malloc(sizeof(*node));

+

+ if (node == NULL)

+ goto fail;

+

+ memset(node, 0, sizeof(*node));

+ node->data = val;

+ node->parent = list;

+

+ /* Randomly determine the number of levels we want to use */

+ node->levels = ares__slist_calc_level(list);

+

+ /* Allocate array of next and prev nodes for linking each level */

+ node->next = ares_malloc(sizeof(*node->next) * node->levels);

+ if (node->next == NULL)

+ goto fail;

+

+ memset(node->next, 0, sizeof(*node->next) * node->levels);

+

+ node->prev = ares_malloc(sizeof(*node->prev) * node->levels);

+ if (node->prev == NULL)

+ goto fail;

+

+ memset(node->prev, 0, sizeof(*node->prev) * node->levels);

+

+ /* If the number of levels is greater than we currently support in the slist,

+ * increase the count */

+ if (list->levels < node->levels) {

+ size_t zero_len = sizeof(*list->head) * (node->levels - list->levels);

+ size_t offset = sizeof(*list->head) * list->levels;

+ void *ptr = ares_realloc(list->head, sizeof(*list->head) * node->levels);

+ if (ptr == NULL)

+ goto fail;

+

+ memset((unsigned char *)ptr + offset, 0, zero_len);

+ list->head = ptr;

+ list->levels = node->levels;

+ }

+

+

+ /* Scan from highest level in the slist, even if we're not using that number

+ * of levels for this entry as this is what makes it O(log n) */

+ for (i=list->levels; i-- > 0; ) {

+ /* set left if left is NULL and the current node value is greater than the

+ * head at this level */

+ if (left == NULL &&

+ list->head[i] != NULL &&

+ list->cmp(node->data, list->head[i]->data) > 0

+ ) {

+ left = list->head[i];

+ }

+

+ if (left != NULL) {

+ /* scan forward to find our insertion point */

+ while (left->next[i] != NULL &&

+ list->cmp(node->data, left->next[i]->data) > 0) {

+ left = left->next[i];

+ }

+ }

+

+ /* search only as we didn't randomly select this number of levels */

+ if (i >= node->levels)

+ continue;

+

+ if (left == NULL) {

+ /* head insertion */

+ node->next[i] = list->head[i];

+ node->prev[i] = NULL;

+ list->head[i] = node;

+ } else {

+ /* Chain */

+ node->next[i] = left->next[i];

+ node->prev[i] = left;

+ left->next[i] = node;

+ }

+

+ if (node->next[i] != NULL) {

+ /* chain prev */

+ node->next[i]->prev[i] = node;

+ } else {

+ if (i == 0) {

+ /* update tail */

+ list->tail = node;

+ }

+ }

+ }

+

+ list->cnt++;

+

+ return node;

+

+fail:

+ if (node) {

+ ares_free(node->prev);

+ ares_free(node->next);

+ ares_free(node);

+ }

+ return NULL;

+}

+

+

+ares__slist_node_t *ares__slist_node_find(ares__slist_t *list, const void *val)

+{

+ size_t i;

+ ares__slist_node_t *node = NULL;

+ int rv = -1;

+

+ if (list == NULL || val == NULL)

+ return NULL;

+

+ /* Scan nodes starting at the highest level. For each level scan forward

+ * until the value is between the prior and next node, or if equal quit

+ * as we found a match */

+ for (i=list->levels; i-- > 0; ) {

+ if (node == NULL)

+ node = list->head[i];

+

+ if (node == NULL)

+ continue;

+

+ do {

+ rv = list->cmp(val, node->data);

+

+ if (rv < 0) {

+ /* back off, our value is greater than current node reference */

+ node = node->prev[i];

+ } else if (rv > 0) {

+ /* move forward and try again. if it goes past, it will loop again and

+ * go to previous entry */

+ node = node->next[i];

+ }

+

+ /* rv == 0 will terminate loop */

+

+ } while (node != NULL && rv > 0);

+

+ /* Found a match, no need to continue */

+ if (rv == 0) {

+ break;

+ }

+ }

+

+ /* no match */

+ if (rv != 0) {

+ return NULL;

+ }

+

+ /* The list may have multiple entries that match. They're guaranteed to be

+ * in order, but we're not guaranteed to have selected the _first_ matching

+ * node. Lets scan backwards to find the first match */

+ while (node->prev[0] != NULL && list->cmp(node->prev[0]->data, val) == 0) {

+ node = node->prev[0];

+ }

+

+ return node;

+}

+

+

+ares__slist_node_t *ares__slist_node_first(ares__slist_t *list)

+{

+ if (list == NULL)

+ return NULL;

+

+ return list->head[0];

+}

+

+

+ares__slist_node_t *ares__slist_node_last(ares__slist_t *list)

+{

+ if (list == NULL)

+ return NULL;

+ return list->tail;

+}

+

+

+ares__slist_node_t *ares__slist_node_next(ares__slist_node_t *node)

+{

+ if (node == NULL)

+ return NULL;

+ return node->next[0];

+}

+

+

+ares__slist_node_t *ares__slist_node_prev(ares__slist_node_t *node)

+{

+ if (node == NULL)

+ return NULL;

+ return node->prev[0];

+}

+

+

+void *ares__slist_node_val(ares__slist_node_t *node)

+{

+ if (node == NULL)

+ return NULL;

+

+ return node->data;

+}

+

+

+size_t ares__slist_len(ares__slist_t *list)

+{

+ if (list == NULL)

+ return 0;

+ return list->cnt;

+}

+

+

+ares__slist_t *ares__slist_node_parent(ares__slist_node_t *node)

+{

+ if (node == NULL)

+ return NULL;

+ return node->parent;

+}

+

+

+void *ares__slist_first_val(ares__slist_t *list)

+{

+ return ares__slist_node_val(ares__slist_node_first(list));

+}

+

+

+void *ares__slist_last_val(ares__slist_t *list)

+{

+ return ares__slist_node_val(ares__slist_node_last(list));

+}

+

+

+void *ares__slist_node_claim(ares__slist_node_t *node)

+{

+ void *val;

+ ares__slist_t *list;

+ size_t i;

+

+ if (node == NULL)

+ return NULL;

+

+ list = node->parent;

+ val = node->data;

+

+ /* relink each node at each level */

+ for (i=node->levels; i-- > 0; ) {

+ if (node->next[i] == NULL) {

+ if (i == 0) {

+ list->tail = node->prev[0];

+ }

+ } else {

+ node->next[i]->prev[i] = node->prev[i];

+ }

+

+ if (node->prev[i] == NULL) {

+ list->head[i] = node->next[i];

+ } else {

+ node->prev[i]->next[i] = node->next[i];

+ }

+ }

+

+ ares_free(node->next);

+ ares_free(node->prev);

+ ares_free(node);

+

+ list->cnt--;

+

+ return val;

+}

+

+

+void ares__slist_node_destroy(ares__slist_node_t *node)

+{

+ ares__slist_destructor_t destruct;

+ void *val;

+

+ if (node == NULL)

+ return;

+

+ destruct = node->parent->destruct;

+ val = ares__slist_node_claim(node);

+

+ if (val != NULL && destruct != NULL)

+ destruct(val);

+}

+

+

+void ares__slist_destroy(ares__slist_t *list)

+{

+ ares__slist_node_t *node;

+

+ if (list == NULL)

+ return;

+

+ while ((node = ares__slist_node_first(list)) != NULL) {

+ ares__slist_node_destroy(node);

+ }

+

+ ares_free(list->head);

+ ares_free(list);

+}

+/* MIT License

+ *

+ * Copyright (c) 2023 Brad House

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+ */

+#ifndef __ARES__SLIST_H

+#define __ARES__SLIST_H

+

+

+/*! \addtogroup ares__slist SkipList Data Structure

+ *

+ * This data structure is known as a Skip List, which in essence is a sorted

+ * linked list with multiple levels of linkage to gain some algorithmic

+ * advantages. The usage symantecs are almost identical to what you'd expect

+ * with a linked list.

+ *

+ * Average time complexity:

+ * - Insert: O(log n)

+ * - Search: O(log n)

+ * - Delete: O(1) -- delete assumes you hold a node pointer

+ *

+ * It should be noted, however, that "effort" involved with an insert or

+ * remove operation is higher than a normal linked list. For very small

+ * lists this may be less efficient, but for any list with a moderate number

+ * of entries this will prove much more efficient.

+ *

+ * This data structure is often compared with a Binary Search Tree in

+ * functionality and usage.

+ *

+ * @{

+ */

+struct ares__slist;

+

+/*! SkipList Object, opaque */

+typedef struct ares__slist ares__slist_t;

+

+struct ares__slist_node;

+

+/*! SkipList Node Object, opaque */

+typedef struct ares__slist_node ares__slist_node_t;

+

+/*! SkipList Node Value destructor callback

+ *

+ * \param[in] data User-defined data to destroy

+ */

+typedef void (*ares__slist_destructor_t)(void *data);

+

+/*! SkipList comparison function

+ *

+ * \param[in] data1 First user-defined data object

+ * \param[in] data2 Second user-defined data object

+ * \return < 0 if data1 < data1, > 0 if data1 > data2, 0 if data1 == data2

+ */

+typedef int (*ares__slist_cmp_t)(const void *data1, const void *data2);

+

+/*! Create SkipList

+ *

+ * \param[in] rand_state Initialized ares random state.

+ * \param[in] cmp SkipList comparison function

+ * \param[in] destruct SkipList Node Value Destructor. Optional, use NULL.

+ * \return Initialized SkipList Object or NULL on misuse or ENOMEM

+ */

+ares__slist_t *ares__slist_create(ares_rand_state *rand_state,

+ ares__slist_cmp_t cmp,

+ ares__slist_destructor_t destruct);

+

+/*! Replace SkipList Node Value Destructor

+ *

+ * \param[in] list Initialized SkipList Object

+ * \param[in] destruct Replacement destructor. May be NULL.

+ */

+void ares__slist_replace_destructor(ares__slist_t *list,

+ ares__slist_destructor_t destruct);

+

+/*! Insert Value into SkipList

+ *

+ * \param[in] list Initialized SkipList Object

+ * \param[in] val Node Value. Must not be NULL. Function takes ownership

+ * and will have destructor called.

+ * \return SkipList Node Object or NULL on misuse or ENOMEM

+ */

+ares__slist_node_t *ares__slist_insert(ares__slist_t *list, void *val);

+

+/*! Fetch first node in SkipList

+ *

+ * \param[in] list Initialized SkipList Object

+ * \return SkipList Node Object or NULL if none

+ */

+ares__slist_node_t *ares__slist_node_first(ares__slist_t *list);

+

+/*! Fetch last node in SkipList

+ *

+ * \param[in] list Initialized SkipList Object

+ * \return SkipList Node Object or NULL if none

+ */

+ares__slist_node_t *ares__slist_node_last(ares__slist_t *list);

+

+/*! Fetch next node in SkipList

+ *

+ * \param[in] node SkipList Node Object

+ * \return SkipList Node Object or NULL if none

+ */

+ares__slist_node_t *ares__slist_node_next(ares__slist_node_t *node);

+

+/*! Fetch previous node in SkipList

+ *

+ * \param[in] node SkipList Node Object

+ * \return SkipList Node Object or NULL if none

+ */

+ares__slist_node_t *ares__slist_node_prev(ares__slist_node_t *node);

+

+/*! Fetch SkipList Node Object by Value

+ *

+ * \param[in] list Initialized SkipList Object

+ * \param[in] val Object to use for comparison

+ * \return SkipList Node Object or NULL if not found

+ */

+ares__slist_node_t *ares__slist_node_find(ares__slist_t *list, const void *val);

+

+

+/*! Fetch Node Value

+ *

+ * \param[in] node SkipList Node Object

+ * \return user defined node value

+ */

+void *ares__slist_node_val(ares__slist_node_t *node);

+

+/*! Fetch number of entries in SkipList Object

+ *

+ * \param[in] list Initialized SkipList Object

+ * \return number of entries

+ */

+size_t ares__slist_len(ares__slist_t *list);

+

+/*! Fetch SkipList Object from SkipList Node

+ *

+ * \param[in] node SkipList Node Object

+ * \return SkipList Object

+ */

+ares__slist_t *ares__slist_node_parent(ares__slist_node_t *node);

+

+/*! Fetch first Node Value in SkipList

+ *

+ * \param[in] list Initialized SkipList Object

+ * \return user defined node value or NULL if none

+ */

+void *ares__slist_first_val(ares__slist_t *list);

+

+/*! Fetch last Node Value in SkipList

+ *

+ * \param[in] list Initialized SkipList Object

+ * \return user defined node value or NULL if none

+ */

+void *ares__slist_last_val(ares__slist_t *list);

+

+/*! Take back ownership of Node Value in SkipList, remove from SkipList.

+ *

+ * \param[in] node SkipList Node Object

+ * \return user defined node value

+ */

+void *ares__slist_node_claim(ares__slist_node_t *node);

+

+/*! Remove Node from SkipList, calling destructor for Node Value.

+ *

+ * \param[in] node SkipList Node Object

+ */

+void ares__slist_node_destroy(ares__slist_node_t *node);

+

+/*! Destroy SkipList Object. If there are any nodes, they will be destroyed.

+ *

+ * \param[in] list Initialized SkipList Object

+ */

+void ares__slist_destroy(ares__slist_t *list);

+

+/*! @} */

+

+#endif /* __ARES__SLIST_H */

+ * Copyright (C) 2019 Andrew Selivanov

+ *

+ * SPDX-License-Identifier: BSD-3-Clause

+/* MIT License

+ *

+ * Copyright (c) 2008 Daniel Stenberg

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * SPDX-License-Identifier: MIT

+/* MIT License

+ * Copyright (c) John Schember

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+/* MIT License

+ * Copyright (c) John Schember

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+/* MIT License

+ *

+ * Copyright (c) 2004 Daniel Stenberg

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * SPDX-License-Identifier: MIT

+ if (ares__llist_len(channel->all_queries) > 0)

+ ares__llist_node_t *node = NULL;

+ ares__llist_node_t *next = NULL;

+

+ ares__llist_t *list_copy = channel->all_queries;

+ channel->all_queries = ares__llist_create(NULL);

+

+ /* Out of memory, this function doesn't return a result code though so we

+ * can't report to caller */

+ if (channel->all_queries == NULL) {

+ channel->all_queries = list_copy;

+ return;

+ }

+

+ node = ares__llist_node_first(list_copy);

+ while (node != NULL) {

+ struct query *query;

+ ares_socket_t fd = ARES_SOCKET_BAD;

+

+ /* Cache next since this node is being deleted */

+ next = ares__llist_node_next(node);

+

+ query = ares__llist_node_claim(node);

+ query->node_all_queries = NULL;

+

+ /* Cache file descriptor for connection so we can clean it up possibly */

+ if (query->conn)

+ fd = query->conn->fd;

+

+ /* NOTE: its possible this may enqueue new queries */

+

+ /* See if the connection should be cleaned up */

+ if (fd != ARES_SOCKET_BAD)

+ ares__check_cleanup_conn(channel, fd);

+

+ node = next;

+

+ ares__llist_destroy(list_copy);

+/* MIT License

+ *

+ * Copyright (c) Massachusetts Institute of Technology

+ * Copyright (c) The c-ares project and its contributors

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * SPDX-License-Identifier: MIT

+/* MIT License

+ *

+ * Copyright (c) 2009 Daniel Stenberg

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * SPDX-License-Identifier: MIT

+/* MIT License

+ *

+ * Copyright (c) 2009 Daniel Stenberg

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+#ifndef __ARES_DATA_H

+#define __ARES_DATA_H

+/* MIT License

+ *

+ * Copyright (c) 1998 Massachusetts Institute of Technology

+ * Copyright (c) 2004 Daniel Stenberg

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+ int i;

+ ares__llist_node_t *node = NULL;

+ /* Destroy all queries */

+ node = ares__llist_node_first(channel->all_queries);

+ while (node != NULL) {

+ ares__llist_node_t *next = ares__llist_node_next(node);

+ struct query *query = ares__llist_node_claim(node);

+

+ query->node_all_queries = NULL;

+ query->callback(query->arg, ARES_EDESTRUCTION, 0, NULL, 0);

+ ares__free_query(query);

+

+ node = next;

+ }

+

+

+ assert(ares__llist_len(channel->all_queries) == 0);

+ assert(ares__htable_stvp_num_keys(channel->queries_by_qid) == 0);

+ assert(ares__slist_len(channel->queries_by_timeout) == 0);

+#ifndef NDEBUG

+ assert(ares__htable_asvp_num_keys(channel->connnode_by_socket) == 0);

+#endif

+

+ ares__llist_destroy(channel->all_queries);

+ ares__slist_destroy(channel->queries_by_timeout);

+ ares__htable_stvp_destroy(channel->queries_by_qid);

+ ares__htable_asvp_destroy(channel->connnode_by_socket);

+

+ ares__close_sockets(server);

+ ares__llist_destroy(server->connections);

+ ares__buf_destroy(server->tcp_parser);

+ ares__buf_destroy(server->tcp_send);

+/* MIT License

+ *

+ * Copyright (c) 1998, 2011 Massachusetts Institute of Technology

+ * Copyright (c) The c-ares project and its contributors

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * SPDX-License-Identifier: MIT

+/* MIT License

+ *

+ * Copyright (c) 1998 Massachusetts Institute of Technology

+ * Copyright (c) The c-ares project and its contributors

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * SPDX-License-Identifier: MIT

+/* MIT License

+ *

+ * Copyright (c) 1998 Massachusetts Institute of Technology

+ * Copyright (c) The c-ares project and its contributors

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * SPDX-License-Identifier: MIT

+ size_t active_queries = ares__llist_len(channel->all_queries);

+ for (i = 0; i < channel->nservers; i++) {

+ ares__llist_node_t *node;

+ server = &channel->servers[i];

+

+ for (node = ares__llist_node_first(server->connections);

+ node != NULL;

+ node = ares__llist_node_next(node)) {

+ struct server_connection *conn = ares__llist_node_val(node);

+

+ if (active_queries || conn->is_tcp) {

+ FD_SET(conn->fd, read_fds);

+ if (conn->fd >= nfds)

+ nfds = conn->fd + 1;

+ }

+

+ if (conn->is_tcp && ares__buf_len(server->tcp_send)) {

+ FD_SET(conn->fd, write_fds);

+ }

+ }

+

+/* MIT License

+ *

+ * Copyright (c) 1998 Massachusetts Institute of Technology

+ * Copyright (c) The c-ares project and its contributors

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * SPDX-License-Identifier: MIT

+/* MIT License

+ *

+ * Copyright (c) 2000 Massachusetts Institute of Technology

+ * Copyright (c) The c-ares project and its contributors

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * SPDX-License-Identifier: MIT

+/* MIT License

+ *

+ * Copyright (c) 1998 Massachusetts Institute of Technology

+ * Copyright (c) 2019 Andrew Selivanov

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * SPDX-License-Identifier: MIT

+/* MIT License

+ *

+ * Copyright (c) 1998, 2011, 2013 Massachusetts Institute of Technology

+ * Copyright (c) 2017 Christian Ammer

+ * Copyright (c) 2019 Andrew Selivanov

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+#include "ares_dns.h"

+ unsigned short qid_a; /* qid for A request */

+ unsigned short qid_aaaa; /* qid for AAAA request */

+

+static struct ares_addrinfo_cname *ares__malloc_addrinfo_cname(void)

+static struct ares_addrinfo *ares__malloc_addrinfo(void)

+static struct ares_addrinfo_node *ares__malloc_addrinfo_node(void)

+ ares_malloc(sizeof(*node));

+

+

+static void terminate_retries(struct host_query *hquery, unsigned short qid)

+{

+ unsigned short term_qid = (qid == hquery->qid_a)?hquery->qid_aaaa:hquery->qid_a;

+ ares_channel channel = hquery->channel;

+ struct query *query = NULL;

+

+ /* No other outstanding queries, nothing to do */

+ if (!hquery->remaining)

+ return;

+

+ query = ares__htable_stvp_get_direct(channel->queries_by_qid, term_qid);

+ if (query == NULL)

+ return;

+

+ query->no_retries = 1;

+}

+

+

+ unsigned short qid = 0;

+ if (status == ARES_SUCCESS) {

+ addinfostatus = ares__parse_into_addrinfo(abuf, alen, 1, hquery->port,

+ hquery->ai);

+ if (addinfostatus == ARES_SUCCESS && alen >= HFIXEDSZ) {

+ qid = DNS_HEADER_QID(abuf); /* Converts to host byte order */

+ terminate_retries(hquery, qid);

+ }

+ if (!hquery->remaining) {

+ if (addinfostatus != ARES_SUCCESS && addinfostatus != ARES_ENODATA) {

+ /* error in parsing result e.g. no memory */

+ if (addinfostatus == ARES_EBADRESP && hquery->ai->nodes) {

+ /* We got a bad response from server, but at least one query

+ * ended with ARES_SUCCESS */

+ end_hquery(hquery, ARES_SUCCESS);

+ } else {

+ end_hquery(hquery, addinfostatus);

+ }

+ } else if (hquery->ai->nodes) {

+ /* at least one query ended with ARES_SUCCESS */

+ end_hquery(hquery, ARES_SUCCESS);

+ } else if (status == ARES_EDESTRUCTION || status == ARES_ECANCELLED) {

+ /* must make sure we don't do next_lookup() on destroy or cancel */

+ end_hquery(hquery, status);

+ } else if (status == ARES_ENOTFOUND || status == ARES_ENODATA ||

+ addinfostatus == ARES_ENODATA) {

+ if (status == ARES_ENODATA || addinfostatus == ARES_ENODATA)

+ hquery->nodata_cnt++;

+ next_lookup(hquery, hquery->nodata_cnt?ARES_ENODATA:status);

+ } else {

+ end_hquery(hquery, status);

+ }

+ hquery = ares_malloc(sizeof(*hquery));

+ memset(hquery, 0, sizeof(*hquery));

+ /* NOTE: hquery may be invalidated during the call to ares_query_qid(),

+ * so should not be referenced after this point */

+ ares_query_qid(hquery->channel, s, C_IN, T_A, host_callback, hquery,

+ &hquery->qid_a);

+ ares_query_qid(hquery->channel, s, C_IN, T_AAAA, host_callback,

+ hquery, &hquery->qid_aaaa);

+ ares_query_qid(hquery->channel, s, C_IN, T_A, host_callback,

+ hquery, &hquery->qid_a);

+ ares_query_qid(hquery->channel, s, C_IN, T_AAAA, host_callback,

+ hquery, &hquery->qid_aaaa);

+ for (p = hquery->name; p && *p; p++)

+/* MIT License

+ *

+ * Copyright (c) 1998 Massachusetts Institute of Technology

+ * Copyright (c) The c-ares project and its contributors

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * SPDX-License-Identifier: MIT

+/* MIT License

+ *

+ * Copyright (c) 1998 Massachusetts Institute of Technology

+ * Copyright (c) The c-ares project and its contributors

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+#ifndef HEADER_CARES_GETENV_H

+#define HEADER_CARES_GETENV_H

+/* MIT License

+ *

+ * Copyright (c) 1998 Massachusetts Institute of Technology

+ * Copyright (c) The c-ares project and its contributors

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+

+static void ptr_rr_name(char *name, int name_size, const struct ares_addr *addr);

+ ptr_rr_name(name, sizeof(name), &aquery->addr);

+static void ptr_rr_name(char *name, int name_size, const struct ares_addr *addr)

+ snprintf(name, name_size, "%lu.%lu.%lu.%lu.in-addr.arpa", a4, a3, a2, a1);

+ snprintf(name, name_size,

+ snprintf(name+strlen(name), name_size-strlen(name),

+/* MIT License

+ * Copyright (c) 1998, 2011, 2013 Massachusetts Institute of Technology

+ * Copyright (c) The c-ares project and its contributors

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+/* MIT License

+ *

+ * Copyright (c) 2005, 2013 Dominick Meglio

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ * SPDX-License-Identifier: MIT

+ snprintf(tmpbuf, sizeof(tmpbuf), "%u", (unsigned int)ntohs(port));

+ snprintf(&tmpbuf[1], sizeof(tmpbuf)-1, "%lu", (unsigned long)addr6->sin6_scope_id);

+ snprintf(&tmpbuf[1], sizeof(tmpbuf)-1, "%u", (unsigned int)addr6->sin6_scope_id);

+ snprintf(&tmpbuf[1], sizeof(tmpbuf)-1, "%lu", (unsigned long)addr6->sin6_scope_id);

+ snprintf(&tmpbuf[1], sizeof(tmpbuf)-1, "%u", (unsigned int)addr6->sin6_scope_id);

+ snprintf(&tmpbuf[1], sizeof(tmpbuf)-1, "%lu", (unsigned long)addr6->sin6_scope_id);

+ snprintf(&tmpbuf[1], sizeof(tmpbuf)-1, "%u", (unsigned int)addr6->sin6_scope_id);

+/* MIT License

+ *

+ * Copyright (c) 2005 Daniel Stenberg

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

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

+ * furnished to do so, subject to the following conditions:

+ * The above copyright notice and this permission notice (including the next

+ * paragraph) shall be included in all copies or substantial portions of the

+ * Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

+ * SOFTWARE.

+ *

+ * SPDX-License-Identifier: MIT

+ size_t active_queries = ares__llist_len(channel->all_queries);

+

+ for (i = 0; i < channel->nservers; i++) {

+ ares__llist_node_t *node;

+ server = &channel->servers[i];

+

+ for (node = ares__llist_node_first(server->connections);

+ node != NULL;

+ node = ares__llist_node_next(node)) {

+

+ struct server_connection *conn = ares__llist_node_val(node);

+

+ if (sockindex >= numsocks || sockindex >= ARES_GETSOCK_MAXNUM)

+ break;

+ if (!active_queries && !conn->is_tcp)

+ continue;

+

+ socks[sockindex] = conn->fd;

+

+ if (active_queries || conn->is_tcp) {

+ bitmap |= ARES_GETSOCK_READABLE(setbits, sockindex);

+ }

+ if (conn->is_tcp && ares__buf_len(server->tcp_send)) {

+ /* then the tcp socket is also writable! */

+ bitmap |= ARES_GETSOCK_WRITABLE(setbits, sockindex);

+ }

+ sockindex++;

+ }