Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

ACE_ATM_Acceptor Class Reference

Defines the member functions for ACE_ATM_Acceptor abstraction. More...

#include <ATM_Acceptor.h>

List of all members.

Public Types

typedef ACE_ATM_Addr PEER_ADDR
typedef ACE_ATM_Stream PEER_STREAM

Public Member Functions

 ACE_ATM_Acceptor (void)
 Default constructor.

 ~ACE_ATM_Acceptor ()
 ACE_ATM_Acceptor (const ACE_Addr &remote_sap, int backlog=ACE_DEFAULT_BACKLOG, ACE_ATM_Params params=ACE_ATM_Params())
 Initiate a passive mode connection.

ACE_HANDLE open (const ACE_Addr &remote_sap, int backlog=ACE_DEFAULT_BACKLOG, ACE_ATM_Params params=ACE_ATM_Params())
 Initiate a passive mode socket.

int close (void)
 Close down the acceptor and release resources.

int accept (ACE_ATM_Stream &new_sap, ACE_Addr *remote_addr=0, ACE_Time_Value *timeout=0, int restart=1, int reset_new_handle=0, ACE_ATM_Params params=ACE_ATM_Params(), ACE_ATM_QoS qos=ACE_ATM_QoS())
int get_local_addr (ACE_ATM_Addr &local_addr)
 Get the local address currently listening on.

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


Public Attributes

 ACE_ALLOC_HOOK_DECLARE
 Declare the dynamic allocation hooks.


Private Attributes

ATM_Acceptor acceptor_

Detailed Description

Defines the member functions for ACE_ATM_Acceptor abstraction.

This class wraps up the ACE_SOCK_Acceptor and ACE_TLI_Acceptor to make the mechanism for the ATM protocol transparent.

Definition at line 60 of file ATM_Acceptor.h.

Member Typedef Documentation

typedef ACE_ATM_Addr ACE_ATM_Acceptor::PEER_ADDR
 

Definition at line 100 of file ATM_Acceptor.h.

typedef ACE_ATM_Stream ACE_ATM_Acceptor::PEER_STREAM
 

Definition at line 101 of file ATM_Acceptor.h.

Constructor & Destructor Documentation

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_ATM_Acceptor::ACE_ATM_Acceptor (  void   ) 
 

Default constructor.

Definition at line 26 of file ATM_Acceptor.cpp.

References ACE_TRACE. 

00027 {
00028   ACE_TRACE ("ACE_ATM_Acceptor::ACE_ATM_Acceptor");
00029 }

ACE_ATM_Acceptor::~ACE_ATM_Acceptor (   ) 
 

Definition at line 31 of file ATM_Acceptor.cpp.

References ACE_TRACE. 

00032 {
00033   ACE_TRACE ("ACE_ATM_Acceptor::~ACE_ATM_Acceptor");
00034 }

ACE_INLINE ACE_ATM_Acceptor::ACE_ATM_Acceptor (  const ACE_Addr &  remote_sap,
int  backlog = ACE_DEFAULT_BACKLOG,
ACE_ATM_Params  params = ACE_ATM_Params()
) 
 

Initiate a passive mode connection.

Definition at line 17 of file ATM_Acceptor.inl.

References ACE_ERROR, ACE_LIB_TEXT, ACE_TRACE, LM_ERROR, and open(). 

00020 {
00021   ACE_TRACE ("ACE_ATM_Acceptor::ACE_ATM_Acceptor");
00022   if (open (remote_sap,
00023             backlog,
00024             params) < 0)
00025     ACE_ERROR ((LM_ERROR,
00026                 ACE_LIB_TEXT ("%p\n"),
00027                 ACE_LIB_TEXT ("ACE_ATM_Acceptor::ACE_ATM_Acceptor")));
00028 }

Member Function Documentation

