/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c

Bug Summary

File:	lib/lwan-thread.c
Warning:	line 1290, column 35 Array subscript is undefined
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name lwan-thread.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -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 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -fno-plt -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/buildbot/lwan-worker/clang-analyze/build/src/lib -resource-dir /usr/lib/clang/13.0.1 -include /home/buildbot/lwan-worker/clang-analyze/build/lwan-build-config.h -D _FILE_OFFSET_BITS=64 -D _TIME_BITS=64 -I /home/buildbot/lwan-worker/clang-analyze/build/src/lib/missing -I /usr/include/luajit-2.1 -I /usr/include/valgrind -I /home/buildbot/lwan-worker/clang-analyze/build/src/lib -I /home/buildbot/lwan-worker/clang-analyze/build -internal-isystem /usr/lib/clang/13.0.1/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/11.2.0/../../../../x86_64-pc-linux-gnu/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wno-unused-parameter -Wno-free-nonheap-object -std=gnu99 -fdebug-compilation-dir=/home/buildbot/lwan-worker/clang-analyze/build/src/lib -ferror-limit 19 -stack-protector 2 -fgnuc-version=4.2.1 -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/buildbot/lwan-worker/clang-analyze/CLANG/2022-03-15-064851-2955116-1 -x c /home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c
1/*
* lwan - simple web server
* Copyright (c) 2012, 2013 L. A. F. Pereira <l@tia.mat.br>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
* USA.
*/

21#define _GNU_SOURCE
22#include <assert.h>
23#include <errno(*__errno_location ()).h>
24#include <fcntl.h>
25#include <pthread.h>
26#include <sched.h>
27#include <stdlib.h>
28#include <string.h>
29#include <sys/epoll.h>
30#include <sys/ioctl.h>
31#include <sys/socket.h>
32#include <unistd.h>

34#if defined(HAVE_SO_ATTACH_REUSEPORT_CBPF)
35#include <linux1/filter.h>
36#endif

38#if defined(HAVE_MBEDTLS)
39#include <mbedtls/entropy.h>
40#include <mbedtls/error.h>
41#include <mbedtls/gcm.h>
42#include <mbedtls/net_sockets.h>
43#include <mbedtls/ssl_internal.h>

45#include <linux1/tls.h>
46#include <netinet/tcp.h>
47#endif

49#include "list.h"
50#include "murmur3.h"
51#include "lwan-private.h"
52#include "lwan-tq.h"

54static void lwan_strbuf_free_defer(void *data)
55{
  return lwan_strbuf_free((struct lwan_strbuf *)data);
57}

59static void graceful_close(struct lwan *l,
                         struct lwan_connection *conn,
                         char buffer[static DEFAULT_BUFFER_SIZE4096])
62{
  int fd = lwan_connection_get_fd(l, conn);

  while (TIOCOUTQ0x5411) {
      /* This ioctl isn't probably doing what it says on the tin; the details
       * are subtle, but it seems to do the trick to allow gracefully closing
       * the connection in some cases with minimal system calls. */
      int bytes_waiting;
      int r = ioctl(fd, TIOCOUTQ0x5411, &bytes_waiting);

      if (!r && !bytes_waiting) /* See note about close(2) below. */
          return;
      if (r < 0 && errno(*__errno_location ()) == EINTR4)
          continue;

      break;
  }

  if (UNLIKELY(shutdown(fd, SHUT_WR) < 0)__builtin_expect(((shutdown(fd, SHUT_WR) < 0)), (0))) {
      if (UNLIKELY(errno == ENOTCONN)__builtin_expect((((*__errno_location ()) == 107)), (0)))
          return;
  }

  for (int tries = 0; tries < 20; tries++) {
      ssize_t r = recv(fd, buffer, DEFAULT_BUFFER_SIZE4096, 0);

      if (!r)
          break;

      if (r < 0) {
          switch (errno(*__errno_location ())) {
          case EAGAIN11:
              break;
          case EINTR4:
              continue;
          default:
              return;
          }
      }

      coro_yield(conn->coro, CONN_CORO_WANT_READ);
  }

  /* close(2) will be called when the coroutine yields with CONN_CORO_ABORT */
106}

108#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION)
109static void lwan_random_seed_prng_for_thread(const struct lwan_thread *t)
110{
  (void)t;
112}

114uint64_t lwan_random_uint64()
115{
  static uint64_t value;

  return ATOMIC_INC(value)(__sync_add_and_fetch(((&(value))), ((1))));
119}
120#else
121static __thread __uint128_t lehmer64_state;

123static void lwan_random_seed_prng_for_thread(const struct lwan_thread *t)
124{
  if (lwan_getentropy(&lehmer64_state, sizeof(lehmer64_state), 0) < 0) {
      lwan_status_warning("Couldn't get proper entropy for PRNG, using fallback seed")lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 126, __FUNCTION__, "Couldn't get proper entropy for PRNG, using fallback seed"
);
      lehmer64_state |= murmur3_fmix64((uint64_t)(uintptr_t)t);
      lehmer64_state <<= 64;
      lehmer64_state |= murmur3_fmix64((uint64_t)t->epoll_fd);
  }
131}

133uint64_t lwan_random_uint64()
134{
  /* https://lemire.me/blog/2019/03/19/the-fastest-conventional-random-number-generator-that-can-pass-big-crush/ */
  lehmer64_state *= 0xda942042e4dd58b5ull;
  return (uint64_t)(lehmer64_state >> 64);
138}
139#endif

141uint64_t lwan_request_get_id(struct lwan_request *request)
142{
  struct lwan_request_parser_helper *helper = request->helper;

  if (helper->request_id == 0)
      helper->request_id = lwan_random_uint64();

  return helper->request_id;
149}

151#if defined(HAVE_MBEDTLS)
152static bool_Bool
153lwan_setup_tls_keys(int fd, const mbedtls_ssl_context *ssl, int rx_or_tx)
154{
  struct tls12_crypto_info_aes_gcm_128 info = {
      .info = {.version = TLS_1_2_VERSION((((0x3) & 0xFF) << 8) | ((0x3) & 0xFF)),
               .cipher_type = TLS_CIPHER_AES_GCM_12851},
  };
  const unsigned char *salt, *iv, *rec_seq;
  const mbedtls_gcm_context *gcm_ctx;
  const mbedtls_aes_context *aes_ctx;

  switch (rx_or_tx) {
  case TLS_RX2:
      salt = ssl->transform->iv_dec;
      rec_seq = ssl->in_ctr;
      gcm_ctx = ssl->transform->cipher_ctx_dec.cipher_ctx;
      break;
  case TLS_TX1:
      salt = ssl->transform->iv_enc;
      rec_seq = ssl->cur_out_ctr;
      gcm_ctx = ssl->transform->cipher_ctx_enc.cipher_ctx;
      break;
  default:
      __builtin_unreachable();
  }

  iv = salt + 4;
  aes_ctx = gcm_ctx->cipher_ctx.cipher_ctx;

  memcpy(info.iv, iv, TLS_CIPHER_AES_GCM_128_IV_SIZE8);
  memcpy(info.rec_seq, rec_seq, TLS_CIPHER_AES_GCM_128_REC_SEQ_SIZE8);
  memcpy(info.key, aes_ctx->rk, TLS_CIPHER_AES_GCM_128_KEY_SIZE16);
  memcpy(info.salt, salt, TLS_CIPHER_AES_GCM_128_SALT_SIZE4);

  if (UNLIKELY(setsockopt(fd, SOL_TLS, rx_or_tx, &info, sizeof(info)) < 0)__builtin_expect(((setsockopt(fd, 282, rx_or_tx, &info, sizeof
(info)) < 0)), (0))) {
      lwan_status_perror("Could not set %s kTLS keys for fd %d",lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 189, __FUNCTION__, "Could not set %s kTLS keys for fd %d", rx_or_tx
 == 1 ? "transmission" : "reception", fd)
                         rx_or_tx == TLS_TX ? "transmission" : "reception",lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 189, __FUNCTION__, "Could not set %s kTLS keys for fd %d", rx_or_tx
 == 1 ? "transmission" : "reception", fd)
                         fd)lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 189, __FUNCTION__, "Could not set %s kTLS keys for fd %d", rx_or_tx
 == 1 ? "transmission" : "reception", fd);
      lwan_always_bzero(&info, sizeof(info));
      return false0;
  }

  lwan_always_bzero(&info, sizeof(info));
  return true1;
196}

