../deps/cares/src/lib/ares

Bug Summary

File:	out/../deps/cares/src/lib/ares_process.c
Warning:	line 1328, column 21 The left operand of '==' is a garbage value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name ares_process.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D V8_DEPRECATION_WARNINGS -D V8_IMMINENT_DEPRECATION_WARNINGS -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D _DARWIN_USE_64_BIT_INODE=1 -D _LARGEFILE_SOURCE -D _FILE_OFFSET_BITS=64 -D _GNU_SOURCE -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D CARES_STATICLIB -D HAVE_CONFIG_H -I ../deps/cares/include -I ../deps/cares/config/linux -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-unused-parameter -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c ../deps/cares/src/lib/ares_process.c

2/* Copyright 1998 by the Massachusetts Institute of Technology.
* Copyright (C) 2004-2017 by Daniel Stenberg
*
* Permission to use, copy, modify, and distribute this
* software and its documentation for any purpose and without
* fee is hereby granted, provided that the above copyright
* notice appear in all copies and that both that copyright
* notice and this permission notice appear in supporting
* documentation, and that the name of M.I.T. not be used in
* advertising or publicity pertaining to distribution of the
* software without specific, written prior permission.
* M.I.T. makes no representations about the suitability of
* this software for any purpose.  It is provided "as is"
* without express or implied warranty.
*/

18#include "ares_setup.h"

20#ifdef HAVE_SYS_UIO_H1
21#  include <sys/uio.h>
22#endif
23#ifdef HAVE_NETINET_IN_H1
24#  include <netinet/in.h>
25#endif
26#ifdef HAVE_NETINET_TCP_H1
27#  include <netinet/tcp.h>
28#endif
29#ifdef HAVE_NETDB_H1
30#  include <netdb.h>
31#endif
32#ifdef HAVE_ARPA_INET_H1
33#  include <arpa/inet.h>
34#endif

36#include "ares_nameser.h"

38#ifdef HAVE_STRINGS_H1
39#  include <strings.h>
40#endif
41#ifdef HAVE_SYS_IOCTL_H1
42#  include <sys/ioctl.h>
43#endif
44#ifdef NETWARE
45#  include <sys/filio.h>
46#endif

48#include <assert.h>
49#include <fcntl.h>
50#include <limits.h>

52#include "ares.h"
53#include "ares_dns.h"
54#include "ares_nowarn.h"
55#include "ares_private.h"


58static int try_again(int errnum);
59static void write_tcp_data(ares_channel channel, fd_set *write_fds,
                         ares_socket_t write_fd, struct timeval *now);
61static void read_tcp_data(ares_channel channel, fd_set *read_fds,
                        ares_socket_t read_fd, struct timeval *now);
63static void read_udp_packets(ares_channel channel, fd_set *read_fds,
                           ares_socket_t read_fd, struct timeval *now);
65static void advance_tcp_send_queue(ares_channel channel, int whichserver,
                                 ares_ssize_t num_bytes);
67static void process_timeouts(ares_channel channel, struct timeval *now);
68static void process_broken_connections(ares_channel channel,
                                     struct timeval *now);
70static void process_answer(ares_channel channel, unsigned char *abuf,
                         int alen, int whichserver, int tcp,
                         struct timeval *now);
73static void handle_error(ares_channel channel, int whichserver,
                       struct timeval *now);
75static void skip_server(ares_channel channel, struct query *query,
                      int whichserver);
77static void next_server(ares_channel channel, struct query *query,
                      struct timeval *now);
79static int open_tcp_socket(ares_channel channel, struct server_state *server);
80static int open_udp_socket(ares_channel channel, struct server_state *server);
81static int same_questions(const unsigned char *qbuf, int qlen,
                        const unsigned char *abuf, int alen);
83static int same_address(struct sockaddr *sa, struct ares_addr *aa);
84static int has_opt_rr(const unsigned char *abuf, int alen);
85static void end_query(ares_channel channel, struct query *query, int status,
                    unsigned char *abuf, int alen);

88/* return true if now is exactly check time or later */
89int ares__timedout(struct timeval *now,
                 struct timeval *check)
91{
long secs = (now->tv_sec - check->tv_sec);

if(secs > 0)
  return 1; /* yes, timed out */
if(secs < 0)
  return 0; /* nope, not timed out */

/* if the full seconds were identical, check the sub second parts */
return (now->tv_usec - check->tv_usec >= 0);
101}

103/* add the specific number of milliseconds to the time in the first argument */
104static void timeadd(struct timeval *now, int millisecs)
105{
now->tv_sec += millisecs/1000;
now->tv_usec += (millisecs%1000)*1000;

if(now->tv_usec >= 1000000) {
  ++(now->tv_sec);
  now->tv_usec -= 1000000;
}
113}

115/*
* generic process function
*/
118static void processfds(ares_channel channel,
                     fd_set *read_fds, ares_socket_t read_fd,
                     fd_set *write_fds, ares_socket_t write_fd)
121{
struct timeval now = ares__tvnow();

write_tcp_data(channel, write_fds, write_fd, &now);
read_tcp_data(channel, read_fds, read_fd, &now);
read_udp_packets(channel, read_fds, read_fd, &now);
2
←
Calling 'read_udp_packets'→
process_timeouts(channel, &now);
process_broken_connections(channel, &now);
129}

131/* Something interesting happened on the wire, or there was a timeout.
* See what's up and respond accordingly.
*/
134void ares_process(ares_channel channel, fd_set *read_fds, fd_set *write_fds)
135{
processfds(channel, read_fds, ARES_SOCKET_BAD-1, write_fds, ARES_SOCKET_BAD-1);
137}

139/* Something interesting happened on the wire, or there was a timeout.
* See what's up and respond accordingly.
*/
142void ares_process_fd(ares_channel channel,
                   ares_socket_t read_fd, /* use ARES_SOCKET_BAD or valid
                                             file descriptors */
                   ares_socket_t write_fd)
146{
processfds(channel, NULL((void*)0), read_fd, NULL((void*)0), write_fd);
1
Calling 'processfds'→
148}


151/* Return 1 if the specified error number describes a readiness error, or 0
* otherwise. This is mostly for HP-UX, which could return EAGAIN or
* EWOULDBLOCK. See this man page
*
* http://devrsrc1.external.hp.com/STKS/cgi-bin/man2html?
*     manpage=/usr/share/man/man2.Z/send.2
*/
158static int try_again(int errnum)
159{
160#if !defined EWOULDBLOCK11 && !defined EAGAIN11
161#error "Neither EWOULDBLOCK nor EAGAIN defined"
162#endif
switch (errnum)
  {
165#ifdef EWOULDBLOCK11
  case EWOULDBLOCK11:
    return 1;
168#endif
169#if defined EAGAIN11 && EAGAIN11 != EWOULDBLOCK11
  case EAGAIN11:
    return 1;
172#endif
  }
return 0;
175}

177static ares_ssize_t socket_writev(ares_channel channel, ares_socket_t s, const struct iovec * vec, int len)
178{
if (channel->sock_funcs)
  return channel->sock_funcs->asendv(s, vec, len, channel->sock_func_cb_data);

return writev(s, vec, len);
183}

