*** empty log message ***

11 files changed, 706 insertions, 1 deletions

diff --git a/ace/MEM_Acceptor.cpp b/ace/MEM_Acceptor.cpp
new file mode 100644
index 00000000000..26af37e247b
--- /dev/null
+++ b/ace/MEM_Acceptor.cpp
@@ -0,0 +1,132 @@
+// MEM_Acceptor.cpp
+// $Id$
+
+#define ACE_BUILD_DLL
+#include "ace/MEM_Acceptor.h"
+
+#if !defined (__ACE_INLINE__)
+#include "ace/MEM_Acceptor.i"
+#endif /* __ACE_INLINE__ */
+
+ACE_RCSID(ace, MEM_Acceptor, "$Id$")
+
+ACE_ALLOC_HOOK_DEFINE(ACE_MEM_Acceptor)
+
+void
+ACE_MEM_Acceptor::dump (void) const
+{
+  ACE_TRACE ("ACE_MEM_Acceptor::dump");
+
+  ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
+  this->local_addr_.dump ();
+  ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
+}
+
+// Do nothing routine for constructor.
+
+ACE_MEM_Acceptor::ACE_MEM_Acceptor (void)
+{
+  ACE_TRACE ("ACE_MEM_Acceptor::ACE_MEM_Acceptor");
+}
+
+// General purpose routine for performing server ACE_SOCK creation.
+
+ACE_MEM_Acceptor::ACE_MEM_Acceptor (const ACE_Addr &remote_sap,
+                                    int reuse_addr,
+                                    int protocol_family,
+                                    int backlog,
+                                    int protocol)
+{
+  ACE_TRACE ("ACE_MEM_Acceptor::ACE_MEM_Acceptor");
+  if (this->open (remote_sap,
+		  reuse_addr,
+		  protocol_family,
+		  backlog,
+		  protocol) == -1)
+    ACE_ERROR ((LM_ERROR,
+		"ACE_MEM_Acceptor::ACE_MEM_Acceptor"));
+}
+
+// General purpose routine for accepting new connections.
+
+int
+ACE_MEM_Acceptor::accept (ACE_MEM_Stream &new_stream,
+                          ACE_Addr *remote_addr,
+                          ACE_Time_Value *timeout,
+                          int restart,
+                          int reset_new_handle) const
+{
+  ACE_TRACE ("ACE_MEM_Acceptor::accept");
+
+  int in_blocking_mode = 0;
+  if (this->shared_accept_start (timeout,
+				 restart,
+				 in_blocking_mode) == -1)
+    return -1;
+  else
+    {
+      sockaddr *addr = 0;
+      int len = 0;
+
+      if (remote_addr != 0)
+	{
+	  len = remote_addr->get_size ();
+	  addr = (sockaddr *) remote_addr->get_addr ();
+	}
+
+      do
+	new_stream.set_handle (ACE_OS::accept (this->get_handle (),
+					       addr,
+					       &len));
+      while (new_stream.get_handle () == ACE_INVALID_HANDLE
+	     && restart != 0
+	     && errno == EINTR
+	     && timeout == 0);
+
+      // Reset the size of the addr, which is only necessary for UNIX
+      // domain sockets.
+      if (new_stream.get_handle () != ACE_INVALID_HANDLE
+	  && remote_addr != 0)
+	remote_addr->set_size (len);
+    }
+
+  return this->shared_accept_finish (new_stream,
+				     in_blocking_mode,
+				     reset_new_handle);
+}
+
+int
+ACE_MEM_Acceptor::shared_accept_finish (ACE_MEM_Stream new_stream,
+                                        int in_blocking_mode,
+                                        int reset_new_handle) const
+{
+  ACE_TRACE ("ACE_MEM_Acceptor::shared_accept_finish ()");
+
+  ACE_HANDLE new_handle = new_stream.get_handle ();
+
+  // Check to see if we were originally in blocking mode, and if so,
+  // set the <new_stream>'s handle and <this> handle to be in blocking
+  // mode.
+  if (in_blocking_mode)
+    {
+      // Save/restore errno.
+      ACE_Errno_Guard error (errno);
+
+      // Only disable ACE_NONBLOCK if we weren't in non-blocking mode
+      // originally.
+      ACE::clr_flags (this->get_handle (),
+		      ACE_NONBLOCK);
+      ACE::clr_flags (new_handle,
+		      ACE_NONBLOCK);
+    }
+
+#if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0)
+  if (reset_new_handle)
+    // Reset the event association inherited by the new handle.
+    ::WSAEventSelect ((SOCKET) new_handle, 0, 0);
+#else
+  ACE_UNUSED_ARG (reset_new_handle);
+#endif /* ACE_WIN32 */
+
+  return new_handle == ACE_INVALID_HANDLE ? -1 : 0;
+}
diff --git a/ace/MEM_Acceptor.h b/ace/MEM_Acceptor.h
new file mode 100644
index 00000000000..8030aa786e3
--- /dev/null
+++ b/ace/MEM_Acceptor.h
@@ -0,0 +1,81 @@
+/* -*- C++ -*- */
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    ace
+//
+// = FILENAME
+//    MEM_Aceeptor.h
+//
+// = AUTHOR
+//    Nanbor Wang
+//
+// ============================================================================
+
+#ifndef ACE_MEM_ACCEPTOR_H
+#define ACE_MEM_ACCEPTOR_H
+
+#include "ace/SOCK_Acceptor.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/UNIX_Addr.h"
+#include "ace/MEM_Stream.h"
+
+// Forward decl.
+class ACE_Reactor;
+
+class ACE_Export ACE_MEM_Acceptor : public ACE_SOCK_Acceptor
+{
+  // = TITLE
+  //     Defines the format and interface for the acceptor side of the
+  //     local ACE_SOCK ACE_Stream.
+public:
+  // = Initialization methods.
+  ACE_MEM_Acceptor (void);
+  // Default constructor.
+
+  ACE_MEM_Acceptor (const ACE_Addr &local_sap,
+                    int reuse_addr = 0,
+                    int protocol_family = PF_INET,
+                    int backlog = ACE_DEFAULT_BACKLOG,
+                    int protocol = 0);
+  // Initiate a passive mode socket.
+
+  int accept (ACE_MEM_Stream &new_ipc_sap,
+              ACE_Addr * = 0,
+              ACE_Time_Value *timeout = 0,
+              int restart = 1,
+              int reset_new_handle = 0) const;
+  // Accept a new data transfer connection.
+
+  int shared_accept_finish (ACE_MEM_Stream new_stream,
+			    int in_blocking_mode,
+			    int reset_new_handle) const;
+  // Perform operations that must occur after <ACE_OS::accept> is
+  // called.
+
+  // = Meta-type info
+  typedef ACE_INET_Addr PEER_ADDR;
+  typedef ACE_MEM_Stream PEER_STREAM;
+
+  void dump (void) const;
+  // Dump the state of an object.
+
+  ACE_ALLOC_HOOK_DECLARE;
+  // Declare the dynamic allocation hooks.
+
+private:
+  ACE_INET_Addr local_addr_;
+  // Address of our rendezvous point.
+};
+
+#if defined (__ACE_INLINE__)
+#include "ace/MEM_Acceptor.i"
+#endif /* __ACE_INLINE__ */
+
+#endif /* ACE_MEM_ACCEPTOR_H */
diff --git a/ace/MEM_Acceptor.i b/ace/MEM_Acceptor.i
new file mode 100644
index 00000000000..b7ae3f98891
--- /dev/null
+++ b/ace/MEM_Acceptor.i
@@ -0,0 +1,4 @@
+/* -*- C++ -*- */
+// $Id$
+
+// MEM_Acceptor.i
diff --git a/ace/MEM_Connector.cpp b/ace/MEM_Connector.cpp
new file mode 100644
index 00000000000..77e98aa9090
--- /dev/null
+++ b/ace/MEM_Connector.cpp
@@ -0,0 +1,77 @@
+// MEM_Connector.cpp
+// $Id$
+
+#define ACE_BUILD_DLL
+#include "ace/MEM_Connector.h"
+
+ACE_RCSID(ace, MEM_Connector, "$Id$")
+
+#if defined (ACE_LACKS_INLINE_FUNCTIONS)
+#include "ace/MEM_Connector.i"
+#endif
+
+ACE_ALLOC_HOOK_DEFINE(ACE_MEM_Connector)
+
+void
+ACE_MEM_Connector::dump (void) const
+{
+  ACE_TRACE ("ACE_MEM_Connector::dump");
+
+  ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
+  ACE_DEBUG ((LM_DEBUG,  ASYS_TEXT ("\n")));
+  ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
+}
+
+ACE_MEM_Connector::ACE_MEM_Connector (void)
+{
+  ACE_TRACE ("ACE_MEM_Connector::ACE_MEM_Connector");
+}
+
+// Establish a connection.
+ACE_MEM_Connector::ACE_MEM_Connector (ACE_MEM_Stream &new_stream,
+                                      const ACE_INET_Addr &remote_sap,
+                                      ACE_Time_Value *timeout,
+                                      const ACE_Addr &local_sap,
+                                      int reuse_addr,
+                                      int flags,
+                                      int perms,
+                                      int protocol_family,
+                                      int protocol)
+{
+  ACE_TRACE ("ACE_MEM_Connector::ACE_MEM_Connector");
+  // This is necessary due to the weird inheritance relationships of
+  // ACE_MEM_Stream.
+  this->connect (new_stream,
+                 remote_sap,
+                 timeout,
+                 local_sap,
+                 reuse_addr,
+                 flags,
+                 perms,
+                 protocol_family,
+                 protocol);
+}
+
+int
+ACE_MEM_Connector::connect (ACE_MEM_Stream &new_stream,
+                            const ACE_INET_Addr &remote_sap,
+                            ACE_Time_Value *timeout,
+                            const ACE_Addr &local_sap,
+                            int reuse_addr,
+                            int flags,
+                            int perms,
+                            int protocol_family,
+                            int protocol)
+{
+  ACE_TRACE ("ACE_MEM_Connector::connect");
+
+  ACE_SOCK_Stream temp_stream;
+  int result = ACE_SOCK_Connector::connect (temp_stream, remote_sap,
+					    timeout, local_sap,
+					    reuse_addr, flags, perms,
+					    protocol_family, protocol);
+
+  new_stream.set_handle (temp_stream.get_handle ());
+  // Do not close the handle.
+  return result;
+}
diff --git a/ace/MEM_Connector.h b/ace/MEM_Connector.h
new file mode 100644
index 00000000000..270fe118e02
--- /dev/null
+++ b/ace/MEM_Connector.h
@@ -0,0 +1,99 @@
+/* -*- C++ -*- */
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    ace
+//
+// = FILENAME
+//    MEM_Connector.h
+//
+// = AUTHOR
+//    Nanbor Wang
+//
+// ============================================================================
+
+#ifndef ACE_MEM_CONNECTOR_H
+#define ACE_MEM_CONNECTOR_H
+
+#include "ace/SOCK_Connector.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/MEM_Stream.h"
+
+class ACE_Export ACE_MEM_Connector : public ACE_SOCK_Connector
+{
+  // = TITLE
+  //     Defines the format and interface for the connector side of
+  //     the <ACE_MEM_Stream>.
+public:
+  // = Initialization methods.
+  ACE_MEM_Connector (void);
+  // Default constructor.
+
+  ACE_MEM_Connector (ACE_MEM_Stream &new_stream,
+                     const ACE_INET_Addr &remote_sap,
+                     ACE_Time_Value *timeout = 0,
+                     const ACE_Addr &local_sap = ACE_Addr::sap_any,
+                     int reuse_addr = 0,
+                     int flags = 0,
+                     int perms = 0,
+                     int protocol_family = PF_INET,
+                     int protocol = 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 <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 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_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_MEM_Stream &new_stream,
+               const ACE_INET_Addr &remote_sap,
+               ACE_Time_Value *timeout = 0,
+               const ACE_Addr &local_sap = ACE_Addr::sap_any,
+               int reuse_addr = 0,
+               int flags = 0,
+               int perms = 0,
+               int protcol_family = PF_INET,
+               int protocol = 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 <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 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_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.
+
+  // = Meta-type info
+  typedef ACE_INET_Addr PEER_ADDR;
+  typedef ACE_MEM_Stream PEER_STREAM;
+
+  void dump (void) const;
+  // Dump the state of an object.
+
+  ACE_ALLOC_HOOK_DECLARE;
+  // Declare the dynamic allocation hooks.
+};
+
+#if !defined (ACE_LACKS_INLINE_FUNCTIONS)
+#include "ace/MEM_Connector.i"
+#endif
+
+#endif /* ACE_MEM_CONNECTOR_H */
diff --git a/ace/MEM_Connector.i b/ace/MEM_Connector.i
new file mode 100644
index 00000000000..5030a777e52
--- /dev/null
+++ b/ace/MEM_Connector.i
@@ -0,0 +1,6 @@
+/* -*- C++ -*- */
+// $Id$
+
+// MEM_Connector.i
+
+// Establish a connection.
diff --git a/ace/MEM_IO.h b/ace/MEM_IO.h
index 88fad12751d..98c5dcff628 100644
--- a/ace/MEM_IO.h
+++ b/ace/MEM_IO.h
@@ -26,7 +26,7 @@
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
-class ACE_Export ACE_MEM_IO : public ACE_SOCK, ACE_MEM_SAP
+class ACE_Export ACE_MEM_IO : public ACE_SOCK, public ACE_MEM_SAP
 {
   // = TITLE
   //     Defines the methods for the ACE shared memeory wrapper I/O routines
diff --git a/ace/MEM_IO.i b/ace/MEM_IO.i
index 8e0fb4b1bb3..01f6484f0bd 100644
--- a/ace/MEM_IO.i
+++ b/ace/MEM_IO.i
@@ -65,6 +65,7 @@ ACE_MEM_IO::recv (void *buf, size_t n, int flags)
       n -= length;
       count += length;
     }
+
   return count;
 }
 
