Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #ifndef _OSL_SOCKET_DECL_HXX_
21 : #define _OSL_SOCKET_DECL_HXX_
22 :
23 : #include <osl/socket.h>
24 : #include <rtl/ustring.hxx>
25 : #include <rtl/byteseq.hxx>
26 :
27 : namespace osl
28 : {
29 : enum __osl_socket_NoCopy { SAL_NO_COPY };
30 :
31 : /** The class should be understood as a reference to a socket address handle ( struct sockaddr ).
32 :
33 : The handle is mutable.
34 : */
35 : class SocketAddr
36 : {
37 : protected:
38 : oslSocketAddr m_handle;
39 : public:
40 :
41 : /** Creates socket address of unknown type.
42 : */
43 : inline SocketAddr();
44 :
45 : /** Copy constructor.
46 : */
47 : inline SocketAddr(const SocketAddr& Addr);
48 :
49 : /** The SocketAddr takes over the responsibility of the handle ( which means,
50 : that the handle gets destructed by the destructor of this reference)
51 :
52 : @param nocopy use SAL_NO_COPY
53 : */
54 : inline SocketAddr(const oslSocketAddr , __osl_socket_NoCopy nocopy );
55 :
56 : /** Copyconstructs the oslSocketAddr handle.
57 : */
58 : inline SocketAddr(oslSocketAddr Addr);
59 :
60 : /** tcpip-specif constructor.
61 : @param strAddrOrHostName strAddrOrHostName hostname or dotted ip-number of the network
62 : interface, the socket shall be created on.
63 : @param nPort tcp-ip port number
64 : */
65 : inline SocketAddr( const ::rtl::OUString& strAddrOrHostName, sal_Int32 nPort );
66 :
67 : /** destroys underlying oslSocketAddress
68 : */
69 : inline ~SocketAddr();
70 :
71 : /** checks, if the SocketAddr was created successful.
72 : @return <code>sal_True</code> if there is a valid underlying handle,
73 : otherwise sal_False.
74 : */
75 : inline sal_Bool is() const;
76 :
77 : /** Converts the address to a (human readable) domain-name.
78 :
79 : @param pResult 0, if you are not interested in errors,
80 : otherwise *pResult contains an error code on failure
81 : or osl_Socket_Ok on success
82 : @return the hostname of this SocketAddr or an empty string on failure.
83 : @see osl_getHostnameOfSocketAddr()
84 : */
85 : inline ::rtl::OUString SAL_CALL getHostname( oslSocketResult *pResult = 0 ) const;
86 :
87 : /** Sets the ipaddress or hostname of the SocketAddress
88 : */
89 : inline sal_Bool SAL_CALL setHostname( const ::rtl::OUString &sDottedIpOrHostname );
90 :
91 : /** Returns the port number of the address.
92 : @return the port in host-byte order or or OSL_INVALID_PORT on errors.
93 : */
94 : inline sal_Int32 SAL_CALL getPort() const;
95 :
96 : /** Sets the port number of the address.
97 : @return true if successfule.
98 : */
99 : inline sal_Bool SAL_CALL setPort( sal_Int32 nPort );
100 :
101 : /** Sets the address of the underlying socket address struct in network byte order.
102 : @return true on success, false signales falure.
103 : */
104 : inline sal_Bool SAL_CALL setAddr( const ::rtl::ByteSequence & address );
105 :
106 : /** Returns the address of the underlying socket in network byte order
107 : */
108 : inline ::rtl::ByteSequence SAL_CALL getAddr( oslSocketResult *pResult = 0 ) const;
109 :
110 : /** assign the handle to this reference. The previous handle is released.
111 : */
112 : inline SocketAddr & SAL_CALL operator= (oslSocketAddr Addr);
113 :
114 : /**
115 : */
116 : inline SocketAddr & SAL_CALL operator= (const SocketAddr& Addr);
117 :
118 : /** Assigns the socket addr without copyconstructing it.
119 : @param nocopy use SAL_NO_COPY
120 : */
121 : inline SocketAddr & SAL_CALL assign( oslSocketAddr Addr, __osl_socket_NoCopy nocopy );
122 :
123 : /** Returns true if the underlying handle is identical to the Addr handle.
124 : */
125 : inline sal_Bool SAL_CALL operator== (oslSocketAddr Addr) const;
126 :
127 : /** Returns true if the underlying handle is identical to the Addr handle.
128 : */
129 : inline sal_Bool SAL_CALL operator== (const SocketAddr & Addr) const;
130 :
131 : /** Returns the underlying SocketAddr handle without copyconstructing it.
132 : */
133 : inline oslSocketAddr SAL_CALL getHandle() const;
134 :
135 : /** Get the hostname for the local interface.
136 : @param pResult after the call *pResult contains osl_Socket_Ok on success or
137 : an error on failure.
138 : @return the hostname
139 : */
140 : static inline ::rtl::OUString SAL_CALL getLocalHostname( oslSocketResult *pResult = 0);
141 :
142 : /** Tries to find an address for a host.
143 : @see osl_resolveHostname()
144 : @return A new created socket-address or 0 if the name could not be found.
145 : */
146 : static inline void SAL_CALL resolveHostname(
147 : const ::rtl::OUString & strHostName , SocketAddr & Addr );
148 :
149 : /**
150 : Tries to find the port associated with the given service/protocol-
151 : pair (e.g. "ftp"/"tcp").
152 : @return the port number in host-byte order or <code>OSL_INVALID_PORT</code>
153 : if no service/protocol pair could be found.
154 : */
155 : static inline sal_Int32 SAL_CALL getServicePort(
156 : const ::rtl::OUString& strServiceName,
157 : const ::rtl::OUString & strProtocolName= ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("tcp")) );
158 : };
159 :
160 :
161 : class Socket
162 : {
163 : protected:
164 : oslSocket m_handle;
165 : protected:
166 : /** Creates a socket. Note it's protected.
167 : @param Type
168 : @param Family
169 : @param Protocol
170 : */
171 : inline Socket(oslSocketType Type,
172 : oslAddrFamily Family = osl_Socket_FamilyInet,
173 : oslProtocol Protocol = osl_Socket_ProtocolIp);
174 : public:
175 : inline Socket( );
176 :
177 : inline Socket( const Socket & socket );
178 :
179 : inline Socket( oslSocket socketHandle );
180 :
181 : /** The instance takes over the handle's ownership without acquiring the
182 : handle, but releases it within the dtor.
183 : @param noacquire use SAL_NO_ACQUIRE
184 : */
185 : inline Socket( oslSocket socketHandle, __sal_NoAcquire noacquire );
186 :
187 : /** Destructor. Releases the underlying handle
188 : */
189 : inline ~Socket();
190 :
191 : /** Assignment operator. If socket was already created, the old one will
192 : be discarded.
193 : */
194 : inline Socket& SAL_CALL operator= ( oslSocket socketHandle);
195 :
196 : /** Assignment operator. If socket was already created, the old one will
197 : be discarded.
198 : */
199 : inline Socket& SAL_CALL operator= (const Socket& sock);
200 :
201 : /**
202 : @return <code>sal_True</code>, when the underlying handle of both
203 : Socket instances are identical, <code>sal_False</code> otherwise.
204 : */
205 : inline sal_Bool SAL_CALL operator==( const Socket& rSocket ) const ;
206 :
207 : /**
208 : @return <code>sal_True</code>, when the underlying handle of both
209 : Socket instances are identical, <code>sal_False</code> otherwise.
210 : */
211 : inline sal_Bool SAL_CALL operator==( const oslSocket socketHandle ) const;
212 :
213 : /** Closes a definite or both directions of the bidirectional stream.
214 :
215 : @param Direction
216 : @see osl_shutdownSocket()
217 : */
218 : inline void SAL_CALL shutdown( oslSocketDirection Direction = osl_Socket_DirReadWrite );
219 :
220 : /** Closes a socket.
221 : Note that closing a socket is identical to shutdown( osl_Socket_DirReadWrite ),
222 : as the operating system distinguish both cases, both functions or offered in this API.
223 : @see osl_closeSocket()
224 : */
225 : inline void SAL_CALL close();
226 :
227 : /** Retrieves the address of the local interface of this socket.
228 : @param Addr [out] receives the address.
229 : @see osl_getLocalAddrOfSocket()
230 : */
231 : inline void SAL_CALL getLocalAddr( SocketAddr &Addr ) const;
232 :
233 : /** Get the local port of the socket. Usually used after bind().
234 : @return the port number or OSL_INVALID_PORT on errors.
235 : */
236 : inline sal_Int32 SAL_CALL getLocalPort() const;
237 :
238 : /** Get the hostname for the local interface.
239 : @return the hostname or an empty string ("").
240 : */
241 : inline ::rtl::OUString SAL_CALL getLocalHost() const;
242 :
243 : /** Retrieves the address of the remote host of this socket.
244 : @param Addr [out] receives the address.
245 : */
246 : inline void SAL_CALL getPeerAddr( SocketAddr & Addr) const;
247 :
248 : /** Get the remote port of the socket.
249 : @return the port number or OSL_INVALID_PORT on errors.
250 : */
251 : inline sal_Int32 SAL_CALL getPeerPort() const;
252 :
253 : /** Get the hostname for the remote interface.
254 : @return the hostname or an empty string ("").
255 : */
256 : inline ::rtl::OUString SAL_CALL getPeerHost() const;
257 :
258 : /** Binds the socket to the specified (local) interface.
259 : @param LocalInterface Address of the Interface
260 : @return True if bind was successful.
261 : */
262 : inline sal_Bool SAL_CALL bind(const SocketAddr& LocalInterface);
263 :
264 : /** Checks if read operations will block.
265 :
266 : You can specify a timeout-value in seconds/nanoseconds that denotes
267 : how the operation will block if the Socket is not ready.
268 : @return <code>sal_True</code> if read operations (recv, recvFrom, accept) on the Socket
269 : will NOT block; <code>sal_False</code> if it would block or if an error occurred.
270 :
271 : @param pTimeout if 0, the operation will block without a timeout. Otherwise
272 : the specified amout of time.
273 : */
274 : inline sal_Bool SAL_CALL isRecvReady(const TimeValue *pTimeout = 0) const;
275 :
276 : /** Checks if send operations will block.
277 :
278 : You can specify a timeout-value in seconds/nanoseconds that denotes
279 : how the operation will block if the Socket is not ready.
280 : @return <code>sal_True</code> if send operations (send, sendTo) on the Socket
281 : will NOT block; <code>sal_False</code> if it would block or if an error occurred.
282 :
283 : @param pTimeout if 0, the operation will block without a timeout. Otherwise
284 : the specified amout of time.
285 : */
286 : inline sal_Bool SAL_CALL isSendReady(const TimeValue *pTimeout = 0) const;
287 :
288 :
289 : /** Checks if a request for out-of-band data will block.
290 :
291 : You can specify a timeout-value in seconds/nanoseconds that denotes
292 : how the operation will block if the Socket has no pending OOB data.
293 :
294 : @return <code>sal_True</code> if OOB-request operations (recv with appropriate flags)
295 : on the Socket will NOT block; <code>sal_False</code> if it would block or if
296 : an error occurred.
297 :
298 : @param pTimeout if 0, the operation will block without a timeout. Otherwise
299 : the specified amout of time.
300 : */
301 : inline sal_Bool SAL_CALL isExceptionPending(const TimeValue *pTimeout = 0) const;
302 :
303 :
304 : /** Queries the socket for its type.
305 : @return one of:
306 : <ul>
307 : <li> <code>osl_Socket_TypeStream</code>
308 : <li> <code>osl_Socket_TypeDgram</code>
309 : <li> <code>osl_Socket_TypeRaw</code>
310 : <li> <code>osl_Socket_TypeRdm</code>
311 : <li> <code>osl_Socket_TypeSeqPacket</code>
312 : <li> <code>osl_invalid_SocketType</code>, if an error occurred
313 : </ul>
314 : */
315 : inline oslSocketType SAL_CALL getType() const;
316 :
317 : /** Retrieves option-attributes associated with the socket.
318 : @param Option The attribute to query.
319 : Valid values (depending on the Level) are:
320 : <ul>
321 : <li> <code>osl_Socket_Option_Debug</code><br>
322 : (sal_Bool) Socket debug flag 1 = enabled, 0 = disabled.
323 :
324 : <li> <code>osl_Socket_OptionAcceptConn</code><br>
325 : <li> <code>osl_Socket_OptionReuseAddr</code><br>
326 : (sal_Bool) Allows the socket to be bound to an address that is
327 : already in use.
328 : 1 = multiple bound allowed, 0 = no multiple bounds allowed
329 :
330 : <li><code>osl_Socket_OptionKeepAlive</code><br>
331 : (sal_Bool) Keepalive packets are sent by the underlying socket.
332 : 1 = enabled, 0 = disabled
333 :
334 : <li><code>osl_Socket_OptionDontRoute</code><br>
335 : (sal_Bool) Do not route: send directly to interface.
336 : 1 = do not route , 0 = routing possible
337 :
338 : <li><code>osl_Socket_OptionBroadcast</code><br>
339 : (sal_Bool) Transmission of broadcast messages are allowed on the socket.
340 : 1 = transmission allowed, 0 = transmission disallowed
341 :
342 : <li><code>osl_Socket_OptionUseLoopback</code><br>
343 :
344 : <li><code>osl_Socket_OptionLinger</code><br>
345 : (linger) Linger on close if unsent data is present.
346 : linger has two members: l_onoff, l_linger
347 : l_onoff = 0 is off, l_onoff > 0 and l_linger= timeout in seconds.
348 :
349 : <li><code>osl_Socket_OptionOOBinLine</code><br>
350 :
351 :
352 : <li><code>osl_Socket_OptionSndBuf</code><br>
353 : (sal_Int32) Size of the send buffer in bytes. Data is sent after
354 : SndTimeo or when the buffer is full. This allows faster writing
355 : to the socket.
356 :
357 : <li><code>osl_Socket_OptionRcvBuf</code><br>
358 : (sal_Int32) Size of the receive buffer in bytes. Data is sent after
359 : SndTimeo or when the buffer is full. This allows faster writing
360 : to the socket and larger packet sizes.
361 :
362 : <li><code>osl_Socket_OptionSndLowat</code><br>
363 :
364 : <li><code>osl_Socket_OptionRcvLowat</code><br>
365 :
366 : <li><code>osl_Socket_OptionSndTimeo</code><br>
367 : (sal_Int32) Data is sent after this timeout. This allows gathering
368 : of data to send larger packages but increases latency times.
369 :
370 : <li><code>osl_Socket_OptionRcvTimeo</code><br>
371 :
372 : <li><code>osl_Socket_OptionError</code><br>
373 : <li><code>osl_Socket_OptionType</code><br>
374 :
375 : <li><code>osl_Socket_OptionTcpNoDelay</code><br>
376 : Disables the Nagle algorithm for send coalescing. (Do not
377 : collect data until a packet is full, instead send immediatly.
378 : This increases network traffic but might improve latency-times.)
379 : 1 = disables the algorithm, 0 = keeps it enabled.
380 : </ul>
381 :
382 : If not above mentioned otherwise, the options are only valid for
383 : level <code>osl_Socket_LevelSocket</code>.
384 : @param pBuffer The Buffer will be filled with the attribute.
385 :
386 : @param BufferLen The size of pBuffer.
387 :
388 : @param Level The option level.
389 :
390 : Valid values are:
391 : <ul>
392 : <li><code>osl_Socket_LevelSocket</code> : Socket Level
393 : <li><code>osl_Socket_LevelTcp</code> : Level of Transmission Control Protocol
394 : </ul>
395 : @return The size of the attribute copied into pBuffer or -1 if an error
396 : occurred.
397 : */
398 : inline sal_Int32 SAL_CALL getOption(
399 : oslSocketOption Option,
400 : void* pBuffer,
401 : sal_uInt32 BufferLen,
402 : oslSocketOptionLevel Level= osl_Socket_LevelSocket) const;
403 :
404 : /** Sets the sockets attributes.
405 :
406 : @param Option denotes the option to modify.
407 : Valid values (depending on the Level) are:
408 : <ul>
409 : <li> osl_Socket_Option_Debug
410 : <li> osl_Socket_OptionAcceptConn
411 : <li> osl_Socket_OptionReuseAddr
412 : <li> osl_Socket_OptionKeepAlive
413 : <li> osl_Socket_OptionDontRoute
414 : <li> osl_Socket_OptionBroadcast
415 : <li> osl_Socket_OptionUseLoopback
416 : <li> osl_Socket_OptionLinger
417 : <li> osl_Socket_OptionOOBinLine
418 : <li> osl_Socket_OptionSndBuf
419 : <li> osl_Socket_OptionRcvBuf
420 : <li> osl_Socket_OptionSndLowat
421 : <li> osl_Socket_OptionRcvLowat
422 : <li> osl_Socket_OptionSndTimeo
423 : <li> osl_Socket_OptionRcvTimeo
424 : <li> osl_Socket_OptionError
425 : <li> osl_Socket_OptionType
426 : <li> osl_Socket_OptionTcpNoDelay
427 : </ul>
428 :
429 : If not above mentioned otherwise, the options are only valid for
430 : level osl_Socket_LevelSocket.
431 :
432 : @param pBuffer Pointer to a Buffer which contains the attribute-value.
433 :
434 : @param BufferLen contains the length of the Buffer.
435 :
436 : @param Level selects the level for which an option should be changed.
437 : Valid values are:
438 : <ul>
439 : <li> osl_Socket_evel_Socket : Socket Level
440 : <li> osl_Socket_Level_Tcp : Level of Transmission Control Protocol
441 : </ul>
442 :
443 : @return True if the option could be changed.
444 : */
445 : inline sal_Bool SAL_CALL setOption( oslSocketOption Option,
446 : void* pBuffer,
447 : sal_uInt32 BufferLen,
448 : oslSocketOptionLevel Level= osl_Socket_LevelSocket ) const;
449 :
450 : /** Convenience function for setting sal_Bool and sal_Int32 option values.
451 : @see setOption()
452 : */
453 : inline sal_Bool setOption( oslSocketOption option, sal_Int32 nValue );
454 :
455 : /** Convenience function for retrieving sal_Bool and sal_Int32 option values.
456 : @see setOption()
457 : */
458 : inline sal_Int32 getOption( oslSocketOption option ) const;
459 :
460 : /** Enables/disables non-blocking mode of the socket.
461 : @param bNonBlockingMode If <code>sal_True</code>, blocking mode will be switched off
462 : If <code>sal_False</code>, the socket will become a blocking
463 : socket (which is the default behaviour of a socket).
464 : @return <code>sal_True</code> if mode could be set.
465 : */
466 : inline sal_Bool SAL_CALL enableNonBlockingMode( sal_Bool bNonBlockingMode);
467 :
468 : /** Query blocking mode of the socket.
469 : @return <code>sal_True</code> if non-blocking mode is set.
470 : */
471 : inline sal_Bool SAL_CALL isNonBlockingMode() const;
472 :
473 :
474 : /** clears the error status
475 : */
476 : inline void SAL_CALL clearError() const;
477 :
478 : /** returns a constant decribing the last error for the socket system.
479 :
480 : @return osl_Socket_E_NONE if no error occurred, invalid_SocketError if
481 : an unknown (unmapped) error occurred, otherwise an enum describing the
482 : error.
483 : @see osl_getLastSocketError()
484 : */
485 : inline oslSocketError getError() const;
486 :
487 : /** Builds a string with the last error-message for the socket.
488 : */
489 : inline ::rtl::OUString getErrorAsString( ) const;
490 :
491 : /** Returns the underlying handle unacquired (The caller must acquire it to keep it).
492 : */
493 : inline oslSocket getHandle() const;
494 : };
495 :
496 :
497 0 : class StreamSocket : public Socket
498 : {
499 : public:
500 : /** Creates a socket.
501 : @param Type For some protocols it might be desirable to
502 : use a different type than <code>osl_Socket_TypeStream</code>
503 : (like <code>osl_Socket_TypeSeqPacket</code>).
504 : Therefore this parameter is not hidden.
505 : */
506 : inline StreamSocket(oslAddrFamily Family = osl_Socket_FamilyInet,
507 : oslProtocol Protocol = osl_Socket_ProtocolIp,
508 : oslSocketType Type = osl_Socket_TypeStream);
509 :
510 : inline StreamSocket( const StreamSocket & );
511 :
512 : inline StreamSocket( oslSocket Socket , __sal_NoAcquire noacquire );
513 :
514 : inline StreamSocket( oslSocket Socket );
515 :
516 : /** Retrieves n bytes from the stream and copies them into pBuffer.
517 : The method avoids incomplete reads due to packet boundaries and is thus
518 : blocking.
519 : @param pBuffer receives the read data. pBuffer must be large enough
520 : to hold n bytes.
521 : @param n the number of bytes to read.
522 : @return the number of read bytes. The number will only be smaller than
523 : n if an exceptional condition (e.g. connection closed) occurs.
524 : */
525 : inline sal_Int32 SAL_CALL read(void* pBuffer, sal_uInt32 n);
526 :
527 : /** Writes n bytes from pBuffer to the stream. The method avoids
528 : incomplete writes due to packet boundaries and is thus blocking.
529 : @param pBuffer contains the data to be written.
530 : @param n the number of bytes to write.
531 : @return the number of written bytes. The number will only be smaller than
532 : n if an exceptional condition (e.g. connection closed) occurs.
533 : */
534 : inline sal_Int32 SAL_CALL write(const void* pBuffer, sal_uInt32 n);
535 :
536 :
537 : /** Tries to receive BytesToRead data from the connected socket,
538 :
539 : @param[out] pBuffer Points to a buffer that will be filled with the received
540 : data. pBuffer must have at least have a size of BytesToRead.
541 : @param[in] BytesToRead The number of bytes to read.
542 : @param[in] flags Modifier for the call. Valid values are:
543 :
544 : <ul>
545 : <li><code>osl_Socket_MsgNormal</code>
546 : <li><code>osl_Socket_MsgOOB</code>
547 : <li><code>osl_Socket_MsgPeek</code>
548 : <li><code>osl_Socket_MsgDontRoute</code>
549 : <li><code>osl_Socket_MsgMaxIOVLen</code>
550 : </ul>
551 : @return the number of received bytes, which may be less than BytesToRead.
552 : */
553 : inline sal_Int32 SAL_CALL recv(void* pBuffer,
554 : sal_uInt32 BytesToRead,
555 : oslSocketMsgFlag flags= osl_Socket_MsgNormal);
556 :
557 : /** Tries to send BytesToSend data to the connected socket.
558 :
559 : @param pBuffer [in] Points to a buffer that contains the send-data.
560 : @param BytesToSend [in] The number of bytes to send. pBuffer must have at least
561 : this size.
562 : @param Flag [in] Modifier for the call. Valid values are:
563 : <ul>
564 : <li><code>osl_Socket_MsgNormal</code>
565 : <li><code>osl_Socket_MsgOOB</code>
566 : <li><code>osl_Socket_MsgPeek</code>
567 : <li><code>osl_Socket_MsgDontRoute</code>
568 : <li><code>osl_Socket_MsgMaxIOVLen</code>
569 : </ul>
570 :
571 : @return the number of transfered bytes. It may be less than BytesToSend.
572 : */
573 : sal_Int32 SAL_CALL send(const void* pBuffer,
574 : sal_uInt32 BytesToSend,
575 : oslSocketMsgFlag= osl_Socket_MsgNormal);
576 : };
577 :
578 0 : class ConnectorSocket : public StreamSocket
579 : {
580 : public:
581 : /** Creates a socket that can connect to a (remote) host.
582 : @param Type For some protocols it might be desirable to
583 : use a different type than sock_stream <code>osl_Socket_TypeSeqPacket</code>
584 : (like <code>osl_Socket_TypeSeqPacket</code>).
585 : Therefore we do not hide this parameter here.
586 : */
587 : ConnectorSocket(oslAddrFamily Family = osl_Socket_FamilyInet,
588 : oslProtocol Protocol = osl_Socket_ProtocolIp,
589 : oslSocketType Type = osl_Socket_TypeStream);
590 :
591 :
592 : /** Connects the socket to a (remote) host.
593 : @param TargetHost The address of the target.
594 : @param pTimeout The timeout for blocking. If 0, a default system dependent timeout
595 : us used.
596 : @return <code> osl_Socket_Ok</code> if connected successfully,
597 : <code>osl_Socket_TimedOut</code> on timeout,
598 : <code>osl_Socket_Interrupted</code> if unblocked forcefully (by osl::Socket::close()),
599 : <code>osl_Socket_Error</code> if connect failed.
600 : */
601 : oslSocketResult SAL_CALL connect(const SocketAddr& TargetHost, const TimeValue* pTimeout = 0);
602 : };
603 :
604 : /** Allows to accept socket connections.
605 : */
606 0 : class AcceptorSocket : public Socket
607 : {
608 : public:
609 : inline AcceptorSocket(oslAddrFamily Family = osl_Socket_FamilyInet,
610 : oslProtocol Protocol = osl_Socket_ProtocolIp,
611 : oslSocketType Type = osl_Socket_TypeStream);
612 :
613 : /** Prepare a socket for the accept-call. The socket must have been
614 : bound before to the local address.
615 : @param MaxPendingConnections The maximum number of pending
616 : connections (waiting to be accepted) on this socket. If you use
617 : -1, a system default value is used.
618 : @return <code>sal_True</code> if call was successful.
619 : */
620 : inline sal_Bool SAL_CALL listen(sal_Int32 MaxPendingConnections= -1);
621 :
622 : /** Accepts incoming connections on the socket. You must
623 : precede this call with osl::Socket::bind() and listen().
624 : @param Connection receives the incoming connection.
625 : @return <code>osl_Socket_Ok</code>, if a connection has been accepted,
626 : <code>osl_Socket_TimedOut</code>, if m_RecvTimeout milliseconds passed without connect,
627 : <code>osl_Socket_Error</code> on errors.
628 : */
629 : inline oslSocketResult SAL_CALL acceptConnection( StreamSocket& Connection);
630 :
631 : /** Accepts incoming connections on the socket. You must
632 : precede this call with osl::Socket::bind() and listen().
633 : @param PeerAddr receives the address of the connecting entity
634 : (your communication partner).
635 : @param Connection receives the incoming connection.
636 : @return <code>osl_Socket_Ok</code>, if a connection has been accepted,
637 : <code>osl_Socket_TimedOut</code>, if m_RecvTimeout milliseconds passed without connect,
638 : <code>osl_Socket_Error</code> on errors.
639 : */
640 : inline oslSocketResult SAL_CALL acceptConnection( StreamSocket& Connection, SocketAddr & PeerAddr);
641 : };
642 :
643 :
644 :
645 : /** A connectionless socket to send and receive datagrams.
646 : */
647 : class DatagramSocket : public Socket
648 : {
649 : public:
650 :
651 : /** Creates a datagram socket.
652 : @param Type is sock_dgram by default.
653 : */
654 : inline DatagramSocket(oslAddrFamily Family= osl_Socket_FamilyInet,
655 : oslProtocol Protocol= osl_Socket_ProtocolIp,
656 : oslSocketType Type= osl_Socket_TypeDgram);
657 :
658 : /** Tries to receives BufferSize data from the socket, if no error occurs.
659 :
660 : @param pSenderAddr [out] You must provide pointer to a SocketAddr.
661 : It will be filled with the address of the datagrams sender.
662 : If pSenderAddr is 0, it is ignored.
663 : @param pBuffer [out] Points to a buffer that will be filled with the received
664 : datagram.
665 : @param BufferSize [in] The size of pBuffer.
666 : @param Flag [in] Modifier for the call. Valid values are:
667 : <ul>
668 : <li><code>osl_Socket_MsgNormal</code>
669 : <li><code>osl_Socket_MsgOOB</code>
670 : <li><code>osl_Socket_MsgPeek</code>
671 : <li><code>osl_Socket_MsgDontRoute</code>
672 : <li><code>osl_Socket_MsgMaxIOVLen</code>
673 : </ul>
674 :
675 : @return the number of received bytes.
676 : */
677 : inline sal_Int32 SAL_CALL recvFrom(void* pBuffer,
678 : sal_uInt32 BufferSize,
679 : SocketAddr* pSenderAddr= 0,
680 : oslSocketMsgFlag Flag= osl_Socket_MsgNormal);
681 :
682 : /** Tries to send one datagram with BytesToSend size to the given ReceiverAddr.
683 : Since there is only send one packet, the function doesn't care about
684 : packet boundaries.
685 :
686 : @param ReceiverAddr [in] A SocketAddr that contains
687 : the destination address for this send.
688 :
689 : @param pBuffer [in] Points to a buffer that contains the send-data.
690 : @param BufferSize [in] The number of bytes to send. pBuffer must have at least
691 : this size.
692 : @param Flag [in] Modifier for the call. Valid values are:
693 :
694 : <ul>
695 : <li><code>osl_Socket_MsgNormal</code>
696 : <li><code>osl_Socket_MsgOOB</code>
697 : <li><code>osl_Socket_MsgPeek</code>
698 : <li><code>osl_Socket_MsgDontRoute</code>
699 : <li><code>osl_Socket_MsgMaxIOVLen</code>
700 : </ul>
701 :
702 : @return the number of transfered bytes.
703 : */
704 : inline sal_Int32 SAL_CALL sendTo( const SocketAddr& ReceiverAddr,
705 : const void* pBuffer,
706 : sal_uInt32 BufferSize,
707 : oslSocketMsgFlag Flag= osl_Socket_MsgNormal);
708 : };
709 :
710 : }
711 :
712 : #endif
713 :
714 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