185static ares_ssize_t socket_write(ares_channel channel, ares_socket_t s, const void * data, size_t len)
186{
if (channel->sock_funcs)
  {
    struct iovec vec;
    vec.iov_base = (void*)data;
    vec.iov_len = len;
    return channel->sock_funcs->asendv(s, &vec, 1, channel->sock_func_cb_data);
  }
return swrite(s, data, len)(ares_ssize_t)send((int)(s), (void *)(data), (size_t)(len), (
int)(MSG_NOSIGNAL));
195}

197/* If any TCP sockets select true for writing, write out queued data
* we have for them.
*/
200static void write_tcp_data(ares_channel channel,
                         fd_set *write_fds,
                         ares_socket_t write_fd,
                         struct timeval *now)
204{
struct server_state *server;
struct send_request *sendreq;
struct iovec *vec;
int i;
ares_ssize_t scount;
ares_ssize_t wcount;
size_t n;

if(!write_fds && (write_fd == ARES_SOCKET_BAD-1))
  /* no possible action */
  return;

for (i = 0; i < channel->nservers; i++)
  {
    /* Make sure server has data to send and is selected in write_fds or
       write_fd. */
    server = &channel->servers[i];
    if (!server->qhead || server->tcp_socket == ARES_SOCKET_BAD-1 ||
        server->is_broken)
      continue;

    if(write_fds) {
      if(!FD_ISSET(server->tcp_socket, write_fds)((((write_fds)->fds_bits)[((server->tcp_socket) / (8 * (
int) sizeof (__fd_mask)))] & ((__fd_mask) (1UL << (
(server->tcp_socket) % (8 * (int) sizeof (__fd_mask)))))) !=
 0))
        continue;
    }
    else {
      if(server->tcp_socket != write_fd)
        continue;
    }

    if(write_fds)
      /* If there's an error and we close this socket, then open
       * another with the same fd to talk to another server, then we
       * don't want to think that it was the new socket that was
       * ready. This is not disastrous, but is likely to result in
       * extra system calls and confusion. */
      FD_CLR(server->tcp_socket, write_fds)((void) (((write_fds)->fds_bits)[((server->tcp_socket) /
 (8 * (int) sizeof (__fd_mask)))] &= ~((__fd_mask) (1UL <<
 ((server->tcp_socket) % (8 * (int) sizeof (__fd_mask)))))
));

    /* Count the number of send queue items. */
    n = 0;
    for (sendreq = server->qhead; sendreq; sendreq = sendreq->next)
      n++;

    /* Allocate iovecs so we can send all our data at once. */
    vec = ares_malloc(n * sizeof(struct iovec));
    if (vec)
      {
        /* Fill in the iovecs and send. */
        n = 0;
        for (sendreq = server->qhead; sendreq; sendreq = sendreq->next)
          {
            vec[n].iov_base = (char *) sendreq->data;
            vec[n].iov_len = sendreq->len;
            n++;
          }
        wcount = socket_writev(channel, server->tcp_socket, vec, (int)n);
        ares_free(vec);
        if (wcount < 0)
          {
            if (!try_again(SOCKERRNO((*__errno_location ()))))
              handle_error(channel, i, now);
            continue;
          }

        /* Advance the send queue by as many bytes as we sent. */
        advance_tcp_send_queue(channel, i, wcount);
      }
    else
      {
        /* Can't allocate iovecs; just send the first request. */
        sendreq = server->qhead;

        scount = socket_write(channel, server->tcp_socket, sendreq->data, sendreq->len);
        if (scount < 0)
          {
            if (!try_again(SOCKERRNO((*__errno_location ()))))
              handle_error(channel, i, now);
            continue;
          }

        /* Advance the send queue by as many bytes as we sent. */
        advance_tcp_send_queue(channel, i, scount);
      }
  }
289}

291/* Consume the given number of bytes from the head of the TCP send queue. */
292static void advance_tcp_send_queue(ares_channel channel, int whichserver,
                                 ares_ssize_t num_bytes)
294{
struct send_request *sendreq;
struct server_state *server = &channel->servers[whichserver];
while (num_bytes > 0) {
  sendreq = server->qhead;
  if ((size_t)num_bytes >= sendreq->len) {
    num_bytes -= sendreq->len;
    server->qhead = sendreq->next;
    if (sendreq->data_storage)
      ares_free(sendreq->data_storage);
    ares_free(sendreq);
    if (server->qhead == NULL((void*)0)) {
      SOCK_STATE_CALLBACK(channel, server->tcp_socket, 1, 0)do { if ((channel)->sock_state_cb) (channel)->sock_state_cb
((channel)->sock_state_cb_data, (server->tcp_socket), (
1), (0)); } while(0);
      server->qtail = NULL((void*)0);

      /* qhead is NULL so we cannot continue this loop */
      break;
    }
  }
  else {
    sendreq->data += num_bytes;
    sendreq->len -= num_bytes;
    num_bytes = 0;
  }
}
319}

321static ares_ssize_t socket_recvfrom(ares_channel channel,
 ares_socket_t s,
 void * data,
 size_t data_len,
 int flags,
 struct sockaddr *from,
 ares_socklen_t *from_len)
328{
 if (channel->sock_funcs14.1
Field 'sock_funcs' is null
)
15
←
Taking false branch→
    return channel->sock_funcs->arecvfrom(s, data, data_len,
flags, from, from_len,
channel->sock_func_cb_data);

334#ifdef HAVE_RECVFROM1
 return recvfrom(s, data, data_len, flags, from, from_len);
16
←
Returning without writing to 'from->sa_family'→
336#else
 return sread(s, data, data_len)(ares_ssize_t)recv((int)(s), (void *)(data), (size_t)(data_len
), (int)(0));
338#endif
339}

341static ares_ssize_t socket_recv(ares_channel channel,
 ares_socket_t s,
 void * data,
 size_t data_len)
345{
 if (channel->sock_funcs)
    return channel->sock_funcs->arecvfrom(s, data, data_len, 0, 0, 0,
channel->sock_func_cb_data);

 return sread(s, data, data_len)(ares_ssize_t)recv((int)(s), (void *)(data), (size_t)(data_len
), (int)(0));
351}

353/* If any TCP socket selects true for reading, read some data,
* allocate a buffer if we finish reading the length word, and process
* a packet if we finish reading one.
*/
357static void read_tcp_data(ares_channel channel, fd_set *read_fds,
                        ares_socket_t read_fd, struct timeval *now)
