/* DNS test framework and libresolv redirection.

   Copyright (C) 2016-2018 Free Software Foundation, Inc.

   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Lesser General Public

   License as published by the Free Software Foundation; either

   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public

   License along with the GNU C Library; if not, see

   <http://www.gnu.org/licenses/>.  */

#include <support/resolv_test.h>

#include <arpa/inet.h>

#include <errno.h>

#include <fcntl.h>

#include <nss.h>

#include <resolv.h>

#include <search.h>

#include <stdlib.h>

#include <string.h>

#include <support/check.h>

#include <support/namespace.h>

#include <support/support.h>

#include <support/test-driver.h>

#include <support/xsocket.h>

#include <support/xthread.h>

#include <support/xunistd.h>

#include <sys/uio.h>

#include <unistd.h>

/* Response builder.  */

enum

  {

    max_response_length = 65536

  };

/* Used for locating domain names containing for the purpose of

   forming compression references.  */

struct compressed_name

{

  uint16_t offset;

  unsigned char length;

  unsigned char name[];         /* Without terminating NUL.  */

};

static struct compressed_name *

allocate_compressed_name (const unsigned char *encoded, unsigned int offset)

{

  /* Compute the length of the domain name.  */

  size_t length;

  {

    const unsigned char *p;

    for (p = encoded; *p != '\0';)

      {

        /* No compression references are allowed.  */

        TEST_VERIFY (*p <= 63);

        /* Skip over the label.  */

        p += 1 + *p;

      }

    length = p - encoded;

    ++length;                   /* For the terminating NUL byte.  */

  }

  TEST_VERIFY_EXIT (length <= 255);

  struct compressed_name *result

    = xmalloc (offsetof (struct compressed_name, name) + length);

  result->offset = offset;

  result->length = length;

  memcpy (result->name, encoded, length);

  return result;

}

/* Convert CH to lower case.  Only change letters in the ASCII

   range.  */

static inline unsigned char

ascii_tolower (unsigned char ch)

{

  if ('A' <= ch && ch <= 'Z')

    return ch - 'A' + 'a';

  else

    return ch;

}

/* Compare both names, for use with tsearch.  The order is arbitrary,

   but the comparison is case-insenstive.  */

static int

compare_compressed_name (const void *left, const void *right)

{

  const struct compressed_name *crleft = left;

  const struct compressed_name *crright = right;

  if (crleft->length != crright->length)

    /* The operands are converted to int before the subtraction.  */

    return crleft->length - crright->length;

  const unsigned char *nameleft = crleft->name;

  const unsigned char *nameright = crright->name;

  while (true)

    {

      int lenleft = *nameleft++;

      int lenright = *nameright++;

      /* Labels must not e compression references.  */

      TEST_VERIFY (lenleft <= 63);

      TEST_VERIFY (lenright <= 63);

      if (lenleft != lenright)

        return left - right;

      if (lenleft == 0)

        /* End of name reached without spotting a difference.  */

        return 0;

      /* Compare the label in a case-insenstive manner.  */

      const unsigned char *endnameleft = nameleft + lenleft;

      while (nameleft < endnameleft)

        {

          int l = *nameleft++;

          int r = *nameright++;

          if (l != r)

            {

              l = ascii_tolower (l);

              r = ascii_tolower (r);

              if (l != r)

                return l - r;

            }

        }

    }

}

struct resolv_response_builder

{

  const unsigned char *query_buffer;

  size_t query_length;

  size_t offset;                /* Bytes written so far in buffer.  */

  ns_sect section;              /* Current section in the DNS packet.  */

  unsigned int truncate_bytes;  /* Bytes to remove at end of response. */

  bool drop;                    /* Discard generated response.  */

  bool close;                   /* Close TCP client connection.  */

  /* Offset of the two-byte RDATA length field in the currently

     written RDATA sub-structure.  0 if no RDATA is being written.  */

  size_t current_rdata_offset;

  /* tsearch tree for locating targets for label compression.  */

  void *compression_offsets;

  /* Must be last.  Not zeroed for performance reasons.  */

  unsigned char buffer[max_response_length];

};

/* Response builder. */

void

resolv_response_init (struct resolv_response_builder *b,

                      struct resolv_response_flags flags)

{

  if (b->offset > 0)

    FAIL_EXIT1 ("response_init: called at offset %zu", b->offset);

  if (b->query_length < 12)

