Changes to attempt to silence bcc64x
[ACE_TAO.git] / ACE / ace / SPIPE_Stream.inl
blob6f78a4fe5cdc1e19ee7bcd821386494bf9afe816
1 // -*- C++ -*-
2 #include "ace/OS_NS_sys_uio.h"
3 #include "ace/OS_NS_errno.h"
4 #include "ace/OS_NS_unistd.h"
5 #if defined (ACE_WIN32)
6 #include "ace/OS_NS_sys_socket.h"
7 #endif
9 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
11 // Create an ACE_SPIPE_Stream.
13 ACE_INLINE int
14 ACE_SPIPE_Stream::get_remote_addr (ACE_SPIPE_Addr &remote_sap) const
16   ACE_TRACE ("ACE_SPIPE_Stream::get_remote_addr");
17   remote_sap = this->remote_addr_;
18   return 0;
21 // Send exactly N bytes from BUF to this socket.  Keeping trying until
22 // this many bytes are sent.
24 ACE_INLINE ssize_t
25 ACE_SPIPE_Stream::send_n (const void *buf, size_t n) const
27   ACE_TRACE ("ACE_SPIPE_Stream::send_n");
28   return ACE::write_n (this->get_handle (), buf, n);
31 // Receive exactly N bytes from this socket into BUF.  Keep trying
32 // until this many bytes are received.
34 ACE_INLINE ssize_t
35 ACE_SPIPE_Stream::recv_n (void *buf, size_t n) const
37   ACE_TRACE ("ACE_SPIPE_Stream::recv_n");
38   return ACE::read_n (this->get_handle (), buf, n);
41 ACE_INLINE ssize_t
42 ACE_SPIPE_Stream::send (const void *buf, size_t n) const
44   ACE_TRACE ("ACE_SPIPE_Stream::send");
45   return ACE_OS::write (this->get_handle (), (const char *) buf, n);
48 ACE_INLINE ssize_t
49 ACE_SPIPE_Stream::recv (void *buf, size_t n) const
51   ACE_TRACE ("ACE_SPIPE_Stream::recv");
52   return ACE_OS::read (this->get_handle (), (char *) buf, n);
55 ACE_INLINE ssize_t
56 ACE_SPIPE_Stream::send (const ACE_Str_Buf *cntl, const ACE_Str_Buf *data, int flags) const
58   ACE_TRACE ("ACE_SPIPE_Stream::send");
59   return ACE_OS::putmsg (this->get_handle (), (strbuf *) cntl, (strbuf *) data, flags);
62 ACE_INLINE ssize_t
63 ACE_SPIPE_Stream::recv (ACE_Str_Buf *cntl, ACE_Str_Buf *data, int *flags) const
65   ACE_TRACE ("ACE_SPIPE_Stream::recv");
66   return ACE_OS::getmsg (this->get_handle (), (strbuf *) cntl, (strbuf *) data, flags);
69 ACE_INLINE ssize_t
70 ACE_SPIPE_Stream::send (const ACE_Str_Buf *cntl, const ACE_Str_Buf *data, int band, int flags) const
72   ACE_TRACE ("ACE_SPIPE_Stream::send");
73   return ACE_OS::putpmsg (this->get_handle (), (strbuf *) cntl, (strbuf *) data, band, flags);
76 ACE_INLINE ssize_t
77 ACE_SPIPE_Stream::recv (ACE_Str_Buf *cntl, ACE_Str_Buf *data, int *band, int *flags) const
79   ACE_TRACE ("ACE_SPIPE_Stream::recv");
80   return ACE_OS::getpmsg (this->get_handle (), (strbuf *) cntl, (strbuf *) data, band, flags);
83 ACE_INLINE ssize_t
84 ACE_SPIPE_Stream::send (const iovec iov[], int n) const
86   ACE_TRACE ("ACE_SPIPE_Stream::send");
87   return ACE_OS::writev (this->get_handle (), iov, n);
90 ACE_INLINE ssize_t
91 ACE_SPIPE_Stream::recv (iovec iov[], int n) const
93   ACE_TRACE ("ACE_SPIPE_Stream::recv");
94   return ACE_OS::readv (this->get_handle (), iov, n);
97 // This routine sends an open file descriptor to this socket.
99 ACE_INLINE int
100 ACE_SPIPE_Stream::send_handle (ACE_HANDLE handle) const
102   ACE_TRACE ("ACE_SPIPE_Stream::send_handle");
103 #if defined (ACE_HAS_STREAM_PIPES)
104   return ACE_OS::ioctl (this->get_handle (), I_SENDFD, (void *) handle);
105 #elif defined (ACE_WIN32) && (defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0))
106   DWORD procID;
107   WSAPROTOCOL_INFO protInfo;
108   ssize_t res = this->recv(&procID, sizeof(procID));
109   if (res != static_cast <ssize_t> (sizeof(procID)))
110   {
111     if(res != -1)
112         errno = ENXIO;
113     return -1;
114   }
115   if (::WSADuplicateSocket ((SOCKET)handle, procID, &protInfo) == -1)
116   {
117     ACE_OS::set_errno_to_wsa_last_error();
118       return -1;
119   }
120   res = this->send(&protInfo, sizeof(protInfo));
121   if (res != static_cast <ssize_t> (sizeof(protInfo)))
122   {
123     if(res != -1)
124         errno = ENXIO;
125     return -1;
126   }
127   // This is just for synchronization, we will ignore the data
128   res = this->recv(&procID, sizeof(procID));
129   if (res != static_cast <ssize_t> (sizeof(procID)))
130   {
131     if(res != -1)
132         errno = ENXIO;
133     return -1;
134   }
135   return 0;
136 #else
137   ACE_UNUSED_ARG (handle);
138   ACE_NOTSUP_RETURN (-1);
139 #endif /* ACE_HAS_STREAM_PIPES */
142 // This file receives an open file descriptor from this socket.
144 ACE_INLINE int
145 ACE_SPIPE_Stream::recv_handle (ACE_HANDLE &handle) const
147   ACE_TRACE ("ACE_SPIPE_Stream::recv_handle");
148 #if defined (ACE_HAS_STREAM_PIPES)
149   strrecvfd recvfd;
151   if (ACE_OS::ioctl (this->get_handle (), I_RECVFD, (void *) &recvfd) == -1)
152     return -1;
153   else
154     {
155       handle = recvfd.fd;
156       return 0;
157     }
158 #elif defined (ACE_WIN32) && \
159       (defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0))
160   pid_t procID = ACE_OS::getpid();
161   WSAPROTOCOL_INFO protInfo;
162   ssize_t res = this->send(&procID, sizeof(procID));
163   if (res != static_cast <ssize_t> (sizeof(procID)))
164   {
165     if(res != -1)
166         errno = ENXIO;
167     return -1;
168   }
169   res = this->recv(&protInfo, sizeof(protInfo));
170   if (res != static_cast <ssize_t> (sizeof(protInfo)))
171   {
172     if(res != -1)
173         errno = ENXIO;
174      return -1;
175   }
176   handle = ACE_OS::socket (FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO, FROM_PROTOCOL_INFO,
177                            &protInfo, 0, 0);
178   if (handle == ACE_INVALID_HANDLE)
179   {
180     return -1;
181   }
182   // Since it does not matter what the data is, just send something to
183   // synchronize the end of the exchange
184   res = this->send(&procID, sizeof(procID));
185   if (res != static_cast <ssize_t> (sizeof(procID)))
186   {
187     if(res != -1)
188         errno = ENXIO;
189     return -1;
190   }
191   return 0;
192 #else
193   ACE_UNUSED_ARG (handle);
194   ACE_NOTSUP_RETURN (-1);
195 #endif /* ACE_HAS_STREAM_PIPES */
198 // This file receives an open file descriptor from this socket and
199 // also passes back the information about the address...
201 ACE_INLINE int
202 ACE_SPIPE_Stream::recv_handle (strrecvfd &recvfd) const
204   ACE_TRACE ("ACE_SPIPE_Stream::recv_handle");
205 #if defined (ACE_HAS_STREAM_PIPES)
206   return ACE_OS::ioctl (this->get_handle (), I_RECVFD, (void *) &recvfd);
207 #else
208   ACE_UNUSED_ARG (recvfd);
209   ACE_NOTSUP_RETURN (-1);
210 #endif /* ACE_HAS_STREAM_PIPES */
213 ACE_INLINE ssize_t
214 ACE_SPIPE_Stream::send (const void *buf, size_t n,
215                         ACE_OVERLAPPED *overlapped) const
217   ACE_TRACE ("ACE_SPIPE_Stream::send");
218   return ACE_OS::write (this->get_handle (),
219                         (const char *) buf, n,
220                         overlapped);
223 ACE_INLINE ssize_t
224 ACE_SPIPE_Stream::recv (void *buf, size_t n,
225                         ACE_OVERLAPPED *overlapped) const
227   ACE_TRACE ("ACE_SPIPE_Stream::recv");
228   return ACE_OS::read (this->get_handle (),
229                        (char *) buf, n,
230                        overlapped);
233 ACE_INLINE ssize_t
234 ACE_SPIPE_Stream::sendv_n (const iovec iov[],
235                            int n) const
237   ACE_TRACE ("ACE_SPIPE_Stream::sendv_n");
238   return ACE::writev_n (this->get_handle (),
239                         iov,
240                         n);
243 // Recv an n byte message from the Stream.
245 ACE_INLINE ssize_t
246 ACE_SPIPE_Stream::recvv_n (iovec iov[],
247                            int n) const
249   ACE_TRACE ("ACE_SPIPE_Stream::recvv_n");
250   // @@ Carlos, can you please update this to call the
251   // new ACE::recvv_n() method that you write?
252   return ACE_OS::readv (this->get_handle (),
253                         iov,
254                         n);
257 // Send an <iovec> of size <n> to the Stream.
259 ACE_INLINE ssize_t
260 ACE_SPIPE_Stream::sendv (const iovec iov[],
261                          int n) const
263   ACE_TRACE ("ACE_SPIPE_Stream::sendv");
264   return ACE_OS::writev (this->get_handle (),
265                          iov,
266                          n);
269 ACE_END_VERSIONED_NAMESPACE_DECL