ACE/apps/JAWS2/JAWS/IO_Acceptor.cpp

   1 #include "JAWS/Data_Block.h"
   2 #include "JAWS/IO_Acceptor.h"
   3
   4 #include "ace/OS_NS_sys_socket.h"
   5
   6
   7 JAWS_IO_Acceptor::JAWS_IO_Acceptor ()
   8 {
   9 }
  10
  11 JAWS_IO_Acceptor::~JAWS_IO_Acceptor ()
  12 {
  13 }
  14
  15 int
  16 JAWS_IO_Acceptor::open (const ACE_INET_Addr &, int)
  17 {
  18   return -1;
  19 }
  20
  21 int
  22 JAWS_IO_Acceptor::open (const ACE_HANDLE &)
  23 {
  24   return -1;
  25 }
  26
  27 void
  28 JAWS_IO_Acceptor::close ()
  29 {
  30 }
  31
  32 int
  33 JAWS_IO_Acceptor::accept (ACE_SOCK_Stream &, ACE_Addr *, ACE_Time_Value *,
  34                           int, int) const
  35 {
  36   return -1;
  37 }
  38
  39 int
  40 JAWS_IO_Acceptor::accept (size_t, const void *)
  41 {
  42   return -1;
  43 }
  44
  45 ACE_HANDLE
  46 JAWS_IO_Acceptor::get_handle ()
  47 {
  48   return ACE_INVALID_HANDLE;
  49 }
  50
  51 int
  52 JAWS_IO_Synch_Acceptor::open (const ACE_INET_Addr &local_sap, int backlog)
  53 {
  54   return this->acceptor_.open (local_sap, 1, PF_INET, backlog);
  55 }
  56
  57 int
  58 JAWS_IO_Synch_Acceptor::open (const ACE_HANDLE &socket)
  59 {
  60   ACE_HANDLE handle = this->acceptor_.get_handle ();
  61   if (handle == socket)
  62     return 0;
  63
  64   if (handle != ACE_INVALID_HANDLE)
  65     ACE_OS::closesocket (this->acceptor_.get_handle ());
  66   this->acceptor_.set_handle (socket);
  67
  68   return 0;
  69 }
  70
  71 int
  72 JAWS_IO_Synch_Acceptor::accept (ACE_SOCK_Stream &new_stream,
  73                                 ACE_Addr *remote_addr,
  74                                 ACE_Time_Value *timeout,
  75                                 int restart,
  76                                 int reset_new_handle) const
  77 {
  78   return this->acceptor_.accept (new_stream, remote_addr, timeout,
  79                                  restart, reset_new_handle);
  80 }
  81
  82 int
  83 JAWS_IO_Synch_Acceptor::accept (size_t, const void *)
  84 {
  85   return -1;
  86 }
  87
  88 ACE_HANDLE
  89 JAWS_IO_Synch_Acceptor::get_handle ()
  90 {
  91   return this->acceptor_.get_handle ();
  92 }
  93
  94
  95 JAWS_IO_Asynch_Acceptor::JAWS_IO_Asynch_Acceptor ()
  96 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || defined (ACE_HAS_AIO_CALLS)
  97   : acceptor_ (*(new ACE_Asynch_Acceptor<JAWS_Asynch_Handler>)),
  98     acceptor_ptr_ (&acceptor_)
  99 #endif
 100 {
 101 }
 102
 103 JAWS_IO_Asynch_Acceptor::~JAWS_IO_Asynch_Acceptor ()
 104 {
 105 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || defined (ACE_HAS_AIO_CALLS)
 106   delete this->acceptor_ptr_;
 107   this->acceptor_ptr_ = 0;
 108 #endif
 109 }
 110
 111 int
 112 JAWS_IO_Asynch_Acceptor::open (const ACE_INET_Addr &address, int backlog)
 113 {
 114 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || defined (ACE_HAS_AIO_CALLS)
 115   // Tell the acceptor to listen on this->port_, which sets up an
 116   // asynchronous I/O request to the OS.
 117
 118   return this->acceptor_.open (address,
 119                                JAWS_Data_Block::JAWS_DATA_BLOCK_SIZE,
 120                                1,
 121                                backlog,
 122                                1,
 123                                0,
 124                                0,
 125                                0,
 126                                0);
 127
 128 #else
 129   ACE_UNUSED_ARG (address);
 130   ACE_UNUSED_ARG (backlog);
 131   return -1;
 132 #endif /* ACE_HAS_WIN32_OVERLAPPED_IO || ACE_HAS_AIO_CALLS */
 133 }
 134
 135 int
 136 JAWS_IO_Asynch_Acceptor::open (const ACE_HANDLE &socket)
 137 {
 138 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || defined (ACE_HAS_AIO_CALLS)
 139   ACE_HANDLE handle = this->handle_;
 140   if (handle == socket)
 141     return 0;
 142
 143   if (handle != ACE_INVALID_HANDLE)
 144     ACE_OS::closesocket (handle);
 145   this->handle_ = socket;
 146
 147   return 0;
 148 #else
 149   ACE_UNUSED_ARG (socket);
 150   return -1;
 151 #endif /* ACE_HAS_WIN32_OVERLAPPED_IO || ACE_HAS_AIO_CALLS */
 152 }
 153
 154 int
 155 JAWS_IO_Asynch_Acceptor::accept (size_t bytes_to_read, const void *act)
 156 {
 157 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || defined (ACE_HAS_AIO_CALLS)
 158   return this->acceptor_.accept (bytes_to_read, act);
 159 #else
 160   ACE_UNUSED_ARG (bytes_to_read);
 161   ACE_UNUSED_ARG (act);
 162   return -1;
 163 #endif /* ACE_HAS_WIN32_OVERLAPPED_IO || ACE_HAS_AIO_CALLS */
 164 }
 165
 166 int
 167 JAWS_IO_Asynch_Acceptor::accept (ACE_SOCK_Stream &, ACE_Addr *,
 168                                  ACE_Time_Value *, int, int) const
 169 {
 170   return -1;
 171 }
 172
 173 ACE_HANDLE
 174 JAWS_IO_Asynch_Acceptor::get_handle ()
 175 {
 176 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || defined (ACE_HAS_AIO_CALLS)
 177   return this->acceptor_.get_handle ();
 178 #else
 179   return ACE_INVALID_HANDLE;
 180 #endif /* ACE_HAS_WIN32_OVERLAPPED_IO || ACE_HAS_AIO_CALLS */
 181 }
 182
 183
 184 void
 185 JAWS_IO_Asynch_Acceptor::close ()
 186 {
 187 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || defined (ACE_HAS_AIO_CALLS)
 188   delete this->acceptor_ptr_;
 189   this->acceptor_ptr_ = 0;
 190 #endif /* ACE_HAS_WIN32_OVERLAPPED_IO || ACE_HAS_AIO_CALLS */
 191 }
 192