int ACE_ATM_Acceptor::accept (  ACE_ATM_Stream &  new_sap,
ACE_Addr *  remote_addr = 0,
ACE_Time_Value *  timeout = 0,
int  restart = 1,
int  reset_new_handle = 0,
ACE_ATM_Params  params = ACE_ATM_Params(),
ACE_ATM_QoS  qos = ACE_ATM_QoS()
) 
 

Accept a new data transfer connection. A timeout of 0 means block forever, a timeout of {0, 0} means poll. restart == 1 means "restart if interrupted."

Definition at line 236 of file ATM_Acceptor.cpp.

References ACE_OS::accept(), acceptor_, ACE_TRACE, ATM_QoS, ACE_ATM_QoS::get_qos(), ACE_ATM_Params::get_rw_flag(), ACE_ATM_Stream::get_stream(), ACE_ATM_Params::get_user_data(), ACE_OS::printf(), and ACE_OS::setsockopt(). 

00243 {
00244   ACE_TRACE ("ACE_ATM_Acceptor::accept");
00245 #if defined (ACE_HAS_FORE_ATM_XTI)
00246   ATM_QoS optbuf = qos.get_qos ();
00247 
00248   return (acceptor_.accept (new_sap.get_stream (),
00249                            remote_addr,
00250                            timeout,
00251                            restart,
00252                            reset_new_handle,
00253                            params.get_rw_flag (),
00254                            params.get_user_data (),
00255                            &optbuf));
00256 #elif defined (ACE_HAS_FORE_ATM_WS2)
00257   ACE_HANDLE n_handle;
00258   ACE_HANDLE s_handle = ((ACE_SOCK_Acceptor *) this) -> get_handle ();
00259   struct sockaddr_atm *cli_addr
00260     = (struct sockaddr_atm *)remote_addr -> get_addr ();
00261   int caddr_len = sizeof (struct sockaddr_atm);
00262 
00263   do {
00264     n_handle = ACE_OS::accept (s_handle,
00265                                reinterpret_cast<struct sockaddr *> (cli_addr),
00266                               &caddr_len);
00267   } while (n_handle == ACE_INVALID_HANDLE && errno == EINTR);
00268 
00269  ((ACE_ATM_Addr *)remote_addr) -> set (cli_addr,
00270  ((ACE_ATM_Addr *)remote_addr) -> get_selector ());
00271  ((ACE_IPC_SAP *)&new_sap) -> set_handle (n_handle);
00272 
00273   return 0;
00274 #elif defined (ACE_HAS_LINUX_ATM)
00275   ACE_UNUSED_ARG (params);
00276 
00277   ACE_HANDLE s_handle = ((ACE_SOCK_Acceptor *) this) -> get_handle ();
00278   struct atm_qos accept_qos = qos.get_qos ();
00279 
00280   if (ACE_OS::setsockopt (s_handle,
00281                          SOL_ATM,
00282                          SO_ATMQOS,
00283                          reinterpret_cast<char*> (&accept_qos),
00284                          sizeof (accept_qos)) < 0) {
00285     ACE_OS::printf ("Acceptor (accept): error setting Qos");
00286   }
00287 
00288   return (acceptor_.accept (new_sap.get_stream (),
00289                           remote_addr,
00290                           timeout,
00291                           restart,
00292                           reset_new_handle));
00293 #else
00294   ACE_UNUSED_ARG (new_sap);
00295   ACE_UNUSED_ARG (remote_addr);
00296   ACE_UNUSED_ARG (timeout);
00297   ACE_UNUSED_ARG (restart);
00298   ACE_UNUSED_ARG (reset_new_handle);
00299   ACE_UNUSED_ARG (params);
00300   ACE_UNUSED_ARG (qos);
00301   return (0);
00302 #endif /* ACE_HAS_FORE_ATM_XTI */
00303 }

ACE_INLINE int ACE_ATM_Acceptor::close (  void   ) 
 

Close down the acceptor and release resources.

Definition at line 32 of file ATM_Acceptor.inl.

References acceptor_. 

00033 {
00034 #if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) || defined (ACE_HAS_LINUX_ATM)
00035   return (acceptor_.close());
00036 #else
00037   return 0;
00038 #endif // ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM
00039 }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE void ACE_ATM_Acceptor::dump (  void   )  const
 