198__attribute__((format(printf, 2, 3)))
199__attribute__((noinline, cold))
200static void lwan_status_mbedtls_error(int error_code, const char *fmt, ...)
201{
  char *formatted;
  va_list ap;
  int r;

  va_start(ap, fmt)__builtin_va_start(ap, fmt);
  r = vasprintf(&formatted, fmt, ap);
  if (r >= 0) {
      char mbedtls_errbuf[128];

      mbedtls_strerror(error_code, mbedtls_errbuf, sizeof(mbedtls_errbuf));
      lwan_status_error("%s: %s", formatted, mbedtls_errbuf)lwan_status_error_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 212, __FUNCTION__, "%s: %s", formatted, mbedtls_errbuf);
      free(formatted);
  }
  va_end(ap)__builtin_va_end(ap);
216}

218static void lwan_setup_tls_free_ssl_context(void *data)
219{
  mbedtls_ssl_context *ssl = data;

  mbedtls_ssl_free(ssl);
223}

225struct lwan_mbedtls_handshake_ctx {
  int fd;
  bool_Bool last_was_send;
228};

230static int lwan_mbedtls_send(void *ctx, const unsigned char *buf, size_t len)
231{
  struct lwan_mbedtls_handshake_ctx *hs_ctx = ctx;
  ssize_t r;

  /* We use MSG_MORE -- flushing when we transition from send() to recv()
   * -- rather than buffering on our side because this contains key
   * material that we would need to only copy, but also zero out after
   * finishing the handshake.  */

  r = send(hs_ctx->fd, buf, len, MSG_MOREMSG_MORE);
  if (UNLIKELY(r < 0)__builtin_expect(((r < 0)), (0))) {
      switch (errno(*__errno_location ())) {
      case EINTR4:
      case EAGAIN11:
          return MBEDTLS_ERR_SSL_WANT_WRITE-0x6880;

      default:
          /* It's not an internal error here, but this seemed the least
           * innapropriate error code for this situation.  lwan_setup_tls()
           * doesn't care. */
          return MBEDTLS_ERR_SSL_INTERNAL_ERROR-0x6C00;
      }
  }

  if (UNLIKELY((ssize_t)(int)r != r)__builtin_expect((((ssize_t)(int)r != r)), (0)))
      return MBEDTLS_ERR_SSL_INTERNAL_ERROR-0x6C00;

  hs_ctx->last_was_send = true1;
  return (int)r;
260}

262static void flush_pending_output(int fd)
263{
  int zero = 0;
  setsockopt(fd, SOL_TCP6, TCP_CORK3, &zero, sizeof(zero));
266}

268static int lwan_mbedtls_recv(void *ctx, unsigned char *buf, size_t len)
269{
  struct lwan_mbedtls_handshake_ctx *hs_ctx = ctx;
  ssize_t r;

  if (hs_ctx->last_was_send)
      flush_pending_output(hs_ctx->fd);

  r = recv(hs_ctx->fd, buf, len, 0);
  if (UNLIKELY(r < 0)__builtin_expect(((r < 0)), (0))) {
      switch (errno(*__errno_location ())) {
      case EINTR4:
      case EAGAIN11:
          return MBEDTLS_ERR_SSL_WANT_READ-0x6900;

      default:
          return MBEDTLS_ERR_SSL_INTERNAL_ERROR-0x6C00;
      }
  }

  if (UNLIKELY((ssize_t)(int)r != r)__builtin_expect((((ssize_t)(int)r != r)), (0)))
      return MBEDTLS_ERR_SSL_INTERNAL_ERROR-0x6C00;

  hs_ctx->last_was_send = false0;
  return (int)r;
293}

295static bool_Bool lwan_setup_tls(const struct lwan *l, struct lwan_connection *conn)
296{
  mbedtls_ssl_context ssl;
  bool_Bool retval = false0;
  int r;

  mbedtls_ssl_init(&ssl);

  r = mbedtls_ssl_setup(&ssl, &l->tls->config);
  if (UNLIKELY(r != 0)__builtin_expect(((r != 0)), (0))) {
      lwan_status_mbedtls_error(r, "Could not setup TLS context");
      return false0;
  }

  /* Yielding the coroutine during the handshake enables the I/O loop to
   * destroy this coro (e.g.  on connection hangup) before we have the
   * opportunity to free the SSL context.  Defer this call for these
   * cases. */
  struct coro_defer *defer =
      coro_defer(conn->coro, lwan_setup_tls_free_ssl_context, &ssl);

  if (UNLIKELY(!defer)__builtin_expect(((!defer)), (0))) {
      lwan_status_error("Could not defer cleanup of the TLS context")lwan_status_error_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 317, __FUNCTION__, "Could not defer cleanup of the TLS context"
);
      return false0;
  }

  int fd = lwan_connection_get_fd(l, conn);

  struct lwan_mbedtls_handshake_ctx ctx = { .fd = fd };
  mbedtls_ssl_set_bio(&ssl, &ctx, lwan_mbedtls_send,
                      lwan_mbedtls_recv, NULL((void*)0));

  while (true1) {
      switch (mbedtls_ssl_handshake(&ssl)) {
      case 0:
          flush_pending_output(fd);
          goto enable_tls_ulp;
      case MBEDTLS_ERR_SSL_ASYNC_IN_PROGRESS-0x6500:
      case MBEDTLS_ERR_SSL_CRYPTO_IN_PROGRESS-0x7000:
      case MBEDTLS_ERR_SSL_WANT_READ-0x6900:
          coro_yield(conn->coro, CONN_CORO_WANT_READ);
          break;
      case MBEDTLS_ERR_SSL_WANT_WRITE-0x6880:
          coro_yield(conn->coro, CONN_CORO_WANT_WRITE);
          break;
      default:
          goto fail;
      }
  }

345enable_tls_ulp:
  if (UNLIKELY(setsockopt(fd, SOL_TCP, TCP_ULP, "tls", sizeof("tls")) < 0)__builtin_expect(((setsockopt(fd, 6, 31, "tls", sizeof("tls")
) < 0)), (0)))
      goto fail;
  if (UNLIKELY(!lwan_setup_tls_keys(fd, &ssl, TLS_RX))__builtin_expect(((!lwan_setup_tls_keys(fd, &ssl, 2))), (
0)))
      goto fail;
  if (UNLIKELY(!lwan_setup_tls_keys(fd, &ssl, TLS_TX))__builtin_expect(((!lwan_setup_tls_keys(fd, &ssl, 1))), (
0)))
      goto fail;

  retval = true1;

355fail:
  coro_defer_disarm(conn->coro, defer);
  mbedtls_ssl_free(&ssl);
  return retval;
359}
360#endif

362__attribute__((noreturn)) static int process_request_coro(struct coro *coro,
                                                        void *data)