359{
struct server_state *server;
int i;
ares_ssize_t count;

if(!read_fds && (read_fd == ARES_SOCKET_BAD-1))
  /* no possible action */
  return;

for (i = 0; i < channel->nservers; i++)
  {
    /* Make sure the server has a socket and is selected in read_fds. */
    server = &channel->servers[i];
    if (server->tcp_socket == ARES_SOCKET_BAD-1 || server->is_broken)
      continue;

    if(read_fds) {
      if(!FD_ISSET(server->tcp_socket, read_fds)((((read_fds)->fds_bits)[((server->tcp_socket) / (8 * (
int) sizeof (__fd_mask)))] & ((__fd_mask) (1UL << (
(server->tcp_socket) % (8 * (int) sizeof (__fd_mask)))))) !=
 0))
        continue;
    }
    else {
      if(server->tcp_socket != read_fd)
        continue;
    }

    if(read_fds)
      /* If there's an error and we close this socket, then open another
       * with the same fd to talk to another server, then we don't want to
       * think that it was the new socket that was ready. This is not
       * disastrous, but is likely to result in extra system calls and
       * confusion. */
      FD_CLR(server->tcp_socket, read_fds)((void) (((read_fds)->fds_bits)[((server->tcp_socket) /
 (8 * (int) sizeof (__fd_mask)))] &= ~((__fd_mask) (1UL <<
 ((server->tcp_socket) % (8 * (int) sizeof (__fd_mask)))))
));

    if (server->tcp_lenbuf_pos != 2)
      {
        /* We haven't yet read a length word, so read that (or
         * what's left to read of it).
         */
        count = socket_recv(channel, server->tcp_socket,
	      server->tcp_lenbuf + server->tcp_lenbuf_pos,
	      2 - server->tcp_lenbuf_pos);
        if (count <= 0)
          {
            if (!(count == -1 && try_again(SOCKERRNO((*__errno_location ())))))
              handle_error(channel, i, now);
            continue;
          }

        server->tcp_lenbuf_pos += (int)count;
        if (server->tcp_lenbuf_pos == 2)
          {
            /* We finished reading the length word.  Decode the
             * length and allocate a buffer for the data.
             */
            server->tcp_length = server->tcp_lenbuf[0] << 8
              | server->tcp_lenbuf[1];
            server->tcp_buffer = ares_malloc(server->tcp_length);
            if (!server->tcp_buffer) {
              handle_error(channel, i, now);
              return; /* bail out on malloc failure. TODO: make this
                         function return error codes */
            }
            server->tcp_buffer_pos = 0;
          }
      }
    else
      {
        /* Read data into the allocated buffer. */
        count = socket_recv(channel, server->tcp_socket,
	      server->tcp_buffer + server->tcp_buffer_pos,
	      server->tcp_length - server->tcp_buffer_pos);
        if (count <= 0)
          {
            if (!(count == -1 && try_again(SOCKERRNO((*__errno_location ())))))
              handle_error(channel, i, now);
            continue;
          }

        server->tcp_buffer_pos += (int)count;
        if (server->tcp_buffer_pos == server->tcp_length)
          {
            /* We finished reading this answer; process it and
             * prepare to read another length word.
             */
            process_answer(channel, server->tcp_buffer, server->tcp_length,
                           i, 1, now);
            ares_free(server->tcp_buffer);
            server->tcp_buffer = NULL((void*)0);
            server->tcp_lenbuf_pos = 0;
            server->tcp_buffer_pos = 0;
          }
      }
  }
452}

454/* If any UDP sockets select true for reading, process them. */
455static void read_udp_packets(ares_channel channel, fd_set *read_fds,
                           ares_socket_t read_fd, struct timeval *now)
457{
struct server_state *server;
int i;
ares_ssize_t count;
unsigned char buf[MAXENDSSZ4096 + 1];
462#ifdef HAVE_RECVFROM1
ares_socklen_t fromlen;
union {
  struct sockaddr     sa;
  struct sockaddr_in  sa4;
  struct sockaddr_in6 sa6;
} from;
469#endif

if(!read_fds2.1
'read_fds' is null
 && (read_fd == ARES_SOCKET_BAD-1))
3
←
Taking false branch→
  /* no possible action */
  return;

for (i = 0; i < channel->nservers; i++)
4
←
Loop condition is true.  Entering loop body→
  {
    /* Make sure the server has a socket and is selected in read_fds. */
    server = &channel->servers[i];

    if (server->udp_socket == ARES_SOCKET_BAD-1 || server->is_broken5.1
Field 'is_broken' is 0
)
5
←
Assuming the condition is false→
6
←
Taking false branch→
      continue;

    if(read_fds6.1
'read_fds' is null
) {
7
←
Taking false branch→
      if(!FD_ISSET(server->udp_socket, read_fds)((((read_fds)->fds_bits)[((server->udp_socket) / (8 * (
int) sizeof (__fd_mask)))] & ((__fd_mask) (1UL << (
(server->udp_socket) % (8 * (int) sizeof (__fd_mask)))))) !=
 0))
        continue;
    }
    else {
      if(server->udp_socket != read_fd)
8
←
Assuming 'read_fd' is equal to field 'udp_socket'→
9
←
Taking false branch→
        continue;
    }

    if(read_fds9.1
'read_fds' is null
)
10
←
Taking false branch→
      /* If there's an error and we close this socket, then open
       * another with the same fd to talk to another server, then we
       * don't want to think that it was the new socket that was
       * ready. This is not disastrous, but is likely to result in
       * extra system calls and confusion. */
      FD_CLR(server->udp_socket, read_fds)((void) (((read_fds)->fds_bits)[((server->udp_socket) /
 (8 * (int) sizeof (__fd_mask)))] &= ~((__fd_mask) (1UL <<
 ((server->udp_socket) % (8 * (int) sizeof (__fd_mask)))))
));

    /* To reduce event loop overhead, read and process as many
     * packets as we can. */
    do {
      if (server->udp_socket == ARES_SOCKET_BAD-1)
11
←
Taking false branch→
        count = 0;

      else {
        if (server->addr.family == AF_INET2)
12
←
Assuming field 'family' is not equal to AF_INET→
13
←
Taking false branch→
          fromlen = sizeof(from.sa4);
        else
          fromlen = sizeof(from.sa6);
        count = socket_recvfrom(channel, server->udp_socket, (void *)buf,
14
←
Calling 'socket_recvfrom'→
17
←
Returning from 'socket_recvfrom'→
                                sizeof(buf), 0, &from.sa, &fromlen);
      }

      if (count == -1 && try_again(SOCKERRNO((*__errno_location ()))))
18
←
Assuming the condition is false→
        continue;
      else if (count <= 0)
19
←
Assuming 'count' is > 0→
20
←
Taking false branch→
        handle_error(channel, i, now);
519#ifdef HAVE_RECVFROM1
      else if (!same_address(&from.sa, &server->addr))
21
←
Calling 'same_address'→
        /* The address the response comes from does not match the address we
         * sent the request to. Someone may be attempting to perform a cache
         * poisoning attack. */
        break;
525#endif
      else
        process_answer(channel, buf, (int)count, i, 0, now);
     } while (count > 0);
  }
530}

532/* If any queries have timed out, note the timeout and move them on. */
533static void process_timeouts(ares_channel channel, struct timeval *now)
534{
time_t t;  /* the time of the timeouts we're processing */
struct query *query;
struct list_node* list_head;
struct list_node* list_node;

/* Process all the timeouts that have fired since the last time we processed
 * timeouts. If things are going well, then we'll have hundreds/thousands of
 * queries that fall into future buckets, and only a handful of requests
 * that fall into the "now" bucket, so this should be quite quick.
 */
for (t = channel->last_timeout_processed; t <= now->tv_sec; t++)
  {
    list_head = &(channel->queries_by_timeout[t % ARES_TIMEOUT_TABLE_SIZE1024]);
    for (list_node = list_head->next; list_node != list_head; )
      {
        query = list_node->data;
        list_node = list_node->next;  /* in case the query gets deleted */
        if (query->timeout.tv_sec && ares__timedout(now, &query->timeout))
          {
            query->error_status = ARES_ETIMEOUT12;
            ++query->timeouts;
            next_server(channel, query, now);
          }
      }
   }
channel->last_timeout_processed = now->tv_sec;
561}

563/* Handle an answer from a server. */
564static void process_answer(ares_channel channel, unsigned char *abuf,
                         int alen, int whichserver, int tcp,
                         struct timeval *now)