Dump the state of an object.

Definition at line 9 of file ATM_Acceptor.inl.

References ACE_TRACE. 

00010 {
00011 #if defined (ACE_HAS_DUMP)
00012   ACE_TRACE ("ACE_ATM_Acceptor::dump");
00013 #endif /* ACE_HAS_DUMP */
00014 }

int ACE_ATM_Acceptor::get_local_addr (  ACE_ATM_Addr &  local_addr  ) 
 

Get the local address currently listening on.

Definition at line 37 of file ATM_Acceptor.cpp.

References acceptor_, ACE_DEBUG, ACE_LIB_TEXT, ACE_TRACE, ATM_Addr, ACE_ATM_Addr::get_addr(), ACE_OS::getsockname(), LM_DEBUG, ACE_OS::memcpy(), and ACE_OS::printf(). 

00038 {
00039   ACE_TRACE ("ACE_ATM_Acceptor::get_local_addr");
00040 
00041 #if defined (ACE_HAS_FORE_ATM_WS2)
00042   unsigned long ret = 0;
00043   DWORD deviceID = 0;
00044   ATM_ADDRESS addr;
00045   struct sockaddr_atm *laddr;
00046 
00047   if (::WSAIoctl ((int) ((ACE_SOCK_Acceptor *)this) -> get_handle (),
00048                 SIO_GET_ATM_ADDRESS,
00049  (LPVOID) &deviceID,
00050                 sizeof (DWORD),
00051  (LPVOID)&addr,
00052                 sizeof (ATM_ADDRESS),
00053                 &ret,
00054                 0,
00055                 0) == SOCKET_ERROR) {
00056     ACE_OS::printf ("ATM_Acceptor (get_local_addr): WSIoctl: %d\n",
00057                     ::WSAGetLastError ());
00058     return -1;
00059   }
00060 
00061   laddr = (struct sockaddr_atm *)local_addr.get_addr ();
00062   ACE_OS::memcpy ((void *)& (laddr -> satm_number),
00063  (void *)&addr,
00064                  ATM_ADDR_SIZE - 1);
00065 
00066   return 0;
00067 #elif defined (ACE_HAS_FORE_ATM_XTI)
00068   ACE_UNUSED_ARG (local_addr);
00069 
00070   return 0;
00071 #elif defined (ACE_HAS_LINUX_ATM)
00072   ATM_Addr *myaddr = (ATM_Addr *)local_addr.get_addr ();
00073   int addrlen = sizeof (myaddr->sockaddratmsvc);
00074 
00075   if (ACE_OS::getsockname (acceptor_.get_handle (),
00076  (struct sockaddr *) & (myaddr->sockaddratmsvc),
00077                           &addrlen) < 0) {
00078     ACE_DEBUG ((LM_DEBUG,
00079                ACE_LIB_TEXT ("ATM_Acceptor (get_local_addr): ioctl: %d\n"),
00080                errno));
00081     return -1;
00082   }
00083 
00084   return (0);
00085 #else
00086   ACE_UNUSED_ARG (local_addr);
00087 
00088   return 0;
00089 #endif /* ACE_HAS_FORE_ATM_WS2 && ACE_HAS_FORE_ATM_XTI */
00090 }

ACE_HANDLE ACE_ATM_Acceptor::open (  const ACE_Addr &  remote_sap,
int  backlog = ACE_DEFAULT_BACKLOG,
ACE_ATM_Params  params = ACE_ATM_Params()
) 
 

Initiate a passive mode socket.

Definition at line 93 of file ATM_Acceptor.cpp.

