// TLI_Acceptor.cpp
// $Id$


#define ACE_BUILD_DLL
#include "ace/TLI_Acceptor.h"

#if defined (ACE_HAS_TLI)

// Put the actual definitions of the ACE_TLI_Request and
// ACE_TLI_Request_Queue classes here to hide them from clients...

struct ACE_TLI_Request
{
  struct t_call *callp_;
  ACE_HANDLE handle_;
  ACE_TLI_Request *next_;
};

class ACE_TLI_Request_Queue
{
public:
  ACE_TLI_Request_Queue (void);
  
  int open (int fd, int size);
  int close (void);

  int enqueue (const char device[], int restart, int rwflag);
  int dequeue (ACE_TLI_Request *&ptr);
  int remove (int sequence_number);

  int is_empty (void) const;
  int is_full (void) const;

  ACE_TLI_Request *alloc (void);
  void    free (ACE_TLI_Request *node);

  void dump (void) const;
  // Dump the state of an object.

  ACE_ALLOC_HOOK_DECLARE;
  // Declare the dynamic allocation hooks.

private:
  int     handle_;
  int     size_;
  int     current_count_;
  ACE_TLI_Request *base_;
  ACE_TLI_Request *tail_;
  ACE_TLI_Request *free_list_;  
};

ACE_ALLOC_HOOK_DEFINE(ACE_TLI_Request_Queue)

void
ACE_TLI_Request_Queue::dump (void) const
{
  ACE_TRACE ("ACE_TLI_Request_Queue::dump");
}

int
ACE_TLI_Request_Queue::is_empty (void) const
{
  ACE_TRACE ("ACE_TLI_Request_Queue::is_empty");
  return this->current_count_ == 0;
}

int
ACE_TLI_Request_Queue::is_full (void) const
{
  ACE_TRACE ("ACE_TLI_Request_Queue::is_full");
  return this->current_count_ + 1 == this->size_; // Add 1 for the dummy.
}

// Add a node to the free list stack.

void
ACE_TLI_Request_Queue::free (ACE_TLI_Request *node)
{
  ACE_TRACE ("ACE_TLI_Request_Queue::free");
  node->next_      = this->free_list_;
  this->free_list_ = node;
}

// Remove a node from the free list stack. 

ACE_TLI_Request *
ACE_TLI_Request_Queue::alloc (void)
{
  ACE_TRACE ("ACE_TLI_Request_Queue::alloc");
  ACE_TLI_Request *temp = this->free_list_;
  this->free_list_ = this->free_list_->next_;
  return temp;
}

ACE_ALLOC_HOOK_DEFINE(ACE_TLI_Acceptor)

void
ACE_TLI_Acceptor::dump (void) const
{
  ACE_TRACE ("ACE_TLI_Acceptor::dump");
}

ACE_TLI_Acceptor::ACE_TLI_Acceptor (void)
  : queue_ (0)
{
  ACE_TRACE ("ACE_TLI_Acceptor::ACE_TLI_Acceptor");
}

int
ACE_TLI_Request_Queue::dequeue (ACE_TLI_Request *&ptr)
{
  ACE_TRACE ("ACE_TLI_Request_Queue::dequeue");
  ptr              = this->tail_->next_;
  this->tail_->next_ = ptr->next_;
  this->current_count_--;
  return 0;
}

// This is hideous... 

static ACE_HANDLE 
open_new_endpoint (ACE_HANDLE listen_handle, const char dev[],
		   struct t_call *callp, int rwf)
{
  ACE_TRACE ("open_new_endpoint");
  ACE_HANDLE fd;
  
  if ((fd = ACE_OS::t_open ((char *) dev, O_RDWR, 0)) == ACE_INVALID_HANDLE 
      || ACE_OS::t_bind (fd, 0, 0) == ACE_INVALID_HANDLE)
    fd = ACE_INVALID_HANDLE;
#if defined (I_PUSH)
  else if (rwf != 0 && ACE_OS::ioctl (fd, I_PUSH, "tirdwr") == ACE_INVALID_HANDLE)
    fd = ACE_INVALID_HANDLE;
#endif /* I_PUSH */

  if (fd == ACE_INVALID_HANDLE)
    ACE_OS::t_snddis (listen_handle, callp);
  return fd;
}

// Close down the acceptor and release resources.

int
ACE_TLI_Request_Queue::close (void)
{
  ACE_TRACE ("ACE_TLI_Request_Queue::close");
  int res = 0;

  for (int i = 0; i < this->size_; i++)
    {
      ACE_TLI_Request &item = this->base_[i];

      item.handle_ = ACE_INVALID_HANDLE;
      if (ACE_OS::t_free ((char *) item.callp_, T_CALL) != 0)
	res = ACE_INVALID_HANDLE;
    }
  delete [] this->base_;
  this->base_ = 0;
  return res;
}