567{
int tc, rcode, packetsz;
unsigned short id;
struct query *query;
struct list_node* list_head;
struct list_node* list_node;

/* If there's no room in the answer for a header, we can't do much
 * with it. */
if (alen < HFIXEDSZ12)
  return;

/* Grab the query ID, truncate bit, and response code from the packet. */
id = DNS_HEADER_QID(abuf)((unsigned short)((unsigned int) 0xffff & (((unsigned int
)((unsigned char)(abuf)[0]) << 8U) | ((unsigned int)((unsigned
 char)(abuf)[1])))));
tc = DNS_HEADER_TC(abuf)(((abuf)[2] >> 1) & 0x1);
rcode = DNS_HEADER_RCODE(abuf)((abuf)[3] & 0xf);

/* Find the query corresponding to this packet. The queries are
 * hashed/bucketed by query id, so this lookup should be quick.  Note that
 * both the query id and the questions must be the same; when the query id
 * wraps around we can have multiple outstanding queries with the same query
 * id, so we need to check both the id and question.
 */
query = NULL((void*)0);
list_head = &(channel->queries_by_qid[id % ARES_QID_TABLE_SIZE2048]);
for (list_node = list_head->next; list_node != list_head;
     list_node = list_node->next)
  {
    struct query *q = list_node->data;
    if ((q->qid == id) && same_questions(q->qbuf, q->qlen, abuf, alen))
      {
        query = q;
        break;
      }
  }
if (!query)
  return;

packetsz = PACKETSZ512;
/* If we use EDNS and server answers with FORMERR without an OPT RR, the protocol
 * extension is not understood by the responder. We must retry the query
 * without EDNS enabled. */
if (channel->flags & ARES_FLAG_EDNS(1 << 8))
{
    packetsz = channel->ednspsz;
    if (rcode == FORMERRns_r_formerr && has_opt_rr(abuf, alen) != 1)
    {
        int qlen = (query->tcplen - 2) - EDNSFIXEDSZ11;
        channel->flags ^= ARES_FLAG_EDNS(1 << 8);
        query->tcplen -= EDNSFIXEDSZ11;
        query->qlen -= EDNSFIXEDSZ11;
        query->tcpbuf[0] = (unsigned char)((qlen >> 8) & 0xff);
        query->tcpbuf[1] = (unsigned char)(qlen & 0xff);
        DNS_HEADER_SET_ARCOUNT(query->tcpbuf + 2, 0)((((query->tcpbuf + 2) + 10)[0] = (unsigned char)(((0) >>
 8) & 0xff)), (((query->tcpbuf + 2) + 10)[1] = (unsigned
 char)((0) & 0xff)));
        query->tcpbuf = ares_realloc(query->tcpbuf, query->tcplen);
        query->qbuf = query->tcpbuf + 2;
        ares__send_query(channel, query, now);
        return;
    }
}

/* If we got a truncated UDP packet and are not ignoring truncation,
 * don't accept the packet, and switch the query to TCP if we hadn't
 * done so already.
 */
if ((tc || alen > packetsz) && !tcp && !(channel->flags & ARES_FLAG_IGNTC(1 << 2)))
  {
    if (!query->using_tcp)
      {
        query->using_tcp = 1;
        ares__send_query(channel, query, now);
      }
    return;
  }

/* Limit alen to PACKETSZ if we aren't using TCP (only relevant if we
 * are ignoring truncation.
 */
if (alen > packetsz && !tcp)
    alen = packetsz;

/* If we aren't passing through all error packets, discard packets
 * with SERVFAIL, NOTIMP, or REFUSED response codes.
 */
if (!(channel->flags & ARES_FLAG_NOCHECKRESP(1 << 7)))
  {
    if (rcode == SERVFAILns_r_servfail || rcode == NOTIMPns_r_notimpl || rcode == REFUSEDns_r_refused)
      {
        skip_server(channel, query, whichserver);
        if (query->server == whichserver)
          next_server(channel, query, now);
        return;
      }
  }

end_query(channel, query, ARES_SUCCESS0, abuf, alen);
663}

665/* Close all the connections that are no longer usable. */
666static void process_broken_connections(ares_channel channel,
                                     struct timeval *now)
668{
int i;
for (i = 0; i < channel->nservers; i++)
  {
    struct server_state *server = &channel->servers[i];
    if (server->is_broken)
      {
        handle_error(channel, i, now);
      }
  }
678}

680/* Swap the contents of two lists */
681static void swap_lists(struct list_node* head_a,
                     struct list_node* head_b)
683{
int is_a_empty = ares__is_list_empty(head_a);
int is_b_empty = ares__is_list_empty(head_b);
struct list_node old_a = *head_a;
struct list_node old_b = *head_b;

if (is_a_empty) {
  ares__init_list_head(head_b);
} else {
  *head_b = old_a;
  old_a.next->prev = head_b;
  old_a.prev->next = head_b;
}
if (is_b_empty) {
  ares__init_list_head(head_a);
} else {
  *head_a = old_b;
  old_b.next->prev = head_a;
  old_b.prev->next = head_a;
}
703}

705static void handle_error(ares_channel channel, int whichserver,
                       struct timeval *now)
707{
struct server_state *server;
struct query *query;
struct list_node list_head;
struct list_node* list_node;

server = &channel->servers[whichserver];

/* Reset communications with this server. */
ares__close_sockets(channel, server);

/* Tell all queries talking to this server to move on and not try this
 * server again. We steal the current list of queries that were in-flight to
 * this server, since when we call next_server this can cause the queries to
 * be re-sent to this server, which will re-insert these queries in that
 * same server->queries_to_server list.
 */
ares__init_list_head(&list_head);
swap_lists(&list_head, &(server->queries_to_server));
for (list_node = list_head.next; list_node != &list_head; )
  {
    query = list_node->data;
    list_node = list_node->next;  /* in case the query gets deleted */
    assert(query->server == whichserver)((void) sizeof ((query->server == whichserver) ? 1 : 0), __extension__
 ({ if (query->server == whichserver) ; else __assert_fail
 ("query->server == whichserver", "../deps/cares/src/lib/ares_process.c"
, 730, __extension__ __PRETTY_FUNCTION__); }));
    skip_server(channel, query, whichserver);
    next_server(channel, query, now);
  }
/* Each query should have removed itself from our temporary list as
 * it re-sent itself or finished up...
 */
assert(ares__is_list_empty(&list_head))((void) sizeof ((ares__is_list_empty(&list_head)) ? 1 : 0
), __extension__ ({ if (ares__is_list_empty(&list_head)) ;
 else __assert_fail ("ares__is_list_empty(&list_head)", "../deps/cares/src/lib/ares_process.c"
, 737, __extension__ __PRETTY_FUNCTION__); }));
738}

740static void skip_server(ares_channel channel, struct query *query,
                      int whichserver)
742{
/* The given server gave us problems with this query, so if we have the
 * luxury of using other servers, then let's skip the potentially broken
 * server and just use the others. If we only have one server and we need to
 * retry then we should just go ahead and re-use that server, since it's our
 * only hope; perhaps we just got unlucky, and retrying will work (eg, the
 * server timed out our TCP connection just as we were sending another
 * request).
 */
if (channel->nservers > 1)
  {
    query->server_info[whichserver].skip_server = 1;
  }
755}

757static void next_server(ares_channel channel, struct query *query,
                      struct timeval *now)