    FAIL_EXIT1 ("response_init called for a query of size %zu",

                b->query_length);

  if (flags.rcode > 15)

    FAIL_EXIT1 ("response_init: invalid RCODE %u", flags.rcode);

  /* Copy the transaction ID.  */

  b->buffer[0] = b->query_buffer[0];

  b->buffer[1] = b->query_buffer[1];

  /* Initialize the flags.  */

  b->buffer[2] = 0x80;                       /* Mark as response.   */

  b->buffer[2] |= b->query_buffer[2] & 0x01; /* Copy the RD bit.  */

  if (flags.tc)

    b->buffer[2] |= 0x02;

  b->buffer[3] = flags.rcode;

  if (!flags.clear_ra)

    b->buffer[3] |= 0x80;

  if (flags.ad)

    b->buffer[3] |= 0x20;

  /* Fill in the initial section count values.  */

  b->buffer[4] = flags.qdcount >> 8;

  b->buffer[5] = flags.qdcount;

  b->buffer[6] = flags.ancount >> 8;

  b->buffer[7] = flags.ancount;

  b->buffer[8] = flags.nscount >> 8;

  b->buffer[9] = flags.nscount;

  b->buffer[10] = flags.adcount >> 8;

  b->buffer[11] = flags.adcount;

  b->offset = 12;

}

void

resolv_response_section (struct resolv_response_builder *b, ns_sect section)

{

  if (b->offset == 0)

    FAIL_EXIT1 ("resolv_response_section: response_init not called before");

  if (section < b->section)

    FAIL_EXIT1 ("resolv_response_section: cannot go back to previous section");

  b->section = section;

}

/* Add a single byte to B.  */

static inline void

response_add_byte (struct resolv_response_builder *b, unsigned char ch)

{

  if (b->offset == max_response_length)

    FAIL_EXIT1 ("DNS response exceeds 64 KiB limit");

  b->buffer[b->offset] = ch;

  ++b->offset;

}

/* Add a 16-bit word VAL to B, in big-endian format.  */

static void

response_add_16 (struct resolv_response_builder *b, uint16_t val)

{

  response_add_byte (b, val >> 8);

  response_add_byte (b, val);

}

/* Increment the pers-section record counter in the packet header.  */

static void

response_count_increment (struct resolv_response_builder *b)

{

  unsigned int offset = b->section;

  offset = 4 + 2 * offset;

  ++b->buffer[offset + 1];

  if (b->buffer[offset + 1] == 0)

    {

      /* Carry.  */

      ++b->buffer[offset];

      if (b->buffer[offset] == 0)

        /* Overflow.  */

        FAIL_EXIT1 ("too many records in section");

    }

}

void

resolv_response_add_question (struct resolv_response_builder *b,

                              const char *name, uint16_t class, uint16_t type)

{

  if (b->offset == 0)

    FAIL_EXIT1 ("resolv_response_add_question: "

                "resolv_response_init not called");

  if (b->section != ns_s_qd)

    FAIL_EXIT1 ("resolv_response_add_question: "

                "must be called in the question section");

  resolv_response_add_name (b, name);

  response_add_16 (b, type);

  response_add_16 (b, class);

  response_count_increment (b);

}

void

resolv_response_add_name (struct resolv_response_builder *b,

                          const char *const origname)