ACE_HANDLE
ACE_TLI_Request_Queue::open (ACE_HANDLE f, int sz)
{
  ACE_TRACE ("ACE_TLI_Request_Queue::open");
  this->handle_   = f;
  this->size_ = sz + 1; // Add one more for the dummy node.

  ACE_NEW_RETURN (this->base_, ACE_TLI_Request[this->size_], ACE_INVALID_HANDLE);

  // Initialize the ACE_Queue and the free list.

  for (int i = 0; i < this->size_; i++)
    {
      ACE_TLI_Request *item = &this->base_[i];
      this->free (item);

      item->handle_ = ACE_INVALID_HANDLE;
      item->callp_ = (t_call *) ACE_OS::t_alloc (this->handle_, T_CALL, T_ALL);

      if (item->callp_ == 0)
	return ACE_INVALID_HANDLE;
    }

  this->tail_ = this->alloc ();
  this->tail_->next_ = this->tail_;
  return 0;
}

ACE_TLI_Request_Queue::ACE_TLI_Request_Queue (void)
  : size_ (0),
    current_count_ (0), 
    base_ (0), 
    tail_ (0), 
    free_list_ (0)
{
  ACE_TRACE ("ACE_TLI_Request_Queue::ACE_TLI_Request_Queue");
}

// Listen for a new connection request and allocate appropriate data
// structures when one arrives.

int
ACE_TLI_Request_Queue::enqueue (const char device[], 
				      int restart, int rwflag)
{
  ACE_TRACE ("ACE_TLI_Request_Queue::enqueue");
  ACE_TLI_Request *temp = this->alloc ();
  ACE_TLI_Request &req  = *this->tail_;
  int	      res;

  do 
    res = ACE_OS::t_listen (this->handle_, req.callp_);
  while (res == ACE_INVALID_HANDLE && restart && t_errno == TSYSERR && errno == EINTR);

  if (res != ACE_INVALID_HANDLE)
    {
      req.handle_ = open_new_endpoint (this->handle_, device, req.callp_, rwflag);

      if (req.handle_ != ACE_INVALID_HANDLE)
	{
	  temp->next_       = this->tail_->next_;
	  this->tail_->next_ = temp;
	  this->tail_       = temp;
	  this->current_count_++;
	  return 0;
	}
    }

  // Something must have gone wrong, so free up allocated space.
  this->free (temp);
  return ACE_INVALID_HANDLE;
}

// Locate and remove SEQUENCE_NUMBER from the list of pending
// connections.

int
ACE_TLI_Request_Queue::remove (int sequence_number)
{
  ACE_TRACE ("ACE_TLI_Request_Queue::remove");
  ACE_TLI_Request *prev = this->tail_;

  // Put the sequence # in the dummy node to simply the search...
  prev->callp_->sequence = sequence_number;  

  ACE_TLI_Request *temp;

  for (temp = this->tail_->next_;
       temp->callp_->sequence != sequence_number;
       temp = temp->next_)
    prev = temp;

  if (temp == this->tail_)
    // Sequence # was not found, since we're back at the dummy node!
    return -1;
  else
    {
      prev->next_ = temp->next_;
      ACE_OS::t_close (temp->handle_);
      this->current_count_--;
      this->free (temp);
      return 0;
    }
}

ACE_HANDLE 
ACE_TLI_Acceptor::open (const ACE_Addr &remote_sap, 
			int reuse_addr, 
			int oflag,
			struct t_info *info, 
			int qlen, 
			const char dev[])
{
  ACE_TRACE ("ACE_TLI_Acceptor::open");
  int res     = 0;
  int one     = 1;

  this->disp_ = 0;

  if ((this->device_ = ACE_OS::strdup (dev)) == 0)
    res = ACE_INVALID_HANDLE;
  else if (this->ACE_TLI::open (dev, oflag, info) == ACE_INVALID_HANDLE)
    res = ACE_INVALID_HANDLE;
  else if (reuse_addr 
	   && this->set_option (SOL_SOCKET, SO_REUSEADDR, 
				&one, sizeof one) == ACE_INVALID_HANDLE)
    res = ACE_INVALID_HANDLE;
  else if ((this->disp_ = 
	    (struct t_discon *) ACE_OS::t_alloc (this->get_handle (), T_DIS, T_ALL)) == 0)
    res = ACE_INVALID_HANDLE;
  else
    {
      struct t_bind req;

      this->backlog_  = qlen;
      req.qlen = qlen;
      req.addr.maxlen = remote_sap.get_size ();

      if (&remote_sap == &ACE_Addr::sap_any)
	// Note that if addr.len == 0 then ACE_TLI selects the port number.
	req.addr.len = 0;
      else
	{
	  req.addr.len = remote_sap.get_size ();
	  req.addr.buf = (char *) remote_sap.get_addr ();
	}

      res = ACE_OS::t_bind (this->get_handle (), &req, 0);
      if (res != ACE_INVALID_HANDLE)
	{
	  ACE_NEW_RETURN (this->queue_, ACE_TLI_Request_Queue, -1);

	  res = this->queue_->open (this->get_handle (), this->backlog_);
	}
    }

  if (res == ACE_INVALID_HANDLE)
    this->close ();
  return this->get_handle ();
}