759{
/* We need to try each server channel->tries times. We have channel->nservers
 * servers to try. In total, we need to do channel->nservers * channel->tries
 * attempts. Use query->try to remember how many times we already attempted
 * this query. Use modular arithmetic to find the next server to try. */
while (++(query->try_count) < (channel->nservers * channel->tries))
  {
    struct server_state *server;

    /* Move on to the next server. */
    query->server = (query->server + 1) % channel->nservers;
    server = &channel->servers[query->server];

    /* We don't want to use this server if (1) we decided this connection is
     * broken, and thus about to be closed, (2) we've decided to skip this
     * server because of earlier errors we encountered, or (3) we already
     * sent this query over this exact connection.
     */
    if (!server->is_broken &&
         !query->server_info[query->server].skip_server &&
         !(query->using_tcp &&
           (query->server_info[query->server].tcp_connection_generation ==
            server->tcp_connection_generation)))
      {
         ares__send_query(channel, query, now);
         return;
      }

    /* You might think that with TCP we only need one try. However, even
     * when using TCP, servers can time-out our connection just as we're
     * sending a request, or close our connection because they die, or never
     * send us a reply because they get wedged or tickle a bug that drops
     * our request.
     */
  }

/* If we are here, all attempts to perform query failed. */
end_query(channel, query, query->error_status, NULL((void*)0), 0);
797}

799void ares__send_query(ares_channel channel, struct query *query,
                    struct timeval *now)
801{
struct send_request *sendreq;
struct server_state *server;
int timeplus;

server = &channel->servers[query->server];
if (query->using_tcp)
  {
    /* Make sure the TCP socket for this server is set up and queue
     * a send request.
     */
    if (server->tcp_socket == ARES_SOCKET_BAD-1)
      {
        if (open_tcp_socket(channel, server) == -1)
          {
            skip_server(channel, query, query->server);
            next_server(channel, query, now);
            return;
          }
      }
    sendreq = ares_malloc(sizeof(struct send_request));
    if (!sendreq)
      {
      end_query(channel, query, ARES_ENOMEM15, NULL((void*)0), 0);
        return;
      }
    memset(sendreq, 0, sizeof(struct send_request));
    /* To make the common case fast, we avoid copies by using the query's
     * tcpbuf for as long as the query is alive. In the rare case where the
     * query ends while it's queued for transmission, then we give the
     * sendreq its own copy of the request packet and put it in
     * sendreq->data_storage.
     */
    sendreq->data_storage = NULL((void*)0);
    sendreq->data = query->tcpbuf;
    sendreq->len = query->tcplen;
    sendreq->owner_query = query;
    sendreq->next = NULL((void*)0);
    if (server->qtail)
      server->qtail->next = sendreq;
    else
      {
        SOCK_STATE_CALLBACK(channel, server->tcp_socket, 1, 1)do { if ((channel)->sock_state_cb) (channel)->sock_state_cb
((channel)->sock_state_cb_data, (server->tcp_socket), (
1), (1)); } while(0);
        server->qhead = sendreq;
      }
    server->qtail = sendreq;
    query->server_info[query->server].tcp_connection_generation =
      server->tcp_connection_generation;
  }
else
  {
    if (server->udp_socket == ARES_SOCKET_BAD-1)
      {
        if (open_udp_socket(channel, server) == -1)
          {
            skip_server(channel, query, query->server);
            next_server(channel, query, now);
            return;
          }
      }
    if (socket_write(channel, server->udp_socket, query->qbuf, query->qlen) == -1)
      {
        /* FIXME: Handle EAGAIN here since it likely can happen. */
        skip_server(channel, query, query->server);
        next_server(channel, query, now);
        return;
      }
  }

  /* For each trip through the entire server list, double the channel's
   * assigned timeout, avoiding overflow.  If channel->timeout is negative,
   * leave it as-is, even though that should be impossible here.
   */
  timeplus = channel->timeout;
  {
    /* How many times do we want to double it?  Presume sane values here. */
    const int shift = query->try_count / channel->nservers;

    /* Is there enough room to shift timeplus left that many times?
     *
     * To find out, confirm that all of the bits we'll shift away are zero.
     * Stop considering a shift if we get to the point where we could shift
     * a 1 into the sign bit (i.e. when shift is within two of the bit
     * count).
     *
     * This has the side benefit of leaving negative numbers unchanged.
     */
    if(shift <= (int)(sizeof(int) * CHAR_BIT8 - 1)
       && (timeplus >> (sizeof(int) * CHAR_BIT8 - 1 - shift)) == 0)
    {
      timeplus <<= shift;
    }
  }

  query->timeout = *now;
  timeadd(&query->timeout, timeplus);
  /* Keep track of queries bucketed by timeout, so we can process
   * timeout events quickly.
   */
  ares__remove_from_list(&(query->queries_by_timeout));
  ares__insert_in_list(
      &(query->queries_by_timeout),
      &(channel->queries_by_timeout[query->timeout.tv_sec %
                                    ARES_TIMEOUT_TABLE_SIZE1024]));

  /* Keep track of queries bucketed by server, so we can process server
   * errors quickly.
   */
  ares__remove_from_list(&(query->queries_to_server));
  ares__insert_in_list(&(query->queries_to_server),
                       &(server->queries_to_server));
912}

914/*
* setsocknonblock sets the given socket to either blocking or non-blocking
* mode based on the 'nonblock' boolean argument. This function is highly
* portable.
*/
919static int setsocknonblock(ares_socket_t sockfd,    /* operate on this */
                         int nonblock   /* TRUE or FALSE */)
921{
922#if defined(USE_BLOCKING_SOCKETS)

return 0; /* returns success */

926#elif defined(HAVE_FCNTL_O_NONBLOCK1)

/* most recent unix versions */
int flags;
flags = fcntl(sockfd, F_GETFL3, 0);
if (FALSE0 != nonblock)
  return fcntl(sockfd, F_SETFL4, flags | O_NONBLOCK04000);
else
  return fcntl(sockfd, F_SETFL4, flags & (~O_NONBLOCK04000));  /* LCOV_EXCL_LINE */

936#elif defined(HAVE_IOCTL_FIONBIO1)

/* older unix versions */
int flags = nonblock ? 1 : 0;
return ioctl(sockfd, FIONBIO0x5421, &flags);

942#elif defined(HAVE_IOCTLSOCKET_FIONBIO)

944#ifdef WATT32
char flags = nonblock ? 1 : 0;
946#else
/* Windows */
unsigned long flags = nonblock ? 1UL : 0UL;
949#endif
return ioctlsocket(sockfd, FIONBIO0x5421, &flags);

952#elif defined(HAVE_IOCTLSOCKET_CAMEL_FIONBIO)

/* Amiga */
long flags = nonblock ? 1L : 0L;
return IoctlSocket(sockfd, FIONBIO0x5421, flags);

958#elif defined(HAVE_SETSOCKOPT_SO_NONBLOCK)

/* BeOS */
long b = nonblock ? 1L : 0L;
return setsockopt(sockfd, SOL_SOCKET1, SO_NONBLOCK, &b, sizeof(b));

964#else
965#  error "no non-blocking method was found/used/set"
966#endif
967}

