#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include <stdio.h>

#include "ntp_assert.h"

#include "ntp_syslog.h"

#include "ntp_stdlib.h"

#include "ntp_lists.h"

#include "recvbuff.h"

#include "iosignal.h"

#if (RECV_INC & (RECV_INC-1))

# error RECV_INC not a power of 2!

#endif

#if (RECV_BATCH & (RECV_BATCH - 1))

#error RECV_BATCH not a power of 2!

#endif

#if (RECV_BATCH < RECV_INC)

#error RECV_BATCH must be >= RECV_INC!

#endif

/*

 * Memory allocation

 */

static u_long volatile full_recvbufs; /* recvbufs on full_recv_fifo */

static u_long volatile free_recvbufs; /* recvbufs on free_recv_list */

static u_long volatile total_recvbufs;  /* total recvbufs currently in use */

static u_long volatile lowater_adds;  /* number of times we have added memory */

static u_long volatile buffer_shortfall;/* number of missed free receive buffers

             between replenishments */

static u_long limit_recvbufs;   /* maximum total of receive buffers */

static u_long emerg_recvbufs;   /* emergency/urgent buffers to keep */

static DECL_FIFO_ANCHOR(recvbuf_t) full_recv_fifo;

static recvbuf_t *       free_recv_list;

#if defined(SYS_WINNT)

/*

 * For Windows we need to set up a lock to manipulate the

 * recv buffers to prevent corruption. We keep it lock for as

 * short a time as possible

 */

static CRITICAL_SECTION RecvLock;

static CRITICAL_SECTION FreeLock;

# define LOCK_R() EnterCriticalSection(&RecvLock)

# define UNLOCK_R() LeaveCriticalSection(&RecvLock)

# define LOCK_F() EnterCriticalSection(&FreeLock)

# define UNLOCK_F() LeaveCriticalSection(&FreeLock)

#else

# define LOCK_R() do {} while (FALSE)

# define UNLOCK_R() do {} while (FALSE)

# define LOCK_F() do {} while (FALSE)

# define UNLOCK_F() do {} while (FALSE)

#endif

#ifdef DEBUG

static void uninit_recvbuff(void);

#endif

u_long

free_recvbuffs (void)

{

  return free_recvbufs;

}

u_long

full_recvbuffs (void)

{

  return full_recvbufs;

}

u_long

total_recvbuffs (void)

{

  return total_recvbufs;

}

u_long

lowater_additions(void)

{

  return lowater_adds;

}

static inline void 

initialise_buffer(recvbuf_t *buff)

{

  ZERO(*buff);

}

static void

create_buffers(

  size_t      nbufs

)

{

  static const u_int  chunk =

#   ifndef DEBUG

          RECV_INC;

#   else

  /* Allocate each buffer individually so they can be free()d

   * during ntpd shutdown on DEBUG builds to keep them out of heap

   * leak reports.

   */

          1;

#   endif

  static int/*BOOL*/  doneonce;

  recvbuf_t *   bufp;

  u_int     i;

  size_t      abuf;

  /*[bug 3666]: followup -- reset shortfalls in all cases */

  abuf = nbufs + buffer_shortfall;

  buffer_shortfall = 0;

  if (limit_recvbufs <= total_recvbufs) {

    if (!doneonce) {

      msyslog(LOG_CRIT, "Unable to allocate receive"

            " buffer, %lu/%lu",

        total_recvbufs, limit_recvbufs);

      doneonce = TRUE;

    }

    return;

  }

  if (abuf < nbufs || abuf > RECV_BATCH) {

    abuf = RECV_BATCH; /* clamp on overflow */

  } else {

    abuf += (~abuf + 1) & (RECV_INC - 1);  /* round up */

  }

  if (abuf > (limit_recvbufs - total_recvbufs)) {

    abuf = limit_recvbufs - total_recvbufs;

  }

  abuf += (~abuf + 1) & (chunk - 1);    /* round up */

  while (abuf) {

    bufp = calloc(chunk, sizeof(*bufp));

    if (!bufp) {

      msyslog(LOG_CRIT, "Out of memory, allocating "

            "%u recvbufs, %lu bytes",

        chunk, (u_long)sizeof(*bufp) * chunk);

      limit_recvbufs = total_recvbufs;

      break;

    }

    for (i = chunk; i; --i,++bufp) {

      LINK_SLIST(free_recv_list, bufp, link);

    }

    free_recvbufs += chunk;

    total_recvbufs += chunk;

    abuf -= chunk;

  }

  ++lowater_adds;

}

void

init_recvbuff(int nbufs)

{

  /*

   * Init buffer free list and stat counters

   */

  free_recvbufs = total_recvbufs = 0;

  full_recvbufs = lowater_adds = 0;

  limit_recvbufs = RECV_TOOMANY;

  emerg_recvbufs = RECV_CLOCK;

  create_buffers(nbufs);

#   if defined(SYS_WINNT)

  InitializeCriticalSection(&RecvLock);

  InitializeCriticalSection(&FreeLock);

#   endif

#   ifdef DEBUG

  atexit(&uninit_recvbuff);

#   endif

}

#ifdef DEBUG

static void

uninit_recvbuff(void)

