Initial ATM library files

21 files changed, 3727 insertions, 0 deletions

diff --git a/ace/ATM/ATM_Acceptor.cpp b/ace/ATM/ATM_Acceptor.cpp
new file mode 100644
index 00000000000..eb4c5d6c874
--- /dev/null
+++ b/ace/ATM/ATM_Acceptor.cpp
@@ -0,0 +1,309 @@
+// $Id$
+
+#include "ATM_Acceptor.h"
+
+ACE_RCSID(ace, ATM_Acceptor, "$Id$")
+
+#if defined (ACE_HAS_ATM)
+
+#if defined (ACE_HAS_LINUX_ATM)
+#include "linux/atmdev.h"
+#endif /* ACE_HAS_LINUX_ATM */
+
+#if !defined (__ACE_INLINE__)
+#include "ATM_Acceptor.i"
+#endif /* __ACE_INLINE__ */
+
+// Put the actual definitions of the ACE_ATM_Request and
+// ACE_ATM_Request_Queue classes here to hide them from clients...
+
+ACE_ALLOC_HOOK_DEFINE(ACE_ATM_Acceptor)
+
+void
+ACE_ATM_Acceptor::dump (void) const
+{
+  ACE_TRACE ("ACE_ATM_Acceptor::dump");
+}
+
+ACE_ATM_Acceptor::ACE_ATM_Acceptor (void)
+{
+  ACE_TRACE ("ACE_ATM_Acceptor::ACE_ATM_Acceptor");
+}
+
+ACE_ATM_Acceptor::~ACE_ATM_Acceptor (void)
+{
+  ACE_TRACE ("ACE_ATM_Acceptor::~ACE_ATM_Acceptor");
+}
+
+int
+ACE_ATM_Acceptor::get_local_addr( ACE_ATM_Addr &local_addr )
+{
+  ACE_TRACE( "ACE_ATM_Acceptor::get_local_addr" );
+
+#if defined (ACE_HAS_FORE_ATM_WS2)
+  unsigned long ret = 0;
+  DWORD deviceID = 0;
+  ATM_ADDRESS addr;
+  struct sockaddr_atm *laddr;
+
+  if ( ::WSAIoctl(( int )(( ACE_SOCK_Acceptor *)this ) -> get_handle(),
+                SIO_GET_ATM_ADDRESS,
+                (LPVOID) &deviceID,
+                sizeof(DWORD),
+                ( LPVOID )&addr,
+                sizeof( ATM_ADDRESS ),
+                &ret,
+                NULL,
+                NULL ) == SOCKET_ERROR ) {
+    ACE_OS::printf( "ATM_Acceptor(get_local_addr): WSIoctl: %d\n",
+                    ::WSAGetLastError());
+    return -1;
+  }
+
+  laddr = ( struct sockaddr_atm *)local_addr.get_addr();
+  ACE_OS::memcpy(( void *)&( laddr -> satm_number ),
+                 ( void *)&addr,
+                 ATM_ADDR_SIZE - 1 );
+
+  return 0;
+#elif defined (ACE_HAS_FORE_ATM_XTI)
+  ACE_UNUSED_ARG( local_addr );
+
+  return 0;
+#elif defined (ACE_HAS_LINUX_ATM)
+  ATM_Addr *myaddr = (ATM_Addr *)local_addr.get_addr();
+  int addrlen = sizeof(myaddr->sockaddratmsvc);
+
+  if (ACE_OS::getsockname(acceptor_.get_handle(),
+                          (struct sockaddr *) &(myaddr->sockaddratmsvc),
+                          &addrlen) < 0) {
+    ACE_DEBUG((LM_DEBUG,
+               ACE_LIB_TEXT ("ATM_Acceptor(get_local_addr): ioctl: %d\n"),
+               errno));
+    return -1;
+  }
+
+  return (0);
+#else
+  ACE_UNUSED_ARG( local_addr );
+
+  return 0;
+#endif /* ACE_HAS_FORE_ATM_WS2 && ACE_HAS_FORE_ATM_XTI */
+}
+
+ACE_HANDLE
+ACE_ATM_Acceptor::open (const ACE_Addr &remote_sap,
+                        int backlog,
+                        ACE_ATM_Params params)
+{
+  ACE_TRACE ("ACE_ATM_Acceptor::open");
+#if defined (ACE_HAS_FORE_ATM_XTI)
+  ACE_HANDLE handle = acceptor_.open (remote_sap,
+                                      params.get_reuse_addr(),
+                                      params.get_oflag(),
+                                      params.get_info(),
+                                      backlog,
+                                      params.get_device());
+  return (handle == ACE_INVALID_HANDLE ? -1 : 0);
+#elif defined (ACE_HAS_FORE_ATM_WS2)
+  struct sockaddr_atm local_atm_addr;
+  ACE_HANDLE ret;
+  DWORD flags = 0;
+
+  /* Create a local endpoint of communication */
+
+  // Only leaves can listen.
+  flags = ACE_FLAG_MULTIPOINT_C_LEAF | ACE_FLAG_MULTIPOINT_D_LEAF;
+
+  if ((ret = ACE_OS::socket (AF_ATM,
+                             SOCK_RAW,
+                             ATMPROTO_AAL5,
+                             NULL,
+                             0,
+                             flags ))
+      == ACE_INVALID_HANDLE) {
+    ACE_OS::printf( "Acceptor(open): socket %d\n",
+                    ::WSAGetLastError());
+    return (ret);
+  }
+
+  ((ACE_SOCK_Acceptor *)this) -> set_handle( ret );
+
+  /* Set up the address information to become a server */
+  ACE_OS::memset ((void *) &local_atm_addr, 0, sizeof local_atm_addr);
+  local_atm_addr.satm_family = AF_ATM;
+  local_atm_addr.satm_number.AddressType = SAP_FIELD_ANY_AESA_REST;
+  local_atm_addr.satm_number.Addr[ ATM_ADDR_SIZE - 1 ]
+    = (( ACE_ATM_Addr *)&remote_sap ) -> get_selector();
+  local_atm_addr.satm_blli.Layer2Protocol = SAP_FIELD_ANY;
+  local_atm_addr.satm_blli.Layer3Protocol = SAP_FIELD_ABSENT;
+  local_atm_addr.satm_bhli.HighLayerInfoType = SAP_FIELD_ABSENT;
+
+  /* Associate address with endpoint */
+  if (ACE_OS::bind ((( ACE_SOCK_Acceptor *)this ) -> get_handle(),
+                    ACE_reinterpret_cast(struct sockaddr *, &local_atm_addr),
+                    sizeof local_atm_addr) == -1) {
+    ACE_OS::printf( "Acceptor(open): bind %d\n", ::WSAGetLastError());
+    return (ACE_INVALID_HANDLE);
+  }
+
+  /* Make endpoint listen for service requests */
+  if (ACE_OS::listen ((( ACE_SOCK_Acceptor *)this ) -> get_handle(),
+                      backlog)
+                    == -1) {
+    ACE_OS::printf( "Acceptor(open): listen %d\n", ::WSAGetLastError());
+    return (ACE_INVALID_HANDLE);
+  }
+
+  return 0;
+#elif defined (ACE_HAS_LINUX_ATM)
+  //we need to set the qos before binding to the socket
+  //use remote_sap as local_sap
+
+  ACE_ATM_Addr local_sap;
+  ATM_Addr *local_sap_addr = (ATM_Addr*)local_sap.get_addr();
+  ACE_ATM_QoS def_qos;
+  ATM_QoS qos = def_qos.get_qos();
+
+  ACE_HANDLE handle;
+  if ((handle = ACE_OS::socket (params.get_protocol_family(),
+                                params.get_type(),
+                                params.get_protocol(),
+                                params.get_protocol_info(),
+                                params.get_sock_group(),
+                                params.get_flags()
+                                ))
+      == ACE_INVALID_HANDLE) {
+    ACE_DEBUG(LM_DEBUG,
+              ACE_LIB_TEXT ("Acceptor(socket): socket %d\n"),
+              errno);
+    return (ACE_INVALID_HANDLE);
+  }
+
+  ((ACE_SOCK_Acceptor *)this) -> set_handle( handle );
+  if (ACE_OS::setsockopt(handle,
+                         SOL_ATM,
+                         SO_ATMQOS,
+                         ACE_reinterpret_cast(char*, &qos),
+                         sizeof(qos)) < 0) {
+    ACE_OS::printf("Acceptor(setsockopt): setsockopt:%d\n",
+                   errno);
+  }
+
+  struct atmif_sioc req;
+  struct sockaddr_atmsvc aux_addr[1024];
+
+  req.number = 0;
+  req.arg = aux_addr;
+  req.length = sizeof(aux_addr);
+  if (ACE_OS::ioctl(handle,
+                    ATM_GETADDR,
+                    &req) < 0) {
+    ACE_OS::perror( "Acceptor(setsockopt): ioctl:");
+  }
+  else {
+    local_sap_addr->sockaddratmsvc = aux_addr[0];
+  }
+  local_sap.set_selector(((ACE_ATM_Addr*)&remote_sap)->get_selector());
+
+  if (ACE_OS::bind (handle,
+                    ACE_reinterpret_cast(struct sockaddr *,
+                                         &(local_sap_addr->sockaddratmsvc)),
+                    sizeof (local_sap_addr->sockaddratmsvc)
+                    ) == -1) {
+    ACE_DEBUG(LM_DEBUG,
+              ACE_LIB_TEXT ("Acceptor(open): bind %d\n"),
+              errno);
+    return -1;
+  }
+  // Make endpoint listen for service requests
+  if (ACE_OS::listen (handle,
+                      backlog)
+      == -1) {
+    ACE_DEBUG(LM_DEBUG,
+              ACE_LIB_TEXT ("Acceptor(listen): listen %d\n"),
+              errno);
+    return -1;
+  }
+
+  return 0;
+#else
+  ACE_UNUSED_ARG (remote_sap);
+  ACE_UNUSED_ARG (backlog);
+  ACE_UNUSED_ARG (params);
+#endif /* ACE_HAS_FORE_ATM_XTI/ACE_HAS_FORE_ATM_WS2/ACE_HAS_LINUX_ATM */
+}
+
+int
+ACE_ATM_Acceptor::accept (ACE_ATM_Stream &new_sap,
+                          ACE_Addr *remote_addr,
+                          ACE_Time_Value *timeout,
+                          int restart,
+                          int reset_new_handle,
+                          ACE_ATM_Params params,
+                          ACE_ATM_QoS qos)
+{
+  ACE_TRACE ("ACE_ATM_Acceptor::accept");
+#if defined (ACE_HAS_FORE_ATM_XTI)
+  ATM_QoS optbuf = qos.get_qos();
+
+  return (acceptor_.accept(new_sap.get_stream(),
+                           remote_addr,
+                           timeout,
+                           restart,
+                           reset_new_handle,
+                           params.get_rw_flag(),
+                           params.get_user_data(),
+                           &optbuf));
+#elif defined (ACE_HAS_FORE_ATM_WS2)
+  ACE_HANDLE n_handle;
+  ACE_HANDLE s_handle = (( ACE_SOCK_Acceptor *) this ) -> get_handle();
+  struct sockaddr_atm *cli_addr
+    = ( struct sockaddr_atm *)remote_addr -> get_addr();
+  int caddr_len = sizeof( struct sockaddr_atm );
+
+  do {
+    n_handle = ACE_OS::accept(s_handle,
+                              ACE_reinterpret_cast(struct sockaddr *,
+                                                   cli_addr ),
+                              &caddr_len );
+  } while ( n_handle == ACE_INVALID_HANDLE && errno == EINTR );
+
+  (( ACE_ATM_Addr *)remote_addr ) -> set( cli_addr,
+                        (( ACE_ATM_Addr *)remote_addr ) -> get_selector());
+  (( ACE_IPC_SAP *)&new_sap ) -> set_handle( n_handle );
+
+  return 0;
+#elif defined (ACE_HAS_LINUX_ATM)
+  ACE_UNUSED_ARG (params);
+
+  ACE_HANDLE s_handle = (( ACE_SOCK_Acceptor *) this ) -> get_handle();
+  struct atm_qos accept_qos = qos.get_qos();
+
+  if (ACE_OS::setsockopt(s_handle,
+                         SOL_ATM,
+                         SO_ATMQOS,
+                         ACE_reinterpret_cast(char*,
+                                              &accept_qos),
+                         sizeof(accept_qos)) < 0) {
+    ACE_OS::printf("Acceptor(accept): error setting Qos");
+  }
+
+  return(acceptor_.accept(new_sap.get_stream(),
+                          remote_addr,
+                          timeout,
+                          restart,
+                          reset_new_handle));
+#else
+  ACE_UNUSED_ARG(new_sap);
+  ACE_UNUSED_ARG(remote_addr);
+  ACE_UNUSED_ARG(timeout);
+  ACE_UNUSED_ARG(restart);
+  ACE_UNUSED_ARG(reset_new_handle);
+  ACE_UNUSED_ARG(params);
+  ACE_UNUSED_ARG(qos);
+  return (0);
+#endif /* ACE_HAS_FORE_ATM_XTI */
+}
+
+#endif /* ACE_HAS_ATM */
diff --git a/ace/ATM/ATM_Acceptor.cpp~ b/ace/ATM/ATM_Acceptor.cpp~
new file mode 100644
index 00000000000..eb4c5d6c874
--- /dev/null
+++ b/ace/ATM/ATM_Acceptor.cpp~
@@ -0,0 +1,309 @@
+// $Id$
+
+#include "ATM_Acceptor.h"
+
+ACE_RCSID(ace, ATM_Acceptor, "$Id$")
+
+#if defined (ACE_HAS_ATM)
+
+#if defined (ACE_HAS_LINUX_ATM)
+#include "linux/atmdev.h"
+#endif /* ACE_HAS_LINUX_ATM */
+
+#if !defined (__ACE_INLINE__)
+#include "ATM_Acceptor.i"
+#endif /* __ACE_INLINE__ */
+
+// Put the actual definitions of the ACE_ATM_Request and
+// ACE_ATM_Request_Queue classes here to hide them from clients...
+
+ACE_ALLOC_HOOK_DEFINE(ACE_ATM_Acceptor)
+
+void
+ACE_ATM_Acceptor::dump (void) const
+{
+  ACE_TRACE ("ACE_ATM_Acceptor::dump");
+}
+
+ACE_ATM_Acceptor::ACE_ATM_Acceptor (void)
+{
+  ACE_TRACE ("ACE_ATM_Acceptor::ACE_ATM_Acceptor");
+}
+
+ACE_ATM_Acceptor::~ACE_ATM_Acceptor (void)
+{
+  ACE_TRACE ("ACE_ATM_Acceptor::~ACE_ATM_Acceptor");
+}
+
+int
+ACE_ATM_Acceptor::get_local_addr( ACE_ATM_Addr &local_addr )
+{
+  ACE_TRACE( "ACE_ATM_Acceptor::get_local_addr" );
+
+#if defined (ACE_HAS_FORE_ATM_WS2)
+  unsigned long ret = 0;
+  DWORD deviceID = 0;
+  ATM_ADDRESS addr;
+  struct sockaddr_atm *laddr;
+
+  if ( ::WSAIoctl(( int )(( ACE_SOCK_Acceptor *)this ) -> get_handle(),
+                SIO_GET_ATM_ADDRESS,
+                (LPVOID) &deviceID,
+                sizeof(DWORD),
+                ( LPVOID )&addr,
+                sizeof( ATM_ADDRESS ),
+                &ret,
+                NULL,
+                NULL ) == SOCKET_ERROR ) {
+    ACE_OS::printf( "ATM_Acceptor(get_local_addr): WSIoctl: %d\n",
+                    ::WSAGetLastError());
+    return -1;
+  }
+
+  laddr = ( struct sockaddr_atm *)local_addr.get_addr();
+  ACE_OS::memcpy(( void *)&( laddr -> satm_number ),
+                 ( void *)&addr,
+                 ATM_ADDR_SIZE - 1 );
+
+  return 0;
+#elif defined (ACE_HAS_FORE_ATM_XTI)
+  ACE_UNUSED_ARG( local_addr );
+
+  return 0;
+#elif defined (ACE_HAS_LINUX_ATM)
+  ATM_Addr *myaddr = (ATM_Addr *)local_addr.get_addr();
+  int addrlen = sizeof(myaddr->sockaddratmsvc);
+
+  if (ACE_OS::getsockname(acceptor_.get_handle(),
+                          (struct sockaddr *) &(myaddr->sockaddratmsvc),
+                          &addrlen) < 0) {
+    ACE_DEBUG((LM_DEBUG,
+               ACE_LIB_TEXT ("ATM_Acceptor(get_local_addr): ioctl: %d\n"),
+               errno));
+    return -1;
+  }
+
+  return (0);
+#else
+  ACE_UNUSED_ARG( local_addr );
+
+  return 0;
+#endif /* ACE_HAS_FORE_ATM_WS2 && ACE_HAS_FORE_ATM_XTI */
+}
+
+ACE_HANDLE
+ACE_ATM_Acceptor::open (const ACE_Addr &remote_sap,
+                        int backlog,
+                        ACE_ATM_Params params)
+{
+  ACE_TRACE ("ACE_ATM_Acceptor::open");
+#if defined (ACE_HAS_FORE_ATM_XTI)
+  ACE_HANDLE handle = acceptor_.open (remote_sap,
+                                      params.get_reuse_addr(),
+                                      params.get_oflag(),
+                                      params.get_info(),
+                                      backlog,
+                                      params.get_device());
+  return (handle == ACE_INVALID_HANDLE ? -1 : 0);
+#elif defined (ACE_HAS_FORE_ATM_WS2)
+  struct sockaddr_atm local_atm_addr;
+  ACE_HANDLE ret;
+  DWORD flags = 0;
+
+  /* Create a local endpoint of communication */
+
+  // Only leaves can listen.
+  flags = ACE_FLAG_MULTIPOINT_C_LEAF | ACE_FLAG_MULTIPOINT_D_LEAF;
+
+  if ((ret = ACE_OS::socket (AF_ATM,
+                             SOCK_RAW,
+                             ATMPROTO_AAL5,
+                             NULL,
+                             0,
+                             flags ))
+      == ACE_INVALID_HANDLE) {
+    ACE_OS::printf( "Acceptor(open): socket %d\n",
+                    ::WSAGetLastError());
+    return (ret);
+  }
+
+  ((ACE_SOCK_Acceptor *)this) -> set_handle( ret );
+
+  /* Set up the address information to become a server */
+  ACE_OS::memset ((void *) &local_atm_addr, 0, sizeof local_atm_addr);
+  local_atm_addr.satm_family = AF_ATM;
+  local_atm_addr.satm_number.AddressType = SAP_FIELD_ANY_AESA_REST;
+  local_atm_addr.satm_number.Addr[ ATM_ADDR_SIZE - 1 ]
+    = (( ACE_ATM_Addr *)&remote_sap ) -> get_selector();
+  local_atm_addr.satm_blli.Layer2Protocol = SAP_FIELD_ANY;
+  local_atm_addr.satm_blli.Layer3Protocol = SAP_FIELD_ABSENT;
+  local_atm_addr.satm_bhli.HighLayerInfoType = SAP_FIELD_ABSENT;
+
+  /* Associate address with endpoint */
+  if (ACE_OS::bind ((( ACE_SOCK_Acceptor *)this ) -> get_handle(),
+                    ACE_reinterpret_cast(struct sockaddr *, &local_atm_addr),
+                    sizeof local_atm_addr) == -1) {
+    ACE_OS::printf( "Acceptor(open): bind %d\n", ::WSAGetLastError());
+    return (ACE_INVALID_HANDLE);
+  }
+
+  /* Make endpoint listen for service requests */
+  if (ACE_OS::listen ((( ACE_SOCK_Acceptor *)this ) -> get_handle(),
+                      backlog)
+                    == -1) {
+    ACE_OS::printf( "Acceptor(open): listen %d\n", ::WSAGetLastError());
+    return (ACE_INVALID_HANDLE);
+  }
+
+  return 0;
+#elif defined (ACE_HAS_LINUX_ATM)
+  //we need to set the qos before binding to the socket
+  //use remote_sap as local_sap
+
+  ACE_ATM_Addr local_sap;
+  ATM_Addr *local_sap_addr = (ATM_Addr*)local_sap.get_addr();
+  ACE_ATM_QoS def_qos;
+  ATM_QoS qos = def_qos.get_qos();
+
+  ACE_HANDLE handle;
+  if ((handle = ACE_OS::socket (params.get_protocol_family(),
+                                params.get_type(),
+                                params.get_protocol(),
+                                params.get_protocol_info(),
+                                params.get_sock_group(),
+                                params.get_flags()
+                                ))
+      == ACE_INVALID_HANDLE) {
+    ACE_DEBUG(LM_DEBUG,
+              ACE_LIB_TEXT ("Acceptor(socket): socket %d\n"),
+              errno);
+    return (ACE_INVALID_HANDLE);
+  }
+
+  ((ACE_SOCK_Acceptor *)this) -> set_handle( handle );
+  if (ACE_OS::setsockopt(handle,
+                         SOL_ATM,
+                         SO_ATMQOS,
+                         ACE_reinterpret_cast(char*, &qos),
+                         sizeof(qos)) < 0) {
+    ACE_OS::printf("Acceptor(setsockopt): setsockopt:%d\n",
+                   errno);
+  }
+
+  struct atmif_sioc req;
+  struct sockaddr_atmsvc aux_addr[1024];
+
+  req.number = 0;
+  req.arg = aux_addr;
+  req.length = sizeof(aux_addr);
+  if (ACE_OS::ioctl(handle,
+                    ATM_GETADDR,
+                    &req) < 0) {
+    ACE_OS::perror( "Acceptor(setsockopt): ioctl:");
+  }
+  else {
+    local_sap_addr->sockaddratmsvc = aux_addr[0];
+  }
+  local_sap.set_selector(((ACE_ATM_Addr*)&remote_sap)->get_selector());
+
+  if (ACE_OS::bind (handle,
+                    ACE_reinterpret_cast(struct sockaddr *,
+                                         &(local_sap_addr->sockaddratmsvc)),
+                    sizeof (local_sap_addr->sockaddratmsvc)
+                    ) == -1) {
+    ACE_DEBUG(LM_DEBUG,
+              ACE_LIB_TEXT ("Acceptor(open): bind %d\n"),
+              errno);
+    return -1;
+  }
+  // Make endpoint listen for service requests
+  if (ACE_OS::listen (handle,
+                      backlog)
+      == -1) {
+    ACE_DEBUG(LM_DEBUG,
+              ACE_LIB_TEXT ("Acceptor(listen): listen %d\n"),
+              errno);
+    return -1;
+  }
+
+  return 0;
+#else
+  ACE_UNUSED_ARG (remote_sap);
+  ACE_UNUSED_ARG (backlog);
+  ACE_UNUSED_ARG (params);
+#endif /* ACE_HAS_FORE_ATM_XTI/ACE_HAS_FORE_ATM_WS2/ACE_HAS_LINUX_ATM */
+}
+
+int
+ACE_ATM_Acceptor::accept (ACE_ATM_Stream &new_sap,
+                          ACE_Addr *remote_addr,
+                          ACE_Time_Value *timeout,
+                          int restart,
+                          int reset_new_handle,
+                          ACE_ATM_Params params,
+                          ACE_ATM_QoS qos)
+{
+  ACE_TRACE ("ACE_ATM_Acceptor::accept");
+#if defined (ACE_HAS_FORE_ATM_XTI)
+  ATM_QoS optbuf = qos.get_qos();
+
+  return (acceptor_.accept(new_sap.get_stream(),
+                           remote_addr,
+                           timeout,
+                           restart,
+                           reset_new_handle,
+                           params.get_rw_flag(),
+                           params.get_user_data(),
+                           &optbuf));
+#elif defined (ACE_HAS_FORE_ATM_WS2)
+  ACE_HANDLE n_handle;
+  ACE_HANDLE s_handle = (( ACE_SOCK_Acceptor *) this ) -> get_handle();
+  struct sockaddr_atm *cli_addr
+    = ( struct sockaddr_atm *)remote_addr -> get_addr();
+  int caddr_len = sizeof( struct sockaddr_atm );
+
+  do {
+    n_handle = ACE_OS::accept(s_handle,
+                              ACE_reinterpret_cast(struct sockaddr *,
+                                                   cli_addr ),
+                              &caddr_len );
+  } while ( n_handle == ACE_INVALID_HANDLE && errno == EINTR );
+
+  (( ACE_ATM_Addr *)remote_addr ) -> set( cli_addr,
+                        (( ACE_ATM_Addr *)remote_addr ) -> get_selector());
+  (( ACE_IPC_SAP *)&new_sap ) -> set_handle( n_handle );
+
+  return 0;
+#elif defined (ACE_HAS_LINUX_ATM)
+  ACE_UNUSED_ARG (params);
+
+  ACE_HANDLE s_handle = (( ACE_SOCK_Acceptor *) this ) -> get_handle();
+  struct atm_qos accept_qos = qos.get_qos();
+
+  if (ACE_OS::setsockopt(s_handle,
+                         SOL_ATM,
+                         SO_ATMQOS,
+                         ACE_reinterpret_cast(char*,
+                                              &accept_qos),
+                         sizeof(accept_qos)) < 0) {
+    ACE_OS::printf("Acceptor(accept): error setting Qos");
+  }
+
+  return(acceptor_.accept(new_sap.get_stream(),
+                          remote_addr,
+                          timeout,
+                          restart,
+                          reset_new_handle));
+#else
+  ACE_UNUSED_ARG(new_sap);
+  ACE_UNUSED_ARG(remote_addr);
+  ACE_UNUSED_ARG(timeout);
+  ACE_UNUSED_ARG(restart);
+  ACE_UNUSED_ARG(reset_new_handle);
+  ACE_UNUSED_ARG(params);
+  ACE_UNUSED_ARG(qos);
+  return (0);
+#endif /* ACE_HAS_FORE_ATM_XTI */
+}
+
+#endif /* ACE_HAS_ATM */
diff --git a/ace/ATM/ATM_Acceptor.h b/ace/ATM/ATM_Acceptor.h
new file mode 100644
index 00000000000..173be1ad532
--- /dev/null
+++ b/ace/ATM/ATM_Acceptor.h
@@ -0,0 +1,109 @@
+/* -*- C++ -*- */
+
+//=============================================================================
+/**
+ *  @file    ATM_Acceptor.h
+ *
+ *  $Id$
+ *
+ *  @author Joe Hoffert
+ */
+//=============================================================================
+
+
+#ifndef ACE_ATM_ACCEPTOR_H
+#define ACE_ATM_ACCEPTOR_H
+#include "ace/pre.h"
+
+#include "ace/Time_Value.h"
+#include "ace/ATM_Stream.h"
+#include "ace/ATM_Params.h"
+#include "ace/ATM_QoS.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#if defined (ACE_HAS_ATM)
+
+#if defined (ACE_HAS_LINUX_ATM)
+#include "atm.h"
+#endif /* ACE_HAS_LINUX_ATM */
+
+#if defined (ACE_HAS_FORE_ATM_WS2) || defined (ACE_HAS_LINUX_ATM)
+#include "SOCK_Acceptor.h"
+typedef ACE_SOCK_Acceptor ATM_Acceptor;
+#elif defined (ACE_HAS_FORE_ATM_XTI)
+#include "TLI_Acceptor.h"
+typedef ACE_TLI_Acceptor ATM_Acceptor;
+#endif // ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM
+
+/**
+ * @class ACE_ATM_Acceptor
+ *
+ * @brief 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.
+ */
+class ACE_Export ACE_ATM_Acceptor
+{
+
+public:
+  // = Initialization and termination methods.
+  /// Default constructor.
+  ACE_ATM_Acceptor (void);
+
+  ~ACE_ATM_Acceptor ();
+
+  /// Initiate a passive mode connection.
+  ACE_ATM_Acceptor (const ACE_Addr &remote_sap,
+                    int backlog = ACE_DEFAULT_BACKLOG,
+                    ACE_ATM_Params params = ACE_ATM_Params());
+
+  /// Initiate a passive mode socket.
+  ACE_HANDLE open (const ACE_Addr &remote_sap,
+                   int backlog = ACE_DEFAULT_BACKLOG,
+                   ACE_ATM_Params params = ACE_ATM_Params());
+
+  /// Close down the acceptor and release resources.
+  int close (void);
+
+  // = Passive connection acceptance method.
+
+  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());
+
+  // 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."
+
+  /// Get the local address currently listening on
+  int get_local_addr( ACE_ATM_Addr &local_addr );
+
+  // = Meta-type info
+  typedef ACE_ATM_Addr PEER_ADDR;
+  typedef ACE_ATM_Stream PEER_STREAM;
+
+  /// Dump the state of an object.
+  void dump (void) const;
+
+  /// Declare the dynamic allocation hooks.
+  ACE_ALLOC_HOOK_DECLARE;
+
+private:
+  ATM_Acceptor acceptor_;
+};
+
+#if defined (__ACE_INLINE__)
+#include "ace/ATM_Acceptor.i"
+#endif /* __ACE_INLINE__ */
+
+#endif /* ACE_HAS_ATM */
+#include "ace/post.h"
+#endif /* ACE_ATM_ACCEPTOR_H */
diff --git a/ace/ATM/ATM_Acceptor.i b/ace/ATM/ATM_Acceptor.i
new file mode 100644
index 00000000000..3561cfa4733
--- /dev/null
+++ b/ace/ATM/ATM_Acceptor.i
@@ -0,0 +1,30 @@
+// $Id$
+
+// ATM_Acceptor.i
+
+ACE_INLINE
+ACE_ATM_Acceptor::ACE_ATM_Acceptor (const ACE_Addr &remote_sap,
+                                    int backlog,
+                                    ACE_ATM_Params params)
+{
+  ACE_TRACE ("ACE_ATM_Acceptor::ACE_ATM_Acceptor");
+  if (open (remote_sap,
+            backlog,
+            params) < 0)
+    ACE_ERROR ((LM_ERROR,
+                ACE_LIB_TEXT ("%p\n"),
+                ACE_LIB_TEXT ("ACE_ATM_Acceptor::ACE_ATM_Acceptor")));
+}
+
+ACE_INLINE
+int
+ACE_ATM_Acceptor::close (void)
+{
+#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) || defined (ACE_HAS_LINUX_ATM)
+  return (acceptor_.close());
+#else
+  return 0;
+#endif // ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM
+}
+
+
diff --git a/ace/ATM/ATM_Addr.cpp b/ace/ATM/ATM_Addr.cpp
new file mode 100644
index 00000000000..ed00d04dca3
--- /dev/null
+++ b/ace/ATM/ATM_Addr.cpp
@@ -0,0 +1,499 @@
+// $Id$
+
+// Defines the Internet domain address family address format.
+
+#include "ace/ATM_Addr.h"
+#include "ace/Log_Msg.h"
+
+#if defined (ACE_HAS_FORE_ATM_WS2)
+#include "forews2.h"
+#endif /* ACE_HAS_FORE_ATM_WS2 */
+
+#if !defined (__ACE_INLINE__)
+#include "ace/ATM_Addr.i"
+#endif /* __ACE_INLINE__ */
+
+ACE_RCSID(ace, ATM_Addr, "$Id$")
+
+ACE_ALLOC_HOOK_DEFINE(ACE_ATM_Addr)
+
+#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
+#define BHLI_MAGIC "FORE_ATM"
+// This is line rate in cells/s for an OC-3 MM interface.
+const long ACE_ATM_Addr::LINE_RATE = 353207;
+const int ACE_ATM_Addr::OPT_FLAGS_CPID = 0x1;
+const int ACE_ATM_Addr::OPT_FLAGS_PMP = 0x2;
+const int ACE_ATM_Addr::DEFAULT_SELECTOR = 0x99;
+#elif defined (ACE_HAS_LINUX_ATM)
+//pbrandao:for Linux:
+//pbrandao:for now stick with current definitions
+//pbrandao:see if later need to change
+const long ACE_ATM_Addr::LINE_RATE = 353207;
+const int ACE_ATM_Addr::OPT_FLAGS_CPID = 0;
+const int ACE_ATM_Addr::OPT_FLAGS_PMP = 0;
+const int ACE_ATM_Addr::DEFAULT_SELECTOR = 0x99;
+#else
+const long ACE_ATM_Addr::LINE_RATE = 0L;
+const int ACE_ATM_Addr::OPT_FLAGS_CPID = 0;
+const int ACE_ATM_Addr::OPT_FLAGS_PMP = 0;
+const int ACE_ATM_Addr::DEFAULT_SELECTOR = 0x0;
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
+
+// Default constructor
+
+ACE_ATM_Addr::ACE_ATM_Addr (u_char selector)
+#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
+  : ACE_Addr (AF_ATM,
+#elif defined (ACE_HAS_LINUX_ATM)
+  : ACE_Addr (PF_ATMSVC,
+#else
+  : ACE_Addr (AF_UNSPEC,
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
+              sizeof this->atm_addr_)
+{
+  // ACE_TRACE ("ACE_ATM_Addr::ACE_ATM_Addr");
+ (void) ACE_OS::memset ((void *) &this->atm_addr_,
+                         0,
+                         sizeof this->atm_addr_);
+  this->init (selector);
+}
+
+// Copy constructor.
+
+ACE_ATM_Addr::ACE_ATM_Addr (const ACE_ATM_Addr &sap,
+                            u_char selector)
+#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
+  : ACE_Addr (AF_ATM,
+#elif defined (ACE_HAS_LINUX_ATM)
+  : ACE_Addr (PF_ATMSVC,
+#else
+  : ACE_Addr (AF_UNSPEC,
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
+              sizeof this->atm_addr_)
+{
+  ACE_TRACE ("ACE_ATM_Addr::ACE_ATM_Addr");
+  this->set (sap, selector);
+#if defined (ACE_HAS_LINUX_ATM)
+  this->atm_addr_.sockaddratmsvc.sas_family = PF_ATMSVC;
+  this->atm_addr_.atmsap.blli[0].l3_proto = ATM_L3_NONE;
+  this->atm_addr_.atmsap.blli[0].l2_proto = ATM_L2_NONE;
+  this->atm_addr_.atmsap.bhli.hl_type = ATM_HL_NONE;
+#endif /* ACE_HAS_LINUX_ATM */
+}
+
+ACE_ATM_Addr::ACE_ATM_Addr (const ATM_Addr *sap,
+                            u_char selector)
+#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
+  : ACE_Addr (AF_ATM,
+#elif defined (ACE_HAS_LINUX_ATM)
+  : ACE_Addr (PF_ATMSVC,
+#else
+  : ACE_Addr (AF_UNSPEC,
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
+              sizeof this->atm_addr_)
+{
+  ACE_TRACE ("ACE_ATM_Addr::ACE_ATM_Addr");
+  this->set (sap, selector);
+}
+
+
+ACE_ATM_Addr::ACE_ATM_Addr (const ACE_TCHAR sap[],
+                            u_char selector)
+#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
+  : ACE_Addr (AF_ATM,
+#elif defined (ACE_HAS_LINUX_ATM)
+  : ACE_Addr (PF_ATMSVC,
+#else
+  : ACE_Addr (AF_UNSPEC,
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
+              sizeof this->atm_addr_)
+{
+  ACE_TRACE ("ACE_ATM_Addr::ACE_ATM_Addr");
+  this->set (sap, selector);
+}
+
+void
+ACE_ATM_Addr::init (u_char selector)
+{
+#if defined (ACE_HAS_FORE_ATM_XTI)
+  // Note: this approach may be FORE implementation-specific.  When we
+  // bind with tag_addr ABSENT and tag_selector PRESENT, only the
+  // selector (i.e. address[19]) is used by the TP.  The rest of the
+  // local address is filled in by the TP and can be obtained via the
+  // 'ret' parameter or with t_getname ()/t_getprotaddr ().
+
+  atm_addr_.addressType = (u_int16_t) AF_ATM;
+
+  atm_addr_.sap.t_atm_sap_addr.SVE_tag_addr = (int8_t) T_ATM_ABSENT;
+  atm_addr_.sap.t_atm_sap_addr.SVE_tag_selector = (int8_t) T_ATM_PRESENT;
+
+  atm_addr_.sap.t_atm_sap_addr.address_format = (u_int8_t) T_ATM_ENDSYS_ADDR;
+  atm_addr_.sap.t_atm_sap_addr.address_length = ATMNSAP_ADDR_LEN;
+  atm_addr_.sap.t_atm_sap_addr.address[ATMNSAP_ADDR_LEN - 1] = selector;
+
+  atm_addr_.sap.t_atm_sap_layer2.SVE_tag = (int8_t) T_ATM_ABSENT;
+  atm_addr_.sap.t_atm_sap_layer3.SVE_tag = (int8_t) T_ATM_ABSENT;
+
+  atm_addr_.sap.t_atm_sap_appl.SVE_tag = (int8_t) T_ATM_PRESENT;
+  atm_addr_.sap.t_atm_sap_appl.ID_type = (u_int8_t) T_ATM_USER_APP_ID;
+
+  ACE_OS::memcpy (atm_addr_.sap.t_atm_sap_appl.ID.user_defined_ID,
+                  BHLI_MAGIC,
+                  sizeof atm_addr_.sap.t_atm_sap_appl.ID);
+#elif defined (ACE_HAS_FORE_ATM_WS2)
+  ACE_OS::memset ((void *)&atm_addr_, 0, sizeof atm_addr_);
+  atm_addr_.satm_number.Addr[ ATM_ADDR_SIZE - 1 ] = (char)selector;
+  atm_addr_.satm_family = AF_ATM;
+  atm_addr_.satm_number.AddressType = ATM_NSAP;
+  atm_addr_.satm_number.NumofDigits = ATM_ADDR_SIZE;
+  atm_addr_.satm_blli.Layer2Protocol = SAP_FIELD_ABSENT;
+  atm_addr_.satm_blli.Layer3Protocol = SAP_FIELD_ABSENT;
+  atm_addr_.satm_bhli.HighLayerInfoType = SAP_FIELD_ABSENT;
+
+  // Need to know the correspondence.
+  //atm_addr_.sap.t_atm_sap_appl.SVE_tag = (int8_t) T_ATM_PRESENT;
+  //atm_addr_.sap.t_atm_sap_appl.ID_type = (u_int8_t) T_ATM_USER_APP_ID;
+  //ACE_OS::memcpy (atm_addr_.sap.t_atm_sap_appl.ID.user_defined_ID,
+  //                BHLI_MAGIC,
+  //                sizeof atm_addr_.sap.t_atm_sap_appl.ID);
+#elif defined (ACE_HAS_LINUX_ATM)
+  atm_addr_.sockaddratmsvc.sas_family = AF_ATMSVC;
+  atm_addr_.sockaddratmsvc.sas_addr.prv[ATM_ESA_LEN - 1] = (char)selector;
+  atm_addr_.atmsap.blli[0].l3_proto = ATM_L3_NONE;
+  atm_addr_.atmsap.blli[0].l2_proto = ATM_L2_NONE;
+  atm_addr_.atmsap.bhli.hl_type = ATM_HL_NONE;
+#else
+  ACE_UNUSED_ARG (selector);
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
+}
+
+int
+ACE_ATM_Addr::set (const ACE_ATM_Addr &sap,
+                   u_char selector)
+{
+  ACE_TRACE ("ACE_ATM_Addr::set");
+
+  this->init (selector);
+
+  this->ACE_Addr::base_set (sap.get_type (),
+                            sap.get_size ());
+
+#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
+  ACE_ASSERT (sap.get_type () == AF_ATM);
+#elif defined (ACE_HAS_LINUX_ATM)
+  ACE_ASSERT (sap.get_type () == PF_ATMSVC);
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 */
+
+ (void) ACE_OS::memcpy ((void *) &this->atm_addr_,
+ (void *) &sap.atm_addr_,
+                         sizeof this->atm_addr_);
+  return 0;
+}
+
+int
+ACE_ATM_Addr::set (const ATM_Addr *sap,
+                   u_char selector)
+{
+  ACE_TRACE ("ACE_ATM_Addr::set");
+
+  this->init (selector);
+
+#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
+  this->ACE_Addr::base_set (AF_ATM,
+#elif defined (ACE_HAS_LINUX_ATM)
+  this->ACE_Addr::base_set (PF_ATMSVC,
+#else
+  this->ACE_Addr::base_set (AF_UNSPEC,
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 */
+                            sizeof (*sap));
+
+ (void) ACE_OS::memcpy ((void *) &this->atm_addr_,
+ (void *) sap,
+                         sizeof this->atm_addr_);
+  return 0;
+}
+
+int
+ACE_ATM_Addr::set (const ACE_TCHAR address[],
+                   u_char selector)
+{
+  ACE_TRACE ("ACE_ATM_Addr::set");
+  int ret;
+
+  this->init (selector);
+
+#if defined (ACE_HAS_FORE_ATM_XTI)
+  atm_addr_.sap.t_atm_sap_addr.SVE_tag_addr =
+ (int8_t) T_ATM_PRESENT;
+#endif /* ACE_HAS_FORE_ATM_XTI */
+
+  ret = this -> string_to_addr (address);
+  this -> set_selector (selector);
+  return ret;
+}
+
+// Transform the string into the current addressing format.
+
+int
+ACE_ATM_Addr::string_to_addr (const ACE_TCHAR sap[])
+{
+  ACE_TRACE ("ACE_ATM_Addr::string_to_addr");
+
+#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
+  this->ACE_Addr::base_set (AF_ATM,
+#elif defined (ACE_HAS_LINUX_ATM)
+  this->ACE_Addr::base_set (PF_ATMSVC,
+#else
+  this->ACE_Addr::base_set (AF_UNSPEC,
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
+                            sizeof this->atm_addr_);
+#if defined (ACE_HAS_FORE_ATM_XTI)
+  struct hostent *entry;
+  struct atmnsap_addr *nsap;
+
+  // Yow, someone gave us a NULL ATM address!
+  if (sap == 0)
+    {
+      errno = EINVAL;
+      return -1;
+    }
+  else if ((entry = gethostbyname_atmnsap ((ACE_TCHAR *)sap)) != 0)
+    {
+      ACE_OS::memcpy (atm_addr_.sap.t_atm_sap_addr.address,
+                      entry->h_addr_list[0],
+                      ATMNSAP_ADDR_LEN - 1);
+    }
+  else if ((nsap = atmnsap_addr (sap)) != 0)
+    {
+      ACE_OS::memcpy (atm_addr_.sap.t_atm_sap_addr.address,
+                      nsap->atmnsap,
+                      ATMNSAP_ADDR_LEN);
+    }
+  else {
+      errno = EINVAL;
+      return -1;
+    }
+#elif defined (ACE_HAS_FORE_ATM_WS2)
+   DWORD dwValue;
+   HANDLE hLookup;
+   WSAQUERYSETW qsRestrictions;
+   CSADDR_INFO  csaBuffer;
+   WCHAR  tmpWStr[100];
+
+   MultiByteToWideChar (CP_ACP, MB_PRECOMPOSED, sap, -1, tmpWStr, 100);
+
+   csaBuffer.LocalAddr.iSockaddrLength = sizeof (struct sockaddr_atm);
+   csaBuffer.LocalAddr.lpSockaddr = (struct sockaddr *)&atm_addr_;
+   csaBuffer.RemoteAddr.iSockaddrLength = sizeof (struct sockaddr_atm);
+   csaBuffer.RemoteAddr.lpSockaddr = (struct sockaddr *)&atm_addr_;
+
+   qsRestrictions.dwSize                  = sizeof (WSAQUERYSETW);
+   qsRestrictions.lpszServiceInstanceName = NULL;
+   qsRestrictions.lpServiceClassId        = &FORE_NAME_CLASS;
+   qsRestrictions.lpVersion               = NULL;
+   qsRestrictions.lpszComment             = NULL;
+   qsRestrictions.dwNameSpace             = FORE_NAME_SPACE;
+   qsRestrictions.lpNSProviderId          = NULL;
+   qsRestrictions.lpszContext             = L"";
+   qsRestrictions.dwNumberOfProtocols     = 0;
+   qsRestrictions.lpafpProtocols          = NULL;
+   qsRestrictions.lpszQueryString         = tmpWStr;
+   qsRestrictions.dwNumberOfCsAddrs       = 1;
+   qsRestrictions.lpcsaBuffer             = &csaBuffer;
+   qsRestrictions.lpBlob                  = NULL; //&blob;
+
+   if (::WSALookupServiceBeginW (&qsRestrictions, LUP_RETURN_ALL, &hLookup)
+        == SOCKET_ERROR) {
+     ACE_OS::printf ("Error: WSALookupServiceBeginW failed! %d\n",
+                     ::WSAGetLastError ());
+           return -1;
+   }
+
+   dwValue = sizeof (WSAQUERYSETW);
+
+   if (::WSALookupServiceNextW (hLookup, 0, &dwValue, &qsRestrictions)
+        == SOCKET_ERROR) {
+     if (WSAGetLastError () != WSA_E_NO_MORE) {
+       ACE_OS::printf ("Error: WSALookupServiceNextW failed! %d\n",
+                       ::WSAGetLastError ());
+             return -1;
+     }
+   }
+
+   if (WSALookupServiceEnd (hLookup) == SOCKET_ERROR) {
+     ACE_OS::printf ("Error : WSALookupServiceEnd failed! %d \n",
+                     ::WSAGetLastError ());
+      errno = EINVAL;
+      return -1;
+   }
+#elif defined (ACE_HAS_LINUX_ATM)
+   if (sap == 0 || !ACE_OS::strcmp (sap,"")) {
+     errno = EINVAL;
+     return -1;
+   }
+
+   if (text2atm ((ACE_TCHAR *)sap,
+ (struct sockaddr *)& (atm_addr_.sockaddratmsvc),
+                 sizeof (atm_addr_.sockaddratmsvc),
+                 T2A_SVC | T2A_NAME) < 0) {
+     ACE_DEBUG (LM_DEBUG,
+               "Error : text2atm failed!\n");
+     errno = EINVAL;
+     return -1;
+   }
+#else
+  ACE_UNUSED_ARG (sap);
+
+  return 0;
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
+
+#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) || defined (ACE_HAS_LINUX_ATM)
+  return 0;
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 */
+}
+
+// Transform the current address into string format.
+
+int
+ACE_ATM_Addr::addr_to_string (ACE_TCHAR addr[],
+                              size_t addrlen) const
+{
+  ACE_TRACE ("ACE_ATM_Addr::addr_to_string");
+
+#if defined (ACE_HAS_FORE_ATM_XTI)
+  ACE_TCHAR buffer[MAXNAMELEN + 1];
+  struct atmnsap_addr nsap;
+  ACE_OS::memcpy (nsap.atmnsap,
+                  atm_addr_.sap.t_atm_sap_addr.address,
+                  ATMNSAP_ADDR_LEN);
+  ACE_OS::sprintf (buffer,
+                   ACE_LIB_TEXT ("%s"),
+                   atmnsap_ntoa (nsap));
+
+  size_t total_len = ACE_OS::strlen (buffer) + sizeof ('\0');
+
+  if (addrlen < total_len)
+    return -1;
+  else
+    ACE_OS::strcpy (addr, buffer);
+
+  return 0;
+#elif defined (ACE_HAS_FORE_ATM_WS2)
+  ACE_TCHAR buffer[MAXNAMELEN + 1];
+  int i;
+
+  if (addrlen < ATM_ADDR_SIZE + 1)
+          return -1;
+
+  for (i = 0; i < ATM_ADDR_SIZE; i++) {
+    buffer[ i * 3 ] = '\0';
+          ACE_OS::sprintf (buffer, ACE_LIB_TEXT ("%s%02x."),
+                     buffer,
+                     atm_addr_.satm_number.Addr[ i ]);
+  }
+
+  buffer[ ATM_ADDR_SIZE * 3 - 1 ] = '\0';
+  ACE_OS::strcpy (addr, buffer);
+
+  return 0;
+#elif defined (ACE_HAS_LINUX_ATM)
+  ACE_TCHAR buffer[MAX_ATM_ADDR_LEN + 1];
+  int total_len;
+  if ((total_len = atm2text (buffer,
+                            sizeof buffer,
+ (struct sockaddr *)& (atm_addr_.sockaddratmsvc),
+                            A2T_PRETTY)) < 0) {
+    ACE_DEBUG ((LM_DEBUG,"ACE_ATM_Addr (addr_to_string): atm2text failed\n"));
+    return -1;
+  }
+  if (addrlen < (size_t)total_len)
+    return -1;
+  else
+    ACE_OS::strcpy (addr,
+                   buffer);
+
+  return 0;
+#else
+  ACE_UNUSED_ARG (addr);
+  ACE_UNUSED_ARG (addrlen);
+  return -1;
+#endif /* ACE_HAS_FORE_ATM_XTI && ACE_HAS_FORE_ATM_WS2 */
+}
+
+const ACE_TCHAR *
+ACE_ATM_Addr::addr_to_string (void) const
+{
+  ACE_TRACE ("ACE_ATM_Addr::addr_to_string");
+
+  static ACE_TCHAR addr[MAXHOSTNAMELEN + 1];
+  if (this->addr_to_string (addr,
+                            MAXHOSTNAMELEN + 1) < 0)
+    return 0;
+
+  return addr;
+}
+
+// Set a pointer to the address.
+void
+ACE_ATM_Addr::set_addr (void *addr, int len)
+{
+  ACE_TRACE ("ACE_ATM_Addr::set_addr");
+
+#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
+  this->ACE_Addr::base_set (AF_ATM,
+#elif defined (ACE_HAS_LINUX_ATM)
+  this->ACE_Addr::base_set (PF_ATMSVC,
+#else
+  this->ACE_Addr::base_set (AF_UNSPEC,
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_WS2 */
+                            len);
+  ACE_OS::memcpy ((void *) &this->atm_addr_,
+ (void *) addr, len);
+}
+
+// Compare two addresses for inequality.
+
+int
+ACE_ATM_Addr::operator != (const ACE_ATM_Addr &sap) const
+{
+  ACE_TRACE ("ACE_ATM_Addr::operator !=");
+  return ! ((*this) == sap);
+}
+
+// Compare two addresses for equality.
+
+int
+ACE_ATM_Addr::operator == (const ACE_ATM_Addr &sap) const
+{
+  ACE_TRACE ("ACE_ATM_Addr::operator ==");
+
+#if defined (ACE_HAS_LINUX_ATM)
+  return (atm_equal ((const struct sockaddr *)& (this->atm_addr_.sockaddratmsvc),
+ (const struct sockaddr *)& (sap.atm_addr_.sockaddratmsvc),
+                    0,
+                    0)
+          &&
+          sap_equal (& (this->atm_addr_.atmsap),
+                    & (sap.atm_addr_.atmsap),
+                    0));
+#else
+  return ACE_OS::memcmp (&atm_addr_,
+                         &sap.atm_addr_,
+                         sizeof (ATM_Addr)) == 0;
+#endif /*  ACE_HAS_LINUX_ATM */
+}
+
+void
+ACE_ATM_Addr::dump (void) const
+{
+  ACE_TRACE ("ACE_ATM_Addr::dump");
+
+  ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
+
+  ACE_TCHAR s[ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 16];
+  ACE_OS::sprintf (s,
+                   ACE_LIB_TEXT ("%s"),
+                   this->addr_to_string ());
+  ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("%s"), s));
+  ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
+}
diff --git a/ace/ATM/ATM_Addr.h b/ace/ATM/ATM_Addr.h
new file mode 100644
index 00000000000..85319006ba5
--- /dev/null
+++ b/ace/ATM/ATM_Addr.h
@@ -0,0 +1,179 @@
+//=============================================================================
+/**
+ *  @file    ATM_Addr.h
+ *
+ *  $Id$
+ *
+ *  @author Joe Hoffert <joeh@cs.wustl.edu>
+ */
+//=============================================================================
+
+#ifndef ACE_ATM_ADDR_H
+#define ACE_ATM_ADDR_H
+#include "ace/pre.h"
+
+#include "ace/ACE.h"
+#include "ace/Addr.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#if defined (ACE_HAS_FORE_ATM_XTI)
+typedef ATMSAPAddress ATM_Addr;
+#elif defined (ACE_HAS_FORE_ATM_WS2)
+#define FORE_NAME_SPACE NS_ALL
+typedef struct sockaddr_atm ATM_Addr;
+#elif defined (ACE_HAS_LINUX_ATM)
+
+#include "atm.h"
+
+//pbrandao:as Linux has this 2 structs separeted we "link it" here
+typedef struct _linux_atm_addr
+{
+  struct sockaddr_atmsvc sockaddratmsvc;
+  struct atm_sap atmsap;
+} ATM_Addr;
+#else
+typedef int ATM_Addr;
+#endif /* ACE_HAS_FORE_ATM_XTI/ACE_HAS_FORE_ATM_WS2/ACE_HAS_LINUX_ATM */
+
+/**
+ * @class ACE_ATM_Addr
+ *
+ * @brief Defines the ATM domain address family address format.
+ */
+class ACE_Export ACE_ATM_Addr : public ACE_Addr
+{
+public:
+  // Constants used for ATM options
+  static const long LINE_RATE;
+  static const int OPT_FLAGS_CPID;
+  static const int OPT_FLAGS_PMP;
+  static const int DEFAULT_SELECTOR;
+
+  // = Initialization methods.
+  /// Default constructor.
+  ACE_ATM_Addr (u_char selector = DEFAULT_SELECTOR);
+
+  /// Copy constructor.
+  ACE_ATM_Addr (const ACE_ATM_Addr &,
+                u_char selector = DEFAULT_SELECTOR);
+
+  /**
+   * Creates an <ACE_ATM_Addr> from an ATMSAPAddress structure. This
+   * is vendor specific (FORE systems). May need to change when other
+   * vendors are supported.
+   */
+  ACE_ATM_Addr (const ATM_Addr *,
+                u_char selector = DEFAULT_SELECTOR);
+
+  /**
+   * Initializes an <ACE_ATM_Addr> from the <sap> which can be
+   * "atm-address" (e.g.,
+   * "47.0005.80.ffe100.0000.f20f.2200.0020480694f9.00") or "hostname"
+   * (e.g., "frisbee.cs.wustl.edu").
+   */
+  ACE_ATM_Addr (const ACE_TCHAR sap[],
+                u_char selector = DEFAULT_SELECTOR);
+
+  /// Default dtor.
+  ~ACE_ATM_Addr (void);
+
+  // = Initialization methods (useful after object construction).
+  /// Default initialization for non-address values (e.g.,
+  /// t_atm_sap_addr.SVE_tag_addr, t_atm_sap_addr.SVE_tag_selector)
+  void init (u_char selector = DEFAULT_SELECTOR);
+
+  /// Initializes from another <ACE_ATM_Addr>.
+  int set (const ACE_ATM_Addr &,
+           u_char selector = DEFAULT_SELECTOR);
+
+  /**
+   * Initializes an <ACE_ATM_Addr> from an ATMSAPAddress/sockaddr_atm
+   * structure. This is vendor specific (FORE systems). May need to
+   * change when other vendors are supported.
+   */
+  int set (const ATM_Addr *,
+           u_char selector = DEFAULT_SELECTOR);
+
+  /**
+   * Initializes an <ACE_ATM_Addr> from the <sap> which can be
+   * "atm-address" (e.g.,
+   * "47.0005.80.ffe100.0000.f20f.2200.0020480694f9.00") or "hostname"
+   * (e.g., "frisbee.cs.wustl.edu").
+   */
+  int set (const ACE_TCHAR sap[],
+           u_char selector = DEFAULT_SELECTOR);
+
+  /**
+   * Initializes an <ACE_ATM_Addr> from the <sap> which can be
+   * "atm-address" (e.g.,
+   * "47.0005.80.ffe100.0000.f20f.2200.0020480694f9.00") or "hostname"
+   * (e.g., "frisbee.cs.wustl.edu").
+   */
+  virtual int string_to_addr (const ACE_TCHAR sap[]);
+
+  /**
+   * Return the character representation of the ATM address (e.g.,
+   * "47.0005.80.ffe100.0000.f20f.2200.0020480694f9.00") storing it in
+   * the <addr> (which is assumed to be <addrlen> bytes long). This
+   * version is reentrant.  Returns -1 if the <addrlen> of the <addr>
+   * is too small, else 0.
+   */
+  virtual int addr_to_string (ACE_TCHAR addr[],
+                              size_t addrlen) const;
+
+  /**
+   * Return the character representation of the ATM address (e.g.,
+   * "47.0005.80.ffe100.0000.f20f.2200.0020480694f9.00"). Returns -1
+   * if the <size> of the <buffer> is too small, else 0.(This version
+   * is non-reentrant since it returns a pointer to a static data
+   * area.)
+   */
+  const ACE_TCHAR *addr_to_string (void) const;
+
+  /// Return a pointer to the underlying network address.
+  virtual void *get_addr (void) const;
+
+  /// Set a pointer to the address.
+  virtual void set_addr (void *, int);
+
+  /// Return the selector for network address.
+  u_char get_selector (void) const;
+
+  /// Set the selector for the network address.
+  void set_selector (u_char);
+
+  /**
+   * Compare two addresses for equality.  The addresses are considered
+   * equal if they contain the same ATM address.  Q: Is there any
+   * other check for equality needed for ATM?
+   */
+  int operator == (const ACE_ATM_Addr &SAP) const;
+
+  /// Compare two addresses for inequality.
+  int operator != (const ACE_ATM_Addr &SAP) const;
+
+  /// Dump the state of an object.
+  void dump (void) const;
+
+  /// Declare the dynamic allocation hooks.
+  ACE_ALLOC_HOOK_DECLARE;
+
+//   char *construct_options (ACE_HANDLE fd,
+//                            int qos_kb,
+//                            int flags,
+//                            long *optsize);
+//   // Construct options for ATM connections
+
+private:
+  ATM_Addr atm_addr_;
+};
+
+#if defined (__ACE_INLINE__)
+#include "ace/ATM_Addr.i"
+#endif /* __ACE_INLINE__ */
+
+#include "ace/post.h"
+#endif /* ACE_ATM_ADDR_H */
diff --git a/ace/ATM/ATM_Addr.i b/ace/ATM/ATM_Addr.i
new file mode 100644
index 00000000000..4b588c8faa7
--- /dev/null
+++ b/ace/ATM/ATM_Addr.i
@@ -0,0 +1,49 @@
+// $Id$
+
+// ATM_Addr.i
+
+// Default dtor.
+ACE_INLINE
+ACE_ATM_Addr::~ACE_ATM_Addr (void)
+{
+}
+
+// Return the address.
+
+ACE_INLINE void *
+ACE_ATM_Addr::get_addr (void) const
+{
+  ACE_TRACE ("ACE_ATM_Addr::get_addr");
+  return (void *) &this->atm_addr_;
+}
+
+ACE_INLINE unsigned char
+ACE_ATM_Addr::get_selector (void) const
+{
+  ACE_TRACE ("ACE_ATM_Addr::get_selector");
+#if defined (ACE_HAS_FORE_ATM_XTI)
+  return atm_addr_.sap.t_atm_sap_addr.address[ATMNSAP_ADDR_LEN - 1];
+#elif defined (ACE_HAS_FORE_ATM_WS2)
+  return atm_addr_.satm_number.Addr[ ATM_ADDR_SIZE - 1 ];
+#elif defined (ACE_HAS_LINUX_ATM)
+  return atm_addr_.sockaddratmsvc.sas_addr.prv[ATM_ESA_LEN - 1];
+#else
+  return 0;
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
+}
+
+ACE_INLINE void
+ACE_ATM_Addr::set_selector (unsigned char selector)
+{
+  ACE_TRACE ("ACE_ATM_Addr::set_selector");
+#if defined (ACE_HAS_FORE_ATM_XTI)
+  atm_addr_.sap.t_atm_sap_addr.address[ATMNSAP_ADDR_LEN - 1] = selector;
+#elif defined (ACE_HAS_FORE_ATM_WS2)
+  atm_addr_.satm_number.Addr[ ATM_ADDR_SIZE - 1 ] = selector;
+#elif defined (ACE_HAS_LINUX_ATM)
+  atm_addr_.sockaddratmsvc.sas_addr.prv[ATM_ESA_LEN - 1] = selector;
+#else
+  ACE_UNUSED_ARG (selector);
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
+}
+
diff --git a/ace/ATM/ATM_Connector.cpp b/ace/ATM/ATM_Connector.cpp
new file mode 100644
index 00000000000..29856669fb7
--- /dev/null
+++ b/ace/ATM/ATM_Connector.cpp
@@ -0,0 +1,140 @@
+// ATM_Connector.cpp
+// $Id$
+
+#include "ace/Handle_Set.h"
+#include "ace/ATM_Connector.h"
+
+ACE_RCSID(ace, ATM_Connector, "$Id$")
+
+#if defined (ACE_HAS_ATM)
+
+#if !defined (__ACE_INLINE__)
+#include "ace/ATM_Connector.i"
+#endif /* __ACE_INLINE__ */
+
+ACE_ALLOC_HOOK_DEFINE(ACE_ATM_Connector)
+
+void
+ACE_ATM_Connector::dump (void) const
+{
+  ACE_TRACE ("ACE_ATM_Connector::dump");
+}
+
+ACE_ATM_Connector::ACE_ATM_Connector (void)
+{
+  ACE_TRACE ("ACE_ATM_Connector::ACE_ATM_Connector");
+}
+
+// Actively connect and produce a new ACE_ATM_Stream if things go well...
+// Connect the <new_stream> to the <remote_sap>, waiting up to
+// <timeout> amount of time if necessary.
+
+int
+ACE_ATM_Connector::connect (ACE_ATM_Stream &new_stream,
+                            const ACE_ATM_Addr &remote_sap,
+                            ACE_ATM_Params params,
+                            ACE_ATM_QoS options,
+                            ACE_Time_Value *timeout,
+                            const ACE_ATM_Addr &local_sap,
+                            int reuse_addr,
+                            int flags,
+                            int perms)
+{
+  ACE_TRACE ("ACE_ATM_Connector::connect");
+#if defined (ACE_HAS_FORE_ATM_XTI)
+  return connector_.connect(new_stream.get_stream(),
+                            remote_sap,
+                            timeout,
+                            local_sap,
+                            reuse_addr,
+                            flags,
+                            perms,
+                            params.get_device(),
+                            params.get_info(),
+                            params.get_rw_flag(),
+                            params.get_user_data(),
+                            &options.get_qos());
+#elif defined (ACE_HAS_FORE_ATM_WS2)
+  ACE_DEBUG(LM_DEBUG,
+            ACE_LIB_TEXT ("ATM_Connector(connect): set QoS parameters\n" ));
+
+  ACE_HANDLE s = new_stream.get_handle();
+  struct sockaddr_atm *saddr = ( struct sockaddr_atm *)remote_sap.get_addr();
+  ACE_QoS cqos = options.get_qos();
+
+  ACE_QoS_Params qos_params = ACE_QoS_Params(0,
+                                             0,
+                                             &cqos,
+                                             0,
+                                             0);
+
+  ACE_DEBUG(LM_DEBUG,
+            ACE_LIB_TEXT ("ATM_Connector(connect): connecting...\n"));
+
+  int result = ACE_OS::connect( s,
+                                ( struct sockaddr *)saddr,
+                                sizeof( struct sockaddr_atm ),
+                                qos_params );
+
+  if ( result != 0 )
+    ACE_OS::printf( "ATM_Connector(connect): connection failed, %d\n",
+                    ::WSAGetLastError());
+
+  return result;
+#elif defined (ACE_HAS_LINUX_ATM)
+  ACE_UNUSED_ARG (params);
+  ACE_UNUSED_ARG (timeout);
+  ACE_UNUSED_ARG (reuse_addr);
+  ACE_UNUSED_ARG (perms);
+  ACE_UNUSED_ARG (flags);
+
+  ACE_HANDLE handle = new_stream.get_handle();
+  ATM_QoS qos =options.get_qos();
+  ATM_Addr *local_addr=(ATM_Addr*)local_sap.get_addr(),
+    *remote_addr=(ATM_Addr*)remote_sap.get_addr();
+
+  if (ACE_OS::setsockopt(handle,
+                         SOL_ATM,
+                         SO_ATMSAP,
+                         ACE_reinterpret_cast(char*,
+                                              &(local_addr->atmsap)),
+                         sizeof(local_addr->atmsap)) < 0) {
+    ACE_OS::printf( "ATM_Connector(connect): unable to set atmsap %d\nContinuing...",
+                    errno);
+  }
+  if (ACE_OS::setsockopt(handle,
+                         SOL_ATM,
+                         SO_ATMQOS,
+                         ACE_reinterpret_cast(char*,
+                                              &qos),
+                         sizeof(qos)) < 0) {
+    ACE_DEBUG((LM_DEBUG,ACE_LIB_TEXT ("ATM_Connector(connect): unable to set qos %d\n"),
+               errno));
+    return -1;
+  }
+
+  int result = ACE_OS::connect(handle,
+                               (struct sockaddr *)&(remote_addr->sockaddratmsvc),
+                               sizeof( remote_addr->sockaddratmsvc));
+
+  if ( result != 0 )
+    ACE_DEBUG(LM_DEBUG,
+              ACE_LIB_TEXT ("ATM_Connector(connect): connection failed, %d\n"),
+              errno);
+
+  return result;
+#else
+  ACE_UNUSED_ARG (new_stream);
+  ACE_UNUSED_ARG (remote_sap);
+  ACE_UNUSED_ARG (params);
+  ACE_UNUSED_ARG (options);
+  ACE_UNUSED_ARG (timeout);
+  ACE_UNUSED_ARG (local_sap);
+  ACE_UNUSED_ARG (reuse_addr);
+  ACE_UNUSED_ARG (flags);
+  ACE_UNUSED_ARG (perms);
+  return 0;
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
+}
+
+#endif /* ACE_HAS_ATM */
diff --git a/ace/ATM/ATM_Connector.h b/ace/ATM/ATM_Connector.h
new file mode 100644
index 00000000000..baa84fd47d6
--- /dev/null
+++ b/ace/ATM/ATM_Connector.h
@@ -0,0 +1,156 @@
+/* -*- C++ -*- */
+
+//=============================================================================
+/**
+ *  @file    ATM_Connector.h
+ *
+ *  $Id$
+ *
+ *  @author Joe Hoffert <joeh@cs.wustl.edu>
+ */
+//=============================================================================
+
+#ifndef ACE_ATM_CONNECTOR_H
+#define ACE_ATM_CONNECTOR_H
+#include "ace/pre.h"
+
+#include "ace/ATM_Stream.h"
+#include "ace/ATM_Params.h"
+#include "ace/ATM_QoS.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#if defined (ACE_HAS_ATM)
+
+#if defined (ACE_WIN32) || defined (ACE_HAS_LINUX_ATM)
+#include "SOCK_Connector.h"
+typedef ACE_SOCK_Connector ATM_Connector;
+#else
+#include "XTI_ATM_Mcast.h"
+typedef ACE_XTI_ATM_Mcast ATM_Connector;
+#endif
+
+/**
+ * @class ACE_ATM_Connector
+ *
+ * @brief Defines an active connection factory for the ACE_ATM C++
+ * wrappers.
+ */
+class ACE_Export ACE_ATM_Connector
+{
+public:
+  // = Initialization methods.
+  /// Default constructor.
+  ACE_ATM_Connector (void);
+
+  /**
+   * Actively connect and produce a <new_stream> if things go well.
+   * The <remote_sap> is the address that we are trying to connect
+   * with.  The <params> are the parameters needed for either socket
+   * or XTI/ATM connections.  The <timeout> is the amount of time to
+   * wait to connect. If it's 0 then we block indefinitely.  If
+   * *timeout == {0, 0} then the connection is done using non-blocking
+   * mode.  In this case, if the connection can't be made immediately
+   * the value of -1 is returned with <errno == EWOULDBLOCK>.  If
+   * *timeout > {0, 0} then this is the maximum amount of time to wait before
+   * timing out.  If the time expires before the connection is made
+   * <errno == ETIME>.  The <local_sap> is the value of local address
+   * to bind to.  If it's the default value of <ACE_ATM_Addr::sap_any> then
+   * the user is letting the OS do the binding.  If <reuse_addr> == 1
+   * then the <local_addr> is reused, even if it hasn't been cleanedup yet.
+   */
+  ACE_ATM_Connector (ACE_ATM_Stream &new_stream,
+                     const ACE_ATM_Addr &remote_sap,
+                     ACE_ATM_Params params = ACE_ATM_Params(),
+                     ACE_ATM_QoS options = ACE_ATM_QoS(),
+                     ACE_Time_Value *timeout = 0,
+                     const ACE_ATM_Addr &local_sap = ACE_ATM_Addr( "", 0 ),
+                     int reuse_addr = 0,
+#if defined (ACE_WIN32)
+                     int flags = 0,
+#else
+                     int flags = O_RDWR,
+#endif /* ACE_WIN32 */
+                     int perms = 0);
+
+  /**
+   * Actively connect and produce a <new_stream> if things go well.
+   * The <remote_sap> is the address that we are trying to connect
+   * with.  The <params> are the parameters needed for either socket
+   * or XTI/ATM connections.  The <timeout> is the amount of time to
+   * wait to connect. If it's 0 then we block indefinitely.  If
+   * *timeout == {0, 0} then the connection is done using non-blocking
+   * mode.  In this case, if the connection can't be made immediately
+   * the value of -1 is returned with <errno == EWOULDBLOCK>.  If
+   * *timeout > {0, 0} then this is the maximum amount of time to wait before
+   * timing out.  If the time expires before the connection is made
+   * <errno == ETIME>.  The <local_sap> is the value of local address
+   * to bind to.  If it's the default value of <ACE_ATM_Addr::sap_any> then
+   * the user is letting the OS do the binding.  If <reuse_addr> == 1
+   * then the <local_addr> is reused, even if it hasn't been cleanedup yet.
+   */
+  int connect (ACE_ATM_Stream &new_stream,
+               const ACE_ATM_Addr &remote_sap,
+               ACE_ATM_Params params = ACE_ATM_Params(),
+               ACE_ATM_QoS options = ACE_ATM_QoS(),
+               ACE_Time_Value *timeout = 0,
+               const ACE_ATM_Addr &local_sap = ACE_ATM_Addr( "",
+                                                             0 ),
+               int reuse_addr = 0,
+#if defined (ACE_WIN32)
+               int flags = 0,
+#else
+               int flags = O_RDWR,
+#endif /* ACE_WIN32 */
+               int perms = 0);
+
+  /**
+   * Try to complete a non-blocking connection.
+   * If connection completion is successful then <new_stream> contains
+   * the connected ACE_SOCK_Stream.  If <remote_sap> is non-NULL then it
+   * will contain the address of the connected peer.
+   */
+  int complete (ACE_ATM_Stream &new_stream,
+                ACE_ATM_Addr *remote_sap,
+                ACE_Time_Value *tv);
+
+  //int add_leaf (ACE_ATM_Stream &current_stream,
+  //              const ACE_Addr &remote_sap,
+  //              ACE_INT32 leaf_id,
+  //              ACE_Time_Value *timeout = 0);
+
+  /**
+   * Actively add a leaf to the root (i.e., point-to-multipoint). The
+   * <remote_sap> is the address of the leaf that we
+   * are trying to add.
+   */
+  int add_leaf (ACE_ATM_Stream &current_stream,
+                const ACE_Addr &remote_sap,
+                ACE_ATM_QoS &qos);
+
+  /// Resets any event associations on this handle
+  int reset_new_handle (ACE_HANDLE handle);
+
+  // = Meta-type info
+  typedef ACE_ATM_Addr PEER_ADDR;
+  typedef ACE_ATM_Stream PEER_STREAM;
+
+  /// Dump the state of an object.
+  void dump (void) const;
+
+  /// Declare the dynamic allocation hooks.
+  ACE_ALLOC_HOOK_DECLARE;
+
+private:
+  ATM_Connector connector_;
+};
+
+#if defined (__ACE_INLINE__)
+#include "ace/ATM_Connector.i"
+#endif /* __ACE_INLINE__ */
+
+#endif /* ACE_HAS_ATM */
+#include "ace/post.h"
+#endif /* ACE_ATM_CONNECTOR_H */
diff --git a/ace/ATM/ATM_Connector.i b/ace/ATM/ATM_Connector.i
new file mode 100644
index 00000000000..fc0eb0f8515
--- /dev/null
+++ b/ace/ATM/ATM_Connector.i
@@ -0,0 +1,119 @@
+/* -*- C++ -*- */
+// $Id$
+
+// ATM_Connector.i
+
+ACE_INLINE
+ACE_ATM_Connector::ACE_ATM_Connector (ACE_ATM_Stream &new_stream,
+                                      const ACE_ATM_Addr &remote_sap,
+                                      ACE_ATM_Params params,
+                                      ACE_ATM_QoS options,
+                                      ACE_Time_Value *timeout,
+                                      const ACE_ATM_Addr &local_sap,
+                                      int reuse_addr,
+                                      int flags,
+                                      int perms)
+{
+  ACE_TRACE ("ACE_ATM_Connector::ACE_ATM_Connector");
+  if ((ACE_HANDLE)this->connect (new_stream,
+                                 remote_sap,
+                                 params,
+                                 options,
+                                 timeout,
+                                 local_sap,
+                                 reuse_addr,
+                                 flags,
+                                 perms) == ACE_INVALID_HANDLE
+      && timeout != 0 && !(errno == EWOULDBLOCK || errno == ETIME))
+    ACE_ERROR ((LM_ERROR,  ACE_LIB_TEXT ("%p\n"),
+                ACE_LIB_TEXT ("ACE_ATM_Stream::ACE_ATM_Stream")));
+}
+
+// Try to complete a non-blocking connection.
+
+ACE_INLINE
+int
+ACE_ATM_Connector::complete (ACE_ATM_Stream &new_stream,
+                             ACE_ATM_Addr *remote_sap,
+                             ACE_Time_Value *tv)
+{
+  ACE_TRACE ("ACE_ATM_Connector::complete");
+#if defined (ACE_HAS_ATM)
+  return connector_.complete(new_stream.get_stream(),
+                             remote_sap,
+                             tv);
+#else
+  ACE_UNUSED_ARG(new_stream);
+  ACE_UNUSED_ARG(remote_sap);
+  ACE_UNUSED_ARG(tv);
+  return 0;
+#endif
+}
+
+ACE_INLINE
+int
+ACE_ATM_Connector::add_leaf (ACE_ATM_Stream &current_stream,
+                             const ACE_Addr &remote_sap,
+                             ACE_ATM_QoS &qos)
+{
+  ACE_TRACE ("ACE_ATM_Connector::add_leaf");
+#if defined (ACE_HAS_FORE_ATM_XTI)
+  return connector_.add_leaf(current_stream.get_stream(),
+                             remote_sap,
+                             leaf_id,
+                             timeout);
+#elif defined (ACE_HAS_FORE_ATM_WS2)
+  struct sockaddr_atm *saddr = (struct sockaddr_atm *)remote_sap.get_addr();
+  ACE_QoS cqos = qos.get_qos();
+  int addr_len = sizeof( struct sockaddr_atm );
+
+  ACE_QoS_Params qos_params(0,
+                            0,
+                            &cqos,
+                            0,
+                            (JL_SENDER_ONLY));
+
+  ACE_OS::printf( "ATM_Connector::add_leaf: connecting...\n" );
+
+  ACE_HANDLE result = ACE_OS::join_leaf(current_stream.get_handle(),
+                                        (struct sockaddr *)saddr,
+                                        addr_len,
+                                        qos_params);
+
+  if ( result == ACE_INVALID_HANDLE )
+    ACE_OS::printf( "ATM_Connector(add_leaf): connection failed, %d\n",
+                    ::WSAGetLastError());
+
+  return (result != ACE_INVALID_HANDLE);
+#elif defined (ACE_HAS_LINUX_ATM)
+  ACE_OS::printf("ATM_Connector(add_leaf): not yet implemented in Linux \n");
+
+  ACE_UNUSED_ARG(current_stream);
+  ACE_UNUSED_ARG(remote_sap);
+  ACE_UNUSED_ARG(leaf_id);
+  ACE_UNUSED_ARG(timeout);
+
+  return 0;
+#else
+  ACE_UNUSED_ARG(current_stream);
+  ACE_UNUSED_ARG(remote_sap);
+  ACE_UNUSED_ARG(leaf_id);
+  ACE_UNUSED_ARG(timeout);
+  return 0;
+#endif
+}
+
+ACE_INLINE
+int
+ACE_ATM_Connector::reset_new_handle (ACE_HANDLE handle)
+{
+#if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)
+  // Reset the event association
+  return ::WSAEventSelect ((SOCKET) handle,
+                           NULL,
+                           0);
+#else /* !defined ACE_HAS_WINSOCK2 */
+  ACE_UNUSED_ARG (handle);
+  return 0;
+#endif /* ACE_WIN32 */
+}
diff --git a/ace/ATM/ATM_Params.cpp b/ace/ATM/ATM_Params.cpp
new file mode 100644
index 00000000000..97bb51a6532
--- /dev/null
+++ b/ace/ATM/ATM_Params.cpp
@@ -0,0 +1,21 @@
+// $Id$
+
+#include "ace/ATM_Params.h"
+
+ACE_RCSID(ace, ATM_Params, "$Id$")
+
+#if defined (ACE_HAS_ATM)
+
+#if !defined (__ACE_INLINE__)
+#include "ace/ATM_Params.i"
+#endif /* __ACE_INLINE__ */
+
+ACE_ALLOC_HOOK_DEFINE(ACE_ATM_Params)
+
+void
+ACE_ATM_Params::dump (void) const
+{
+  ACE_TRACE ("ACE_ATM_Params::dump");
+}
+
+#endif /* ACE_HAS_ATM */
diff --git a/ace/ATM/ATM_Params.h b/ace/ATM/ATM_Params.h
new file mode 100644
index 00000000000..5544bd3afcd
--- /dev/null
+++ b/ace/ATM/ATM_Params.h
@@ -0,0 +1,184 @@
+
+//=============================================================================
+/**
+ *  @file    ATM_Params.h
+ *
+ *  $Id$
+ *
+ *  @author Joe Hoffert <joeh@cs.wustl.edu>
+ */
+//=============================================================================
+
+
+#ifndef ACE_ATM_PARAMS_H
+#define ACE_ATM_PARAMS_H
+#include "ace/pre.h"
+
+#include "ace/ACE.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#if defined (ACE_HAS_ATM)
+
+#if defined (ACE_HAS_FORE_ATM_XTI)
+#include "ace/TLI.h"
+#define ATM_PROTOCOL_DEFAULT 0
+typedef struct t_info Param_Info;
+typedef struct netbuf Param_Udata;
+#elif defined (ACE_HAS_FORE_ATM_WS2)
+#include "ace/SOCK.h"
+#define ATM_PROTOCOL_DEFAULT ATMPROTO_AAL5
+#define ACE_XTI_ATM_DEVICE ""
+typedef int Param_Info;
+typedef int Param_Udata;
+#elif defined (ACE_HAS_LINUX_ATM)
+#include "atm.h"
+#define AF_ATM PF_ATMSVC
+#define ACE_XTI_ATM_DEVICE ""
+#define ATM_PROTOCOL_DEFAULT ATM_AAL5
+typedef int Param_Info;
+typedef int Param_Udata;
+#else
+#define ACE_XTI_ATM_DEVICE ""
+typedef int Param_Info;
+typedef int Param_Udata;
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
+
+/**
+ * @class ACE_ATM_Params
+ *
+ * @brief Wrapper class that simplifies the information passed to the ATM
+ * enabled <ACE_ATM_Connector> class.
+ */
+class ACE_Export ACE_ATM_Params
+{
+public:
+  /**
+   * Initialize the data members.  This class combines options from
+   * ACE_SOCK_Connector (<protocol_family>, <protocol>, <type>,
+   * <protocol_info>, <group>, and <flags>) and
+   * ACE_TLI_Connector (<device>, <info>, <rw_flag>, <oflag>, and <udata>)
+   * so that either mechanism can be used transparently for ATM.
+   */
+  ACE_ATM_Params (int rw_flag = 1,
+                  const char device[] = ACE_XTI_ATM_DEVICE,
+                  Param_Info *info = 0,
+                  Param_Udata *udata = 0,
+                  int oflag = O_RDWR,
+                  int protocol_family = AF_ATM,
+                  int protocol = ATM_PROTOCOL_DEFAULT,
+                  int type =
+#if defined (ACE_HAS_LINUX_ATM)
+                  SOCK_DGRAM,
+#else
+                  SOCK_RAW,
+#endif /* ACE_HAS_LINUX_ATM */
+                  ACE_Protocol_Info *protocol_info = 0,
+                  ACE_SOCK_GROUP g = 0,
+                  u_long flags
+                    = ACE_FLAG_MULTIPOINT_C_ROOT
+                    | ACE_FLAG_MULTIPOINT_D_ROOT, // connector by default
+                  int reuse_addr = 0);
+
+  ~ACE_ATM_Params ();
+
+  /// Get/set protocol family.
+  int get_protocol_family (void) const;
+  void set_protocol_family (int);
+
+  /// Get/set protocol.
+  int get_protocol (void) const;
+  void set_protocol (int);
+
+  /// Get/set type.
+  int get_type (void) const;
+  void set_type (int);
+
+  /// Get/set protocol info.
+  ACE_Protocol_Info *get_protocol_info( void );
+  void set_protocol_info( ACE_Protocol_Info *);
+
+  /// Get/set socket group.
+  ACE_SOCK_GROUP get_sock_group( void );
+  void set_sock_group( ACE_SOCK_GROUP );
+
+  /// Get/set socket flags.
+  u_long get_flags( void );
+  void set_flags( u_long );
+
+  /// Get/set reuse_addr flag.
+  int get_reuse_addr (void) const;
+  void set_reuse_addr (int);
+
+  /// Get device.
+  const char* get_device (void) const;
+
+  /// Get/set info.
+  Param_Info* get_info (void) const;
+  void set_info (Param_Info *);
+
+  /// Get/set r/w flag.
+  int get_rw_flag (void) const;
+  void set_rw_flag (int);
+
+  /// Get/set user data.
+  Param_Udata* get_user_data (void) const;
+  void set_user_data (Param_Udata*);
+
+  /// /set open flag.
+  int get_oflag (void) const;
+  void set_oflag (int);
+
+  /// Dump the state of an object.
+  void dump (void) const;
+
+  /// Declare the dynamic allocation hooks.
+  ACE_ALLOC_HOOK_DECLARE;
+
+private:
+  /// Protocol family for sockets connections.
+  int protocol_family_;
+
+  /// Protocol for sockets connections.
+  int protocol_;
+
+  /// Type for opening sockets.
+  int type_;
+
+  /// Information about the protocol.
+  ACE_Protocol_Info *protocol_info_;
+
+  /// Socket group used (for sockets only).
+  ACE_SOCK_GROUP group_;
+
+  /// Flags for sockets (for sockets only).
+  u_long flags_;
+
+  /// Flag for reusing address for opening sockets.
+  int reuse_addr_;
+
+  /// Device name for XTI/ATM connections.
+  const char *device_;
+
+  /// Info for XTI/ATM connections.
+  Param_Info *info_;
+
+  /// R/W flag for XTI/ATM connections.
+  int rw_flag_;
+
+  /// User data for XTI/ATM connections.
+  Param_Udata *udata_;
+
+  /// Open flag for XTI/ATM connections.
+  int oflag_;
+};
+
+#if defined (__ACE_INLINE__)
+#include "ace/ATM_Params.i"
+#endif /* __ACE_INLINE__ */
+
+#endif /* ACE_HAS_ATM */
+#include "ace/post.h"
+#endif /* ACE_ATM_PARAMS_H */
diff --git a/ace/ATM/ATM_Params.i b/ace/ATM/ATM_Params.i
new file mode 100644
index 00000000000..2ebd431058d
--- /dev/null
+++ b/ace/ATM/ATM_Params.i
@@ -0,0 +1,223 @@
+// $Id$
+
+// ATM_Params.i
+
+ACE_INLINE
+ACE_ATM_Params::ACE_ATM_Params (int rw_flag,
+                                const char device[],
+                                Param_Info *info,
+                                Param_Udata *udata,
+                                int oflag,
+                                int protocol_family,
+                                int protocol,
+                                int type,
+                                ACE_Protocol_Info *protocol_info,
+                                ACE_SOCK_GROUP g,
+                                u_long flags,
+                                int reuse_addr)
+  : protocol_family_(protocol_family),
+    protocol_(protocol),
+    type_(type),
+    protocol_info_(protocol_info),
+    group_(g),
+    flags_(flags),
+    reuse_addr_(reuse_addr),
+    device_(device),
+    info_(info),
+    rw_flag_(rw_flag),
+    udata_(udata),
+    oflag_(oflag)
+{
+  ACE_TRACE ("ACE_ATM_Params::ACE_ATM_Params");
+}
+
+// Default dtor.
+ACE_INLINE
+ACE_ATM_Params::~ACE_ATM_Params (void)
+{
+  ACE_TRACE ("ACE_ATM_Params::~ACE_ATM_Params");
+}
+
+ACE_INLINE
+int
+ACE_ATM_Params::get_protocol_family (void) const
+{
+  ACE_TRACE ("ACE_ATM_Params::get_protocol_family");
+  return protocol_family_;
+}
+
+ACE_INLINE
+void
+ACE_ATM_Params::set_protocol_family (int family)
+{
+  ACE_TRACE ("ACE_ATM_Params::set_protocol_family");
+  protocol_family_ = family;
+}
+
+ACE_INLINE
+int
+ACE_ATM_Params::get_protocol (void) const
+{
+  ACE_TRACE ("ACE_ATM_Params::get_protocol");
+  return protocol_;
+}
+
+ACE_INLINE
+void
+ACE_ATM_Params::set_protocol (int protocol)
+{
+  ACE_TRACE ("ACE_ATM_Params::set_protocol");
+  protocol_ = protocol;
+}
+
+ACE_INLINE
+int
+ACE_ATM_Params::get_type (void) const
+{
+  ACE_TRACE ("ACE_ATM_Params::get_type");
+  return type_;
+}
+
+ACE_INLINE
+void
+ACE_ATM_Params::set_type (int type)
+{
+  ACE_TRACE ("ACE_ATM_Params::set_type");
+  type_ = type;
+}
+
+ACE_INLINE
+ACE_Protocol_Info*
+ACE_ATM_Params::get_protocol_info( void )
+{
+  ACE_TRACE ("ACE_ATM_Params::get_protocol_info");
+  return protocol_info_;
+}
+
+ACE_INLINE
+void
+ACE_ATM_Params::set_protocol_info( ACE_Protocol_Info *protocol_info )
+{
+  ACE_TRACE ("ACE_ATM_Params::set_protocol_info");
+  protocol_info_ = protocol_info;
+}
+
+ACE_INLINE
+ACE_SOCK_GROUP
+ACE_ATM_Params::get_sock_group( void )
+{
+  ACE_TRACE ("ACE_ATM_Params::get_sock_group");
+  return group_;
+}
+
+ACE_INLINE
+void
+ACE_ATM_Params::set_sock_group( ACE_SOCK_GROUP g )
+{
+  ACE_TRACE ("ACE_ATM_Params::set_sock_group");
+  group_ = g;
+}
+
+ACE_INLINE
+u_long
+ACE_ATM_Params::get_flags( void )
+{
+  ACE_TRACE ("ACE_ATM_Params::get_flags");
+  return flags_;
+}
+
+ACE_INLINE
+void
+ACE_ATM_Params::set_flags( u_long flags)
+{
+  ACE_TRACE ("ACE_ATM_Params::set_flags");
+  flags_ = flags;
+}
+
+ACE_INLINE
+int
+ACE_ATM_Params::get_reuse_addr (void) const
+{
+  ACE_TRACE ("ACE_ATM_Params::get_reuse_addr");
+  return reuse_addr_;
+}
+
+ACE_INLINE
+void
+ACE_ATM_Params::set_reuse_addr (int reuse_addr)
+{
+  ACE_TRACE ("ACE_ATM_Params::set_reuse_addr");
+  reuse_addr_ = reuse_addr;
+}
+
+ACE_INLINE
+const char*
+ACE_ATM_Params::get_device (void) const
+{
+  ACE_TRACE ("ACE_ATM_Params::get_device");
+  return device_;
+}
+
+ACE_INLINE
+Param_Info*
+ACE_ATM_Params::get_info (void) const
+{
+  ACE_TRACE ("ACE_ATM_Params::get_info");
+  return info_;
+}
+
+ACE_INLINE
+void
+ACE_ATM_Params::set_info (Param_Info* info)
+{
+  ACE_TRACE ("ACE_ATM_Params::set_info");
+  info_ = info;
+}
+
+ACE_INLINE
+int
+ACE_ATM_Params::get_rw_flag (void) const
+{
+  ACE_TRACE ("ACE_ATM_Params::get_rw_flag");
+  return rw_flag_;
+}
+
+ACE_INLINE
+void
+ACE_ATM_Params::set_rw_flag (int rw_flag)
+{
+  ACE_TRACE ("ACE_ATM_Params::set_rw_flag");
+  rw_flag_ = rw_flag;
+}
+
+ACE_INLINE
+Param_Udata*
+ACE_ATM_Params::get_user_data (void) const
+{
+  ACE_TRACE ("ACE_ATM_Params::get_user_data");
+  return udata_;
+}
+
+ACE_INLINE
+void
+ACE_ATM_Params::set_user_data (Param_Udata *udata)
+{
+  ACE_TRACE ("ACE_ATM_Params::set_user_data");
+  udata_ = udata;
+}
+
+ACE_INLINE
+int
+ACE_ATM_Params::get_oflag (void) const
+{
+  ACE_TRACE ("ACE_ATM_Params::get_oflag");
+  return oflag_;
+}
+
+ACE_INLINE
+void
+ACE_ATM_Params::set_oflag (int oflag)
+{
+  ACE_TRACE ("ACE_ATM_Params::set_oflag");
+  oflag_ = oflag;
+}
diff --git a/ace/ATM/ATM_QoS.cpp b/ace/ATM/ATM_QoS.cpp
new file mode 100644
index 00000000000..d2e33d8706a
--- /dev/null
+++ b/ace/ATM/ATM_QoS.cpp
@@ -0,0 +1,632 @@
+// $Id$
+
+#include "ace/ATM_QoS.h"
+
+ACE_RCSID(ace, ATM_QoS, "$Id$")
+
+#if defined (ACE_HAS_ATM)
+
+#if !defined (__ACE_INLINE__)
+#include "ace/ATM_QoS.i"
+#endif /* __ACE_INLINE__ */
+
+#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
+#define BHLI_MAGIC "FORE_ATM"
+// This is line rate in cells/s for an OC-3 MM interface.
+const long ACE_ATM_QoS::LINE_RATE = 353207;
+const int ACE_ATM_QoS::OPT_FLAGS_CPID = 0x1;
+const int ACE_ATM_QoS::OPT_FLAGS_PMP = 0x2;
+const int ACE_ATM_QoS::DEFAULT_SELECTOR = 0x99;
+const int ACE_ATM_QoS::DEFAULT_PKT_SIZE = 8192;
+#elif defined (ACE_HAS_LINUX_ATM)
+//pbrandao:for Linux:
+//pbrandao:for now stick with current definitions
+//pbrandao:see if later need to change
+const long ACE_ATM_QoS::LINE_RATE = 353207;
+const int ACE_ATM_QoS::OPT_FLAGS_CPID = 0x1;
+const int ACE_ATM_QoS::OPT_FLAGS_PMP = 0x2;
+const int ACE_ATM_QoS::DEFAULT_SELECTOR = 0x99;
+const int ACE_ATM_QoS::DEFAULT_PKT_SIZE = 8192;
+#else
+const long ACE_ATM_QoS::LINE_RATE = 0L;
+const int ACE_ATM_QoS::OPT_FLAGS_CPID = 0;
+const int ACE_ATM_QoS::OPT_FLAGS_PMP = 0;
+const int ACE_ATM_QoS::DEFAULT_SELECTOR = 0x0;
+const int ACE_ATM_QoS::DEFAULT_PKT_SIZE = 0;
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
+
+ACE_ALLOC_HOOK_DEFINE(ACE_ATM_QoS)
+
+ACE_ATM_QoS::ACE_ATM_QoS (int pktSize)
+{
+  ACE_TRACE ("ACE_ATM_QoS::ACE_ATM_QoS");
+#if defined (ACE_HAS_LINUX_ATM)
+    ACE_OS::memset(&qos_, 0, sizeof(qos_));
+    qos_.aal = ATM_PROTOCOL_DEFAULT;
+    qos_.rxtp.traffic_class = ATM_ANYCLASS;
+    qos_.rxtp.max_sdu = pktSize;
+    qos_.txtp.traffic_class = ATM_ANYCLASS;
+    qos_.txtp.max_sdu = pktSize;
+#else
+    ACE_UNUSED_ARG (pktSize);
+#endif /* ACE_HAS_LINUX_ATM */
+}
+
+ACE_ATM_QoS::ACE_ATM_QoS(int rate,
+                         int pktSize)
+{
+  ACE_TRACE( "ACE_ATM_QoS::ACE_ATM_QoS" );
+#if defined (ACE_HAS_FORE_ATM_WS2)
+  AAL_PARAMETERS_IE ie_aalparams;
+  ATM_TRAFFIC_DESCRIPTOR_IE ie_td;
+  ATM_BROADBAND_BEARER_CAPABILITY_IE ie_bbc;
+  ATM_QOS_CLASS_IE ie_qos;
+  Q2931_IE *ie_ptr;
+  int size;
+
+  // Setting up cbr parameters ...
+  ie_aalparams.AALType = AALTYPE_5;
+  ie_aalparams.AALSpecificParameters.AAL5Parameters.ForwardMaxCPCSSDUSize
+    = pktSize; // was 1516;
+  ie_aalparams.AALSpecificParameters.AAL5Parameters.BackwardMaxCPCSSDUSize
+    = pktSize; // was 1516;
+  ie_aalparams.AALSpecificParameters.AAL5Parameters.Mode = AAL5_MODE_MESSAGE;
+  ie_aalparams.AALSpecificParameters.AAL5Parameters.SSCSType = AAL5_SSCS_NULL;
+
+  size = sizeof(Q2931_IE_TYPE) + sizeof(ULONG) + sizeof(AAL_PARAMETERS_IE);
+
+  ie_td.Forward.PeakCellRate_CLP0 = SAP_FIELD_ABSENT;
+  ie_td.Forward.PeakCellRate_CLP01 = rate;
+  ie_td.Forward.SustainableCellRate_CLP0 = SAP_FIELD_ABSENT;
+  ie_td.Forward.SustainableCellRate_CLP01 = SAP_FIELD_ABSENT;
+  ie_td.Forward.MaxBurstSize_CLP0 = SAP_FIELD_ABSENT;
+  ie_td.Forward.MaxBurstSize_CLP01 = SAP_FIELD_ABSENT;
+  ie_td.Forward.Tagging = SAP_FIELD_ABSENT;
+
+  ie_td.Backward.PeakCellRate_CLP0 = SAP_FIELD_ABSENT;
+  ie_td.Backward.PeakCellRate_CLP01 = rate;
+  ie_td.Backward.SustainableCellRate_CLP0 = SAP_FIELD_ABSENT;
+  ie_td.Backward.SustainableCellRate_CLP01 = SAP_FIELD_ABSENT;
+  ie_td.Backward.MaxBurstSize_CLP0 = SAP_FIELD_ABSENT;
+  ie_td.Backward.MaxBurstSize_CLP01 = SAP_FIELD_ABSENT;
+  ie_td.Backward.Tagging = SAP_FIELD_ABSENT;
+
+  ie_td.BestEffort = 0; // Note: this must be set to zero for CBR.
+
+  size += sizeof( Q2931_IE_TYPE )
+    + sizeof( ULONG )
+    + sizeof( ATM_TRAFFIC_DESCRIPTOR_IE );
+
+  ie_bbc.BearerClass = BCOB_X;
+  ie_bbc.TrafficType = TT_CBR;
+  ie_bbc.TimingRequirements = TR_END_TO_END;
+  ie_bbc.ClippingSusceptability = CLIP_NOT;
+  ie_bbc.UserPlaneConnectionConfig = UP_P2P;
+
+  size += sizeof( Q2931_IE_TYPE )
+    + sizeof( ULONG )
+    + sizeof( ATM_BROADBAND_BEARER_CAPABILITY_IE );
+
+  ie_qos.QOSClassForward = QOS_CLASS1;
+  ie_qos.QOSClassBackward = QOS_CLASS1; // This may not be really used
+  // since we do only simplex data xfer.
+
+  size += sizeof(Q2931_IE_TYPE) + sizeof(ULONG) + sizeof(ATM_QOS_CLASS_IE);
+
+  qos_.ProviderSpecific.buf = (char *) ACE_OS::malloc(size);
+  if (qos_.ProviderSpecific.buf == 0) {
+    ACE_ERROR((LM_ERROR,
+               ACE_LIB_TEXT ("ACE_ATM_QoS::ACE_ATM_QoS: Unable to allocate %d bytes for qos_.ProviderSpecific.buf\n"),
+               size));
+    return;
+  }
+  qos_.ProviderSpecific.len = size;
+  ACE_OS::memset(qos_.ProviderSpecific.buf, 0, size);
+
+  ie_ptr = (Q2931_IE *) qos_.ProviderSpecific.buf;
+  ie_ptr->IEType = IE_AALParameters;
+  ie_ptr->IELength = sizeof( Q2931_IE_TYPE )
+    + sizeof( ULONG )
+    + sizeof( AAL_PARAMETERS_IE );
+  ACE_OS::memcpy(ie_ptr->IE, &ie_aalparams, sizeof(AAL_PARAMETERS_IE));
+
+  ie_ptr = (Q2931_IE *) ((char *)ie_ptr + ie_ptr->IELength);
+  ie_ptr->IEType = IE_TrafficDescriptor;
+  ie_ptr->IELength = sizeof( Q2931_IE_TYPE )
+    + sizeof( ULONG )
+    + sizeof( ATM_TRAFFIC_DESCRIPTOR_IE );
+  ACE_OS::memcpy(ie_ptr->IE, &ie_td, sizeof(ATM_TRAFFIC_DESCRIPTOR_IE));
+
+  ie_ptr = (Q2931_IE *) ((char *)ie_ptr + ie_ptr->IELength);
+  ie_ptr->IEType = IE_BroadbandBearerCapability;
+  ie_ptr->IELength = sizeof( Q2931_IE_TYPE )
+    + sizeof( ULONG )
+    + sizeof( ATM_BROADBAND_BEARER_CAPABILITY_IE );
+  ACE_OS::memcpy(ie_ptr->IE,
+                 &ie_bbc,
+                 sizeof(ATM_BROADBAND_BEARER_CAPABILITY_IE));
+
+  ie_ptr = (Q2931_IE *) ((char *)ie_ptr + ie_ptr->IELength);
+  ie_ptr->IEType = IE_QOSClass;
+  ie_ptr->IELength = sizeof( Q2931_IE_TYPE )
+    + sizeof( ULONG )
+    + sizeof( ATM_QOS_CLASS_IE );
+  ACE_OS::memcpy(ie_ptr->IE, &ie_qos, sizeof(ATM_QOS_CLASS_IE));
+
+  //    qos_.SendingFlowspec.TokenRate = 0xffffffff;
+  //    qos_.SendingFlowspec.TokenBucketSize = 0xffffffff;
+  //    qos_.SendingFlowspec.PeakBandwidth = 0xffffffff;
+  //    qos_.SendingFlowspec.Latency = 0xffffffff;
+  //    qos_.SendingFlowspec.DelayVariation = 0xffffffff;
+  //    qos_.SendingFlowspec.ServiceType = SERVICETYPE_BESTEFFORT;
+  // This will most probably be ignored by the service provider.
+  //    qos_.SendingFlowspec.MaxSduSize = 0xffffffff;
+  //    qos_.SendingFlowspec.MinimumPolicedSize = 0xffffffff;
+
+  //    qos_.ReceivingFlowspec.TokenRate = 0xffffffff;
+  //    qos_.ReceivingFlowspec.TokenBucketSize = 0xffffffff;
+  //    qos_.ReceivingFlowspec.PeakBandwidth = 0xffffffff;
+  //    qos_.ReceivingFlowspec.Latency = 0xffffffff;
+  //    qos_.ReceivingFlowspec.DelayVariation = 0xffffffff;
+  //    qos_.ReceivingFlowspec.ServiceType = SERVICETYPE_BESTEFFORT;
+  // This will most probably be ignored by the service provider.
+  //    qos_.ReceivingFlowspec.MaxSduSize = 0xffffffff;
+  //    qos_.ReceivingFlowspec.MinimumPolicedSize = 0;
+
+  ACE_Flow_Spec send_fspec( 0xffffffff,
+                            0xffffffff,
+                            0xffffffff,
+                            0xffffffff,
+                            0xffffffff,
+                            SERVICETYPE_BESTEFFORT,
+                            // This will most probably ignored by SP.
+                            0xffffffff,
+                            0xffffffff,
+                            15,
+                            ACE_DEFAULT_THREAD_PRIORITY ),
+    recv_fspec( 0xffffffff,
+                0xffffffff,
+                0xffffffff,
+                0xffffffff,
+                0xffffffff,
+                SERVICETYPE_BESTEFFORT,
+                // This will most probably ignored by SP.
+                0xffffffff,
+                0,
+                15,
+                ACE_DEFAULT_THREAD_PRIORITY );
+
+  qos_.sending_flowspec( send_fspec );
+  qos_.receiving_flowspec( recv_fspec );
+#elif defined (ACE_HAS_FORE_ATM_XTI)
+  ACE_UNUSED_ARG (rate);
+  ACE_UNUSED_ARG (pktSize);
+#elif defined (ACE_HAS_LINUX_ATM)
+  ACE_OS::memset(&qos_,
+                 0,
+                 sizeof(qos_));
+  qos_.aal = ATM_PROTOCOL_DEFAULT;
+  qos_.rxtp.max_sdu = pktSize;
+
+  if (rate > 0) {
+    qos_.rxtp.pcr = rate;
+    qos_.rxtp.traffic_class = ATM_CBR;
+    qos_.txtp.traffic_class = ATM_CBR;
+    qos_.txtp.pcr = rate;
+  }
+  else {
+    qos_.rxtp.traffic_class = ATM_UBR;
+    qos_.txtp.traffic_class = ATM_UBR;
+  }
+
+  qos_.txtp.max_sdu = pktSize;
+#else
+  ACE_UNUSED_ARG (rate);
+#endif /* ACE_HAS_FORE_ATM_WS2 || ACE_HAS_FORE_ATM_XTI || ACE_HAS_LINUX_ATM */
+}
+
+void
+ACE_ATM_QoS::set_cbr_rate (int rate,
+                           int pktSize)
+{
+  ACE_TRACE ("ACE_ATM_QoS::set_cbr_rate");
+#if defined (ACE_HAS_FORE_ATM_WS2)
+  /*
+  AAL_PARAMETERS_IE ie_aalparams;
+  ATM_TRAFFIC_DESCRIPTOR_IE ie_td;
+  ATM_BROADBAND_BEARER_CAPABILITY_IE ie_bbc;
+  ATM_QOS_CLASS_IE ie_qos;
+  Q2931_IE *ie_ptr;
+  int size;
+  */
+
+  ACE_OS::printf( "ATM_QoS(set_cbr_rate): set rate to %d c/s\n", rate );
+
+  // Setting up cbr parameters ...
+  /*
+  FORE has changed this - we no longer specify QoS this way
+  ie_aalparams.AALType = AALTYPE_5;
+  ie_aalparams.AALSpecificParameters.AAL5Parameters.ForwardMaxCPCSSDUSize
+    = pktSize; // was 1516;
+  ie_aalparams.AALSpecificParameters.AAL5Parameters.BackwardMaxCPCSSDUSize
+    = pktSize; // was 1516;
+  ie_aalparams.AALSpecificParameters.AAL5Parameters.Mode = AAL5_MODE_MESSAGE;
+  ie_aalparams.AALSpecificParameters.AAL5Parameters.SSCSType = AAL5_SSCS_NULL;
+
+  size = sizeof(Q2931_IE_TYPE) + sizeof(ULONG) + sizeof(AAL_PARAMETERS_IE);
+
+  ie_td.Forward.PeakCellRate_CLP0 = SAP_FIELD_ABSENT;
+  ie_td.Forward.PeakCellRate_CLP01 = rate;
+  ie_td.Forward.SustainableCellRate_CLP0 = SAP_FIELD_ABSENT;
+  ie_td.Forward.SustainableCellRate_CLP01 = SAP_FIELD_ABSENT;
+  ie_td.Forward.MaxBurstSize_CLP0 = SAP_FIELD_ABSENT;
+  ie_td.Forward.MaxBurstSize_CLP01 = SAP_FIELD_ABSENT;
+  ie_td.Forward.Tagging = SAP_FIELD_ABSENT;
+
+  ie_td.Backward.PeakCellRate_CLP0 = SAP_FIELD_ABSENT;
+  ie_td.Backward.PeakCellRate_CLP01 = rate;
+  ie_td.Backward.SustainableCellRate_CLP0 = SAP_FIELD_ABSENT;
+  ie_td.Backward.SustainableCellRate_CLP01 = SAP_FIELD_ABSENT;
+  ie_td.Backward.MaxBurstSize_CLP0 = SAP_FIELD_ABSENT;
+  ie_td.Backward.MaxBurstSize_CLP01 = SAP_FIELD_ABSENT;
+  ie_td.Backward.Tagging = SAP_FIELD_ABSENT;
+
+  ie_td.BestEffort = 0; // Note: this must be set to zero for CBR.
+
+  size += sizeof( Q2931_IE_TYPE ) +
+          sizeof( ULONG ) +
+          sizeof( ATM_TRAFFIC_DESCRIPTOR_IE );
+
+  ie_bbc.BearerClass = BCOB_X;
+  ie_bbc.TrafficType = TT_CBR;
+  ie_bbc.TimingRequirements = TR_END_TO_END;
+  ie_bbc.ClippingSusceptability = CLIP_NOT;
+  ie_bbc.UserPlaneConnectionConfig = UP_P2P;
+
+  size += sizeof(Q2931_IE_TYPE) +
+          sizeof(ULONG) +
+          sizeof(ATM_BROADBAND_BEARER_CAPABILITY_IE);
+
+  ie_qos.QOSClassForward = QOS_CLASS1;
+  ie_qos.QOSClassBackward = QOS_CLASS1; // This may not be really used
+  // since we only simplex data xfer.
+
+  size += sizeof(Q2931_IE_TYPE) + sizeof(ULONG) + sizeof(ATM_QOS_CLASS_IE);
+
+  qos_.ProviderSpecific.buf = (char *) ACE_OS::malloc(size);
+  if (qos_.ProviderSpecific.buf == 0) {
+    ACE_ERROR((LM_ERROR,
+               ACE_LIB_TEXT ("ACE_ATM_QoS::ACE_ATM_QoS: Unable to allocate %d bytes for qos_.ProviderSpecific.buf\n"),
+               size));
+    return;
+  }
+  qos_.ProviderSpecific.len = size;
+  ACE_OS::memset(qos_.ProviderSpecific.buf, 0, size);
+
+  ie_ptr = (Q2931_IE *) qos_.ProviderSpecific.buf;
+  ie_ptr->IEType = IE_AALParameters;
+  ie_ptr->IELength = sizeof( Q2931_IE_TYPE ) +
+                     sizeof( ULONG ) +
+                     sizeof( AAL_PARAMETERS_IE );
+  ACE_OS::memcpy(ie_ptr->IE, &ie_aalparams, sizeof(AAL_PARAMETERS_IE));
+
+  ie_ptr = (Q2931_IE *) ((char *)ie_ptr + ie_ptr->IELength);
+  ie_ptr->IEType = IE_TrafficDescriptor;
+  ie_ptr->IELength = sizeof( Q2931_IE_TYPE ) +
+                     sizeof( ULONG ) +
+                     sizeof( ATM_TRAFFIC_DESCRIPTOR_IE );
+  ACE_OS::memcpy(ie_ptr->IE, &ie_td, sizeof(ATM_TRAFFIC_DESCRIPTOR_IE));
+
+  ie_ptr = (Q2931_IE *) ((char *)ie_ptr + ie_ptr->IELength);
+  ie_ptr->IEType = IE_BroadbandBearerCapability;
+  ie_ptr->IELength = sizeof( Q2931_IE_TYPE ) +
+                     sizeof( ULONG ) +
+                     sizeof( ATM_BROADBAND_BEARER_CAPABILITY_IE );
+  ACE_OS::memcpy( ie_ptr->IE,
+                  &ie_bbc,
+                  sizeof( ATM_BROADBAND_BEARER_CAPABILITY_IE ));
+
+  ie_ptr = (Q2931_IE *) ((char *)ie_ptr + ie_ptr->IELength);
+  ie_ptr->IEType = IE_QOSClass;
+  ie_ptr->IELength = sizeof(Q2931_IE_TYPE) + sizeof(ULONG) +
+                     sizeof(ATM_QOS_CLASS_IE);
+  ACE_OS::memcpy(ie_ptr->IE, &ie_qos, sizeof(ATM_QOS_CLASS_IE));
+  */
+
+  const int BYTES_PER_ATM_CELL = 53;
+  ACE_OS::memset(&qos_, 0, sizeof(ATM_QoS));
+  // Setting the token rate sets the minimum rate. 3 Mbits/sec seems too high.
+  //  Certainly for Vaudeville audio, we only need about 1000 c/s which is
+  //  424000 bits/sec which is 53000 bytes/sec.
+  //qos_.SendingFlowspec.TokenRate = 3*(1024*128);      // 3Mbits/sec
+  qos_.SendingFlowspec.TokenRate = 53000;               // 1000 cells/sec
+  qos_.SendingFlowspec.TokenBucketSize = 32*1024;       // our block size
+  //ourQos.SendingFlowspec.PeakBandwidth = ourQos.SendingFlowspec.TokenRate;
+  qos_.SendingFlowspec.ServiceType = SERVICETYPE_GUARANTEED;
+  // Peak bandwidth is in bytes/sec. The rate is specified in cells/sec so
+  //  we need to convert from cells/sec to bytes/sec (i.e., multiply by 53).
+  qos_.SendingFlowspec.PeakBandwidth = rate * BYTES_PER_ATM_CELL;
+  qos_.SendingFlowspec.Latency = -1;    // we don't care too much
+  qos_.SendingFlowspec.DelayVariation = -1; // we don't care too much
+  // no provider-specific data allowed on ATM
+  qos_.ProviderSpecific.buf=NULL;
+  qos_.ProviderSpecific.len=0;
+  // unidirectional P2MP; we don't need to setup the Receiving flowspec
+
+  //qos_.SendingFlowspec.TokenRate = 0xffffffff;
+  //qos_.SendingFlowspec.TokenBucketSize = 0xffffffff;
+  //qos_.SendingFlowspec.PeakBandwidth = 0xffffffff;
+  //qos_.SendingFlowspec.Latency = 0xffffffff;
+  //qos_.SendingFlowspec.DelayVariation = 0xffffffff;
+  //qos_.SendingFlowspec.ServiceType = SERVICETYPE_BESTEFFORT;
+  // This will most probably be ignored by the service provider.
+  //qos_.SendingFlowspec.MaxSduSize = 0xffffffff;
+  //qos_.SendingFlowspec.MinimumPolicedSize = 0xffffffff;
+
+  //qos_.ReceivingFlowspec.TokenRate = 0xffffffff;
+  //qos_.ReceivingFlowspec.TokenBucketSize = 0xffffffff;
+  //qos_.ReceivingFlowspec.PeakBandwidth = 0xffffffff;
+  //qos_.ReceivingFlowspec.Latency = 0xffffffff;
+  //qos_.ReceivingFlowspec.DelayVariation = 0xffffffff;
+  //qos_.ReceivingFlowspec.ServiceType = SERVICETYPE_BESTEFFORT;
+  // This will most probably be ignored by the service provider.
+  //qos_.ReceivingFlowspec.MaxSduSize = 0xffffffff;
+  //qos_.ReceivingFlowspec.MinimumPolicedSize = 0;
+
+  /*
+  ACE_Flow_Spec send_fspec( 0xffffffff,
+                            0xffffffff,
+                            0xffffffff,
+                            0xffffffff,
+                            0xffffffff,
+                            SERVICETYPE_BESTEFFORT,
+                            // This will most probably ignored by SP.
+                            0xffffffff,
+                            0xffffffff,
+                            15,
+                            ACE_DEFAULT_THREAD_PRIORITY ),
+  recv_fspec( 0xffffffff,
+              0xffffffff,
+              0xffffffff,
+              0xffffffff,
+              0xffffffff,
+              SERVICETYPE_BESTEFFORT,
+              // This will most probably ignored by SP.
+              0xffffffff,
+              0,
+              15,
+              ACE_DEFAULT_THREAD_PRIORITY );
+
+  qos_.sending_flowspec( send_fspec );
+  qos_.receiving_flowspec( recv_fspec );
+  */
+#elif defined (ACE_HAS_FORE_ATM_XTI)
+  ACE_UNUSED_ARG (rate);
+  ACE_UNUSED_ARG (pktSize);
+#elif defined (ACE_HAS_LINUX_ATM)
+  ACE_UNUSED_ARG (pktSize);
+
+  qos_.rxtp.traffic_class = ATM_CBR;
+  qos_.rxtp.pcr = rate;
+  qos_.txtp.traffic_class = ATM_CBR;
+  qos_.txtp.pcr = rate;
+#else
+  ACE_UNUSED_ARG (rate);
+#endif /* ACE_HAS_FORE_ATM_WS2 || ACE_HAS_FORE_ATM_XTI || ACE_HAS_LINUX_ATM */
+}
+
+void
+ACE_ATM_QoS::dump (void) const
+{
+  ACE_TRACE ("ACE_ATM_QoS::dump");
+}
+
+void
+ACE_ATM_QoS::set_rate (ACE_HANDLE fd,
+                       int rate,
+                       int flags)
+{
+  ACE_TRACE ("ACE_ATM_QoS::set_rate");
+#if defined (ACE_HAS_FORE_ATM_WS2) || defined (ACE_HAS_LINUX_ATM)
+  set_cbr_rate( rate );
+
+  ACE_UNUSED_ARG( fd );
+  ACE_UNUSED_ARG( flags );
+#elif defined (ACE_HAS_FORE_ATM_XTI)
+  long optlen = 0;
+  qos_.buf = construct_options(fd,
+                               rate,
+                               flags,
+                               &optlen);
+  qos_.len = optlen;
+#else
+  ACE_UNUSED_ARG (rate);
+#endif /* ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM || ACE_HAS_FORE_ATM_XTI */
+}
+
+char*
+ACE_ATM_QoS::construct_options (ACE_HANDLE fd,
+                                int rate,
+                                int flags,
+                                long *len)
+{
+#if defined (ACE_HAS_FORE_ATM_WS2) || defined (ACE_HAS_LINUX_ATM)
+  ACE_UNUSED_ARG (fd);
+  ACE_UNUSED_ARG (rate);
+  ACE_UNUSED_ARG (flags);
+  ACE_UNUSED_ARG (len);
+  return (0);
+#elif defined (ACE_HAS_FORE_ATM_XTI)
+  struct t_opthdr *popt;
+  char *buf;
+  int qos_cells;
+  struct t_info info;
+
+  if (ACE_OS::t_getinfo (fd, &info) == -1)
+    {
+      ACE_OS::t_error ("t_getinfo");
+      return 0;
+    }
+
+  buf = (char *) ACE_OS::malloc (info.options);
+
+  if (buf == 0)
+    ACE_ERROR_RETURN ((LM_ERROR,
+                       ACE_LIB_TEXT ("Unable to allocate %d bytes for options\n"),
+                       info.options),
+                      0);
+
+  popt = (struct t_opthdr *) buf;
+
+  if (flags & OPT_FLAGS_CPID)
+    {
+      // This constructs the T_ATM_ORIG_ADDR option, which is used to
+      // signal the UNI 3.1 Calling Party ID Information Element.
+      t_atm_addr *source_addr;
+
+      popt->len = sizeof (struct t_opthdr) + sizeof (t_atm_addr);
+      popt->level = T_ATM_SIGNALING;
+      popt->name = T_ATM_ORIG_ADDR;
+      popt->status = 0;
+
+      source_addr =
+        (t_atm_addr *)((char *) popt + sizeof (struct t_opthdr));
+
+      source_addr->address_format = T_ATM_ENDSYS_ADDR;
+      source_addr->address_length = ATMNSAP_ADDR_LEN;
+
+      ATMSAPAddress local_addr;
+      struct t_bind boundaddr;
+
+      boundaddr.addr.maxlen = sizeof(local_addr);
+      boundaddr.addr.buf = (char *) &local_addr;
+
+      //if (ACE_OS::t_getprotaddr(fd, &boundaddr, NULL) < 0) {
+      if (ACE_OS::t_getname(fd,
+                            &boundaddr.addr,
+                            LOCALNAME) < 0)
+        {
+          ACE_OS::t_error("t_getname (local_address)");
+          ACE_ERROR ((LM_ERROR,
+                      ACE_LIB_TEXT ("Can't get local address!\n")));
+          ACE_OS::free (buf);
+          return 0;
+        }
+
+      ACE_OS::memcpy(source_addr->address,
+                     local_addr.sap.t_atm_sap_addr.address,
+                     ATMNSAP_ADDR_LEN);
+
+      popt = T_OPT_NEXTHDR (buf, info.options , popt);
+    }
+
+  // This constructs all options necessary (bearer cap., QoS, and
+  // Traffic Descriptor) to signal for a CBR connection with the
+  // specified QoS in kbit/sec., and/or specify a PMP connection.
+
+  // For FORE 200e cards, the adapter shapes traffic to CBR with rate
+  // equal to PCR CLP=0+1 (traffic.forward.PCR_all_traffic)
+
+  qos_cells = (rate * 1000) / (48*8);
+
+  if ((qos_cells > 0 && qos_cells < LINE_RATE)
+      || (ACE_BIT_ENABLED (flags, OPT_FLAGS_PMP)))
+    {
+      struct t_atm_bearer *bearer;
+      struct t_atm_traffic *traffic;
+
+      // T_ATM_BEARER_CAP: Broadband bearer capability
+      popt->len = sizeof (struct t_opthdr) + sizeof (struct t_atm_bearer);
+      popt->level = T_ATM_SIGNALING;
+      popt->name = T_ATM_BEARER_CAP;
+      popt->status = 0;
+
+      bearer = (struct t_atm_bearer *)((char *) popt +
+                                       sizeof (struct t_opthdr));
+      bearer->bearer_class = T_ATM_CLASS_X;
+
+      if (qos_cells)
+        {
+          bearer->traffic_type = T_ATM_CBR;
+          bearer->timing_requirements = T_ATM_END_TO_END;
+        }
+      else
+        {
+          bearer->traffic_type   = 0; // UBR
+          bearer->timing_requirements = 0;
+        }
+      bearer->clipping_susceptibility = T_ATM_NULL;
+
+      if (ACE_BIT_ENABLED (flags, OPT_FLAGS_PMP))
+        bearer->connection_configuration = T_ATM_1_TO_MANY;
+      else
+        bearer->connection_configuration = T_ATM_1_TO_1;
+
+      popt = T_OPT_NEXTHDR (buf, info.options, popt);
+
+      // T_ATM_TRAFFIC: traffic descriptor
+      popt->len = sizeof (struct t_opthdr) + sizeof (struct t_atm_traffic);
+      popt->level = T_ATM_SIGNALING;
+      popt->name = T_ATM_TRAFFIC;
+      popt->status = 0;
+
+      traffic = (struct t_atm_traffic *)((char *) popt +
+                                         sizeof (struct t_opthdr));
+
+      traffic->forward.PCR_high_priority = T_ATM_ABSENT;
+      traffic->forward.PCR_all_traffic = qos_cells ? qos_cells : LINE_RATE;
+      traffic->forward.SCR_high_priority = T_ATM_ABSENT;
+      traffic->forward.SCR_all_traffic = T_ATM_ABSENT;
+      traffic->forward.MBS_high_priority = T_ATM_ABSENT;
+      traffic->forward.MBS_all_traffic = T_ATM_ABSENT;
+      traffic->forward.tagging = T_NO;
+
+      traffic->backward.PCR_high_priority = T_ATM_ABSENT;
+      traffic->backward.PCR_all_traffic =
+        (ACE_BIT_ENABLED (flags, OPT_FLAGS_PMP))
+        ? 0 : qos_cells ? qos_cells : LINE_RATE;
+      traffic->backward.SCR_high_priority = T_ATM_ABSENT;
+      traffic->backward.SCR_all_traffic = T_ATM_ABSENT;
+      traffic->backward.MBS_high_priority = T_ATM_ABSENT;
+      traffic->backward.MBS_all_traffic = T_ATM_ABSENT;
+      traffic->backward.tagging = T_NO;
+
+      traffic->best_effort = qos_cells ? T_NO : T_YES;
+
+      popt = T_OPT_NEXTHDR (buf,
+                            info.options,
+                            popt);
+    }
+
+  if (qos_cells > 0 && qos_cells < LINE_RATE)
+    {
+      struct t_atm_qos *qos;
+
+      // T_ATM_QOS: Quality of Service
+      popt->len = sizeof (struct t_opthdr) + sizeof (struct t_atm_qos);
+      popt->level = T_ATM_SIGNALING;
+      popt->name = T_ATM_QOS;
+      popt->status = 0;
+
+      qos = (struct t_atm_qos *)((char *) popt + sizeof (struct t_opthdr));
+      qos->coding_standard = T_ATM_ITU_CODING;
+      qos->forward.qos_class = T_ATM_QOS_CLASS_1;
+      qos->backward.qos_class = T_ATM_QOS_CLASS_1;
+
+      popt = T_OPT_NEXTHDR (buf, info.options, popt);
+    }
+
+  // Return actual size of options and option buffer to user.
+  *len = (char *) popt - buf;
+
+  return buf;
+#else
+  ACE_UNUSED_ARG (fd);
+  ACE_UNUSED_ARG (rate);
+  ACE_UNUSED_ARG (flag);
+  ACE_UNUSED_ARG (len);
+  return (0);
+#endif /* ACE_HAS_FORE_ATM_WS2 */
+}
+
+#endif /* ACE_HAS_ATM */
diff --git a/ace/ATM/ATM_QoS.h b/ace/ATM/ATM_QoS.h
new file mode 100644
index 00000000000..2b94534a8b1
--- /dev/null
+++ b/ace/ATM/ATM_QoS.h
@@ -0,0 +1,103 @@
+/* -*- C++ -*- */
+
+//=============================================================================
+/**
+ *  @file    ATM_QoS.h
+ *
+ *  $Id$
+ *
+ *  @author Joe Hoffert
+ */
+//=============================================================================
+
+
+#ifndef ACE_ATM_QoS_H
+#define ACE_ATM_QoS_H
+#include "ace/pre.h"
+
+#include "ace/ACE.h"
+
+#if !defined(ACE_LACKS_PRAGMA_ONCE)
+#pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#if defined (ACE_HAS_ATM)
+
+#if defined (ACE_HAS_FORE_ATM_WS2)
+// just map to WS2 GQOS struct
+typedef ACE_QoS ATM_QoS;
+#elif defined (ACE_HAS_FORE_ATM_XTI)
+typedef struct netbuf ATM_QoS;
+#elif defined (ACE_HAS_LINUX_ATM)
+#include "atm.h"
+#include "ATM_Params.h"
+typedef struct atm_qos ATM_QoS;
+#else
+typedef int ATM_QoS;
+#endif /* ACE_HAS_FORE_ATM_WS2 || ACE_HAS_FORE_ATM_XTI || ACE_HAS_LINUX_ATM */
+
+/**
+ * @class ACE_ATM_QoS
+ *
+ * @brief Define the QoS parameters for ATM
+ *
+ * This class wraps up QoS parameters for both ATM/XTI and
+ * ATM/WinSock2 to make the mechanism for the ATM protocol
+ * transparent.
+ */
+class ACE_Export ACE_ATM_QoS
+{
+public:
+  // Constants used for ATM options
+  static const long LINE_RATE;
+  static const int OPT_FLAGS_CPID;
+  static const int OPT_FLAGS_PMP;
+  static const int DEFAULT_SELECTOR;
+  static const int DEFAULT_PKT_SIZE;
+
+  // = Initializattion and termination methods.
+  /// Default constructor.
+  ACE_ATM_QoS(int = DEFAULT_PKT_SIZE);
+
+  /// Constructor with a CBR rate.
+  ACE_ATM_QoS(int,
+              int = DEFAULT_PKT_SIZE);
+
+  ~ACE_ATM_QoS ();
+
+  /// Set the rate.
+  void set_rate (ACE_HANDLE,
+                 int,
+                 int);
+
+  /// Set CBR rate in cells per second.
+  void set_cbr_rate (int,
+                     int = DEFAULT_PKT_SIZE);
+
+  /// Get ATM_QoS struct.
+  ATM_QoS get_qos (void);
+
+  /// Dump the state of an object.
+  void dump (void) const;
+
+  /// Declare the dynamic allocation hooks.
+  ACE_ALLOC_HOOK_DECLARE;
+
+protected:
+  /// Construct QoS options.
+  char* construct_options(ACE_HANDLE,
+                          int,
+                          int,
+                          long*);
+
+private:
+  ATM_QoS qos_;
+};
+
+#if defined (__ACE_INLINE__)
+#include "ace/ATM_QoS.i"
+#endif /* __ACE_INLINE__ */
+
+#endif /* ACE_HAS_ATM */
+#include "ace/post.h"
+#endif /* ACE_ATM_QoS_H */
diff --git a/ace/ATM/ATM_QoS.i b/ace/ATM/ATM_QoS.i
new file mode 100644
index 00000000000..349fb962027
--- /dev/null
+++ b/ace/ATM/ATM_QoS.i
@@ -0,0 +1,17 @@
+// $Id$
+
+// ATM_QoS.i
+
+ACE_INLINE
+ACE_ATM_QoS::~ACE_ATM_QoS ()
+{
+  ACE_TRACE ("ACE_ATM_QoS::~ACE_ATM_QoS");
+}
+
+ACE_INLINE
+ATM_QoS
+ACE_ATM_QoS::get_qos (void)
+{
+  ACE_TRACE ("ACE_ATM_QoS::get_qos");
+  return qos_;
+}
diff --git a/ace/ATM/ATM_Stream.cpp b/ace/ATM/ATM_Stream.cpp
new file mode 100644
index 00000000000..997e36122ba
--- /dev/null
+++ b/ace/ATM/ATM_Stream.cpp
@@ -0,0 +1,291 @@
+// $Id$
+
+#include "ace/ATM_Stream.h"
+
+ACE_RCSID (ace, ATM_Stream, "$Id$")
+
+#if defined (ACE_HAS_ATM)
+
+#if !defined (__ACE_INLINE__)
+#include "ace/ATM_Stream.i"
+#endif /* __ACE_INLINE__ */
+
+ACE_ALLOC_HOOK_DEFINE (ACE_ATM_Stream)
+
+void
+ACE_ATM_Stream::dump (void) const
+{
+  ACE_TRACE ("ACE_ATM_Stream::dump");
+}
+
+char*
+ACE_ATM_Stream::get_peer_name (void) const
+{
+  ACE_TRACE ("ACE_ATM_Stream::get_peer_name");
+#if defined (ACE_HAS_FORE_ATM_XTI)
+  //   // Use t_getprotaddr for XTI/ATM
+  //   struct t_bind *localaddr
+  //     = (struct t_bind *) ACE_OS::t_alloc (get_handle (),
+  //                                          T_BIND,
+  //                                          T_ADDR);
+  //   struct t_bind *peeraddr
+  //      = (struct t_bind *) ACE_OS::t_alloc (get_handle (),
+  //                                           T_BIND,
+  //                                           T_ADDR);
+  //   ::t_getprotaddr (get_handle (),
+  //                   localaddr,
+  //                   peeraddr);
+
+  //   char* connected_name = (char*) ACE_OS::malloc (peeraddr->addr.len + 1);
+  //   ACE_OS::strcpy (connected_name,
+  //                  peeraddr->addr.buf);
+  //   ACE_OS::t_free ((char *) localaddr,
+  //                   T_BIND);
+  //   ACE_OS::t_free ((char *) peeraddr,
+  //                   T_BIND);
+  //   return (connected_name);
+
+#error "This doesn't seem to work. May need to jimmy-rig something with the"
+#error "/etc/xti_hosts file - Ugh!"
+
+  ACE_ATM_Addr sa;
+  struct netbuf name;
+  name.maxlen = sa.get_size ();
+  name.buf = (char *) sa.get_addr ();
+  ACE_OS::t_getname (this->get_handle (), &name, REMOTENAME);
+  //  ACE_OS::ioctl (this->get_handle (),
+  //               TI_GETPEERNAME,
+  //               &name);
+  return (name.buf);
+
+#elif defined (ACE_HAS_FORE_ATM_WS2)
+  // Use getpeername for WinSock2.
+  struct sockaddr_atm name;
+  ACE_OS::memset (&name, 0, sizeof (name));
+  int nameSize = sizeof (name);
+
+  if (ACE_OS::getpeername (this->get_handle (),
+ (struct sockaddr *) &name,
+                          &nameSize) != 0) {
+    return 0;
+  }
+
+  char buffer[256];
+  for (unsigned int index = 0; index < ATM_ADDR_SIZE - 1; index++) {
+    buffer[ index * 3 ] = '\0';
+    sprintf (buffer, "%s%02x.", buffer, name.satm_number.Addr[ index ]);
+  }
+  buffer[ (ATM_ADDR_SIZE - 1) * 3 ] = '\0';
+  sprintf (buffer, "%s%02x.", buffer, 0);
+  buffer[ ATM_ADDR_SIZE * 3 - 1 ] = '\0';
+  for (index = 0; index < ACE_OS::strlen (buffer); ++index)
+    buffer[index] = tolower (buffer[index]);
+
+  ifstream atm_hosts ("C:/WINNT/atmhosts");
+  assert (atm_hosts.is_open ());
+
+  // Find the host address in the ATM hosts file and return the
+  //  host name
+  char line[256];
+  char *host_ptr, *host_name = 0;
+  ACE_NEW_RETURN (host_name, char[256], 0);
+  while (!atm_hosts.eof ()) {
+    atm_hosts.getline (line, 256);
+    // Convert the line to lower case to ease comparison
+    for (index = 0; index < ACE_OS::strlen (line); ++index)
+      line[index] = tolower (line[index]);
+    if (strstr (line, buffer) != 0)
+      {
+        // Grab the second token which is the host name
+        strtok (line, " \t");
+        host_ptr = strtok (0, " \t");
+        strcpy (host_name, host_ptr);
+        break;
+      }
+  }
+
+  return host_name;
+#elif defined (ACE_HAS_LINUX_ATM)
+  ATM_Addr name;
+  int nameSize = sizeof (name.sockaddratmsvc);
+
+  if (ACE_OS::getpeername (this->get_handle (),
+ (struct sockaddr *) & (name.sockaddratmsvc),
+                          &nameSize) < 0) {
+    ACE_OS::perror ("ACE_ATM_Stream (get_peer_name) : ");
+    return 0;
+  }
+
+  static ACE_TCHAR buffer[MAX_ATM_ADDR_LEN + 1];
+  int total_len;
+  if ((total_len = atm2text (buffer,sizeof buffer,
+ (struct sockaddr *) & (name.sockaddratmsvc),
+                            A2T_PRETTY|A2T_NAME)) < 0) {
+    ACE_DEBUG ((LM_DEBUG,ACE_LIB_TEXT ("ACE_ATM_Stream (get_peer_name) :%d"),errno));
+    return 0;
+  }
+
+  return (char*) buffer;
+#else
+  return 0;
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
+}
+
+ACE_HANDLE
+ACE_ATM_Stream::get_handle (void) const
+{
+  ACE_TRACE ("ACE_ATM_Stream::get_handle");
+#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) || defined (ACE_HAS_LINUX_ATM)
+  return stream_.get_handle ();
+#else
+  return 0;
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
+}
+
+int
+ACE_ATM_Stream::get_vpi_vci (ACE_UINT16 &vpi,
+                             ACE_UINT16 &vci) const
+{
+  ACE_TRACE ("ACE_ATM_Stream::get_vpi_vci");
+#if defined (ACE_HAS_FORE_ATM_XTI)
+  struct t_atm_conn_prop conn_prop;
+  char* connect_opts = (char *) &conn_prop;
+  int opt_size = sizeof (t_atm_conn_prop);
+  struct t_info info;
+  struct t_optmgmt opt_req, opt_ret;
+
+  if (ACE_OS::t_getinfo (stream_.get_handle (),
+                        &info) < 0)
+    {
+      ACE_OS::t_error ("t_getinfo");
+      return -1;
+    }
+
+  char *buf_req = (char *) ACE_OS::malloc (info.options);
+  if (buf_req == (char *) NULL)
+    {
+      ACE_OS::fprintf (stderr,
+                      "Unable to allocate %ld bytes for options\n",
+                      info.options);
+      return -1;
+    }
+
+  char *buf_ret = (char *) ACE_OS::malloc (info.options);
+  if (buf_ret == (char *) NULL)
+    {
+      ACE_OS::fprintf (stderr,
+                      "Unable to allocate %ld bytes for options\n",
+                      info.options);
+      return -1;
+    }
+
+  ACE_OS::memset (&opt_req, 0, sizeof (opt_req));
+  ACE_OS::memset (&opt_ret, 0, sizeof (opt_ret));
+
+  struct t_opthdr *popt = (struct t_opthdr *) buf_req;
+  struct t_opthdr *popt_ret = (struct t_opthdr *) buf_ret;
+
+  popt->len= sizeof (struct t_opthdr) + opt_size;
+
+  // We are only concerned with SVCs so no other check or values are needed
+  //  here.
+  popt->level = T_ATM_SIGNALING;
+  popt->name = T_ATM_CONN_PROP;
+  popt->status = 0;
+
+  opt_req.opt.len = popt->len;
+  opt_req.opt.buf = (char *) popt;
+  opt_req.flags = T_CURRENT;
+
+  popt = T_OPT_NEXTHDR (buf_req,
+                       info.options,
+                       popt);
+  opt_ret.opt.maxlen  = info.options;
+  opt_ret.opt.buf = (char *) popt_ret;
+
+  if (ACE_OS::t_optmgmt (stream_.get_handle (),
+                        &opt_req,
+                        &opt_ret) < 0) {
+    ACE_OS::t_error ("t_optmgmt");
+    return -1;
+  }
+
+  ACE_OS::memcpy (connect_opts,
+ (char *) popt_ret + sizeof (struct t_opthdr),
+                 opt_size);
+
+  ACE_OS::free (buf_ret);
+  ACE_OS::free (buf_req);
+
+  vpi = conn_prop.vpi;
+  vci = conn_prop.vci;
+  return (0);
+#elif defined (ACE_HAS_FORE_ATM_WS2)
+  ATM_CONNECTION_ID connID;
+  DWORD bytes = 0;
+
+  if (::WSAIoctl ((int) this -> get_handle (),
+                  SIO_GET_ATM_CONNECTION_ID,
+                  NULL,
+                  0,
+ (LPVOID) &connID,
+                  sizeof (ATM_CONNECTION_ID),
+                  &bytes,
+                  NULL,
+                  NULL)
+       == SOCKET_ERROR) {
+    ACE_OS::printf ("Error: WSAIoctl %d\n", WSAGetLastError ());
+  }
+
+  vpi = (ACE_UINT16) connID.VPI;
+  vci = (ACE_UINT16) connID.VCI;
+
+  return 0;
+#elif defined (ACE_HAS_LINUX_ATM)
+#if defined (SO_ATMPVC) /* atm version>=0.62 */
+  struct sockaddr_atmpvc mypvcaddr;
+  int addrpvclen = sizeof (mypvcaddr);
+  if (ACE_OS::getsockopt (stream_.get_handle (),
+                         SOL_ATM,
+                         SO_ATMPVC,
+                         ACE_reinterpret_cast (char*,&mypvcaddr),
+                         &addrpvclen) < 0) {
+    ACE_DEBUG (LM_DEBUG,
+              ACE_LIB_TEXT ("ACE_ATM_Stream::get_vpi_vci: getsockopt %d\n"),
+              errno);
+    return -1;
+  }
+  vpi = (ACE_UINT16) mypvcaddr.sap_addr.vpi;
+  vci = (ACE_UINT16) mypvcaddr.sap_addr.vci;
+
+  return 0;
+#elif defined (SO_VCID) /* patch for atm version 0.59 */
+  struct atm_vcid mypvcid;
+  int pvcidlen = sizeof (mypvcid);
+  if (ACE_OS::getsockopt (stream_.get_handle (),
+                         SOL_ATM,SO_VCID,
+                         ACE_reinterpret_cast (char*,&mypvcid),
+                         &pvcidlen) < 0) {
+    ACE_DEBUG (LM_DEBUG,
+              ACE_LIB_TEXT ("ACE_ATM_Stream::get_vpi_vci: getsockopt %d\n"),
+              errno);
+    return -1;
+  }
+  vpi = (ACE_UINT16) mypvcid.vpi;
+  vci = (ACE_UINT16) mypvcid.vci;
+
+  return 0;
+#else
+  ACE_DEBUG (LM_DEBUG,
+            ACE_LIB_TEXT ("ACE_ATM_Stream::get_vpi_vci: Not implemented in this ATM version. Update to >= 0.62\n Or patch 0.59"));
+  ACE_UNUSED_ARG (vci);
+  ACE_UNUSED_ARG (vpi);
+
+  return (-1);
+#endif /* SO_ATMPVC || SO_VCID */
+#else
+  return (-1);
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */
+}
+
+#endif /* ACE_HAS_ATM */
diff --git a/ace/ATM/ATM_Stream.h b/ace/ATM/ATM_Stream.h
new file mode 100644
index 00000000000..f9dd3741f96
--- /dev/null
+++ b/ace/ATM/ATM_Stream.h
@@ -0,0 +1,96 @@
+/* -*- C++ -*- */
+
+//=============================================================================
+/**
+ *  @file    ATM_Stream.h
+ *
+ *  $Id$
+ *
+ *  @author Joe Hoffert
+ */
+//=============================================================================
+
+
+#ifndef ACE_ATM_STREAM_H
+#define ACE_ATM_STREAM_H
+#include "ace/pre.h"
+
+#include "ace/ATM_Addr.h"
+#include "ace/ATM_Params.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#if defined (ACE_HAS_ATM)
+
+#if defined (ACE_WIN32)
+#include "SOCK_Stream.h"
+typedef ACE_SOCK_Stream ATM_Stream;
+#else
+#include "TLI_Stream.h"
+typedef ACE_TLI_Stream ATM_Stream;
+#endif
+
+/**
+ * @class ACE_ATM_Stream
+ *
+ * @brief Defines the member functions for ACE_ATM_Stream abstraction.
+ */
+class ACE_Export ACE_ATM_Stream
+{
+public:
+  // = Initialization and termination methods.
+  /// Default constructor.
+  ACE_ATM_Stream (void);
+
+  // = ATM-specific open and shutdown operations.
+  /// open the stream.
+  /// Close down and release resources.
+  int open (ACE_ATM_Params params = ACE_ATM_Params());
+  int close (void);
+
+  /// Get the underlying handle.
+  ACE_HANDLE get_handle (void) const;
+
+  /// Get the underlying stream.
+  ATM_Stream& get_stream (void);
+
+  /// Get the name of the connected host.
+  char* get_peer_name (void) const;
+
+  /// Get the VPI and VCI of the stream.
+  int get_vpi_vci (ACE_UINT16 &vpi,
+                   ACE_UINT16 &vci) const;
+
+  /// Recv an n byte buffer from the connected transport mechanism.
+  ssize_t recv (void *buf,
+                size_t n,
+                int *flags = 0) const;
+
+  /// Send exactly n bytes to the connected transport mechanism.
+  ssize_t send_n (const void *buf,
+                  size_t n,
+                  int flags) const;
+
+  // = Meta-type info
+  typedef ACE_ATM_Addr PEER_ADDR;
+
+  /// Dump the state of an object.
+  void dump (void) const;
+
+  /// Declare the dynamic allocation hooks.
+  ACE_ALLOC_HOOK_DECLARE;
+
+private:
+  /// Typedef'd to the appropriate stream mechanism above.
+  ATM_Stream stream_;
+};
+
+#if defined (__ACE_INLINE__)
+#include "ace/ATM_Stream.i"
+#endif /* __ACE_INLINE__ */
+
+#endif /* ACE_HAS_ATM */
+#include "ace/post.h"
+#endif /* ACE_ATM_STREAM_H */
diff --git a/ace/ATM/ATM_Stream.i b/ace/ATM/ATM_Stream.i
new file mode 100644
index 00000000000..505bf497cb3
--- /dev/null
+++ b/ace/ATM/ATM_Stream.i
@@ -0,0 +1,123 @@
+// $Id$
+
+// ATM_Stream.i
+
+#include "ace/ATM_Stream.h"
+
+ACE_INLINE
+ACE_ATM_Stream::ACE_ATM_Stream (void)
+{
+  ACE_TRACE ("ACE_ATM_Stream::ACE_ATM_Stream");
+}
+
+ACE_INLINE
+int
+ACE_ATM_Stream::open (ACE_ATM_Params params)
+{
+  ACE_TRACE ("ACE_ATM_Stream::open");
+#if defined (ACE_HAS_FORE_ATM_XTI)
+  ACE_HANDLE handle = stream_.open (params.get_device(),
+                                    params.get_oflag(),
+                                    params.get_info());
+  return (handle == ACE_INVALID_HANDLE ? -1 : 0);
+#elif defined (ACE_HAS_FORE_ATM_WS2)
+  params.set_flags( ACE_FLAG_MULTIPOINT_C_ROOT | ACE_FLAG_MULTIPOINT_D_ROOT );
+
+  int retval = stream_.open (params.get_type(),
+                             params.get_protocol_family(),
+                             params.get_protocol(),
+                             params.get_protocol_info(),
+                             params.get_sock_group(),
+                             params.get_flags(),
+                             params.get_reuse_addr());
+  if (retval == -1)
+    return -1;
+
+  struct sockaddr_atm sock_addr;
+
+  ACE_OS::memset(&sock_addr, 0, sizeof(struct sockaddr_atm));
+  sock_addr.satm_family = AF_ATM;
+  sock_addr.satm_number.AddressType=ADDR_ANY;
+  sock_addr.satm_number.NumofDigits = ATM_ADDR_SIZE;
+  sock_addr.satm_blli.Layer2Protocol = SAP_FIELD_ABSENT;
+  sock_addr.satm_blli.Layer3Protocol = SAP_FIELD_ABSENT;
+  sock_addr.satm_bhli.HighLayerInfoType = SAP_FIELD_ABSENT;
+  if (ACE_OS::bind(get_handle(),
+                   (struct sockaddr FAR *)&sock_addr,
+                   sizeof(struct sockaddr_atm)) < 0)
+    {
+      ACE_OS::printf("Error binding local address: %d",WSAGetLastError());
+      return -1;
+    }
+
+  return 0;
+#else
+  ACE_UNUSED_ARG(params);
+  return 0;
+#endif /* ACE_HAS_FORE_ATM_XTI */
+}
+
+ACE_INLINE
+int
+ACE_ATM_Stream::close (void)
+{
+  ACE_TRACE ("ACE_ATM_Stream::close");
+#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2)
+  return stream_.close ();
+#else
+  return 0;
+#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 */
+}
+
+ACE_INLINE
+ATM_Stream&
+ACE_ATM_Stream::get_stream (void)
+{
+  ACE_TRACE ("ACE_ATM_Stream::get_stream");
+  return stream_;
+}
+
+ACE_INLINE
+ssize_t
+ACE_ATM_Stream::recv (void *buf,
+                      size_t n,
+                      int *flags) const
+{
+  ACE_TRACE ("ACE_ATM_Stream::recv");
+#if defined (ACE_HAS_FORE_ATM_XTI)
+  return stream_.recv (buf,
+                       n,
+                       flags);
+#elif defined (ACE_HAS_FORE_ATM_WS2)
+  return stream_.recv (buf,
+                       n);
+#else
+  ACE_UNUSED_ARG(buf);
+  ACE_UNUSED_ARG(n);
+  ACE_UNUSED_ARG(flags);
+  return (0);
+#endif /* ACE_HAS_FORE_ATM_XTI */
+}
+
+ACE_INLINE
+ssize_t
+ACE_ATM_Stream::send_n (const void *buf,
+                        size_t n,
+                        int flags) const
+{
+  ACE_TRACE ("ACE_ATM_Stream::send_n");
+#if defined (ACE_HAS_FORE_ATM_XTI)
+  return stream_.send_n (buf,
+                         n,
+                         flags);
+#elif defined (ACE_HAS_FORE_ATM_WS2)
+  return stream_.send_n (buf,
+                         n,
+                         flags);
+#else
+  ACE_UNUSED_ARG(buf);
+  ACE_UNUSED_ARG(n);
+  ACE_UNUSED_ARG(flags);
+  return (0);
+#endif /* ACE_HAS_FORE_ATM_XTI */
+}
diff --git a/ace/ATM/Makefile b/ace/ATM/Makefile
new file mode 100644
index 00000000000..c519719e86a
--- /dev/null
+++ b/ace/ATM/Makefile
@@ -0,0 +1,49 @@
+# $Id$
+
+#----------------------------------------------------------------------------
+#       Makefile for the libACE_ATM
+#----------------------------------------------------------------------------
+
+MAKEFILE = Makefile
+LIBOS   = libACE_ATM
+LIB      = $(LIBOS).a
+SHLIB    = $(LIBOS).$(SOEXT)
+
+
+OS_FILES = \
+	ATM_Acceptor\
+	ATM_Addr\
+	ATM_Connector\
+	ATM_Params\
+	ATM_QoS\
+	ATM_Stream
+
+#----------------------------------------------------------------------------
+#       Include macros and targets
+#----------------------------------------------------------------------------
+
+include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU
+
+####
+#### ACE_COMPONENTS support.
+####
+FILES += $(OS_FILES)
+
+LSRC  = $(addsuffix .cpp,$(FILES))
+
+include $(ACE_ROOT)/include/makeinclude/macros.GNU
+include $(ACE_ROOT)/include/makeinclude/rules.common.GNU
+include $(ACE_ROOT)/include/makeinclude/rules.nested.GNU
+include $(ACE_ROOT)/include/makeinclude/rules.lib.GNU
+include $(ACE_ROOT)/include/makeinclude/rules.local.GNU
+
+INSTALL =
+
+clean:
+	$(RM) -f $(LIBOS).a $(LIBOS).so
+
+#----------------------------------------------------------------------------
+#       Dependencies
+#----------------------------------------------------------------------------
+# DO NOT DELETE THIS LINE -- g++dep uses it.
+# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY.
diff --git a/ace/ATM/Makefile~ b/ace/ATM/Makefile~
new file mode 100644
index 00000000000..faed337f700
--- /dev/null
+++ b/ace/ATM/Makefile~
@@ -0,0 +1,89 @@
+# $Id$
+
+#----------------------------------------------------------------------------
+#       Makefile for the libACE_ATM
+#----------------------------------------------------------------------------
+
+MAKEFILE = Makefile
+LIBOS   = libACE_ATM
+LIB      = $(LIBOS).a
+SHLIB    = $(LIBOS).$(SOEXT)
+
+
+OS_FILES = \
+	Base_Thread_Adapter\
+	Basic_Types\
+	Date_Time\
+	gethrtime\
+	Handle_Ops\
+	Handle_Set\
+	Init_ACE\
+	OS\
+	OS_Dirent\
+	OS_Errno\
+	OS_Log_Msg_Attributes\
+	OS_Memory\
+	OS_QoS\
+	OS_String\
+	OS_Thread_Adapter\
+	OS_TLI\
+	Sched_Params\
+	Thread_Hook
+
+#----------------------------------------------------------------------------
+#       Include macros and targets
+#----------------------------------------------------------------------------
+
+include $(ACE_ROOT)/include/makeinclude/wrapper_macros.GNU
+
+####
+#### ACE_COMPONENTS support.
+####
+FILES += $(OS_FILES)
+
+LSRC  = $(addsuffix .cpp,$(FILES))
+
+include $(ACE_ROOT)/include/makeinclude/macros.GNU
+include $(ACE_ROOT)/include/makeinclude/rules.common.GNU
+include $(ACE_ROOT)/include/makeinclude/rules.nested.GNU
+include $(ACE_ROOT)/include/makeinclude/rules.lib.GNU
+include $(ACE_ROOT)/include/makeinclude/rules.local.GNU
+
+INSTALL =
+
+clean:
+	$(RM) -f $(LIBOS).a $(LIBOS).so
+
+#----------------------------------------------------------------------------
+#       Local targets
+#----------------------------------------------------------------------------
+
+
+
+#----------------------------------------------------------------------------
+#       Dependencies
+#----------------------------------------------------------------------------
+# DO NOT DELETE THIS LINE -- g++dep uses it.
+# DO NOT PUT ANYTHING AFTER THIS LINE, IT WILL GO AWAY.
+
+
+ATM_Acceptor.cpp
+ATM_Acceptor.h
+ATM_Acceptor.i
+ATM_Addr.cpp
+ATM_Addr.h
+ATM_Addr.i
+ATM_Connector.cpp
+ATM_Connector.h
+ATM_Connector.i
+ATM_Params.cpp
+ATM_Params.h
+ATM_Params.i
+ATM_QoS.cpp
+ATM_QoS.h
+ATM_QoS.i
+ATM_Stream.cpp
+ATM_Stream.h
+ATM_Stream.i
+Makefile
+Makefile~