969static int configure_socket(ares_socket_t s, int family, ares_channel channel)
970{
union {
  struct sockaddr     sa;
  struct sockaddr_in  sa4;
  struct sockaddr_in6 sa6;
} local;

/* do not set options for user-managed sockets */
if (channel->sock_funcs)
  return 0;

(void)setsocknonblock(s, TRUE1);

983#if defined(FD_CLOEXEC1) && !defined(MSDOS)
/* Configure the socket fd as close-on-exec. */
if (fcntl(s, F_SETFD2, FD_CLOEXEC1) == -1)
  return -1;  /* LCOV_EXCL_LINE */
987#endif

/* Set the socket's send and receive buffer sizes. */
if ((channel->socket_send_buffer_size > 0) &&
    setsockopt(s, SOL_SOCKET1, SO_SNDBUF7,
               (void *)&channel->socket_send_buffer_size,
               sizeof(channel->socket_send_buffer_size)) == -1)
  return -1;

if ((channel->socket_receive_buffer_size > 0) &&
    setsockopt(s, SOL_SOCKET1, SO_RCVBUF8,
               (void *)&channel->socket_receive_buffer_size,
               sizeof(channel->socket_receive_buffer_size)) == -1)
  return -1;

1002#ifdef SO_BINDTODEVICE25
if (channel->local_dev_name[0]) {
  if (setsockopt(s, SOL_SOCKET1, SO_BINDTODEVICE25,
                 channel->local_dev_name, sizeof(channel->local_dev_name))) {
    /* Only root can do this, and usually not fatal if it doesn't work, so */
    /* just continue on. */
  }
}
1010#endif

if (family == AF_INET2) {
  if (channel->local_ip4) {
    memset(&local.sa4, 0, sizeof(local.sa4));
    local.sa4.sin_family = AF_INET2;
    local.sa4.sin_addr.s_addr = htonl(channel->local_ip4)__bswap_32 (channel->local_ip4);
    if (bind(s, &local.sa, sizeof(local.sa4)) < 0)
      return -1;
  }
}
else if (family == AF_INET610) {
  if (memcmp(channel->local_ip6, &ares_in6addr_any,
             sizeof(channel->local_ip6)) != 0) {
    memset(&local.sa6, 0, sizeof(local.sa6));
    local.sa6.sin6_family = AF_INET610;
    memcpy(&local.sa6.sin6_addr, channel->local_ip6,
           sizeof(channel->local_ip6));
    if (bind(s, &local.sa, sizeof(local.sa6)) < 0)
      return -1;
  }
}

return 0;
1034}

1036static int open_tcp_socket(ares_channel channel, struct server_state *server)
1037{
ares_socket_t s;
int opt;
ares_socklen_t salen;
union {
  struct sockaddr_in  sa4;
  struct sockaddr_in6 sa6;
} saddr;
struct sockaddr *sa;

switch (server->addr.family)
  {
    case AF_INET2:
      sa = (void *)&saddr.sa4;
      salen = sizeof(saddr.sa4);
      memset(sa, 0, salen);
      saddr.sa4.sin_family = AF_INET2;
      if (server->addr.tcp_port) {
        saddr.sa4.sin_port = aresx_sitous(server->addr.tcp_port);
      } else {
        saddr.sa4.sin_port = aresx_sitous(channel->tcp_port);
      }
      memcpy(&saddr.sa4.sin_addr, &server->addr.addrV4addr.addr4,
             sizeof(server->addr.addrV4addr.addr4));
      break;
    case AF_INET610:
      sa = (void *)&saddr.sa6;
      salen = sizeof(saddr.sa6);
      memset(sa, 0, salen);
      saddr.sa6.sin6_family = AF_INET610;
      if (server->addr.tcp_port) {
        saddr.sa6.sin6_port = aresx_sitous(server->addr.tcp_port);
      } else {
        saddr.sa6.sin6_port = aresx_sitous(channel->tcp_port);
      }
      memcpy(&saddr.sa6.sin6_addr, &server->addr.addrV6addr.addr6,
             sizeof(server->addr.addrV6addr.addr6));
      break;
    default:
      return -1;  /* LCOV_EXCL_LINE */
  }

/* Acquire a socket. */
s = ares__open_socket(channel, server->addr.family, SOCK_STREAMSOCK_STREAM, 0);
if (s == ARES_SOCKET_BAD-1)
  return -1;

/* Configure it. */
if (configure_socket(s, server->addr.family, channel) < 0)
  {
     ares__close_socket(channel, s);
     return -1;
  }

1091#ifdef TCP_NODELAY1
/*
 * Disable the Nagle algorithm (only relevant for TCP sockets, and thus not
 * in configure_socket). In general, in DNS lookups we're pretty much
 * interested in firing off a single request and then waiting for a reply,
 * so batching isn't very interesting.
 */
opt = 1;
if (channel->sock_funcs == 0
   &&
   setsockopt(s, IPPROTO_TCPIPPROTO_TCP, TCP_NODELAY1,
              (void *)&opt, sizeof(opt)) == -1)
  {
     ares__close_socket(channel, s);
     return -1;
  }
1107#endif

if (channel->sock_config_cb)
  {
    int err = channel->sock_config_cb(s, SOCK_STREAMSOCK_STREAM,
                                      channel->sock_config_cb_data);
    if (err < 0)
      {
        ares__close_socket(channel, s);
        return err;
      }
  }

/* Connect to the server. */
if (ares__connect_socket(channel, s, sa, salen) == -1)
  {
    int err = SOCKERRNO((*__errno_location ()));

    if (err != EINPROGRESS115 && err != EWOULDBLOCK11)
      {
        ares__close_socket(channel, s);
        return -1;
      }
  }

if (channel->sock_create_cb)
  {
    int err = channel->sock_create_cb(s, SOCK_STREAMSOCK_STREAM,
                                      channel->sock_create_cb_data);
    if (err < 0)
      {
        ares__close_socket(channel, s);
        return err;
      }
  }

SOCK_STATE_CALLBACK(channel, s, 1, 0)do { if ((channel)->sock_state_cb) (channel)->sock_state_cb
((channel)->sock_state_cb_data, (s), (1), (0)); } while(0);
server->tcp_buffer_pos = 0;
server->tcp_socket = s;
server->tcp_connection_generation = ++channel->tcp_connection_generation;
return 0;
1148}

