dep/ACE_wrappers/ace/ATM_Acceptor.cpp

   1 // $Id: ATM_Acceptor.cpp 80826 2008-03-04 14:51:23Z wotte $
   2
   3 #include "ace/ATM_Acceptor.h"
   4
   5 ACE_RCSID(ace, ATM_Acceptor, "$Id: ATM_Acceptor.cpp 80826 2008-03-04 14:51:23Z wotte $")
   6
   7 #if defined (ACE_HAS_ATM)
   8
   9 #if defined (ACE_HAS_LINUX_ATM)
  10 #include /**/ "linux/atmdev.h"
  11 #endif /* ACE_HAS_LINUX_ATM */
  12
  13 #if !defined (__ACE_INLINE__)
  14 #include "ace/ATM_Acceptor.inl"
  15 #endif /* __ACE_INLINE__ */
  16
  17
  18 // Open versioned namespace, if enabled by the user.
  19 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  20
  21 // Put the actual definitions of the ACE_ATM_Request and
  22 // ACE_ATM_Request_Queue classes here to hide them from clients...
  23
  24 ACE_ALLOC_HOOK_DEFINE(ACE_ATM_Acceptor)
  25
  26 ACE_ATM_Acceptor::ACE_ATM_Acceptor (void)
  27 {
  28   ACE_TRACE ("ACE_ATM_Acceptor::ACE_ATM_Acceptor");
  29 }
  30
  31 ACE_ATM_Acceptor::~ACE_ATM_Acceptor (void)
  32 {
  33   ACE_TRACE ("ACE_ATM_Acceptor::~ACE_ATM_Acceptor");
  34 }
  35
  36 int
  37 ACE_ATM_Acceptor::get_local_addr (ACE_ATM_Addr &local_addr)
  38 {
  39   ACE_TRACE ("ACE_ATM_Acceptor::get_local_addr");
  40
  41 #if defined (ACE_HAS_FORE_ATM_WS2)
  42   unsigned long ret = 0;
  43   DWORD deviceID = 0;
  44   ATM_ADDRESS addr;
  45   struct sockaddr_atm *laddr;
  46
  47   if (::WSAIoctl ((int) ((ACE_SOCK_Acceptor *)this) -> get_handle (),
  48                 SIO_GET_ATM_ADDRESS,
  49  (LPVOID) &deviceID,
  50                 sizeof (DWORD),
  51  (LPVOID)&addr,
  52                 sizeof (ATM_ADDRESS),
  53                 &ret,
  54                 0,
  55                 0) == SOCKET_ERROR) {
  56     ACE_OS::printf ("ATM_Acceptor (get_local_addr): WSIoctl: %d\n",
  57                     ::WSAGetLastError ());
  58     return -1;
  59   }
  60
  61   laddr = (struct sockaddr_atm *)local_addr.get_addr ();
  62   ACE_OS::memcpy ((void *)& (laddr -> satm_number),
  63  (void *)&addr,
  64                  ATM_ADDR_SIZE - 1);
  65
  66   return 0;
  67 #elif defined (ACE_HAS_FORE_ATM_XTI)
  68   ACE_UNUSED_ARG (local_addr);
  69
  70   return 0;
  71 #elif defined (ACE_HAS_LINUX_ATM)
  72   ATM_Addr *myaddr = (ATM_Addr *)local_addr.get_addr ();
  73   int addrlen = sizeof (myaddr->sockaddratmsvc);
  74
  75   if (ACE_OS::getsockname (acceptor_.get_handle (),
  76  (struct sockaddr *) & (myaddr->sockaddratmsvc),
  77                           &addrlen) < 0) {
  78     ACE_DEBUG ((LM_DEBUG,
  79                ACE_TEXT ("ATM_Acceptor (get_local_addr): ioctl: %d\n"),
  80                errno));
  81     return -1;
  82   }
  83
  84   return (0);
  85 #else
  86   ACE_UNUSED_ARG (local_addr);
  87
  88   return 0;
  89 #endif /* ACE_HAS_FORE_ATM_WS2 && ACE_HAS_FORE_ATM_XTI */
  90 }
  91
  92 ACE_HANDLE
  93 ACE_ATM_Acceptor::open (const ACE_Addr &remote_sap,
  94                         int backlog,
  95                         ACE_ATM_Params params)
  96 {
  97   ACE_TRACE ("ACE_ATM_Acceptor::open");
  98 #if defined (ACE_HAS_FORE_ATM_XTI)
  99   ACE_HANDLE handle = acceptor_.open (remote_sap,
 100                                       params.get_reuse_addr (),
 101                                       params.get_oflag (),
 102                                       params.get_info (),
 103                                       backlog,
 104                                       params.get_device ());
 105   return (handle == ACE_INVALID_HANDLE ? -1 : 0);
 106 #elif defined (ACE_HAS_FORE_ATM_WS2)
 107   struct sockaddr_atm local_atm_addr;
 108   ACE_HANDLE ret;
 109   DWORD flags = 0;
 110
 111   /* Create a local endpoint of communication */
 112
 113   // Only leaves can listen.
 114   flags = ACE_FLAG_MULTIPOINT_C_LEAF | ACE_FLAG_MULTIPOINT_D_LEAF;
 115
 116   if ((ret = ACE_OS::socket (AF_ATM,
 117                              SOCK_RAW,
 118                              ATMPROTO_AAL5,
 119                              0,
 120                              0,
 121                              flags))
 122       == ACE_INVALID_HANDLE) {
 123     ACE_OS::printf ("Acceptor (open): socket %d\n",
 124                     ::WSAGetLastError ());
 125     return (ret);
 126   }
 127
 128  ((ACE_SOCK_Acceptor *)this) -> set_handle (ret);
 129
 130   /* Set up the address information to become a server */
 131   ACE_OS::memset ((void *) &local_atm_addr, 0, sizeof local_atm_addr);
 132   local_atm_addr.satm_family = AF_ATM;
 133   local_atm_addr.satm_number.AddressType = SAP_FIELD_ANY_AESA_REST;
 134   local_atm_addr.satm_number.Addr[ ATM_ADDR_SIZE - 1 ]
 135     = ((ACE_ATM_Addr *)&remote_sap) -> get_selector ();
 136   local_atm_addr.satm_blli.Layer2Protocol = SAP_FIELD_ANY;
 137   local_atm_addr.satm_blli.Layer3Protocol = SAP_FIELD_ABSENT;
 138   local_atm_addr.satm_bhli.HighLayerInfoType = SAP_FIELD_ABSENT;
 139
 140   /* Associate address with endpoint */
 141   if (ACE_OS::bind (((ACE_SOCK_Acceptor *)this) -> get_handle (),
 142                     reinterpret_cast<struct sockaddr *> (&local_atm_addr),
 143                     sizeof local_atm_addr) == -1) {
 144     ACE_OS::printf ("Acceptor (open): bind %d\n", ::WSAGetLastError ());
 145     return (ACE_INVALID_HANDLE);
 146   }
 147
 148   /* Make endpoint listen for service requests */
 149   if (ACE_OS::listen (( (ACE_SOCK_Acceptor *)this) -> get_handle (),
 150                       backlog)
 151                     == -1) {
 152     ACE_OS::printf ("Acceptor (open): listen %d\n", ::WSAGetLastError ());
 153     return (ACE_INVALID_HANDLE);
 154   }
 155
 156   return 0;
 157 #elif defined (ACE_HAS_LINUX_ATM)
 158   //we need to set the qos before binding to the socket
 159   //use remote_sap as local_sap
 160
 161   ACE_ATM_Addr local_sap;
 162   ATM_Addr *local_sap_addr = (ATM_Addr*)local_sap.get_addr ();
 163   ACE_ATM_QoS def_qos;
 164   ATM_QoS qos = def_qos.get_qos ();
 165
 166   ACE_HANDLE handle;
 167   if ((handle = ACE_OS::socket (params.get_protocol_family (),
 168                                 params.get_type (),
 169                                 params.get_protocol (),
 170                                 params.get_protocol_info (),
 171                                 params.get_sock_group (),
 172                                 params.get_flags ()
 173                                ))
 174       == ACE_INVALID_HANDLE) {
 175     ACE_DEBUG (LM_DEBUG,
 176               ACE_TEXT ("Acceptor (socket): socket %d\n"),
 177               errno);
 178     return (ACE_INVALID_HANDLE);
 179   }
 180
 181  ((ACE_SOCK_Acceptor *)this) -> set_handle (handle);
 182   if (ACE_OS::setsockopt (handle,
 183                          SOL_ATM,
 184                          SO_ATMQOS,
 185                          reinterpret_cast<char*> (&qos),
 186                          sizeof (qos)) < 0) {
 187     ACE_OS::printf ("Acceptor (setsockopt): setsockopt:%d\n",
 188                    errno);
 189   }
 190
 191   struct atmif_sioc req;
 192   struct sockaddr_atmsvc aux_addr[1024];
 193
 194   req.number = 0;
 195   req.arg = aux_addr;
 196   req.length = sizeof (aux_addr);
 197   if (ACE_OS::ioctl (handle,
 198                     ATM_GETADDR,
 199                     &req) < 0) {
 200     ACE_OS::perror ("Acceptor (setsockopt): ioctl:");
 201   }
 202   else {
 203     local_sap_addr->sockaddratmsvc = aux_addr[0];
 204   }
 205   local_sap.set_selector (( (ACE_ATM_Addr*)&remote_sap)->get_selector ());
 206
 207   if (ACE_OS::bind (handle,
 208                     reinterpret_cast<struct sockaddr *> (
 209                       &(local_sap_addr->sockaddratmsvc)),
 210                     sizeof (local_sap_addr->sockaddratmsvc)
 211                    ) == -1) {
 212     ACE_DEBUG (LM_DEBUG,
 213               ACE_TEXT ("Acceptor (open): bind %d\n"),
 214               errno);
 215     return -1;
 216   }
 217   // Make endpoint listen for service requests
 218   if (ACE_OS::listen (handle,
 219                       backlog)
 220       == -1) {
 221     ACE_DEBUG (LM_DEBUG,
 222               ACE_TEXT ("Acceptor (listen): listen %d\n"),
 223               errno);
 224     return -1;
 225   }
 226
 227   return 0;
 228 #else
 229   ACE_UNUSED_ARG (remote_sap);
 230   ACE_UNUSED_ARG (backlog);
 231   ACE_UNUSED_ARG (params);
 232 #endif /* ACE_HAS_FORE_ATM_XTI/ACE_HAS_FORE_ATM_WS2/ACE_HAS_LINUX_ATM */
 233 }
 234
 235 int
 236 ACE_ATM_Acceptor::accept (ACE_ATM_Stream &new_sap,
 237                           ACE_Addr *remote_addr,
 238                           ACE_Time_Value *timeout,
 239                           int restart,
 240                           int reset_new_handle,
 241                           ACE_ATM_Params params,
 242                           ACE_ATM_QoS qos)
 243 {
 244   ACE_TRACE ("ACE_ATM_Acceptor::accept");
 245 #if defined (ACE_HAS_FORE_ATM_XTI)
 246   ATM_QoS optbuf = qos.get_qos ();
 247
 248   return (acceptor_.accept (new_sap.get_stream (),
 249                            remote_addr,
 250                            timeout,
 251                            restart,
 252                            reset_new_handle,
 253                            params.get_rw_flag (),
 254                            params.get_user_data (),
 255                            &optbuf));
 256 #elif defined (ACE_HAS_FORE_ATM_WS2)
 257   ACE_HANDLE n_handle;
 258   ACE_HANDLE s_handle = ((ACE_SOCK_Acceptor *) this) -> get_handle ();
 259   struct sockaddr_atm *cli_addr
 260     = (struct sockaddr_atm *)remote_addr -> get_addr ();
 261   int caddr_len = sizeof (struct sockaddr_atm);
 262
 263   do {
 264     n_handle = ACE_OS::accept (s_handle,
 265                                reinterpret_cast<struct sockaddr *> (cli_addr),
 266                               &caddr_len);
 267   } while (n_handle == ACE_INVALID_HANDLE && errno == EINTR);
 268
 269  ((ACE_ATM_Addr *)remote_addr) -> set (cli_addr,
 270  ((ACE_ATM_Addr *)remote_addr) -> get_selector ());
 271  ((ACE_IPC_SAP *)&new_sap) -> set_handle (n_handle);
 272
 273   return 0;
 274 #elif defined (ACE_HAS_LINUX_ATM)
 275   ACE_UNUSED_ARG (params);
 276
 277   ACE_HANDLE s_handle = ((ACE_SOCK_Acceptor *) this) -> get_handle ();
 278   struct atm_qos accept_qos = qos.get_qos ();
 279
 280   if (ACE_OS::setsockopt (s_handle,
 281                          SOL_ATM,
 282                          SO_ATMQOS,
 283                          reinterpret_cast<char*> (&accept_qos),
 284                          sizeof (accept_qos)) < 0) {
 285     ACE_OS::printf ("Acceptor (accept): error setting Qos");
 286   }
 287
 288   return (acceptor_.accept (new_sap.get_stream (),
 289                           remote_addr,
 290                           timeout,
 291                           restart,
 292                           reset_new_handle));
 293 #else
 294   ACE_UNUSED_ARG (new_sap);
 295   ACE_UNUSED_ARG (remote_addr);
 296   ACE_UNUSED_ARG (timeout);
 297   ACE_UNUSED_ARG (restart);
 298   ACE_UNUSED_ARG (reset_new_handle);
 299   ACE_UNUSED_ARG (params);
 300   ACE_UNUSED_ARG (qos);
 301   return (0);
 302 #endif /* ACE_HAS_FORE_ATM_XTI */
 303 }
 304
 305 // Close versioned namespace, if enabled by the user.
 306 ACE_END_VERSIONED_NAMESPACE_DECL
 307
 308
 309 #endif /* ACE_HAS_ATM */