{

  unsigned char encoded_name[NS_MAXDNAME];

  if (ns_name_pton (origname, encoded_name, sizeof (encoded_name)) < 0)

    FAIL_EXIT1 ("ns_name_pton (\"%s\"): %m", origname);

  /* Copy the encoded name into the output buffer, apply compression

     where possible.  */

  for (const unsigned char *name = encoded_name; ;)

    {

      if (*name == '\0')

        {

          /* We have reached the end of the name.  Add the terminating

             NUL byte.  */

          response_add_byte (b, '\0');

          break;

        }

      /* Set to the compression target if compression is possible.  */

      struct compressed_name *crname_target;

      /* Compression references can only reach the beginning of the

         packet.  */

      enum { compression_limit = 1 << 12 };

      {

        /* The trailing part of the name to be looked up in the tree

           with the compression targets.  */

        struct compressed_name *crname

          = allocate_compressed_name (name, b->offset);

        if (b->offset < compression_limit)

          {

            /* Add the name to the tree, for future compression

               references.  */

            void **ptr = tsearch (crname, &b->compression_offsets,

                                  compare_compressed_name);

            if (ptr == NULL)

              FAIL_EXIT1 ("tsearch out of memory");

            crname_target = *ptr;

            if (crname_target != crname)

              /* The new name was not actually added to the tree.

                 Deallocate it.  */

              free (crname);

            else

              /* Signal that the tree did not yet contain the name,

                 but keep the allocation because it is now part of the

                 tree.  */

              crname_target = NULL;

          }

        else

          {

            /* This name cannot be reached by a compression reference.

               No need to add it to the tree for future reference.  */

            void **ptr = tfind (crname, &b->compression_offsets,

                                compare_compressed_name);

            if (ptr != NULL)

              crname_target = *ptr;

            else

              crname_target = NULL;

            TEST_VERIFY (crname_target != crname);

            /* Not added to the tree.  */

            free (crname);

          }

      }

      if (crname_target != NULL)

        {

          /* The name is known.  Reference the previous location.  */

          unsigned int old_offset = crname_target->offset;

          TEST_VERIFY_EXIT (old_offset < compression_limit);

          response_add_byte (b, 0xC0 | (old_offset >> 8));

          response_add_byte (b, old_offset);

          break;

        }

      else

        {

          /* The name is new.  Add this label.  */

          unsigned int len = 1 + *name;

          resolv_response_add_data (b, name, len);

          name += len;

        }

    }

}

void

resolv_response_open_record (struct resolv_response_builder *b,

                             const char *name,

                             uint16_t class, uint16_t type, uint32_t ttl)

{

  if (b->section == ns_s_qd)

    FAIL_EXIT1 ("resolv_response_open_record called in question section");

  if (b->current_rdata_offset != 0)

    FAIL_EXIT1 ("resolv_response_open_record called with open record");

  resolv_response_add_name (b, name);

  response_add_16 (b, type);

  response_add_16 (b, class);

  response_add_16 (b, ttl >> 16);

  response_add_16 (b, ttl);

  b->current_rdata_offset = b->offset;

  /* Add room for the RDATA length.  */

  response_add_16 (b, 0);

}

void

resolv_response_close_record (struct resolv_response_builder *b)

{

  size_t rdata_offset = b->current_rdata_offset;

  if (rdata_offset == 0)

    FAIL_EXIT1 ("response_close_record called without open record");

  size_t rdata_length = b->offset - rdata_offset - 2;

  if (rdata_length > 65535)

    FAIL_EXIT1 ("RDATA length %zu exceeds limit", rdata_length);

  b->buffer[rdata_offset] = rdata_length >> 8;

  b->buffer[rdata_offset + 1] = rdata_length;

  response_count_increment (b);

  b->current_rdata_offset = 0;

}

void

resolv_response_add_data (struct resolv_response_builder *b,

                          const void *data, size_t length)

{

  size_t remaining = max_response_length - b->offset;

  if (remaining < length)

    FAIL_EXIT1 ("resolv_response_add_data: not enough room for %zu bytes",

                length);

  memcpy (b->buffer + b->offset, data, length);

  b->offset += length;

}

void

resolv_response_drop (struct resolv_response_builder *b)

{

  b->drop = true;

}

void

resolv_response_close (struct resolv_response_builder *b)

{

  b->close = true;

}

void

resolv_response_truncate_data (struct resolv_response_builder *b, size_t count)

{

  if (count > 65535)

    FAIL_EXIT1 ("resolv_response_truncate_data: argument too large: %zu",

                count);

  b->truncate_bytes = count;

}

size_t

resolv_response_length (const struct resolv_response_builder *b)

{

  return b->offset;

}

unsigned char *

resolv_response_buffer (const struct resolv_response_builder *b)

{

  unsigned char *result = xmalloc (b->offset);

  memcpy (result, b->buffer, b->offset);

  return result;

}

struct resolv_response_builder *

resolv_response_builder_allocate (const unsigned char *query_buffer,

                                  size_t query_length)

{

  struct resolv_response_builder *b = xmalloc (sizeof (*b));

  memset (b, 0, offsetof (struct resolv_response_builder, buffer));

  b->query_buffer = query_buffer;

  b->query_length = query_length;

  return b;

}

void

resolv_response_builder_free (struct resolv_response_builder *b)

{

  tdestroy (b->compression_offsets, free);

  free (b);

}

/* DNS query processing. */

/* Data extracted from the question section of a DNS packet.  */

struct query_info

{

  char qname[MAXDNAME];

  uint16_t qclass;