diff --git a/ace/MEM_Stream.cpp b/ace/MEM_Stream.cpp
new file mode 100644
index 00000000000..de870c1c66b
--- /dev/null
+++ b/ace/MEM_Stream.cpp
@@ -0,0 +1,35 @@
+// MEM_Stream.cpp
+// $Id$
+
+#define ACE_BUILD_DLL
+#include "ace/MEM_Stream.h"
+
+#if defined (ACE_LACKS_INLINE_FUNCTIONS)
+#include "ace/MEM_Stream.i"
+#endif
+
+ACE_RCSID(ace, MEM_Stream, "$Id$")
+
+ACE_ALLOC_HOOK_DEFINE(ACE_MEM_Stream)
+
+void
+ACE_MEM_Stream::dump (void) const
+{
+  ACE_TRACE ("ACE_MEM_Stream::dump");
+}
+
+int
+ACE_MEM_Stream::close (void)
+{
+#if defined (ACE_WIN32)
+  // We need the following call to make things work correctly on
+  // Win32, which requires use to do a <close_writer> before doing the
+  // close in order to avoid losing data.  Note that we don't need to
+  // do this on UNIX since it doesn't have this "feature".  Moreover,
+  // this will cause subtle problems on UNIX due to the way that
+  // fork() works.
+  this->close_writer ();
+#endif /* ACE_WIN32 */
+  // Close down the socket.
+  return ACE_SOCK::close ();
+}
diff --git a/ace/MEM_Stream.h b/ace/MEM_Stream.h
new file mode 100644
index 00000000000..c93a5d04d6b
--- /dev/null
+++ b/ace/MEM_Stream.h
@@ -0,0 +1,119 @@
+/* -*- C++ -*- */
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    ace
+//
+// = FILENAME
+//    MEM_Stream.h
+//
+// = AUTHOR
+//    Nanbor Wang
+//
+// ============================================================================
+
+#ifndef ACE_MEM_STREAM_H
+#define ACE_MEM_STREAM_H
+
+#include "ace/MEM_IO.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/INET_Addr.h"
+
+class ACE_Export ACE_MEM_Stream : public ACE_MEM_IO
+{
+  // = TITLE
+  //     Defines the methods in the <ACE_MEM_Stream> abstraction.
+  //
+  // = DESCRIPTION
+  //     This adds additional wrapper methods atop the <ACE_MEM_IO>
+  //     class.
+public:
+  // Initialization and termination methods.
+  ACE_MEM_Stream (void);
+  // Constructor.
+
+  ACE_MEM_Stream (ACE_HANDLE h);
+  // Constructor (sets the underlying <ACE_HANDLE> with <h>).
+
+  ~ACE_MEM_Stream (void);
+  // Destructor.
+
+/*
+  //= The following two methods use write and read system calls.
+  ssize_t send_n (const void *buf, int n) const;
+  // Send n bytes, keep trying until n are sent.
+  ssize_t recv_n (void *buf, int n) const;
+  // Recv n bytes, keep trying until n are received.
+
+  // = The following two methods use the send and recv system calls.
+  ssize_t send_n (const void *buf, int n, int flags) const;
+  // Send n bytes, keep trying until n are sent.
+  ssize_t recv_n (void *buf, int n, int flags) const;
+  // Recv n bytes, keep trying until n are received.
+
+  ssize_t send_n (const void *buf,
+                  size_t len,
+                  int flags,
+                  const ACE_Time_Value *timeout);
+  // Try to send exactly <len> bytes into <buf> from <handle> (uses
+  // the <send> call).  If <send> blocks for longer than <timeout> the
+  // number of bytes actually sent is returned with <errno == ETIME>.
+  // If a timeout does not occur, <send_n> return <len> (i.e., the
+  // number of bytes requested to be sent).
+
+  ssize_t recv_n (void *buf,
+                  size_t len,
+                  int flags,
+                  const ACE_Time_Value *timeout);
+  // Try to recv exactly <len> bytes into <buf> from <handle> (uses
+  // the <ACE::recv_n> call).  The <ACE_Time_Value> indicates how long
+  // to blocking trying to receive.  If <timeout> == 0, the caller
+  // will block until action is possible, else will wait until the
+  // relative time specified in *<timeout> elapses).  If <recv> blocks
+  // for longer than <timeout> the number of bytes actually read is
+  // returned with <errno == ETIME>.  If a timeout does not occur,
+  // <recv_n> return <len> (i.e., the number of bytes requested to be
+  // read).
+
+  ssize_t sendv_n (const iovec iov[],
+                   size_t n) const;
+  // Send an <iovec> of size <n> to the connected socket (uses
+  // <ACE::sendv_n>).  Will block until all bytes are sent or an error
+  // occurs.
+
+  ssize_t recvv_n (iovec iov[],
+                   size_t n) const;
+  // Receive an <iovec> of size <n> to the connected socket.
+*/
+  // = Selectively close endpoints.
+  int close_reader (void);
+  // Close down the reader.
+  int close_writer (void);
+  // Close down the writer.
+
+  int close (void);
+  // Close down the socket (we need this to make things work correctly
+  // on Win32, which requires use to do a <close_writer> before doing
+  // the close to avoid losing data).
+
+  // = Meta-type info
+  typedef ACE_INET_Addr PEER_ADDR;
+
+  void dump (void) const;
+  // Dump the state of an object.
+
+  ACE_ALLOC_HOOK_DECLARE;
+  // Declare the dynamic allocation hooks.
+};
+
+#if !defined (ACE_LACKS_INLINE_FUNCTIONS)
+#include "ace/MEM_Stream.i"
+#endif
+
+#endif /* ACE_MEM_STREAM_H */
diff --git a/ace/MEM_Stream.i b/ace/MEM_Stream.i
new file mode 100644
index 00000000000..a365f2d5dd0
--- /dev/null
+++ b/ace/MEM_Stream.i
@@ -0,0 +1,151 @@
+/* -*- C++ -*- */
+// $Id$
+
+// MEM_Stream.i
+
+#include "ace/MEM_Stream.h"
+
+ASYS_INLINE
+ACE_MEM_Stream::ACE_MEM_Stream (void)
+{
+  // ACE_TRACE ("ACE_MEM_Stream::ACE_MEM_Stream");
+}
+
+ASYS_INLINE
+ACE_MEM_Stream::ACE_MEM_Stream (ACE_HANDLE h)
+{
+  // ACE_TRACE ("ACE_MEM_Stream::ACE_MEM_Stream");
+  this->set_handle (h);
+}
+
+ASYS_INLINE
+ACE_MEM_Stream::~ACE_MEM_Stream (void)
+{
+  // ACE_TRACE ("ACE_MEM_Stream::~ACE_MEM_Stream");
+}
+
+ASYS_INLINE int
+ACE_MEM_Stream::close_reader (void)
+{
+  ACE_TRACE ("ACE_MEM_Stream::close_reader");
+  if (this->get_handle () != ACE_INVALID_HANDLE)
+    return ACE_OS::shutdown (this->get_handle (), 0);
+  else
+    return 0;
+}
+
+// Shut down just the writing end of a ACE_SOCK.
+
+ASYS_INLINE int
+ACE_MEM_Stream::close_writer (void)
+{
+  ACE_TRACE ("ACE_MEM_Stream::close_writer");
+  if (this->get_handle () != ACE_INVALID_HANDLE)
+    return ACE_OS::shutdown (this->get_handle (), 1);
+  else
+    return 0;
+}
+
+#if 0
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::recv_n (void *buf,
+                         size_t len,
+                         int flags,
+                         const ACE_Time_Value *timeout) const
+{
+  ACE_TRACE ("ACE_MEM_Stream::recv_n");
+  return ACE::recv_n (this->get_handle (),
+                      buf,
+                      len,
+                      flags,
+                      timeout);
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::recv_n (void *buf,
+                         size_t len,
+                         const ACE_Time_Value *timeout) const
+{
+  ACE_TRACE ("ACE_MEM_Stream::recv_n");
+  return ACE::recv_n (this->get_handle (),
+                      buf,
+                      len,
+                      timeout);
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::recvv_n (iovec iov[],
+                          size_t n,
+                          const ACE_Time_Value *timeout) const
+{
+  ACE_TRACE ("ACE_MEM_Stream::recvv_n");
+  return ACE::recvv_n (this->get_handle (),
+                       iov,
+                       n,
+                       timeout);
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::send_n (const void *buf,
+                         size_t len,
+                         int flags,
+                         const ACE_Time_Value *timeout) const
+{
+  ACE_TRACE ("ACE_MEM_Stream::send_n");
+  return ACE::send_n (this->get_handle (),
+                      buf,
+                      len,
+                      flags,
+                      timeout);
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::send_n (const void *buf,
+                         size_t len,
+                         const ACE_Time_Value *timeout) const
+{
+  ACE_TRACE ("ACE_MEM_Stream::send_n");
+  return ACE::send_n (this->get_handle (),
+                      buf,
+                      len,
+                      timeout);
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::sendv_n (iovec iov[],
+                          size_t n,
+                          const ACE_Time_Value *timeout) const
+{
+  ACE_TRACE ("ACE_MEM_Stream::sendv_n");
+  return ACE::sendv_n (this->get_handle (),
+                       iov,
+                       n,
+                       timeout);
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::send_urg (const void *ptr,
+                           size_t len,
+                           const ACE_Time_Value *timeout) const
+{
+  ACE_TRACE ("ACE_MEM_Stream::send_urg");
+  return ACE::send (this->get_handle (),
+                    ptr,
+                    len,
+                    MSG_OOB,
+                    timeout);
+}
+
+ASYS_INLINE ssize_t
+ACE_MEM_Stream::recv_urg (void *ptr,
+                           size_t len,
+                           const ACE_Time_Value *timeout) const
+{
+  ACE_TRACE ("ACE_MEM_Stream::recv_urg");
+  return ACE::recv (this->get_handle (),
+                    ptr,
+                    len,
+                    MSG_OOB,
+                    timeout);
+}
+#endif /* 0 */