/***************************************************************************

 *                                  _   _ ____  _

 *  Project                     ___| | | |  _ \| |

 *                             / __| | | | |_) | |

 *                            | (__| |_| |  _ <| |___

 *                             \___|\___/|_| \_\_____|

 *

 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.

 *

 * This software is licensed as described in the file COPYING, which

 * you should have received as part of this distribution. The terms

 * are also available at https://curl.se/docs/copyright.html.

 *

 * You may opt to use, copy, modify, merge, publish, distribute and/or sell

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

 * furnished to do so, under the terms of the COPYING file.

 *

 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY

 * KIND, either express or implied.

 *

 * SPDX-License-Identifier: curl

 *

 ***************************************************************************/

#include "curl_setup.h"

#include <curl/curl.h>

#include "urldata.h"

#include "curl_trc.h"

#include "multihandle.h"

#include "multiif.h"

#include "multi_ntfy.h"

/* The last 3 #include files should be in this order */

#include "curl_printf.h"

#include "curl_memory.h"

#include "memdebug.h"

struct mntfy_entry {

  unsigned int mid;

  unsigned int type;

};

#define CURL_MNTFY_CHUNK_SIZE   128

struct mntfy_chunk {

  struct mntfy_chunk *next;

  size_t r_offset;

  size_t w_offset;

  struct mntfy_entry entries[CURL_MNTFY_CHUNK_SIZE];

};

static struct mntfy_chunk *mnfty_chunk_create(void)

{

  return calloc(1, sizeof(struct mntfy_chunk));

}

static void mnfty_chunk_destroy(struct mntfy_chunk *chunk)

{

  free(chunk);

}

static void mnfty_chunk_reset(struct mntfy_chunk *chunk)

{

  memset(chunk, 0, sizeof(*chunk));

}

static bool mntfy_chunk_append(struct mntfy_chunk *chunk,

                               struct Curl_easy *data,

                               unsigned int type)

{

  struct mntfy_entry *e;

  if(chunk->w_offset >= CURL_MNTFY_CHUNK_SIZE)

    return FALSE;

  e = &chunk->entries[chunk->w_offset++];

  e->mid = data->mid;

  e->type = type;

  return TRUE;

}

static struct mntfy_chunk *mntfy_non_full_tail(struct curl_multi_ntfy *mntfy)

{

  struct mntfy_chunk *chunk;

  if(!mntfy->tail) {

    chunk = mnfty_chunk_create();

    if(!chunk)

      return NULL;

    DEBUGASSERT(!mntfy->head);

    mntfy->head = mntfy->tail = chunk;

    return chunk;

  }

  else if(mntfy->tail->w_offset < CURL_MNTFY_CHUNK_SIZE)

    return mntfy->tail;

  else { /* tail is full. */

    chunk = mnfty_chunk_create();

    if(!chunk)

      return NULL;

    DEBUGASSERT(mntfy->head);

    mntfy->tail->next = chunk;

    mntfy->tail = chunk;

    return chunk;

  }

}

static void mntfy_chunk_dispatch_all(struct Curl_multi *multi,

                                     struct mntfy_chunk *chunk)

{

  struct mntfy_entry *e;

  struct Curl_easy *data;

  if(multi->ntfy.ntfy_cb) {

    while((chunk->r_offset < chunk->w_offset) && !multi->ntfy.failure) {

      e = &chunk->entries[chunk->r_offset];

      data = e->mid ? Curl_multi_get_easy(multi, e->mid) : multi->admin;

      /* only when notification has not been disabled in the meantime */

      if(data && Curl_uint_bset_contains(&multi->ntfy.enabled, e->type)) {

        /* this may cause new notifications to be added! */

        CURL_TRC_M(multi->admin, "[NTFY] dispatch %d to xfer %u",

                   e->type, e->mid);

        multi->ntfy.ntfy_cb(multi, e->type, data, multi->ntfy.ntfy_cb_data);

      }

      /* once dispatched, safe to increment */

      chunk->r_offset++;

    }

  }

  mnfty_chunk_reset(chunk);

}

void Curl_mntfy_init(struct Curl_multi *multi)

{

  memset(&multi->ntfy, 0, sizeof(multi->ntfy));

  Curl_uint_bset_init(&multi->ntfy.enabled);

}

CURLMcode Curl_mntfy_resize(struct Curl_multi *multi)

{

  if(Curl_uint_bset_resize(&multi->ntfy.enabled, CURLMNOTIFY_EASY_DONE + 1))

    return CURLM_OUT_OF_MEMORY;

  return CURLM_OK;

}

void Curl_mntfy_cleanup(struct Curl_multi *multi)

{

  while(multi->ntfy.head) {

    struct mntfy_chunk *chunk = multi->ntfy.head;

    multi->ntfy.head = chunk->next;

    mnfty_chunk_destroy(chunk);

  }

  multi->ntfy.tail = NULL;

  Curl_uint_bset_destroy(&multi->ntfy.enabled);

}

CURLMcode Curl_mntfy_enable(struct Curl_multi *multi, unsigned int type)

{

  if(type > CURLMNOTIFY_EASY_DONE)

    return CURLM_UNKNOWN_OPTION;

  Curl_uint_bset_add(&multi->ntfy.enabled, type);

  return CURLM_OK;

}

CURLMcode Curl_mntfy_disable(struct Curl_multi *multi, unsigned int type)

{

  if(type > CURLMNOTIFY_EASY_DONE)

    return CURLM_UNKNOWN_OPTION;

  Curl_uint_bset_remove(&multi->ntfy.enabled, type);

  return CURLM_OK;

}

void Curl_mntfy_add(struct Curl_easy *data, unsigned int type)

{

  struct Curl_multi *multi = data ? data->multi : NULL;

  if(multi && multi->ntfy.ntfy_cb && !multi->ntfy.failure &&

     Curl_uint_bset_contains(&multi->ntfy.enabled, type)) {

    /* append to list of outstanding notifications */

    struct mntfy_chunk *tail = mntfy_non_full_tail(&multi->ntfy);

  CURL_TRC_M(data, "[NTFY] add %d for xfer %u", type, data->mid);

    if(tail)

      mntfy_chunk_append(tail, data, type);

    else

      multi->ntfy.failure = CURLM_OUT_OF_MEMORY;

  }

}

CURLMcode Curl_mntfy_dispatch_all(struct Curl_multi *multi)

{

  DEBUGASSERT(!multi->in_ntfy_callback);

  multi->in_ntfy_callback = TRUE;

  while(multi->ntfy.head && !multi->ntfy.failure) {

    struct mntfy_chunk *chunk = multi->ntfy.head;

    /* this may cause new notifications to be added! */

    mntfy_chunk_dispatch_all(multi, chunk);

    DEBUGASSERT(chunk->r_offset == chunk->w_offset);

    if(chunk == multi->ntfy.tail) /* last one, keep */

      break;

    DEBUGASSERT(chunk->next);

    DEBUGASSERT(multi->ntfy.head != multi->ntfy.tail);

    multi->ntfy.head = chunk->next;

    mnfty_chunk_destroy(chunk);

  }

  multi->in_ntfy_callback = FALSE;

  if(multi->ntfy.failure) {

    CURLMcode result = multi->ntfy.failure;

    multi->ntfy.failure = CURLM_OK; /* reset, once delivered */

    return result;

  }

  return CURLM_OK;

}