{

  recvbuf_t *rbunlinked;

  for (;;) {

    UNLINK_FIFO(rbunlinked, full_recv_fifo, link);

    if (rbunlinked == NULL)

      break;

    free(rbunlinked);

  }

  for (;;) {

    UNLINK_HEAD_SLIST(rbunlinked, free_recv_list, link);

    if (rbunlinked == NULL)

      break;

    free(rbunlinked);

  }

#   if defined(SYS_WINNT)

  DeleteCriticalSection(&FreeLock);

  DeleteCriticalSection(&RecvLock);

#   endif

}

#endif  /* DEBUG */

/*

 * freerecvbuf - make a single recvbuf available for reuse

 */

void

freerecvbuf(recvbuf_t *rb)

{

  if (rb) {

    if (--rb->used != 0) {

      msyslog(LOG_ERR, "******** freerecvbuff non-zero usage: %d *******", rb->used);

      rb->used = 0;

    }

    LOCK_F();

    LINK_SLIST(free_recv_list, rb, link);

    ++free_recvbufs;

    UNLOCK_F();

  }

}

void

add_full_recv_buffer(recvbuf_t *rb)

{

  if (rb == NULL) {

    msyslog(LOG_ERR, "add_full_recv_buffer received NULL buffer");

    return;

  }

  LOCK_R();

  LINK_FIFO(full_recv_fifo, rb, link);

  ++full_recvbufs;

  UNLOCK_R();

}

recvbuf_t *

get_free_recv_buffer(

    int /*BOOL*/ urgent

    )

{

  recvbuf_t *buffer = NULL;

  LOCK_F();

  if (free_recvbufs > (urgent ? 0 : emerg_recvbufs)) {

    UNLINK_HEAD_SLIST(buffer, free_recv_list, link);

  }

  if (buffer != NULL) {

    if (free_recvbufs)

      --free_recvbufs;

    initialise_buffer(buffer);

    ++buffer->used;

  } else {

    ++buffer_shortfall;

  }

  UNLOCK_F();

  return buffer;

}

#ifdef HAVE_IO_COMPLETION_PORT

recvbuf_t *

get_free_recv_buffer_alloc(

    int /*BOOL*/ urgent

    )

{

  LOCK_F(); 

  if (free_recvbufs <= emerg_recvbufs || buffer_shortfall > 0)

    create_buffers(RECV_INC);

  UNLOCK_F();

  return get_free_recv_buffer(urgent);

}

#endif

recvbuf_t *

get_full_recv_buffer(void)

{

  recvbuf_t * rbuf;

  /*

   * make sure there are free buffers when we wander off to do

   * lengthy packet processing with any buffer we grab from the

   * full list.

   * 

   * fixes malloc() interrupted by SIGIO risk (Bug 889)

   */

  LOCK_F(); 

  if (free_recvbufs <= emerg_recvbufs || buffer_shortfall > 0)

    create_buffers(RECV_INC);

  UNLOCK_F();

  /*

   * try to grab a full buffer

   */

  LOCK_R();

  UNLINK_FIFO(rbuf, full_recv_fifo, link);

  if (rbuf != NULL && full_recvbufs)

    --full_recvbufs;

  UNLOCK_R();

  return rbuf;

}

/*

 * purge_recv_buffers_for_fd() - purges any previously-received input

 *         from a given file descriptor.

 */

void

purge_recv_buffers_for_fd(

  int fd

  )

{

  recvbuf_t *rbufp;

  recvbuf_t *next;

  recvbuf_t *punlinked;

  recvbuf_t *freelist = NULL;

  /* We want to hold only one lock at a time. So we do a scan on

   * the full buffer queue, collecting items as we go, and when

   * done we spool the the collected items to 'freerecvbuf()'.

   */

  LOCK_R();

  for (rbufp = HEAD_FIFO(full_recv_fifo);

       rbufp != NULL;

       rbufp = next)

  {

    next = rbufp->link;

#     ifdef HAVE_IO_COMPLETION_PORT

    if (rbufp->dstadr == NULL && rbufp->fd == fd)

#     else

    if (rbufp->fd == fd)

#     endif

    {

      UNLINK_MID_FIFO(punlinked, full_recv_fifo,

          rbufp, link, recvbuf_t);

      INSIST(punlinked == rbufp);

      if (full_recvbufs)

        --full_recvbufs;

      rbufp->link = freelist;

      freelist = rbufp;

    }

  }

  UNLOCK_R();

  while (freelist) {

    next = freelist->link;

    freerecvbuf(freelist);

    freelist = next;

  }

}

/*

 * Checks to see if there are buffers to process

 */

isc_boolean_t has_full_recv_buffer(void)

{

  if (HEAD_FIFO(full_recv_fifo) != NULL)

    return (ISC_TRUE);

  else

    return (ISC_FALSE);

}

#ifdef NTP_DEBUG_LISTS_H

void

check_gen_fifo_consistency(void *fifo)

{

  gen_fifo *pf;

  gen_node *pthis;

  gen_node **pptail;

  pf = fifo;

  REQUIRE((NULL == pf->phead && NULL == pf->pptail) ||

    (NULL != pf->phead && NULL != pf->pptail));

  pptail = &pf->phead;

  for (pthis = pf->phead;

       pthis != NULL;

       pthis = pthis->link)

    if (NULL != pthis->link)

      pptail = &pthis->link;

  REQUIRE(NULL == pf->pptail || pptail == pf->pptail);

}

#endif  /* NTP_DEBUG_LISTS_H */