364{
  /* NOTE: This function should not return; coro_yield should be used
   * instead.  This ensures the storage for `strbuf` is alive when the
   * coroutine ends and lwan_strbuf_free() is called. */
  struct lwan_connection *conn = data;
  struct lwan *lwan = conn->thread->lwan;
  int fd = lwan_connection_get_fd(lwan, conn);
  enum lwan_request_flags flags = lwan->config.request_flags;
  struct lwan_strbuf strbuf = LWAN_STRBUF_STATIC_INIT(struct lwan_strbuf) { .buffer = "" };
  char request_buffer[DEFAULT_BUFFER_SIZE4096];
  struct lwan_value buffer = {.value = request_buffer, .len = 0};
  char *next_request = NULL((void*)0);
  char *header_start[N_HEADER_START64];
  struct lwan_proxy proxy;
  const int error_when_n_packets = lwan_calculate_n_packets(DEFAULT_BUFFER_SIZE4096);

  coro_defer(coro, lwan_strbuf_free_defer, &strbuf);

  const size_t init_gen = 1; /* 1 call to coro_defer() */
  assert(init_gen == coro_deferred_get_generation(coro))((void) sizeof ((init_gen == coro_deferred_get_generation(coro
)) ? 1 : 0), __extension__ ({ if (init_gen == coro_deferred_get_generation
(coro)) ; else __assert_fail ("init_gen == coro_deferred_get_generation(coro)"
, "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 383, __extension__ __PRETTY_FUNCTION__); }));

385#if defined(HAVE_MBEDTLS)
  if (conn->flags & CONN_TLS) {
      if (UNLIKELY(!lwan_setup_tls(lwan, conn))__builtin_expect(((!lwan_setup_tls(lwan, conn))), (0))) {
          coro_yield(conn->coro, CONN_CORO_ABORT);
          __builtin_unreachable();
      }
  }
392#else
  assert(!(conn->flags & CONN_TLS))((void) sizeof ((!(conn->flags & CONN_TLS)) ? 1 : 0), __extension__
 ({ if (!(conn->flags & CONN_TLS)) ; else __assert_fail
 ("!(conn->flags & CONN_TLS)", "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 393, __extension__ __PRETTY_FUNCTION__); }));
394#endif

  while (true1) {
      struct lwan_request_parser_helper helper = {
          .buffer = &buffer,
          .next_request = next_request,
          .error_when_n_packets = error_when_n_packets,
          .header_start = header_start,
      };
      struct lwan_request request = {.conn = conn,
                                     .global_response_headers = &lwan->headers,
                                     .fd = fd,
                                     .response = {.buffer = &strbuf},
                                     .flags = flags,
                                     .proxy = &proxy,
                                     .helper = &helper};

      lwan_process_request(lwan, &request);

      /* Run the deferred instructions now (except those used to initialize
       * the coroutine), so that if the connection is gracefully closed,
       * the storage for ``helper'' is still there. */
      coro_deferred_run(coro, init_gen);

      if (UNLIKELY(!(conn->flags & CONN_IS_KEEP_ALIVE))__builtin_expect(((!(conn->flags & CONN_IS_KEEP_ALIVE)
)), (0))) {
          graceful_close(lwan, conn, request_buffer);
          break;
      }

      if (next_request && *next_request) {
          conn->flags |= CONN_CORK;

          if (!(conn->flags & CONN_EVENTS_WRITE))
              coro_yield(coro, CONN_CORO_WANT_WRITE);
      } else {
          conn->flags &= ~CONN_CORK;
          coro_yield(coro, CONN_CORO_WANT_READ);
      }

      /* Ensure string buffer is reset between requests, and that the backing
       * store isn't over 2KB. */
      lwan_strbuf_reset_trim(&strbuf, 2048);

      /* Only allow flags from config. */
      flags = request.flags & (REQUEST_PROXIED | REQUEST_ALLOW_CORS | REQUEST_WANTS_HSTS_HEADER);
      next_request = helper.next_request;
  }

  coro_yield(coro, CONN_CORO_ABORT);
  __builtin_unreachable();
444}

446static ALWAYS_INLINEinline __attribute__((always_inline)) uint32_t
447conn_flags_to_epoll_events(enum lwan_connection_flags flags)
448{
  static const uint32_t map[CONN_EVENTS_MASK + 1] = {
      [0 /* Suspended (timer or await) */] = EPOLLRDHUPEPOLLRDHUP,
      [CONN_EVENTS_WRITE] = EPOLLOUTEPOLLOUT | EPOLLRDHUPEPOLLRDHUP,
      [CONN_EVENTS_READ] = EPOLLINEPOLLIN | EPOLLRDHUPEPOLLRDHUP,
      [CONN_EVENTS_READ_WRITE] = EPOLLINEPOLLIN | EPOLLOUTEPOLLOUT | EPOLLRDHUPEPOLLRDHUP,
  };

  return map[flags & CONN_EVENTS_MASK];
457}

459static void update_epoll_flags(int fd,
                             struct lwan_connection *conn,
                             int epoll_fd,
                             enum lwan_connection_coro_yield yield_result)
463{
  static const enum lwan_connection_flags or_mask[CONN_CORO_MAX] = {
      [CONN_CORO_YIELD] = 0,

      [CONN_CORO_WANT_READ_WRITE] = CONN_EVENTS_READ_WRITE,
      [CONN_CORO_WANT_READ] = CONN_EVENTS_READ,
      [CONN_CORO_WANT_WRITE] = CONN_EVENTS_WRITE,

      /* While the coro is suspended, we're not interested in either EPOLLIN
       * or EPOLLOUT events.  We still want to track this fd in epoll, though,
       * so unset both so that only EPOLLRDHUP (plus the implicitly-set ones)
       * are set. */
      [CONN_CORO_SUSPEND] = CONN_SUSPENDED,

      /* Ideally, when suspending a coroutine, the current flags&CONN_EVENTS_MASK
       * would have to be stored and restored -- however, resuming as if the
       * client coroutine is interested in a write event always guarantees that
       * they'll be resumed as they're TCP sockets.  There's a good chance that
       * trying to read from a socket after resuming a coroutine will succeed,
       * but if it doesn't because read() returns -EAGAIN, the I/O wrappers will
       * yield with CONN_CORO_WANT_READ anyway.  */
      [CONN_CORO_RESUME] = CONN_EVENTS_WRITE,
  };
  static const enum lwan_connection_flags and_mask[CONN_CORO_MAX] = {
      [CONN_CORO_YIELD] = ~0,

      [CONN_CORO_WANT_READ_WRITE] = ~0,
      [CONN_CORO_WANT_READ] = ~CONN_EVENTS_WRITE,
      [CONN_CORO_WANT_WRITE] = ~CONN_EVENTS_READ,

      [CONN_CORO_SUSPEND] = ~CONN_EVENTS_READ_WRITE,
      [CONN_CORO_RESUME] = ~CONN_SUSPENDED,
  };
  enum lwan_connection_flags prev_flags = conn->flags;

  conn->flags |= or_mask[yield_result];
  conn->flags &= and_mask[yield_result];

  assert(!(conn->flags & (CONN_LISTENER_HTTP | CONN_LISTENER_HTTPS)))((void) sizeof ((!(conn->flags & (CONN_LISTENER_HTTP |
 CONN_LISTENER_HTTPS))) ? 1 : 0), __extension__ ({ if (!(conn
->flags & (CONN_LISTENER_HTTP | CONN_LISTENER_HTTPS)))
 ; else __assert_fail ("!(conn->flags & (CONN_LISTENER_HTTP | CONN_LISTENER_HTTPS))"
, "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 501, __extension__ __PRETTY_FUNCTION__); }));
  assert((conn->flags & CONN_TLS) == (prev_flags & CONN_TLS))((void) sizeof (((conn->flags & CONN_TLS) == (prev_flags
 & CONN_TLS)) ? 1 : 0), __extension__ ({ if ((conn->flags
 & CONN_TLS) == (prev_flags & CONN_TLS)) ; else __assert_fail
 ("(conn->flags & CONN_TLS) == (prev_flags & CONN_TLS)"
, "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 502, __extension__ __PRETTY_FUNCTION__); }));

  if (conn->flags == prev_flags)
      return;

  struct epoll_event event = {
      .events = conn_flags_to_epoll_events(conn->flags),
      .data.ptr = conn,
  };

  if (UNLIKELY(epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fd, &event) < 0)__builtin_expect(((epoll_ctl(epoll_fd, 3, fd, &event) <
 0)), (0)))
      lwan_status_perror("epoll_ctl")lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 513, __FUNCTION__, "epoll_ctl");
514}

516static void clear_async_await_flag(void *data)
517{
  struct lwan_connection *async_fd_conn = data;

  async_fd_conn->flags &= ~CONN_ASYNC_AWAIT;
521}

523static enum lwan_connection_coro_yield
524resume_async(struct timeout_queue *tq,
           enum lwan_connection_coro_yield yield_result,
           int64_t from_coro,
           struct lwan_connection *conn,
           int epoll_fd)
529{
  static const enum lwan_connection_flags to_connection_flags[] = {
      [CONN_CORO_ASYNC_AWAIT_READ] = CONN_EVENTS_READ,
      [CONN_CORO_ASYNC_AWAIT_WRITE] = CONN_EVENTS_WRITE,
      [CONN_CORO_ASYNC_AWAIT_READ_WRITE] = CONN_EVENTS_READ_WRITE,
  };
  int await_fd = (int)((uint64_t)from_coro >> 32);
  enum lwan_connection_flags flags;
  int op;

  assert(await_fd >= 0)((void) sizeof ((await_fd >= 0) ? 1 : 0), __extension__ ({
 if (await_fd >= 0) ; else __assert_fail ("await_fd >= 0"
, "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 539, __extension__ __PRETTY_FUNCTION__); }));
  assert(yield_result >= CONN_CORO_ASYNC_AWAIT_READ &&((void) sizeof ((yield_result >= CONN_CORO_ASYNC_AWAIT_READ
 && yield_result <= CONN_CORO_ASYNC_AWAIT_READ_WRITE
) ? 1 : 0), __extension__ ({ if (yield_result >= CONN_CORO_ASYNC_AWAIT_READ
 && yield_result <= CONN_CORO_ASYNC_AWAIT_READ_WRITE
) ; else __assert_fail ("yield_result >= CONN_CORO_ASYNC_AWAIT_READ && yield_result <= CONN_CORO_ASYNC_AWAIT_READ_WRITE"
, "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 541, __extension__ __PRETTY_FUNCTION__); }))
         yield_result <= CONN_CORO_ASYNC_AWAIT_READ_WRITE)((void) sizeof ((yield_result >= CONN_CORO_ASYNC_AWAIT_READ
 && yield_result <= CONN_CORO_ASYNC_AWAIT_READ_WRITE
) ? 1 : 0), __extension__ ({ if (yield_result >= CONN_CORO_ASYNC_AWAIT_READ
 && yield_result <= CONN_CORO_ASYNC_AWAIT_READ_WRITE
) ; else __assert_fail ("yield_result >= CONN_CORO_ASYNC_AWAIT_READ && yield_result <= CONN_CORO_ASYNC_AWAIT_READ_WRITE"
, "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 541, __extension__ __PRETTY_FUNCTION__); }));

  flags = to_connection_flags[yield_result];

  struct lwan_connection *await_fd_conn = &tq->lwan->conns[await_fd];
  if (LIKELY(await_fd_conn->flags & CONN_ASYNC_AWAIT)__builtin_expect((!!(await_fd_conn->flags & CONN_ASYNC_AWAIT
)), (1))) {
      if (LIKELY((await_fd_conn->flags & CONN_EVENTS_MASK) == flags)__builtin_expect((!!((await_fd_conn->flags & CONN_EVENTS_MASK
) == flags)), (1)))
          return CONN_CORO_SUSPEND;

      op = EPOLL_CTL_MOD3;
  } else {
      op = EPOLL_CTL_ADD1;
      flags |= CONN_ASYNC_AWAIT;
      coro_defer(conn->coro, clear_async_await_flag, await_fd_conn);
  }

  struct epoll_event event = {.events = conn_flags_to_epoll_events(flags),
                              .data.ptr = conn};
  if (LIKELY(!epoll_ctl(epoll_fd, op, await_fd, &event))__builtin_expect((!!(!epoll_ctl(epoll_fd, op, await_fd, &
event))), (1))) {
      await_fd_conn->flags &= ~CONN_EVENTS_MASK;
      await_fd_conn->flags |= flags;
      return CONN_CORO_SUSPEND;
  }

  return CONN_CORO_ABORT;
566}

568static ALWAYS_INLINEinline __attribute__((always_inline)) void resume_coro(struct timeout_queue *tq,
                                    struct lwan_connection *conn,
                                    int epoll_fd)
571{
  assert(conn->coro)((void) sizeof ((conn->coro) ? 1 : 0), __extension__ ({ if
 (conn->coro) ; else __assert_fail ("conn->coro", "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 572, __extension__ __PRETTY_FUNCTION__); }));

  int64_t from_coro = coro_resume(conn->coro);
  enum lwan_connection_coro_yield yield_result = from_coro & 0xffffffff;

  if (UNLIKELY(yield_result >= CONN_CORO_ASYNC)__builtin_expect(((yield_result >= CONN_CORO_ASYNC)), (0)))
      yield_result = resume_async(tq, yield_result, from_coro, conn, epoll_fd);

  if (UNLIKELY(yield_result == CONN_CORO_ABORT)__builtin_expect(((yield_result == CONN_CORO_ABORT)), (0)))
      return timeout_queue_expire(tq, conn);

  return update_epoll_flags(lwan_connection_get_fd(tq->lwan, conn), conn,
                            epoll_fd, yield_result);
585}

587static void update_date_cache(struct lwan_thread *thread)
588{
  time_t now = time(NULL((void*)0));

  lwan_format_rfc_time(now, thread->date.date);
  lwan_format_rfc_time(now + (time_t)thread->lwan->config.expires,
                       thread->date.expires);
594}

596__attribute__((cold))
597static bool_Bool send_buffer_without_coro(int fd, const char *buf, size_t buf_len, int flags)
598{
  size_t total_sent = 0;

  for (int try = 0; try < 10; try++) {
      size_t to_send = buf_len - total_sent;
      if (!to_send)
          return true1;

      ssize_t sent = send(fd, buf + total_sent, to_send, flags);
      if (sent <= 0) {
          if (errno(*__errno_location ()) == EINTR4)
              continue;
          if (errno(*__errno_location ()) == EAGAIN11)
              continue;
          break;
      }

      total_sent += (size_t)sent;
  }

  return false0;
619}

621__attribute__((cold))
622static bool_Bool send_string_without_coro(int fd, const char *str, int flags)
623{
  return send_buffer_without_coro(fd, str, strlen(str), flags);
625}

627__attribute__((cold)) static void
628send_last_response_without_coro(const struct lwan *l,
                              const struct lwan_connection *conn,
                              enum lwan_http_status status)
631{
  int fd = lwan_connection_get_fd(l, conn);

  if (conn->flags & CONN_TLS) {
      /* There's nothing that can be done here if a client is expecting a
       * TLS connection: the TLS handshake requires a coroutine as it
       * might yield.  (In addition, the TLS handshake might allocate
       * memory, and if you couldn't create a coroutine at this point,
       * it's unlikely you'd be able to allocate memory for the TLS
       * context anyway.) */
      goto shutdown_and_close;
  }

  if (!send_string_without_coro(fd, "HTTP/1.0 ", MSG_MOREMSG_MORE))
      goto shutdown_and_close;

  if (!send_string_without_coro(
          fd, lwan_http_status_as_string_with_code(status), MSG_MOREMSG_MORE))
      goto shutdown_and_close;

  if (!send_string_without_coro(fd, "\r\nConnection: close", MSG_MOREMSG_MORE))
      goto shutdown_and_close;

  if (!send_string_without_coro(fd, "\r\nContent-Type: text/html", MSG_MOREMSG_MORE))
      goto shutdown_and_close;

  if (send_buffer_without_coro(fd, l->headers.value, l->headers.len,
                               MSG_MOREMSG_MORE)) {
      struct lwan_strbuf buffer;

      lwan_strbuf_init(&buffer);
      lwan_fill_default_response(&buffer, status);

      send_buffer_without_coro(fd, lwan_strbuf_get_buffer(&buffer),
                               lwan_strbuf_get_length(&buffer), 0);

      lwan_strbuf_free(&buffer);
  }

670shutdown_and_close:
  shutdown(fd, SHUT_RDWRSHUT_RDWR);
  close(fd);
673}

675static ALWAYS_INLINEinline __attribute__((always_inline)) bool_Bool spawn_coro(struct lwan_connection *conn,
                                   struct coro_switcher *switcher,
                                   struct timeout_queue *tq)
678{
  struct lwan_thread *t = conn->thread;
680#if defined(HAVE_MBEDTLS)
  const enum lwan_connection_flags flags_to_keep = conn->flags & CONN_TLS;
682#else
  const enum lwan_connection_flags flags_to_keep = 0;
684#endif

  assert(!conn->coro)((void) sizeof ((!conn->coro) ? 1 : 0), __extension__ ({ if
 (!conn->coro) ; else __assert_fail ("!conn->coro", "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 686, __extension__ __PRETTY_FUNCTION__); }));
  assert(!(conn->flags & CONN_ASYNC_AWAIT))((void) sizeof ((!(conn->flags & CONN_ASYNC_AWAIT)) ? 1
 : 0), __extension__ ({ if (!(conn->flags & CONN_ASYNC_AWAIT
)) ; else __assert_fail ("!(conn->flags & CONN_ASYNC_AWAIT)"
, "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 687, __extension__ __PRETTY_FUNCTION__); }));
  assert(t)((void) sizeof ((t) ? 1 : 0), __extension__ ({ if (t) ; else __assert_fail
 ("t", "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 688, __extension__ __PRETTY_FUNCTION__); }));
  assert((uintptr_t)t >= (uintptr_t)tq->lwan->thread.threads)((void) sizeof (((uintptr_t)t >= (uintptr_t)tq->lwan->
thread.threads) ? 1 : 0), __extension__ ({ if ((uintptr_t)t >=
 (uintptr_t)tq->lwan->thread.threads) ; else __assert_fail
 ("(uintptr_t)t >= (uintptr_t)tq->lwan->thread.threads"
, "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 689, __extension__ __PRETTY_FUNCTION__); }));
  assert((uintptr_t)t <((void) sizeof (((uintptr_t)t < (uintptr_t)(tq->lwan->
thread.threads + tq->lwan->thread.count)) ? 1 : 0), __extension__
 ({ if ((uintptr_t)t < (uintptr_t)(tq->lwan->thread.
threads + tq->lwan->thread.count)) ; else __assert_fail
 ("(uintptr_t)t < (uintptr_t)(tq->lwan->thread.threads + tq->lwan->thread.count)"
, "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 691, __extension__ __PRETTY_FUNCTION__); }))
         (uintptr_t)(tq->lwan->thread.threads + tq->lwan->thread.count))((void) sizeof (((uintptr_t)t < (uintptr_t)(tq->lwan->
thread.threads + tq->lwan->thread.count)) ? 1 : 0), __extension__
 ({ if ((uintptr_t)t < (uintptr_t)(tq->lwan->thread.
threads + tq->lwan->thread.count)) ; else __assert_fail
 ("(uintptr_t)t < (uintptr_t)(tq->lwan->thread.threads + tq->lwan->thread.count)"
, "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 691, __extension__ __PRETTY_FUNCTION__); }));

  *conn = (struct lwan_connection){
      .coro = coro_new(switcher, process_request_coro, conn),
      .flags = CONN_EVENTS_READ | flags_to_keep,
      .time_to_expire = tq->current_time + tq->move_to_last_bump,
      .thread = t,
  };
  if (LIKELY(conn->coro)__builtin_expect((!!(conn->coro)), (1))) {
      timeout_queue_insert(tq, conn);
      return true1;
  }

  conn->flags = 0;

  int fd = lwan_connection_get_fd(tq->lwan, conn);

  lwan_status_error("Couldn't spawn coroutine for file descriptor %d", fd)lwan_status_error_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 708, __FUNCTION__, "Couldn't spawn coroutine for file descriptor %d"
, fd);

  send_last_response_without_coro(tq->lwan, conn, HTTP_UNAVAILABLE);
  return false0;
712}

714static bool_Bool process_pending_timers(struct timeout_queue *tq,
                                 struct lwan_thread *t,
                                 int epoll_fd)
717{
  struct timeout *timeout;
  bool_Bool should_expire_timers = false0;

  while ((timeout = timeouts_get(t->wheel))) {
      struct lwan_request *request;

      if (timeout == &tq->timeout) {
          should_expire_timers = true1;
          continue;
      }

      request = container_of(timeout, struct lwan_request, timeout)((struct lwan_request *) ((char *)(timeout) - __builtin_offsetof
(struct lwan_request, timeout)) + ((typeof(*(timeout)) *)0 !=
 (typeof(((struct lwan_request *)0)->timeout) *)0));

      update_epoll_flags(request->fd, request->conn, epoll_fd,
                         CONN_CORO_RESUME);
  }

  if (should_expire_timers) {
      timeout_queue_expire_waiting(tq);

      /* tq timeout expires every 1000ms if there are connections, so
       * update the date cache at this point as well.  */
      update_date_cache(t);

      if (!timeout_queue_empty(tq)) {
          timeouts_add(t->wheel, &tq->timeout, 1000);
          return true1;
      }

      timeouts_del(t->wheel, &tq->timeout);
  }

  return false0;
751}

753static int
754turn_timer_wheel(struct timeout_queue *tq, struct lwan_thread *t, int epoll_fd)
755{
  const int infinite_timeout = -1;
  timeout_t wheel_timeout;
  struct timespec now;

  if (UNLIKELY(clock_gettime(monotonic_clock_id, &now) < 0)__builtin_expect(((clock_gettime(monotonic_clock_id, &now
) < 0)), (0)))
      lwan_status_critical("Could not get monotonic time")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 761, __FUNCTION__, "Could not get monotonic time");

  timeouts_update(t->wheel,
                  (timeout_t)(now.tv_sec * 1000 + now.tv_nsec / 1000000));

  /* Check if there's an expired timer. */
  wheel_timeout = timeouts_timeout(t->wheel);
  if (wheel_timeout > 0) {
      return (int)wheel_timeout; /* No, but will soon. Wake us up in
                                    wheel_timeout ms. */
  }

  if (UNLIKELY((int64_t)wheel_timeout < 0)__builtin_expect((((int64_t)wheel_timeout < 0)), (0)))
      return infinite_timeout; /* None found. */

  if (!process_pending_timers(tq, t, epoll_fd))
      return infinite_timeout; /* No more timers to process. */

  /* After processing pending timers, determine when to wake up. */
  return (int)timeouts_timeout(t->wheel);
781}

783static bool_Bool accept_waiting_clients(const struct lwan_thread *t,
                                 const struct lwan_connection *listen_socket)
785{
  const uint32_t read_events = conn_flags_to_epoll_events(CONN_EVENTS_READ);
  struct lwan_connection *conns = t->lwan->conns;
  int listen_fd = (int)(intptr_t)(listen_socket - conns);
  enum lwan_connection_flags new_conn_flags = 0;

791#if defined(HAVE_MBEDTLS)
  if (listen_socket->flags & CONN_LISTENER_HTTPS) {
      assert(listen_fd == t->tls_listen_fd)((void) sizeof ((listen_fd == t->tls_listen_fd) ? 1 : 0), __extension__
 ({ if (listen_fd == t->tls_listen_fd) ; else __assert_fail
 ("listen_fd == t->tls_listen_fd", "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 793, __extension__ __PRETTY_FUNCTION__); }));
      assert(!(listen_socket->flags & CONN_LISTENER_HTTP))((void) sizeof ((!(listen_socket->flags & CONN_LISTENER_HTTP
)) ? 1 : 0), __extension__ ({ if (!(listen_socket->flags &
 CONN_LISTENER_HTTP)) ; else __assert_fail ("!(listen_socket->flags & CONN_LISTENER_HTTP)"
, "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 794, __extension__ __PRETTY_FUNCTION__); }));
      new_conn_flags = CONN_TLS;
  } else {
      assert(listen_fd == t->listen_fd)((void) sizeof ((listen_fd == t->listen_fd) ? 1 : 0), __extension__
 ({ if (listen_fd == t->listen_fd) ; else __assert_fail ("listen_fd == t->listen_fd"
, "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 797, __extension__ __PRETTY_FUNCTION__); }));
      assert(listen_socket->flags & CONN_LISTENER_HTTP)((void) sizeof ((listen_socket->flags & CONN_LISTENER_HTTP
) ? 1 : 0), __extension__ ({ if (listen_socket->flags &
 CONN_LISTENER_HTTP) ; else __assert_fail ("listen_socket->flags & CONN_LISTENER_HTTP"
, "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 798, __extension__ __PRETTY_FUNCTION__); }));
  }
800#endif

  while (true1) {
      int fd = accept4(listen_fd, NULL((void*)0), NULL((void*)0), SOCK_NONBLOCKSOCK_NONBLOCK | SOCK_CLOEXECSOCK_CLOEXEC);

      if (LIKELY(fd >= 0)__builtin_expect((!!(fd >= 0)), (1))) {
          struct lwan_connection *conn = &conns[fd];
          struct epoll_event ev = {.data.ptr = conn, .events = read_events};
          int r;

          conn->flags = new_conn_flags;

          r = epoll_ctl(conn->thread->epoll_fd, EPOLL_CTL_ADD1, fd, &ev);
          if (UNLIKELY(r < 0)__builtin_expect(((r < 0)), (0))) {
              lwan_status_perror("Could not add file descriptor %d to epoll "lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 816, __FUNCTION__, "Could not add file descriptor %d to epoll "
 "set %d. Dropping connection", fd, conn->thread->epoll_fd
)
                                 "set %d. Dropping connection",lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 816, __FUNCTION__, "Could not add file descriptor %d to epoll "
 "set %d. Dropping connection", fd, conn->thread->epoll_fd
)
                                 fd, conn->thread->epoll_fd)lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 816, __FUNCTION__, "Could not add file descriptor %d to epoll "
 "set %d. Dropping connection", fd, conn->thread->epoll_fd
);
              send_last_response_without_coro(t->lwan, conn, HTTP_UNAVAILABLE);
              conn->flags = 0;
          }

          continue;
      }

      switch (errno(*__errno_location ())) {
      default:
          lwan_status_perror("Unexpected error while accepting connections")lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 826, __FUNCTION__, "Unexpected error while accepting connections"
);
          /* fallthrough */

      case EAGAIN11:
          return true1;

      case EBADF9:
      case ECONNABORTED103:
      case EINVAL22:
          lwan_status_info("Listening socket closed")lwan_status_info_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 835, __FUNCTION__, "Listening socket closed");
          return false0;
      }
  }

  __builtin_unreachable();
841}

843static int create_listen_socket(struct lwan_thread *t,
                              unsigned int num,
                              bool_Bool tls)
846{
  const struct lwan *lwan = t->lwan;
  int listen_fd;

  listen_fd = lwan_create_listen_socket(lwan, num == 0, tls);
  if (listen_fd < 0)
      lwan_status_critical("Could not create listen_fd")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 852, __FUNCTION__, "Could not create listen_fd");

   /* Ignore errors here, as this is just a hint */
855#if defined(HAVE_SO_ATTACH_REUSEPORT_CBPF)
  /* From socket(7): "These  options may be set repeatedly at any time on
   * any socket in the group to replace the current BPF program used by
   * all sockets in the group." */
  if (num == 0) {
      /* From socket(7): "The  BPF program must return an index between 0 and
       * N-1 representing the socket which should receive the packet (where N
       * is the number of sockets in the group)." */
      const uint32_t cpu_ad_off = (uint32_t)SKF_AD_OFF(-0x1000) + SKF_AD_CPU36;
      struct sock_filter filter[] = {
          {BPF_LD0x00 | BPF_W0x00 | BPF_ABS0x20, 0, 0, cpu_ad_off},   /* A = curr_cpu_index */
          {BPF_RET0x06 | BPF_A0x10, 0, 0, 0},                     /* return A */
      };
      struct sock_fprog fprog = {.filter = filter, .len = N_ELEMENTS(filter)((!sizeof(char[1 - 2 * __builtin_types_compatible_p( __typeof__
(filter), __typeof__(&(filter)[0]))])) | sizeof(filter) /
 sizeof(filter[0]))};

      (void)setsockopt(listen_fd, SOL_SOCKET1, SO_ATTACH_REUSEPORT_CBPF51,
                       &fprog, sizeof(fprog));
      (void)setsockopt(listen_fd, SOL_SOCKET1, SO_LOCK_FILTER44,
                       (int[]){1}, sizeof(int));
  }
875#elif defined(HAVE_SO_INCOMING_CPU) && defined(__x86_64__1)
  (void)setsockopt(listen_fd, SOL_SOCKET1, SO_INCOMING_CPU49, &t->cpu,
                   sizeof(t->cpu));
878#endif

  struct epoll_event event = {
      .events = EPOLLINEPOLLIN | EPOLLETEPOLLET | EPOLLERREPOLLERR,
      .data.ptr = &t->lwan->conns[listen_fd],
  };
  if (epoll_ctl(t->epoll_fd, EPOLL_CTL_ADD1, listen_fd, &event) < 0)
      lwan_status_critical_perror("Could not add socket to epoll")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 885, __FUNCTION__, "Could not add socket to epoll");

  return listen_fd;
888}

890static void *thread_io_loop(void *data)
891{
  struct lwan_thread *t = data;
  int epoll_fd = t->epoll_fd;
  const int max_events = LWAN_MIN((int)t->lwan->thread.max_fd, 1024)({ const __typeof__(((int)t->lwan->thread.max_fd) + 0) lwan_tmp_id4
 = ((int)t->lwan->thread.max_fd); const __typeof__((1024
) + 0) lwan_tmp_id5 = (1024); lwan_tmp_id4 > lwan_tmp_id5 ?
 lwan_tmp_id5 : lwan_tmp_id4; });
  struct lwan *lwan = t->lwan;
  struct epoll_event *events;
  struct coro_switcher switcher;
  struct timeout_queue tq;

  lwan_status_debug("Worker thread #%zd starting",lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 901, __FUNCTION__, "Worker thread #%zd starting", t - t->
lwan->thread.threads + 1)
                    t - t->lwan->thread.threads + 1)lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 901, __FUNCTION__, "Worker thread #%zd starting", t - t->
lwan->thread.threads + 1);
  lwan_set_thread_name("worker");

  events = calloc((size_t)max_events, sizeof(*events));
  if (UNLIKELY(!events)__builtin_expect(((!events)), (0)))
      lwan_status_critical("Could not allocate memory for events")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 906, __FUNCTION__, "Could not allocate memory for events");

  update_date_cache(t);

  timeout_queue_init(&tq, lwan);

  lwan_random_seed_prng_for_thread(t);

  pthread_barrier_wait(&lwan->thread.barrier);

  for (;;) {
      int timeout = turn_timer_wheel(&tq, t, epoll_fd);
      int n_fds = epoll_wait(epoll_fd, events, max_events, timeout);
      bool_Bool accepted_connections = false0;

      if (UNLIKELY(n_fds < 0)__builtin_expect(((n_fds < 0)), (0))) {
          if (errno(*__errno_location ()) == EBADF9 || errno(*__errno_location ()) == EINVAL22)
              break;
          continue;
      }

      for (struct epoll_event *event = events; n_fds--; event++) {
          struct lwan_connection *conn = event->data.ptr;

          if (UNLIKELY(event->events & (EPOLLRDHUP | EPOLLHUP))__builtin_expect(((event->events & (EPOLLRDHUP | EPOLLHUP
))), (0))) {
              timeout_queue_expire(&tq, conn);
              continue;
          }

          if (conn->flags & (CONN_LISTENER_HTTP | CONN_LISTENER_HTTPS)) {
              if (LIKELY(accept_waiting_clients(t, conn))__builtin_expect((!!(accept_waiting_clients(t, conn))), (1))) {
                  accepted_connections = true1;
                  continue;
              }
              close(epoll_fd);
              epoll_fd = -1;
              break;
          }

          if (!conn->coro) {
              if (UNLIKELY(!spawn_coro(conn, &switcher, &tq))__builtin_expect(((!spawn_coro(conn, &switcher, &tq))
), (0))) {
                  send_last_response_without_coro(t->lwan, conn, HTTP_INTERNAL_ERROR);
                  continue;
              }
          }

          resume_coro(&tq, conn, epoll_fd);
          timeout_queue_move_to_last(&tq, conn);
      }

      if (accepted_connections)
          timeouts_add(t->wheel, &tq.timeout, 1000);
  }

  pthread_barrier_wait(&lwan->thread.barrier);

  timeout_queue_expire_all(&tq);
  free(events);

  return NULL((void*)0);
966}

968static void create_thread(struct lwan *l, struct lwan_thread *thread)
969{
  int ignore;
  pthread_attr_t attr;

  thread->lwan = l;

  thread->wheel = timeouts_open(&ignore);
  if (!thread->wheel)
      lwan_status_critical("Could not create timer wheel")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 977, __FUNCTION__, "Could not create timer wheel");

  if ((thread->epoll_fd = epoll_create1(EPOLL_CLOEXECEPOLL_CLOEXEC)) < 0)
      lwan_status_critical_perror("epoll_create")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 980, __FUNCTION__, "epoll_create");

  if (pthread_attr_init(&attr))
      lwan_status_critical_perror("pthread_attr_init")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 983, __FUNCTION__, "pthread_attr_init");

  if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEMPTHREAD_SCOPE_SYSTEM))
      lwan_status_critical_perror("pthread_attr_setscope")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 986, __FUNCTION__, "pthread_attr_setscope");

  if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLEPTHREAD_CREATE_JOINABLE))
      lwan_status_critical_perror("pthread_attr_setdetachstate")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 989, __FUNCTION__, "pthread_attr_setdetachstate");

  if (pthread_create(&thread->self, &attr, thread_io_loop, thread))
      lwan_status_critical_perror("pthread_create")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 992, __FUNCTION__, "pthread_create");

  if (pthread_attr_destroy(&attr))
      lwan_status_critical_perror("pthread_attr_destroy")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 995, __FUNCTION__, "pthread_attr_destroy");
996}

998#if defined(__linux__1) && defined(__x86_64__1)
999static bool_Bool read_cpu_topology(struct lwan *l, uint32_t siblings[])
1000{
  char path[PATH_MAX4096];

  for (uint32_t i = 0; i < l->available_cpus; i++)
      siblings[i] = 0xbebacafe;

  for (unsigned int i = 0; i < l->available_cpus; i++) {
      FILE *sib;
      uint32_t id, sibling;
      char separator;

      snprintf(path, sizeof(path),
               "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list",
               i);

      sib = fopen(path, "re");
      if (!sib) {
          lwan_status_warning("Could not open `%s` to determine CPU topology",lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1018, __FUNCTION__, "Could not open `%s` to determine CPU topology"
, path)
                              path)lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1018, __FUNCTION__, "Could not open `%s` to determine CPU topology"
, path);
          return false0;
      }

      switch (fscanf(sib, "%u%c%u", &id, &separator, &sibling)) {
      case 2: /* No SMT */
          siblings[i] = id;
          break;
      case 3: /* SMT */
          if (!(separator == ',' || separator == '-')) {
              lwan_status_critical("Expecting either ',' or '-' for sibling separator")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1028, __FUNCTION__, "Expecting either ',' or '-' for sibling separator"
);
              __builtin_unreachable();
          }

          siblings[i] = sibling;
          break;
      default:
          lwan_status_critical("%s has invalid format", path)lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1035, __FUNCTION__, "%s has invalid format", path);
          __builtin_unreachable();
      }

      fclose(sib);
  }

  /* Perform a sanity check here, as some systems seem to filter out the
   * result of sysconf() to obtain the number of configured and online
   * CPUs but don't bother changing what's available through sysfs as far
   * as the CPU topology information goes.  It's better to fall back to a
   * possibly non-optimal setup than just crash during startup while
   * trying to perform an out-of-bounds array access.  */
  for (unsigned int i = 0; i < l->available_cpus; i++) {
      if (siblings[i] == 0xbebacafe) {
          lwan_status_warning("Could not determine sibling for CPU %d", i)lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1050, __FUNCTION__, "Could not determine sibling for CPU %d"
, i);
          return false0;
      }

      if (siblings[i] >= l->available_cpus) {
          lwan_status_warning("CPU information topology says CPU %d exists, "lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1058, __FUNCTION__, "CPU information topology says CPU %d exists, "
 "but max available CPUs is %d (online CPUs: %d). " "Is Lwan running in a (broken) container?"
, siblings[i], l->available_cpus, l->online_cpus)
                              "but max available CPUs is %d (online CPUs: %d). "lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1058, __FUNCTION__, "CPU information topology says CPU %d exists, "
 "but max available CPUs is %d (online CPUs: %d). " "Is Lwan running in a (broken) container?"
, siblings[i], l->available_cpus, l->online_cpus)
                              "Is Lwan running in a (broken) container?",lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1058, __FUNCTION__, "CPU information topology says CPU %d exists, "
 "but max available CPUs is %d (online CPUs: %d). " "Is Lwan running in a (broken) container?"
, siblings[i], l->available_cpus, l->online_cpus)
                              siblings[i], l->available_cpus, l->online_cpus)lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1058, __FUNCTION__, "CPU information topology says CPU %d exists, "
 "but max available CPUs is %d (online CPUs: %d). " "Is Lwan running in a (broken) container?"
, siblings[i], l->available_cpus, l->online_cpus);
          return false0;
      }
  }

  return true1;
1064}

1066static void
1067siblings_to_schedtbl(struct lwan *l, uint32_t siblings[], uint32_t schedtbl[])
1068{
  int *seen = alloca(l->available_cpus * sizeof(int))__builtin_alloca (l->available_cpus * sizeof(int));
  unsigned int n_schedtbl = 0;

  for (uint32_t i = 0; i < l->available_cpus; i++)
      seen[i] = -1;

  for (uint32_t i = 0; i < l->available_cpus; i++) {
      if (seen[siblings[i]] < 0) {
          seen[siblings[i]] = (int)i;
      } else {
          schedtbl[n_schedtbl++] = (uint32_t)seen[siblings[i]];
          schedtbl[n_schedtbl++] = i;
      }
  }

  if (n_schedtbl != l->available_cpus)
      memcpy(schedtbl, seen, l->available_cpus * sizeof(int));
1086}

1088static bool_Bool
1089topology_to_schedtbl(struct lwan *l, uint32_t schedtbl[], uint32_t n_threads)
1090{
  uint32_t *siblings = alloca(l->available_cpus * sizeof(uint32_t))__builtin_alloca (l->available_cpus * sizeof(uint32_t));

  if (read_cpu_topology(l, siblings)) {
8
←
Assuming the condition is false→
9
←
Taking false branch→
      uint32_t *affinity = alloca(l->available_cpus * sizeof(uint32_t))__builtin_alloca (l->available_cpus * sizeof(uint32_t));

      siblings_to_schedtbl(l, siblings, affinity);

      for (uint32_t i = 0; i < n_threads; i++)
          schedtbl[i] = affinity[i % l->available_cpus];
      return true1;
  }

  for (uint32_t i = 0; i < n_threads; i++)
10
←
Assuming 'i' is >= 'n_threads'→
11
←
Loop condition is false. Execution continues on line 1105→
      schedtbl[i] = (i / 2) % l->thread.count;
  return false0;
12
←
Returning without writing to '*schedtbl'→
1106}

1108static void
1109adjust_thread_affinity(const struct lwan_thread *thread)
1110{
  cpu_set_t set;

  CPU_ZERO(&set)do __builtin_memset (&set, '\0', sizeof (cpu_set_t)); while
 (0);
  CPU_SET(thread->cpu, &set)(__extension__ ({ size_t __cpu = (thread->cpu); __cpu / 8 <
 (sizeof (cpu_set_t)) ? (((__cpu_mask *) ((&set)->__bits
))[((__cpu) / (8 * sizeof (__cpu_mask)))] |= ((__cpu_mask) 1 <<
 ((__cpu) % (8 * sizeof (__cpu_mask))))) : 0; }));

  if (pthread_setaffinity_np(thread->self, sizeof(set), &set))
      lwan_status_warning("Could not set thread affinity")lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1117, __FUNCTION__, "Could not set thread affinity");
1118}
1119#endif

1121#if defined(HAVE_MBEDTLS)
1122static bool_Bool is_tls_ulp_supported(void)
1123{
  FILE *available_ulp = fopen("/proc/sys/net/ipv4/tcp_available_ulp", "re");
  char buffer[512];
  bool_Bool available = false0;

  if (!available_ulp)
      return false0;

  if (fgets(buffer, 512, available_ulp)) {
      if (strstr(buffer, "tls"))
          available = true1;
  }

  fclose(available_ulp);
  return available;
1138}

1140static bool_Bool lwan_init_tls(struct lwan *l)
1141{
  static const int aes128_ciphers[] = {
      /* Only allow Ephemeral Diffie-Hellman key exchange, so Perfect
       * Forward Secrecy is possible.  */
      MBEDTLS_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA2560xC02F,
      MBEDTLS_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA2560xC02B,
      MBEDTLS_TLS_DHE_RSA_WITH_AES_128_GCM_SHA2560x9E,
      MBEDTLS_TLS_DHE_PSK_WITH_AES_128_GCM_SHA2560xAA,

      /* FIXME: Other ciphers are supported by kTLS, notably AES256 and
       * ChaCha20-Poly1305.  Add those here and patch
       * lwan_setup_tls_keys() to match.  */

      /* FIXME: Maybe allow this to be user-tunable like other servers do?  */
      0,
  };
  int r;

  if (!l->config.ssl.cert || !l->config.ssl.key)
      return false0;

  if (!is_tls_ulp_supported()) {
      lwan_status_critical(lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1164, __FUNCTION__, "TLS ULP not loaded. Try running `modprobe tls` as root."
)
          "TLS ULP not loaded. Try running `modprobe tls` as root.")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1164, __FUNCTION__, "TLS ULP not loaded. Try running `modprobe tls` as root."
);
  }

  l->tls = calloc(1, sizeof(*l->tls));
  if (!l->tls)
      lwan_status_critical("Could not allocate memory for SSL context")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1169, __FUNCTION__, "Could not allocate memory for SSL context"
);

  lwan_status_debug("Initializing mbedTLS")lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1171, __FUNCTION__, "Initializing mbedTLS");

  mbedtls_ssl_config_init(&l->tls->config);
  mbedtls_x509_crt_init(&l->tls->server_cert);
  mbedtls_pk_init(&l->tls->server_key);
  mbedtls_entropy_init(&l->tls->entropy);
  mbedtls_ctr_drbg_init(&l->tls->ctr_drbg);

  r = mbedtls_x509_crt_parse_file(&l->tls->server_cert, l->config.ssl.cert);
  if (r) {
      lwan_status_mbedtls_error(r, "Could not parse certificate at %s",
                                l->config.ssl.cert);
      abort();
  }

  r = mbedtls_pk_parse_keyfile(&l->tls->server_key, l->config.ssl.key, NULL((void*)0));
  if (r) {
      lwan_status_mbedtls_error(r, "Could not parse key file at %s",
                                l->config.ssl.key);
      abort();
  }

  /* Even though this points to files that will probably be outside
   * the reach of the server (if straightjackets are used), wipe this
   * struct to get rid of the paths to these files. */
  lwan_always_bzero(l->config.ssl.cert, strlen(l->config.ssl.cert));
  free(l->config.ssl.cert);
  lwan_always_bzero(l->config.ssl.key, strlen(l->config.ssl.key));
  free(l->config.ssl.key);
  lwan_always_bzero(&l->config.ssl, sizeof(l->config.ssl));

  mbedtls_ssl_conf_ca_chain(&l->tls->config, l->tls->server_cert.next, NULL((void*)0));
  r = mbedtls_ssl_conf_own_cert(&l->tls->config, &l->tls->server_cert,
                                &l->tls->server_key);
  if (r) {
      lwan_status_mbedtls_error(r, "Could not set cert/key");
      abort();
  }

  r = mbedtls_ctr_drbg_seed(&l->tls->ctr_drbg, mbedtls_entropy_func,
                            &l->tls->entropy, NULL((void*)0), 0);
  if (r) {
      lwan_status_mbedtls_error(r, "Could not seed ctr_drbg");
      abort();
  }

  r = mbedtls_ssl_config_defaults(&l->tls->config, MBEDTLS_SSL_IS_SERVER1,
                                  MBEDTLS_SSL_TRANSPORT_STREAM0,
                                  MBEDTLS_SSL_PRESET_DEFAULT0);
  if (r) {
      lwan_status_mbedtls_error(r, "Could not set mbedTLS default config");
      abort();
  }

  mbedtls_ssl_conf_rng(&l->tls->config, mbedtls_ctr_drbg_random,
                       &l->tls->ctr_drbg);
  mbedtls_ssl_conf_ciphersuites(&l->tls->config, aes128_ciphers);

  mbedtls_ssl_conf_renegotiation(&l->tls->config,
                                 MBEDTLS_SSL_RENEGOTIATION_DISABLED0);
  mbedtls_ssl_conf_legacy_renegotiation(&l->tls->config,
                                        MBEDTLS_SSL_LEGACY_NO_RENEGOTIATION0);

1234#if defined(MBEDTLS_SSL_ALPN)
  static const char *alpn_protos[] = {"http/1.1", NULL((void*)0)};
  mbedtls_ssl_conf_alpn_protocols(&l->tls->config, alpn_protos);
1237#endif

  return true1;
1240}
1241#endif

1243void lwan_thread_init(struct lwan *l)
1244{
  const unsigned int total_conns = l->thread.max_fd * l->thread.count;
1246#if defined(HAVE_MBEDTLS)
  const bool_Bool tls_initialized = lwan_init_tls(l);
1248#else
  const bool_Bool tls_initialized = false0;
1250#endif

  lwan_status_debug("Initializing threads")lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1252, __FUNCTION__, "Initializing threads");

  l->thread.threads =
      calloc((size_t)l->thread.count, sizeof(struct lwan_thread));
  if (!l->thread.threads)
1
Assuming field 'threads' is non-null→
2
←
Taking false branch→
      lwan_status_critical("Could not allocate memory for threads")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1257, __FUNCTION__, "Could not allocate memory for threads"
);

  uint32_t *schedtbl;
  uint32_t n_threads;
  bool_Bool adj_affinity;

1263#if defined(__x86_64__1) && defined(__linux__1)
  if (l->online_cpus > 1) {
3
←
Assuming field 'online_cpus' is > 1→
4
←
Taking true branch→
      static_assert_Static_assert(sizeof(struct lwan_connection) == 32,
                    "Two connections per cache line");
1267#ifdef _SC_LEVEL1_DCACHE_LINESIZE_SC_LEVEL1_DCACHE_LINESIZE
      assert(sysconf(_SC_LEVEL1_DCACHE_LINESIZE) == 64)((void) sizeof ((sysconf(_SC_LEVEL1_DCACHE_LINESIZE) == 64) ?
: 0), __extension__ ({ if (sysconf(_SC_LEVEL1_DCACHE_LINESIZE
) == 64) ; else __assert_fail ("sysconf(_SC_LEVEL1_DCACHE_LINESIZE) == 64"
, "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1268, __extension__ __PRETTY_FUNCTION__); }));
5
←
Assuming the condition is true→
6
←
Taking true branch→
1269#endif
      lwan_status_debug("%d CPUs of %d are online. "lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1272, __FUNCTION__, "%d CPUs of %d are online. " "Reading topology to pre-schedule clients"
, l->online_cpus, l->available_cpus)
                        "Reading topology to pre-schedule clients",lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1272, __FUNCTION__, "%d CPUs of %d are online. " "Reading topology to pre-schedule clients"
, l->online_cpus, l->available_cpus)
                        l->online_cpus, l->available_cpus)lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1272, __FUNCTION__, "%d CPUs of %d are online. " "Reading topology to pre-schedule clients"
, l->online_cpus, l->available_cpus);
      /*
       * Pre-schedule each file descriptor, to reduce some operations in the
       * fast path.
       *
       * Since struct lwan_connection is guaranteed to be 32-byte long, two of
       * them can fill up a cache line.  Assume siblings share cache lines and
       * use the CPU topology to group two connections per cache line in such
       * a way that false sharing is avoided.
       */
      n_threads = (uint32_t)lwan_nextpow2((size_t)((l->thread.count - 1) * 2));
      schedtbl = alloca(n_threads * sizeof(uint32_t))__builtin_alloca (n_threads * sizeof(uint32_t));

      adj_affinity = topology_to_schedtbl(l, schedtbl, n_threads);
7
←
Calling 'topology_to_schedtbl'→
13
←
Returning from 'topology_to_schedtbl'→

      n_threads--; /* Transform count into mask for AND below */

      for (unsigned int i = 0; i < total_conns; i++)
14
←
Assuming 'i' is < 'total_conns'→
15
←
Loop condition is true.  Entering loop body→
          l->conns[i].thread = &l->thread.threads[schedtbl[i & n_threads]];
16
←
Array subscript is undefined
  } else
1292#endif /* __x86_64__ && __linux__ */
  {
      lwan_status_debug("Using round-robin to preschedule clients")lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1294, __FUNCTION__, "Using round-robin to preschedule clients"
);

      for (unsigned int i = 0; i < l->thread.count; i++)
          l->thread.threads[i].cpu = i % l->online_cpus;
      for (unsigned int i = 0; i < total_conns; i++)
          l->conns[i].thread = &l->thread.threads[i % l->thread.count];

      schedtbl = NULL((void*)0);
      adj_affinity = false0;
      n_threads = l->thread.count;
  }

  for (unsigned int i = 0; i < l->thread.count; i++) {
      struct lwan_thread *thread = NULL((void*)0);

      if (schedtbl) {
          /* This is not the most elegant thing, but this assures that the
           * listening sockets are added to the SO_REUSEPORT group in a
           * specific order, because that's what the CBPF program to direct
           * the incoming connection to the right CPU will use. */
          for (uint32_t thread_id = 0; thread_id < l->thread.count;
               thread_id++) {
              if (schedtbl[thread_id & n_threads] == i) {
                  thread = &l->thread.threads[thread_id];
                  break;
              }
          }
          if (!thread) {
              /* FIXME: can this happen when we have a offline CPU? */
              lwan_status_critical(lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1324, __FUNCTION__, "Could not figure out which CPU thread %d should go to"
, i)
                  "Could not figure out which CPU thread %d should go to", i)lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1324, __FUNCTION__, "Could not figure out which CPU thread %d should go to"
, i);
          }
      } else {
          thread = &l->thread.threads[i % l->thread.count];
      }

      if (pthread_barrier_init(&l->thread.barrier, NULL((void*)0), 2))
          lwan_status_critical("Could not create barrier")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1331, __FUNCTION__, "Could not create barrier");

      create_thread(l, thread);

      if ((thread->listen_fd = create_listen_socket(thread, i, false0)) < 0)
          lwan_status_critical_perror("Could not create listening socket")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1336, __FUNCTION__, "Could not create listening socket");
      l->conns[thread->listen_fd].flags |= CONN_LISTENER_HTTP;

      if (tls_initialized) {
          if ((thread->tls_listen_fd = create_listen_socket(thread, i, true1)) < 0)
              lwan_status_critical_perror("Could not create TLS listening socket")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1341, __FUNCTION__, "Could not create TLS listening socket"
);
          l->conns[thread->tls_listen_fd].flags |= CONN_LISTENER_HTTPS;
      } else {
          thread->tls_listen_fd = -1;
      }

      if (adj_affinity) {
          l->thread.threads[i].cpu = schedtbl[i & n_threads];
          adjust_thread_affinity(thread);
      }

      pthread_barrier_wait(&l->thread.barrier);
  }

  lwan_status_debug("Worker threads created and ready to serve")lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1355, __FUNCTION__, "Worker threads created and ready to serve"
);
1356}

1358void lwan_thread_shutdown(struct lwan *l)
1359{
  lwan_status_debug("Shutting down threads")lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 1360, __FUNCTION__, "Shutting down threads");

  for (unsigned int i = 0; i < l->thread.count; i++) {
      struct lwan_thread *t = &l->thread.threads[i];
      int epoll_fd = t->epoll_fd;
      int listen_fd = t->listen_fd;

      t->listen_fd = -1;
      t->epoll_fd = -1;
      close(epoll_fd);
      close(listen_fd);
  }

  pthread_barrier_wait(&l->thread.barrier);
  pthread_barrier_destroy(&l->thread.barrier);

  for (unsigned int i = 0; i < l->thread.count; i++) {
      struct lwan_thread *t = &l->thread.threads[i];

      pthread_join(l->thread.threads[i].self, NULL((void*)0));
      timeouts_close(t->wheel);
  }

  free(l->thread.threads);

1385#if defined(HAVE_MBEDTLS)
  if (l->tls) {
      mbedtls_ssl_config_free(&l->tls->config);
      mbedtls_x509_crt_free(&l->tls->server_cert);
      mbedtls_pk_free(&l->tls->server_key);
      mbedtls_entropy_free(&l->tls->entropy);
      mbedtls_ctr_drbg_free(&l->tls->ctr_drbg);
      free(l->tls);
  }
1394#endif
1395}