  uint16_t qtype;

  struct resolv_edns_info edns;

};

/* Update *INFO from the specified DNS packet.  */

static void

parse_query (struct query_info *info,

             const unsigned char *buffer, size_t length)

{

  HEADER hd;

  _Static_assert (sizeof (hd) == 12, "DNS header size");

  if (length < sizeof (hd))

    FAIL_EXIT1 ("malformed DNS query: too short: %zu bytes", length);

  memcpy (&hd, buffer, sizeof (hd));

  if (ntohs (hd.qdcount) != 1)

    FAIL_EXIT1 ("malformed DNS query: wrong question count: %d",

                (int) ntohs (hd.qdcount));

  if (ntohs (hd.ancount) != 0)

    FAIL_EXIT1 ("malformed DNS query: wrong answer count: %d",

                (int) ntohs (hd.ancount));

  if (ntohs (hd.nscount) != 0)

    FAIL_EXIT1 ("malformed DNS query: wrong authority count: %d",

                (int) ntohs (hd.nscount));

  if (ntohs (hd.arcount) > 1)

    FAIL_EXIT1 ("malformed DNS query: wrong additional count: %d",

                (int) ntohs (hd.arcount));

  int ret = dn_expand (buffer, buffer + length, buffer + sizeof (hd),

                       info->qname, sizeof (info->qname));

  if (ret < 0)

    FAIL_EXIT1 ("malformed DNS query: cannot uncompress QNAME");

  /* Obtain QTYPE and QCLASS.  */

  size_t remaining = length - (12 + ret);

  struct

  {

    uint16_t qtype;

    uint16_t qclass;

  } qtype_qclass;

  if (remaining < sizeof (qtype_qclass))

    FAIL_EXIT1 ("malformed DNS query: "

                "query lacks QCLASS/QTYPE, QNAME: %s", info->qname);

  memcpy (&qtype_qclass, buffer + 12 + ret, sizeof (qtype_qclass));

  info->qclass = ntohs (qtype_qclass.qclass);

  info->qtype = ntohs (qtype_qclass.qtype);

  memset (&info->edns, 0, sizeof (info->edns));

  if (ntohs (hd.arcount) > 0)

    {

      /* Parse EDNS record.  */

      struct __attribute__ ((packed, aligned (1)))

      {

        uint8_t root;

        uint16_t rtype;

        uint16_t payload;

        uint8_t edns_extended_rcode;

        uint8_t edns_version;

        uint16_t flags;

        uint16_t rdatalen;

      } rr;

      _Static_assert (sizeof (rr) == 11, "EDNS record size");

      if (remaining < 4 + sizeof (rr))

        FAIL_EXIT1 ("mailformed DNS query: no room for EDNS record");

      memcpy (&rr, buffer + 12 + ret + 4, sizeof (rr));

      if (rr.root != 0)

        FAIL_EXIT1 ("malformed DNS query: invalid OPT RNAME: %d\n", rr.root);

      if (rr.rtype != htons (41))

        FAIL_EXIT1 ("malformed DNS query: invalid OPT type: %d\n",

                    ntohs (rr.rtype));

      info->edns.active = true;

      info->edns.extended_rcode = rr.edns_extended_rcode;

      info->edns.version = rr.edns_version;

      info->edns.flags = ntohs (rr.flags);

      info->edns.payload_size = ntohs (rr.payload);

    }

}

/* Main testing framework.  */

/* Per-server information.  One struct is allocated for each test

   server.  */

struct resolv_test_server

{

  /* Local address of the server.  UDP and TCP use the same port.  */

  struct sockaddr_in address;

  /* File descriptor of the UDP server, or -1 if this server is

     disabled.  */

  int socket_udp;

  /* File descriptor of the TCP server, or -1 if this server is

     disabled.  */

  int socket_tcp;

  /* Counter of the number of responses processed so far.  */

  size_t response_number;

  /* Thread handles for the server threads (if not disabled in the

     configuration).  */

  pthread_t thread_udp;

  pthread_t thread_tcp;

};

/* Main struct for keeping track of libresolv redirection and

   testing.  */

struct resolv_test

{

  /* After initialization, any access to the struct must be performed

     while this lock is acquired.  */

  pthread_mutex_t lock;

  /* Data for each test server. */

  struct resolv_test_server servers[resolv_max_test_servers];

  /* Used if config.single_thread_udp is true.  */

