/*

   Unix SMB/CIFS implementation.

   common events code for fd events

   Copyright (C) Stefan Metzmacher 2009

     ** NOTE! The following LGPL license applies to the tevent

     ** library. This does NOT imply that all of Samba is released

     ** under the LGPL

   This 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 3 of the License, or (at your option) any later version.

   This 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 this library; if not, see <http://www.gnu.org/licenses/>.

*/

#include "replace.h"

#define TEVENT_DEPRECATED 1

#include "tevent.h"

#include "tevent_internal.h"

#include "tevent_util.h"

_PRIVATE_

const char *tevent_common_fd_str(struct tevent_common_fd_buf *buf,

         const char *description,

         const struct tevent_fd *fde)

{

  snprintf(buf->buf, sizeof(buf->buf),

     "%s[fde=%p,"

     "fd=%d,flags=0x%x(%s%s%s),%s]",

     description, fde, fde->fd,

     fde->flags,

     (fde->flags & TEVENT_FD_ERROR) ? "E" : "",

     (fde->flags & TEVENT_FD_READ) ? "R" : "",

     (fde->flags & TEVENT_FD_WRITE) ? "W" : "",

     fde->handler_name);

  return buf->buf;

}

int tevent_common_fd_destructor(struct tevent_fd *fde)

{

  struct tevent_fd *primary = NULL;

  if (fde->destroyed) {

    tevent_common_check_double_free(fde, "tevent_fd double free");

    goto done;

  }

  fde->destroyed = true;

  /*

   * The caller should have cleared it from any mpx relationship

   */

  primary = tevent_common_fd_mpx_primary(fde);

  if (primary != fde) {

    tevent_abort(fde->event_ctx,

      "tevent_common_fd_destructor: fde not mpx primary");

  } else if (fde->mpx.list != NULL) {

    tevent_abort(fde->event_ctx,

      "tevent_common_fd_destructor: fde has mpx fdes");

  }

  if (fde->event_ctx) {

    tevent_trace_fd_callback(fde->event_ctx, fde, TEVENT_EVENT_TRACE_DETACH);

    DLIST_REMOVE(fde->event_ctx->fd_events, fde);

  }

  if (fde->close_fn) {

    fde->close_fn(fde->event_ctx, fde, fde->fd, fde->private_data);

    fde->fd = -1;

    fde->close_fn = NULL;

  }

  fde->event_ctx = NULL;

done:

  if (fde->busy) {

    return -1;

  }

  fde->wrapper = NULL;

  return 0;

}

struct tevent_fd *tevent_common_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,

               int fd, uint16_t flags,

               tevent_fd_handler_t handler,

               void *private_data,

               const char *handler_name,

               const char *location)

{

  struct tevent_fd *fde;

  /* tevent will crash later on select() if we save

   * a negative file descriptor. Better to fail here

   * so that consumers will be able to debug it

   */

  if (fd < 0) return NULL;

  fde = talloc(mem_ctx?mem_ctx:ev, struct tevent_fd);

  if (!fde) return NULL;

  *fde = (struct tevent_fd) {

    .event_ctx  = ev,

    .fd   = fd,

    .flags    = flags,

    .handler  = handler,

    .private_data = private_data,

    .handler_name = handler_name,

    .location = location,

  };

  tevent_trace_fd_callback(fde->event_ctx, fde, TEVENT_EVENT_TRACE_ATTACH);

  DLIST_ADD(ev->fd_events, fde);

  tevent_common_fd_mpx_reinit(fde);

  talloc_set_destructor(fde, tevent_common_fd_destructor);

  return fde;

}

uint16_t tevent_common_fd_get_flags(struct tevent_fd *fde)

{

  return fde->flags;

}

void tevent_common_fd_set_flags(struct tevent_fd *fde, uint16_t flags)

{

  if (fde->flags == flags) return;

  fde->flags = flags;

}

void tevent_common_fd_set_close_fn(struct tevent_fd *fde,

           tevent_fd_close_fn_t close_fn)

{

  fde->close_fn = close_fn;

}

int tevent_common_invoke_fd_handler(struct tevent_fd *fde, uint16_t flags,

            bool *removed)

{

  struct tevent_context *handler_ev = fde->event_ctx;

  if (removed != NULL) {

    *removed = false;

  }

  if (fde->event_ctx == NULL) {

    return 0;

  }

  fde->busy = true;

  if (fde->wrapper != NULL) {

    handler_ev = fde->wrapper->wrap_ev;

    tevent_wrapper_push_use_internal(handler_ev, fde->wrapper);

    fde->wrapper->ops->before_fd_handler(

          fde->wrapper->wrap_ev,

          fde->wrapper->private_state,

          fde->wrapper->main_ev,

          fde,

          flags,

          fde->handler_name,

          fde->location);

  }

  tevent_trace_fd_callback(fde->event_ctx, fde, TEVENT_EVENT_TRACE_BEFORE_HANDLER);

  fde->handler(handler_ev, fde, flags, fde->private_data);

  if (fde->wrapper != NULL) {

    fde->wrapper->ops->after_fd_handler(

          fde->wrapper->wrap_ev,

          fde->wrapper->private_state,

          fde->wrapper->main_ev,

          fde,

          flags,

          fde->handler_name,

          fde->location);

    tevent_wrapper_pop_use_internal(handler_ev, fde->wrapper);

  }

  fde->busy = false;

  if (fde->destroyed) {

    talloc_set_destructor(fde, NULL);

    TALLOC_FREE(fde);

    if (removed != NULL) {

      *removed = true;

    }

  }

  return 0;

}

void tevent_fd_set_tag(struct tevent_fd *fde, uint64_t tag)

{

  if (fde == NULL) {

    return;

  }

  fde->tag = tag;

}

uint64_t tevent_fd_get_tag(const struct tevent_fd *fde)

{

  if (fde == NULL) {

    return 0;

  }

  return fde->tag;

}