1150static int open_udp_socket(ares_channel channel, struct server_state *server)
1151{
ares_socket_t s;
ares_socklen_t salen;
union {
  struct sockaddr_in  sa4;
  struct sockaddr_in6 sa6;
} saddr;
struct sockaddr *sa;

switch (server->addr.family)
  {
    case AF_INET2:
      sa = (void *)&saddr.sa4;
      salen = sizeof(saddr.sa4);
      memset(sa, 0, salen);
      saddr.sa4.sin_family = AF_INET2;
      if (server->addr.udp_port) {
        saddr.sa4.sin_port = aresx_sitous(server->addr.udp_port);
      } else {
        saddr.sa4.sin_port = aresx_sitous(channel->udp_port);
      }
      memcpy(&saddr.sa4.sin_addr, &server->addr.addrV4addr.addr4,
             sizeof(server->addr.addrV4addr.addr4));
      break;
    case AF_INET610:
      sa = (void *)&saddr.sa6;
      salen = sizeof(saddr.sa6);
      memset(sa, 0, salen);
      saddr.sa6.sin6_family = AF_INET610;
      if (server->addr.udp_port) {
        saddr.sa6.sin6_port = aresx_sitous(server->addr.udp_port);
      } else {
        saddr.sa6.sin6_port = aresx_sitous(channel->udp_port);
      }
      memcpy(&saddr.sa6.sin6_addr, &server->addr.addrV6addr.addr6,
             sizeof(server->addr.addrV6addr.addr6));
      break;
    default:
      return -1;  /* LCOV_EXCL_LINE */
  }

/* Acquire a socket. */
s = ares__open_socket(channel, server->addr.family, SOCK_DGRAMSOCK_DGRAM, 0);
if (s == ARES_SOCKET_BAD-1)
  return -1;

/* Set the socket non-blocking. */
if (configure_socket(s, server->addr.family, channel) < 0)
  {
     ares__close_socket(channel, s);
     return -1;
  }

if (channel->sock_config_cb)
  {
    int err = channel->sock_config_cb(s, SOCK_DGRAMSOCK_DGRAM,
                                      channel->sock_config_cb_data);
    if (err < 0)
      {
        ares__close_socket(channel, s);
        return err;
      }
  }

/* Connect to the server. */
if (ares__connect_socket(channel, s, sa, salen) == -1)
  {
    int err = SOCKERRNO((*__errno_location ()));

    if (err != EINPROGRESS115 && err != EWOULDBLOCK11)
      {
        ares__close_socket(channel, s);
        return -1;
      }
  }

if (channel->sock_create_cb)
  {
    int err = channel->sock_create_cb(s, SOCK_DGRAMSOCK_DGRAM,
                                      channel->sock_create_cb_data);
    if (err < 0)
      {
        ares__close_socket(channel, s);
        return err;
      }
  }

SOCK_STATE_CALLBACK(channel, s, 1, 0)do { if ((channel)->sock_state_cb) (channel)->sock_state_cb
((channel)->sock_state_cb_data, (s), (1), (0)); } while(0);

server->udp_socket = s;
return 0;
1242}

1244static int same_questions(const unsigned char *qbuf, int qlen,
                        const unsigned char *abuf, int alen)
1246{
struct {
  const unsigned char *p;
  int qdcount;
  char *name;
  long namelen;
  int type;
  int dnsclass;
} q, a;
int i, j;

if (qlen < HFIXEDSZ12 || alen < HFIXEDSZ12)
  return 0;

/* Extract qdcount from the request and reply buffers and compare them. */
q.qdcount = DNS_HEADER_QDCOUNT(qbuf)((unsigned short)((unsigned int) 0xffff & (((unsigned int
)((unsigned char)((qbuf) + 4)[0]) << 8U) | ((unsigned int
)((unsigned char)((qbuf) + 4)[1])))));
a.qdcount = DNS_HEADER_QDCOUNT(abuf)((unsigned short)((unsigned int) 0xffff & (((unsigned int
)((unsigned char)((abuf) + 4)[0]) << 8U) | ((unsigned int
)((unsigned char)((abuf) + 4)[1])))));
if (q.qdcount != a.qdcount)
  return 0;

/* For each question in qbuf, find it in abuf. */
q.p = qbuf + HFIXEDSZ12;
for (i = 0; i < q.qdcount; i++)
  {
    /* Decode the question in the query. */
    if (ares_expand_name(q.p, qbuf, qlen, &q.name, &q.namelen)
        != ARES_SUCCESS0)
      return 0;
    q.p += q.namelen;
    if (q.p + QFIXEDSZ4 > qbuf + qlen)
      {
        ares_free(q.name);
        return 0;
      }
    q.type = DNS_QUESTION_TYPE(q.p)((unsigned short)((unsigned int) 0xffff & (((unsigned int
)((unsigned char)(q.p)[0]) << 8U) | ((unsigned int)((unsigned
 char)(q.p)[1])))));
    q.dnsclass = DNS_QUESTION_CLASS(q.p)((unsigned short)((unsigned int) 0xffff & (((unsigned int
)((unsigned char)((q.p) + 2)[0]) << 8U) | ((unsigned int
)((unsigned char)((q.p) + 2)[1])))));
    q.p += QFIXEDSZ4;

    /* Search for this question in the answer. */
    a.p = abuf + HFIXEDSZ12;
    for (j = 0; j < a.qdcount; j++)
      {
        /* Decode the question in the answer. */
        if (ares_expand_name(a.p, abuf, alen, &a.name, &a.namelen)
            != ARES_SUCCESS0)
          {
            ares_free(q.name);
            return 0;
          }
        a.p += a.namelen;
        if (a.p + QFIXEDSZ4 > abuf + alen)
          {
            ares_free(q.name);
            ares_free(a.name);
            return 0;
          }
        a.type = DNS_QUESTION_TYPE(a.p)((unsigned short)((unsigned int) 0xffff & (((unsigned int
)((unsigned char)(a.p)[0]) << 8U) | ((unsigned int)((unsigned
 char)(a.p)[1])))));
        a.dnsclass = DNS_QUESTION_CLASS(a.p)((unsigned short)((unsigned int) 0xffff & (((unsigned int
)((unsigned char)((a.p) + 2)[0]) << 8U) | ((unsigned int
)((unsigned char)((a.p) + 2)[1])))));
        a.p += QFIXEDSZ4;

        /* Compare the decoded questions. */
        if (strcasecmp(q.name, a.name) == 0 && q.type == a.type
            && q.dnsclass == a.dnsclass)
          {
            ares_free(a.name);
            break;
          }
        ares_free(a.name);
      }

    ares_free(q.name);
    if (j == a.qdcount)
      return 0;
  }
return 1;
1321}

1323static int same_address(struct sockaddr *sa, struct ares_addr *aa)
1324{
void *addr1;
void *addr2;

if (sa->sa_family == aa->family)
22
←
The left operand of '==' is a garbage value
  {
    switch (aa->family)
      {
        case AF_INET2:
          addr1 = &aa->addrV4addr.addr4;
          addr2 = &(CARES_INADDR_CAST(struct sockaddr_in *, sa)((struct sockaddr_in *)((void *)sa)))->sin_addr;
          if (memcmp(addr1, addr2, sizeof(aa->addrV4addr.addr4)) == 0)
            return 1; /* match */
          break;
        case AF_INET610:
          addr1 = &aa->addrV6addr.addr6;
          addr2 = &(CARES_INADDR_CAST(struct sockaddr_in6 *, sa)((struct sockaddr_in6 *)((void *)sa)))->sin6_addr;
          if (memcmp(addr1, addr2, sizeof(aa->addrV6addr.addr6)) == 0)
            return 1; /* match */
          break;
        default:
          break;  /* LCOV_EXCL_LINE */
      }
  }
return 0; /* different */
1349}