  pthread_t thread_udp_single;

  struct resolv_redirect_config config;

  bool termination_requested;

};

/* Function implementing a server thread.  */

typedef void (*thread_callback) (struct resolv_test *, int server_index);

/* Storage for thread-specific data, for passing to the

   thread_callback function.  */

struct thread_closure

{

  struct resolv_test *obj;      /* Current test object.  */

  thread_callback callback;     /* Function to call.  */

  int server_index;             /* Index of the implemented server.  */

};

/* Wrap response_callback as a function which can be passed to

   pthread_create.  */

static void *

thread_callback_wrapper (void *arg)

{

  struct thread_closure *closure = arg;

  closure->callback (closure->obj, closure->server_index);

  free (closure);

  return NULL;

}

/* Start a server thread for the specified SERVER_INDEX, implemented

   by CALLBACK.  */

static pthread_t

start_server_thread (struct resolv_test *obj, int server_index,

                     thread_callback callback)

{

  struct thread_closure *closure = xmalloc (sizeof (*closure));

  *closure = (struct thread_closure)

    {

      .obj = obj,

      .callback = callback,

      .server_index = server_index,

    };

  return xpthread_create (NULL, thread_callback_wrapper, closure);

}

/* Process one UDP query.  Return false if a termination requested has

   been detected.  */

static bool

server_thread_udp_process_one (struct resolv_test *obj, int server_index)

{

  unsigned char query[512];

  struct sockaddr_storage peer;

  socklen_t peerlen = sizeof (peer);

  size_t length = xrecvfrom (obj->servers[server_index].socket_udp,

                             query, sizeof (query), 0,

                             (struct sockaddr *) &peer, &peerlen);

  /* Check for termination.  */

  {

    bool termination_requested;

    xpthread_mutex_lock (&obj->lock);

    termination_requested = obj->termination_requested;

    xpthread_mutex_unlock (&obj->lock);

    if (termination_requested)

      return false;

  }

  struct query_info qinfo;

  parse_query (&qinfo, query, length);

  if (test_verbose > 0)

    {

      if (test_verbose > 1)

        printf ("info: UDP server %d: incoming query:"

                " %zd bytes, %s/%u/%u, tnxid=0x%02x%02x\n",

                server_index, length, qinfo.qname, qinfo.qclass, qinfo.qtype,

                query[0], query[1]);

      else

        printf ("info: UDP server %d: incoming query:"

                " %zd bytes, %s/%u/%u\n",

                server_index, length, qinfo.qname, qinfo.qclass, qinfo.qtype);

    }

  struct resolv_response_context ctx =

    {

      .test = obj,

      .client_address = &peer,

      .client_address_length = peerlen,

      .query_buffer = query,

      .query_length = length,

      .server_index = server_index,

      .tcp = false,

      .edns = qinfo.edns,

    };

  struct resolv_response_builder *b

    = resolv_response_builder_allocate (query, length);

  obj->config.response_callback

    (&ctx, b, qinfo.qname, qinfo.qclass, qinfo.qtype);

  if (b->drop)

    {

      if (test_verbose)

        printf ("info: UDP server %d: dropping response to %s/%u/%u\n",

                server_index, qinfo.qname, qinfo.qclass, qinfo.qtype);

    }

  else

    {

      if (test_verbose)

        {

          if (b->offset >= 12)

            printf ("info: UDP server %d: sending response:"

                    " %zu bytes, RCODE %d (for %s/%u/%u)\n",

                    ctx.server_index, b->offset, b->buffer[3] & 0x0f,

                    qinfo.qname, qinfo.qclass, qinfo.qtype);

          else

            printf ("info: UDP server %d: sending response: %zu bytes"

                    " (for %s/%u/%u)\n",

                    server_index, b->offset,

                    qinfo.qname, qinfo.qclass, qinfo.qtype);

          if (b->truncate_bytes > 0)

            printf ("info:    truncated by %u bytes\n", b->truncate_bytes);

        }

      resolv_response_send_udp (&ctx, b);

    }

  resolv_response_builder_free (b);

  return true;

}

void

resolv_response_send_udp (const struct resolv_response_context *ctx,

                          struct resolv_response_builder *b)

{

  TEST_VERIFY_EXIT (!ctx->tcp);

  size_t to_send = b->offset;

  if (to_send < b->truncate_bytes)

    to_send = 0;

  else

    to_send -= b->truncate_bytes;