ACE_TLI_Acceptor::ACE_TLI_Acceptor (const ACE_Addr &remote_sap, 
				    int reuse_addr, 
				    int oflag,
				    struct t_info *info, 
				    int back,
				    const char dev[])
{
  ACE_TRACE ("ACE_TLI_Acceptor::ACE_TLI_Acceptor");
  if (this->open (remote_sap, reuse_addr, oflag, 
		  info, back, dev) == ACE_INVALID_HANDLE)
    ACE_ERROR ((LM_ERROR, "%p\n", "ACE_TLI_Acceptor::ACE_TLI_Acceptor"));
}

int
ACE_TLI_Acceptor::close (void)
{
  ACE_TRACE ("ACE_TLI_Acceptor::close");
  if (this->device_ != 0)
    {
      if (this->queue_ != 0)
	{
	  this->queue_->close ();
	  delete this->queue_;
	}

      ACE_OS::t_free ((char *) this->disp_, T_DIS);
      ACE_OS::free (ACE_MALLOC_T (this->device_));
      this->disp_ = 0;
      this->device_ = 0;
      return this->ACE_TLI::close ();
    }
  return 0;
}

// Perform the logic required to handle the arrival of asynchronous
// events while we are trying to accept a new connection request.

int
ACE_TLI_Acceptor::handle_async_event (int restart, int rwf)
{
  ACE_TRACE ("ACE_TLI_Acceptor::handle_async_event");
  int event;
		      
  switch (event = this->look ())
    {
    case T_DISCONNECT: 
      this->rcvdis (this->disp_);
      this->queue_->remove (this->disp_->sequence);
      break;
    case T_LISTEN:
      this->queue_->enqueue (this->device_, restart, rwf);
      break;
    default:
      return -1;
    }
  return 0;
}

int
ACE_TLI_Acceptor::accept (ACE_TLI_Stream &new_tli_sap, 
			  ACE_Addr *remote_addr,
			  ACE_Time_Value *timeout, 
			  int restart, 
			  int rwf,
			  netbuf *udata,
			  netbuf *opt)
{
  ACE_TRACE ("ACE_TLI_Acceptor::accept");
  ACE_TLI_Request *req = 0;
  int res = 0;
  
  if (timeout != 0 
      && ACE::handle_timed_accept (this->get_handle (), 
				   timeout, restart) == -1)
    return -1;
  else if (this->queue_->is_empty ())
    {
      req = this->queue_->alloc ();

      do 
	res = ACE_OS::t_listen (this->get_handle (), req->callp_);
      while (res == ACE_INVALID_HANDLE 
	     && restart 
	     && errno == EINTR);

      if (res != ACE_INVALID_HANDLE)
	res = req->handle_ = open_new_endpoint (this->get_handle (), 
						this->device_, req->callp_, rwf);
    }
  else
    res = this->queue_->dequeue (req);

  if (udata != 0)
    ACE_OS::memcpy ((void *) &req->callp_->udata, (void *) udata, sizeof *udata);
  if (opt != 0)
    ACE_OS::memcpy ((void *) &req->callp_->opt, (void *) opt, sizeof *opt);

  while (res != ACE_INVALID_HANDLE)
    if ((res = ACE_OS::t_accept (this->get_handle (), req->handle_, 
				 req->callp_)) != ACE_INVALID_HANDLE)
      break; // Got one!
    else if (t_errno == TLOOK)
      res = this->handle_async_event (restart, rwf);
    else if (restart && t_errno == TSYSERR && errno == EINTR)
      res = 0;

  if (res == ACE_INVALID_HANDLE)
    {
      if (errno != EWOULDBLOCK)
	{
	  new_tli_sap.set_handle (ACE_INVALID_HANDLE);
	  if (req->handle_ != ACE_INVALID_HANDLE)
	    ACE_OS::t_close (req->handle_);
	}
    }
  else
    {
      new_tli_sap.set_handle (req->handle_);

      if (remote_addr != 0)
	remote_addr->set_addr ((void *) req->callp_->addr.buf, req->callp_->addr.len);
    }

  req->handle_ = ACE_INVALID_HANDLE;
  this->queue_->free (req);
  new_tli_sap.set_rwflag (rwf);
  return new_tli_sap.get_handle () == ACE_INVALID_HANDLE ? -1 : 0;
}

#endif /* ACE_HAS_TLI */