References acceptor_, ACE_DEBUG, ACE_FLAG_MULTIPOINT_C_LEAF, ACE_FLAG_MULTIPOINT_D_LEAF, ACE_LIB_TEXT, ACE_TRACE, ATM_Addr, ATM_QoS, ACE_OS::bind(), ACE_ATM_Addr::get_addr(), ACE_ATM_Params::get_device(), ACE_ATM_Params::get_flags(), ACE_ATM_Params::get_info(), ACE_ATM_Params::get_oflag(), ACE_ATM_Params::get_protocol(), ACE_ATM_Params::get_protocol_family(), ACE_ATM_Params::get_protocol_info(), ACE_ATM_QoS::get_qos(), ACE_ATM_Params::get_reuse_addr(), ACE_ATM_Params::get_sock_group(), ACE_ATM_Params::get_type(), ACE_OS::ioctl(), ACE_OS::listen(), LM_DEBUG, ACE_OS::memset(), ACE_OS::perror(), ACE_OS::printf(), ACE_ATM_Addr::set_selector(), ACE_OS::setsockopt(), and ACE_OS::socket().

Referenced by ACE_ATM_Acceptor(). 

00096 {
00097   ACE_TRACE ("ACE_ATM_Acceptor::open");
00098 #if defined (ACE_HAS_FORE_ATM_XTI)
00099   ACE_HANDLE handle = acceptor_.open (remote_sap,
00100                                       params.get_reuse_addr (),
00101                                       params.get_oflag (),
00102                                       params.get_info (),
00103                                       backlog,
00104                                       params.get_device ());
00105   return (handle == ACE_INVALID_HANDLE ? -1 : 0);
00106 #elif defined (ACE_HAS_FORE_ATM_WS2)
00107   struct sockaddr_atm local_atm_addr;
00108   ACE_HANDLE ret;
00109   DWORD flags = 0;
00110 
00111   /* Create a local endpoint of communication */
00112 
00113   // Only leaves can listen.
00114   flags = ACE_FLAG_MULTIPOINT_C_LEAF | ACE_FLAG_MULTIPOINT_D_LEAF;
00115 
00116   if ((ret = ACE_OS::socket (AF_ATM,
00117                              SOCK_RAW,
00118                              ATMPROTO_AAL5,
00119                              0,
00120                              0,
00121                              flags))
00122       == ACE_INVALID_HANDLE) {
00123     ACE_OS::printf ("Acceptor (open): socket %d\n",
00124                     ::WSAGetLastError ());
00125     return (ret);
00126   }
00127 
00128  ((ACE_SOCK_Acceptor *)this) -> set_handle (ret);
00129 
00130   /* Set up the address information to become a server */
00131   ACE_OS::memset ((void *) &local_atm_addr, 0, sizeof local_atm_addr);
00132   local_atm_addr.satm_family = AF_ATM;
00133   local_atm_addr.satm_number.AddressType = SAP_FIELD_ANY_AESA_REST;
00134   local_atm_addr.satm_number.Addr[ ATM_ADDR_SIZE - 1 ]
00135     = ((ACE_ATM_Addr *)&remote_sap) -> get_selector ();
00136   local_atm_addr.satm_blli.Layer2Protocol = SAP_FIELD_ANY;
00137   local_atm_addr.satm_blli.Layer3Protocol = SAP_FIELD_ABSENT;
00138   local_atm_addr.satm_bhli.HighLayerInfoType = SAP_FIELD_ABSENT;
00139 
00140   /* Associate address with endpoint */
00141   if (ACE_OS::bind (((ACE_SOCK_Acceptor *)this) -> get_handle (),
00142                     reinterpret_cast<struct sockaddr *> (&local_atm_addr),
00143                     sizeof local_atm_addr) == -1) {
00144     ACE_OS::printf ("Acceptor (open): bind %d\n", ::WSAGetLastError ());
00145     return (ACE_INVALID_HANDLE);
00146   }
00147 
00148   /* Make endpoint listen for service requests */
00149   if (ACE_OS::listen (( (ACE_SOCK_Acceptor *)this) -> get_handle (),
00150                       backlog)
00151                     == -1) {
00152     ACE_OS::printf ("Acceptor (open): listen %d\n", ::WSAGetLastError ());
00153     return (ACE_INVALID_HANDLE);
00154   }
00155 
00156   return 0;
00157 #elif defined (ACE_HAS_LINUX_ATM)
00158   //we need to set the qos before binding to the socket
00159   //use remote_sap as local_sap
00160 
00161   ACE_ATM_Addr local_sap;
00162   ATM_Addr *local_sap_addr = (ATM_Addr*)local_sap.get_addr ();
00163   ACE_ATM_QoS def_qos;
00164   ATM_QoS qos = def_qos.get_qos ();
00165 
00166   ACE_HANDLE handle;
00167   if ((handle = ACE_OS::socket (params.get_protocol_family (),
00168                                 params.get_type (),
00169                                 params.get_protocol (),
00170                                 params.get_protocol_info (),
00171                                 params.get_sock_group (),
00172                                 params.get_flags ()
00173                                ))
00174       == ACE_INVALID_HANDLE) {
00175     ACE_DEBUG (LM_DEBUG,
00176               ACE_LIB_TEXT ("Acceptor (socket): socket %d\n"),
00177               errno);
00178     return (ACE_INVALID_HANDLE);
00179   }
00180 
00181  ((ACE_SOCK_Acceptor *)this) -> set_handle (handle);
00182   if (ACE_OS::setsockopt (handle,
00183                          SOL_ATM,
00184                          SO_ATMQOS,
00185                          reinterpret_cast<char*> (&qos),
00186                          sizeof (qos)) < 0) {
00187     ACE_OS::printf ("Acceptor (setsockopt): setsockopt:%d\n",
00188                    errno);
00189   }
00190 
00191   struct atmif_sioc req;
00192   struct sockaddr_atmsvc aux_addr[1024];
00193 
00194   req.number = 0;
00195   req.arg = aux_addr;
00196   req.length = sizeof (aux_addr);
00197   if (ACE_OS::ioctl (handle,
00198                     ATM_GETADDR,
00199                     &req) < 0) {
00200     ACE_OS::perror ("Acceptor (setsockopt): ioctl:");
00201   }
00202   else {
00203     local_sap_addr->sockaddratmsvc = aux_addr[0];
00204   }
00205   local_sap.set_selector (( (ACE_ATM_Addr*)&remote_sap)->get_selector ());
00206 
00207   if (ACE_OS::bind (handle,
00208                     reinterpret_cast<struct sockaddr *> (
00209                       &(local_sap_addr->sockaddratmsvc)),
00210                     sizeof (local_sap_addr->sockaddratmsvc)
00211                    ) == -1) {
00212     ACE_DEBUG (LM_DEBUG,
00213               ACE_LIB_TEXT ("Acceptor (open): bind %d\n"),
00214               errno);
00215     return -1;
00216   }
00217   // Make endpoint listen for service requests
00218   if (ACE_OS::listen (handle,
00219                       backlog)
00220       == -1) {
00221     ACE_DEBUG (LM_DEBUG,
00222               ACE_LIB_TEXT ("Acceptor (listen): listen %d\n"),
00223               errno);
00224     return -1;
00225   }
00226 
00227   return 0;
00228 #else
00229   ACE_UNUSED_ARG (remote_sap);
00230   ACE_UNUSED_ARG (backlog);
00231   ACE_UNUSED_ARG (params);
00232 #endif /* ACE_HAS_FORE_ATM_XTI/ACE_HAS_FORE_ATM_WS2/ACE_HAS_LINUX_ATM */
00233 }

Member Data Documentation

ATM_Acceptor ACE_ATM_Acceptor::acceptor_ [private]
 

Definition at line 110 of file ATM_Acceptor.h.

Referenced by accept(), close(), get_local_addr(), and open().

ACE_ATM_Acceptor::ACE_ALLOC_HOOK_DECLARE
 

Declare the dynamic allocation hooks.

Definition at line 107 of file ATM_Acceptor.h.

The documentation for this class was generated from the following files:
Generated on Thu Nov 9 11:20:08 2006 for ACE by doxygen 1.3.6