  /* Ignore most errors here because the other end may have closed

     the socket.  */

  if (sendto (ctx->test->servers[ctx->server_index].socket_udp,

              b->buffer, to_send, 0,

              ctx->client_address, ctx->client_address_length) < 0)

    TEST_VERIFY_EXIT (errno != EBADF);

}

/* UDP thread_callback function.  Variant for one thread per

   server.  */

static void

server_thread_udp (struct resolv_test *obj, int server_index)

{

  while (server_thread_udp_process_one (obj, server_index))

    ;

}

/* Single-threaded UDP processing function, for the single_thread_udp

   case.  */

static void *

server_thread_udp_single (void *closure)

{

  struct resolv_test *obj = closure;

  struct pollfd fds[resolv_max_test_servers];

  for (int server_index = 0; server_index < resolv_max_test_servers;

       ++server_index)

    if (obj->config.servers[server_index].disable_udp)

      fds[server_index] = (struct pollfd) {.fd = -1};

    else

      {

        fds[server_index] = (struct pollfd)

          {

            .fd = obj->servers[server_index].socket_udp,

            .events = POLLIN

          };

        /* Make the socket non-blocking.  */

        int flags = fcntl (obj->servers[server_index].socket_udp, F_GETFL, 0);

        if (flags < 0)

          FAIL_EXIT1 ("fcntl (F_GETFL): %m");

        flags |= O_NONBLOCK;

        if (fcntl (obj->servers[server_index].socket_udp, F_SETFL, flags) < 0)

          FAIL_EXIT1 ("fcntl (F_SETFL): %m");

      }

  while (true)

    {

      xpoll (fds, resolv_max_test_servers, -1);

      for (int server_index = 0; server_index < resolv_max_test_servers;

           ++server_index)

        if (fds[server_index].revents != 0)

          {

            if (!server_thread_udp_process_one (obj, server_index))

              goto out;

            fds[server_index].revents = 0;

          }

    }

 out:

  return NULL;

}

/* Start the single UDP handler thread (for the single_thread_udp

   case).  */

static void

start_server_thread_udp_single (struct resolv_test *obj)

{

  obj->thread_udp_single

    = xpthread_create (NULL, server_thread_udp_single, obj);

}

/* Data describing a TCP client connect.  */

struct tcp_thread_closure

{

  struct resolv_test *obj;

  int server_index;

  int client_socket;

};

/* Read a complete DNS query packet.  If EOF_OK, an immediate

   end-of-file condition is acceptable.  */

static bool

read_fully (int fd, void *buf, size_t len, bool eof_ok)

{

  const void *const end = buf + len;

  while (buf < end)

    {

      ssize_t ret = read (fd, buf, end - buf);

      if (ret == 0)

        {

          if (!eof_ok)

            {

              support_record_failure ();

              printf ("error: unexpected EOF on TCP connection\n");

            }

          return false;

        }

      else if (ret < 0)

        {

          if (!eof_ok || errno != ECONNRESET)

            {

              support_record_failure ();

              printf ("error: TCP read: %m\n");

            }

          return false;

        }

      buf += ret;

      eof_ok = false;

    }

  return true;

}

/* Write an array of iovecs.  Terminate the process on failure.  */

static void

writev_fully (int fd, struct iovec *buffers, size_t count)

{

  while (count > 0)

    {

      /* Skip zero-length write requests.  */

      if (buffers->iov_len == 0)

        {

          ++buffers;

          --count;

          continue;

        }

      /* Try to rewrite the remaing buffers.  */

      ssize_t ret = writev (fd, buffers, count);

      if (ret < 0)

        FAIL_EXIT1 ("writev: %m");

      if (ret == 0)

        FAIL_EXIT1 ("writev: invalid return value zero");

      /* Find the buffers that were successfully written.  */

      while (ret > 0)

        {

          if (count == 0)

            FAIL_EXIT1 ("internal writev consistency failure");

          /* Current buffer was partially written.  */

          if (buffers->iov_len > (size_t) ret)

            {

              buffers->iov_base += ret;

              buffers->iov_len -= ret;

              ret = 0;

            }

          else

            {

              ret -= buffers->iov_len;

              buffers->iov_len = 0;

              ++buffers;

              --count;

            }

        }

    }

}

/* Thread callback for handling a single established TCP connection to

   a client.  */

static void *

server_thread_tcp_client (void *arg)

{

  struct tcp_thread_closure *closure = arg;