1351/* search for an OPT RR in the response */
1352static int has_opt_rr(const unsigned char *abuf, int alen)
1353{
unsigned int qdcount, ancount, nscount, arcount, i;
const unsigned char *aptr;
int status;

if (alen < HFIXEDSZ12)
  return -1;

/* Parse the answer header. */
qdcount = DNS_HEADER_QDCOUNT(abuf)((unsigned short)((unsigned int) 0xffff & (((unsigned int
)((unsigned char)((abuf) + 4)[0]) << 8U) | ((unsigned int
)((unsigned char)((abuf) + 4)[1])))));
ancount = DNS_HEADER_ANCOUNT(abuf)((unsigned short)((unsigned int) 0xffff & (((unsigned int
)((unsigned char)((abuf) + 6)[0]) << 8U) | ((unsigned int
)((unsigned char)((abuf) + 6)[1])))));
nscount = DNS_HEADER_NSCOUNT(abuf)((unsigned short)((unsigned int) 0xffff & (((unsigned int
)((unsigned char)((abuf) + 8)[0]) << 8U) | ((unsigned int
)((unsigned char)((abuf) + 8)[1])))));
arcount = DNS_HEADER_ARCOUNT(abuf)((unsigned short)((unsigned int) 0xffff & (((unsigned int
)((unsigned char)((abuf) + 10)[0]) << 8U) | ((unsigned int
)((unsigned char)((abuf) + 10)[1])))));

aptr = abuf + HFIXEDSZ12;

/* skip the questions */
for (i = 0; i < qdcount; i++)
  {
    char* name;
    long len;
    status = ares_expand_name(aptr, abuf, alen, &name, &len);
    if (status != ARES_SUCCESS0)
      return -1;
    ares_free_string(name);
    if (aptr + len + QFIXEDSZ4 > abuf + alen)
      return -1;
    aptr += len + QFIXEDSZ4;
  }

/* skip the ancount and nscount */
for (i = 0; i < ancount + nscount; i++)
  {
    char* name;
    long len;
    int dlen;
    status = ares_expand_name(aptr, abuf, alen, &name, &len);
    if (status != ARES_SUCCESS0)
      return -1;
    ares_free_string(name);
    if (aptr + len + RRFIXEDSZ10 > abuf + alen)
      return -1;
    aptr += len;
    dlen = DNS_RR_LEN(aptr)((unsigned short)((unsigned int) 0xffff & (((unsigned int
)((unsigned char)((aptr) + 8)[0]) << 8U) | ((unsigned int
)((unsigned char)((aptr) + 8)[1])))));
    aptr += RRFIXEDSZ10;
    if (aptr + dlen > abuf + alen)
      return -1;
    aptr += dlen;
  }

/* search for rr type (41) - opt */
for (i = 0; i < arcount; i++)
  {
    char* name;
    long len;
    int dlen;
    status = ares_expand_name(aptr, abuf, alen, &name, &len);
    if (status != ARES_SUCCESS0)
      return -1;
    ares_free_string(name);
    if (aptr + len + RRFIXEDSZ10 > abuf + alen)
      return -1;
    aptr += len;

    if (DNS_RR_TYPE(aptr)((unsigned short)((unsigned int) 0xffff & (((unsigned int
)((unsigned char)(aptr)[0]) << 8U) | ((unsigned int)((unsigned
 char)(aptr)[1]))))) == T_OPT41)
      return 1;

    dlen = DNS_RR_LEN(aptr)((unsigned short)((unsigned int) 0xffff & (((unsigned int
)((unsigned char)((aptr) + 8)[0]) << 8U) | ((unsigned int
)((unsigned char)((aptr) + 8)[1])))));
    aptr += RRFIXEDSZ10;
    if (aptr + dlen > abuf + alen)
      return -1;
    aptr += dlen;
  }

return 0;
1428}

1430static void end_query (ares_channel channel, struct query *query, int status,
                     unsigned char *abuf, int alen)
1432{
int i;

/* First we check to see if this query ended while one of our send
 * queues still has pointers to it.
 */
for (i = 0; i < channel->nservers; i++)
  {
    struct server_state *server = &channel->servers[i];
    struct send_request *sendreq;
    for (sendreq = server->qhead; sendreq; sendreq = sendreq->next)
      if (sendreq->owner_query == query)
        {
          sendreq->owner_query = NULL((void*)0);
          assert(sendreq->data_storage == NULL)((void) sizeof ((sendreq->data_storage == ((void*)0)) ? 1 :
 0), __extension__ ({ if (sendreq->data_storage == ((void*
)0)) ; else __assert_fail ("sendreq->data_storage == NULL"
, "../deps/cares/src/lib/ares_process.c", 1446, __extension__
 __PRETTY_FUNCTION__); }));
          if (status == ARES_SUCCESS0)
            {
              /* We got a reply for this query, but this queued sendreq
               * points into this soon-to-be-gone query's tcpbuf. Probably
               * this means we timed out and queued the query for
               * retransmission, then received a response before actually
               * retransmitting. This is perfectly fine, so we want to keep
               * the connection running smoothly if we can. But in the worst
               * case we may have sent only some prefix of the query, with
               * some suffix of the query left to send. Also, the buffer may
               * be queued on multiple queues. To prevent dangling pointers
               * to the query's tcpbuf and handle these cases, we just give
               * such sendreqs their own copy of the query packet.
               */
             sendreq->data_storage = ares_malloc(sendreq->len);
             if (sendreq->data_storage != NULL((void*)0))
               {
                 memcpy(sendreq->data_storage, sendreq->data, sendreq->len);
                 sendreq->data = sendreq->data_storage;
               }
            }
          if ((status != ARES_SUCCESS0) || (sendreq->data_storage == NULL((void*)0)))
            {
              /* We encountered an error (probably a timeout, suggesting the
               * DNS server we're talking to is probably unreachable,
               * wedged, or severely overloaded) or we couldn't copy the
               * request, so mark the connection as broken. When we get to
               * process_broken_connections() we'll close the connection and
               * try to re-send requests to another server.
               */
             server->is_broken = 1;
             /* Just to be paranoid, zero out this sendreq... */
             sendreq->data = NULL((void*)0);
             sendreq->len = 0;
           }
        }
  }

/* Invoke the callback */
query->callback(query->arg, status, query->timeouts, abuf, alen);
ares__free_query(query);

/* Simple cleanup policy: if no queries are remaining, close all network
 * sockets unless STAYOPEN is set.
 */
if (!(channel->flags & ARES_FLAG_STAYOPEN(1 << 4)) &&
    ares__is_list_empty(&(channel->all_queries)))
  {
    for (i = 0; i < channel->nservers; i++)
      ares__close_sockets(channel, &channel->servers[i]);
  }
1498}

1500void ares__free_query(struct query *query)
1501{
/* Remove the query from all the lists in which it is linked */
ares__remove_from_list(&(query->queries_by_qid));
ares__remove_from_list(&(query->queries_by_timeout));
ares__remove_from_list(&(query->queries_to_server));
ares__remove_from_list(&(query->all_queries));
/* Zero out some important stuff, to help catch bugs */
query->callback = NULL((void*)0);
query->arg = NULL((void*)0);
/* Deallocate the memory associated with the query */
ares_free(query->tcpbuf);
ares_free(query->server_info);
ares_free(query);
1514}

1516ares_socket_t ares__open_socket(ares_channel channel,
                              int af, int type, int protocol)
1518{
if (channel->sock_funcs)
  return channel->sock_funcs->asocket(af,
                                      type,
                                      protocol,
                                      channel->sock_func_cb_data);
else
  return socket(af, type, protocol);
1526}

1528int ares__connect_socket(ares_channel channel,
                       ares_socket_t sockfd,
                       const struct sockaddr *addr,
                       ares_socklen_t addrlen)
1532{
if (channel->sock_funcs)
  return channel->sock_funcs->aconnect(sockfd,
                                       addr,
                                       addrlen,
                                       channel->sock_func_cb_data);
else
  return connect(sockfd, addr, addrlen);
1540}

1542void ares__close_socket(ares_channel channel, ares_socket_t s)
1543{
if (channel->sock_funcs)
  channel->sock_funcs->aclose(s, channel->sock_func_cb_data);
else
  sclose(s)close((s));
1548}