summaryrefslogtreecommitdiffstats
path: root/include/osl/socket.hxx
diff options
context:
space:
mode:
Diffstat (limited to 'include/osl/socket.hxx')
-rw-r--r--include/osl/socket.hxx571
1 files changed, 571 insertions, 0 deletions
diff --git a/include/osl/socket.hxx b/include/osl/socket.hxx
new file mode 100644
index 0000000000..78d410e99a
--- /dev/null
+++ b/include/osl/socket.hxx
@@ -0,0 +1,571 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+/*
+ * This file is part of LibreOffice published API.
+ */
+
+#ifndef INCLUDED_OSL_SOCKET_HXX
+#define INCLUDED_OSL_SOCKET_HXX
+
+#include "osl/socket_decl.hxx"
+
+namespace osl
+{
+
+ inline SocketAddr::SocketAddr()
+ : m_handle( osl_createEmptySocketAddr( osl_Socket_FamilyInet ) )
+ {}
+
+
+ inline SocketAddr::SocketAddr(const SocketAddr& Addr)
+ : m_handle( osl_copySocketAddr( Addr.m_handle ) )
+ {
+ }
+
+#if defined LIBO_INTERNAL_ONLY
+ SocketAddr::SocketAddr(SocketAddr && other) noexcept : m_handle(other.m_handle) {
+ other.m_handle = nullptr;
+ }
+#endif
+
+ inline SocketAddr::SocketAddr(oslSocketAddr Addr)
+ : m_handle( osl_copySocketAddr( Addr ) )
+ {
+ }
+
+
+ inline SocketAddr::SocketAddr(oslSocketAddr Addr, __osl_socket_NoCopy )
+ : m_handle( Addr )
+ {
+ }
+
+
+ inline SocketAddr::SocketAddr( const ::rtl::OUString& strAddrOrHostName, sal_Int32 nPort)
+ : m_handle( osl_createInetSocketAddr( strAddrOrHostName.pData, nPort ) )
+ {
+ if(! m_handle )
+ {
+ m_handle = osl_resolveHostname(strAddrOrHostName.pData);
+
+ // host found?
+ if(m_handle)
+ {
+ osl_setInetPortOfSocketAddr(m_handle, nPort);
+ }
+ else
+ {
+ osl_destroySocketAddr( m_handle );
+ m_handle = NULL;
+ }
+ }
+ }
+
+
+ inline SocketAddr::~SocketAddr()
+ {
+ if( m_handle )
+ osl_destroySocketAddr( m_handle );
+ }
+
+
+ inline ::rtl::OUString SocketAddr::getHostname( oslSocketResult *pResult ) const
+ {
+ ::rtl::OUString hostname;
+ oslSocketResult result = osl_getHostnameOfSocketAddr( m_handle, &(hostname.pData) );
+ if( pResult )
+ *pResult = result;
+ return hostname;
+ }
+
+
+ inline sal_Int32 SAL_CALL SocketAddr::getPort() const
+ {
+ return osl_getInetPortOfSocketAddr(m_handle);
+ }
+
+
+ inline bool SAL_CALL SocketAddr::setPort( sal_Int32 nPort )
+ {
+ return osl_setInetPortOfSocketAddr(m_handle, nPort );
+ }
+
+ inline bool SAL_CALL SocketAddr::setHostname( const ::rtl::OUString &sDottedIpOrHostname )
+ {
+ *this = SocketAddr( sDottedIpOrHostname , getPort() );
+ return is();
+ }
+
+
+ inline bool SAL_CALL SocketAddr::setAddr( const ::rtl::ByteSequence & address )
+ {
+ return osl_setAddrOfSocketAddr( m_handle, address.getHandle() )
+ == osl_Socket_Ok;
+ }
+
+ inline ::rtl::ByteSequence SAL_CALL SocketAddr::getAddr( oslSocketResult *pResult ) const
+ {
+ ::rtl::ByteSequence sequence;
+ oslSocketResult result = osl_getAddrOfSocketAddr( m_handle, reinterpret_cast<sal_Sequence **>(&sequence) );
+ if( pResult )
+ *pResult = result;
+ return sequence;
+ }
+
+
+ inline SocketAddr & SAL_CALL SocketAddr::operator= (oslSocketAddr Addr)
+ {
+ oslSocketAddr pNewAddr = osl_copySocketAddr( Addr );
+ if( m_handle )
+ osl_destroySocketAddr( m_handle );
+ m_handle = pNewAddr;
+ return *this;
+ }
+
+
+ inline SocketAddr & SAL_CALL SocketAddr::operator= (const SocketAddr& Addr)
+ {
+ *this = Addr.getHandle();
+ return *this;
+ }
+
+#if defined LIBO_INTERNAL_ONLY
+ SocketAddr & SocketAddr::operator =(SocketAddr && other) noexcept {
+ if (m_handle != nullptr) {
+ osl_destroySocketAddr(m_handle);
+ }
+ m_handle = other.m_handle;
+ other.m_handle = nullptr;
+ return *this;
+ }
+#endif
+
+ inline SocketAddr & SAL_CALL SocketAddr::assign( oslSocketAddr Addr, __osl_socket_NoCopy )
+ {
+ if( m_handle )
+ osl_destroySocketAddr( m_handle );
+ m_handle = Addr;
+ return *this;
+ }
+
+
+ inline bool SAL_CALL SocketAddr::operator== (oslSocketAddr Addr) const
+ {
+ return osl_isEqualSocketAddr( m_handle, Addr );
+ }
+
+ inline oslSocketAddr SocketAddr::getHandle() const
+ {
+ return m_handle;
+ }
+
+
+ inline bool SocketAddr::is() const
+ {
+ return m_handle != NULL;
+ }
+
+ inline ::rtl::OUString SAL_CALL SocketAddr::getLocalHostname( oslSocketResult *pResult )
+ {
+ ::rtl::OUString hostname;
+ oslSocketResult result = osl_getLocalHostname( &(hostname.pData) );
+ if(pResult )
+ *pResult = result;
+ return hostname;
+ }
+
+ inline void SAL_CALL SocketAddr::resolveHostname(
+ const ::rtl::OUString & strHostName, SocketAddr &Addr)
+ {
+ Addr = SocketAddr( osl_resolveHostname( strHostName.pData ) , SAL_NO_COPY );
+ }
+
+ inline sal_Int32 SAL_CALL SocketAddr::getServicePort(
+ const ::rtl::OUString& strServiceName,
+ const ::rtl::OUString & strProtocolName )
+ {
+ return osl_getServicePort( strServiceName.pData, strProtocolName.pData );
+ }
+
+
+ inline Socket::Socket(oslSocketType Type,
+ oslAddrFamily Family,
+ oslProtocol Protocol)
+ : m_handle( osl_createSocket(Family, Type, Protocol) )
+ {}
+
+
+ inline Socket::Socket( oslSocket socketHandle, __sal_NoAcquire )
+ : m_handle( socketHandle )
+ {}
+
+
+ inline Socket::Socket( oslSocket socketHandle )
+ : m_handle( socketHandle )
+ {
+ osl_acquireSocket( m_handle );
+ }
+
+
+ inline Socket::Socket( const Socket & socket )
+ : m_handle( socket.getHandle() )
+ {
+ osl_acquireSocket( m_handle );
+ }
+
+
+ inline Socket::~Socket()
+ {
+ osl_releaseSocket( m_handle );
+ }
+
+
+ inline Socket& Socket::operator= ( oslSocket socketHandle)
+ {
+ osl_acquireSocket( socketHandle );
+ osl_releaseSocket( m_handle );
+ m_handle = socketHandle;
+ return *this;
+ }
+
+
+ inline Socket& Socket::operator= (const Socket& sock)
+ {
+ *this = sock.getHandle();
+ return *this;
+ }
+
+
+ inline bool Socket::operator==( const Socket& rSocket ) const
+ {
+ return m_handle == rSocket.getHandle();
+ }
+
+
+ inline bool Socket::operator==( const oslSocket socketHandle ) const
+ {
+ return m_handle == socketHandle;
+ }
+
+
+ inline void Socket::shutdown( oslSocketDirection Direction )
+ {
+ osl_shutdownSocket( m_handle , Direction );
+ }
+
+
+ inline void Socket::close()
+ {
+ osl_closeSocket( m_handle );
+ }
+
+
+ inline void Socket::getLocalAddr( SocketAddr & addr) const
+ {
+ addr.assign( osl_getLocalAddrOfSocket( m_handle ) , SAL_NO_COPY );
+ }
+
+
+ inline sal_Int32 Socket::getLocalPort() const
+ {
+ SocketAddr addr( NULL );
+ getLocalAddr( addr );
+ return addr.getPort();
+ }
+
+
+ inline ::rtl::OUString Socket::getLocalHost() const
+ {
+ SocketAddr addr( NULL );
+ getLocalAddr( addr );
+ return addr.getHostname();
+ }
+
+
+ inline void Socket::getPeerAddr( SocketAddr &addr ) const
+ {
+ addr.assign( osl_getPeerAddrOfSocket( m_handle ), SAL_NO_COPY );
+ }
+
+
+ inline sal_Int32 Socket::getPeerPort() const
+ {
+ SocketAddr addr( NULL );
+ getPeerAddr( addr );
+ return addr.getPort();
+ }
+
+
+ inline ::rtl::OUString Socket::getPeerHost() const
+ {
+ SocketAddr addr( NULL );
+ getPeerAddr( addr );
+ return addr.getHostname();
+ }
+
+
+ inline bool Socket::bind(const SocketAddr& LocalInterface)
+ {
+ return osl_bindAddrToSocket( m_handle , LocalInterface.getHandle() );
+ }
+
+
+ inline bool Socket::isRecvReady(const TimeValue *pTimeout ) const
+ {
+ return osl_isReceiveReady( m_handle , pTimeout );
+ }
+
+
+ inline bool Socket::isSendReady(const TimeValue *pTimeout ) const
+ {
+ return osl_isSendReady( m_handle, pTimeout );
+ }
+
+
+ inline bool Socket::isExceptionPending(const TimeValue *pTimeout ) const
+ {
+ return osl_isExceptionPending( m_handle, pTimeout );
+ }
+
+
+ inline oslSocketType Socket::getType() const
+ {
+ return osl_getSocketType( m_handle );
+ }
+
+
+ inline sal_Int32 Socket::getOption(
+ oslSocketOption Option,
+ void* pBuffer,
+ sal_uInt32 BufferLen,
+ oslSocketOptionLevel Level) const
+ {
+ return osl_getSocketOption( m_handle, Level, Option, pBuffer , BufferLen );
+ }
+
+
+ inline bool Socket::setOption( oslSocketOption Option,
+ void* pBuffer,
+ sal_uInt32 BufferLen,
+ oslSocketOptionLevel Level ) const
+ {
+ return osl_setSocketOption( m_handle, Level, Option , pBuffer, BufferLen );
+ }
+
+
+ inline bool Socket::setOption( oslSocketOption option, sal_Int32 nValue )
+ {
+ return setOption( option, &nValue, sizeof( nValue ) );
+ }
+
+
+ inline sal_Int32 Socket::getOption( oslSocketOption option ) const
+ {
+ sal_Int32 n;
+ getOption( option, &n, sizeof( n ) );
+ return n;
+ }
+
+
+ inline bool Socket::enableNonBlockingMode( bool bNonBlockingMode)
+ {
+ return osl_enableNonBlockingMode( m_handle , bNonBlockingMode );
+ }
+
+
+ inline bool Socket::isNonBlockingMode() const
+ {
+ return osl_isNonBlockingMode( m_handle );
+ }
+
+
+ inline void SAL_CALL Socket::clearError() const
+ {
+ sal_Int32 err = 0;
+ getOption(osl_Socket_OptionError, &err, sizeof(err));
+ }
+
+
+ inline oslSocketError Socket::getError() const
+ {
+ return osl_getLastSocketError( m_handle );
+ }
+
+
+ inline ::rtl::OUString Socket::getErrorAsString( ) const
+ {
+ ::rtl::OUString error;
+ osl_getLastSocketErrorDescription( m_handle, &(error.pData) );
+ return error;
+ }
+
+
+ inline oslSocket Socket::getHandle() const
+ {
+ return m_handle;
+ }
+
+
+ inline StreamSocket::StreamSocket(oslAddrFamily Family,
+ oslProtocol Protocol,
+ oslSocketType Type )
+ : Socket( Type, Family, Protocol )
+ {}
+
+
+ inline StreamSocket::StreamSocket( oslSocket socketHandle, __sal_NoAcquire noacquire )
+ : Socket( socketHandle, noacquire )
+ {}
+
+
+ inline StreamSocket::StreamSocket( oslSocket socketHandle )
+ : Socket( socketHandle )
+ {}
+
+
+ inline sal_Int32 StreamSocket::read(void* pBuffer, sal_uInt32 n)
+ {
+ return osl_readSocket( m_handle, pBuffer, n );
+ }
+
+
+ inline sal_Int32 StreamSocket::write(const void* pBuffer, sal_uInt32 n)
+ {
+ return osl_writeSocket( m_handle, pBuffer, n );
+ }
+
+
+ inline sal_Int32 StreamSocket::recv(void* pBuffer,
+ sal_uInt32 BytesToRead,
+ oslSocketMsgFlag Flag)
+ {
+ return osl_receiveSocket( m_handle, pBuffer,BytesToRead, Flag );
+ }
+
+
+ inline sal_Int32 StreamSocket::send(const void* pBuffer,
+ sal_uInt32 BytesToSend,
+ oslSocketMsgFlag Flag)
+ {
+ return osl_sendSocket( m_handle, pBuffer, BytesToSend, Flag );
+ }
+
+
+ inline ConnectorSocket::ConnectorSocket(oslAddrFamily Family,
+ oslProtocol Protocol,
+ oslSocketType Type)
+ : StreamSocket( Family, Protocol ,Type )
+ {}
+
+
+ inline oslSocketResult ConnectorSocket::connect( const SocketAddr& TargetHost,
+ const TimeValue* pTimeout )
+ {
+ return osl_connectSocketTo( m_handle , TargetHost.getHandle(), pTimeout );
+ }
+
+
+ inline AcceptorSocket::AcceptorSocket(oslAddrFamily Family ,
+ oslProtocol Protocol ,
+ oslSocketType Type )
+ : Socket( Type, Family, Protocol )
+ {}
+
+
+ inline bool AcceptorSocket::listen(sal_Int32 MaxPendingConnections)
+ {
+ return osl_listenOnSocket( m_handle, MaxPendingConnections );
+ }
+
+
+ inline oslSocketResult AcceptorSocket::acceptConnection( StreamSocket& Connection)
+ {
+ oslSocket o = osl_acceptConnectionOnSocket( m_handle, NULL );
+ oslSocketResult status = osl_Socket_Ok;
+ if( o )
+ {
+ Connection = StreamSocket( o , SAL_NO_ACQUIRE );
+ }
+ else
+ {
+ Connection = StreamSocket();
+ status = osl_Socket_Error;
+ }
+ return status;
+ }
+
+
+ inline oslSocketResult AcceptorSocket::acceptConnection(
+ StreamSocket& Connection, SocketAddr & PeerAddr)
+ {
+ // TODO change in/OUT parameter
+ oslSocket o = osl_acceptConnectionOnSocket(
+ m_handle, reinterpret_cast<oslSocketAddr *>(&PeerAddr));
+ oslSocketResult status = osl_Socket_Ok;
+ if( o )
+ {
+ Connection = StreamSocket( o , SAL_NO_ACQUIRE );
+ }
+ else
+ {
+ Connection = StreamSocket();
+ status = osl_Socket_Error;
+ }
+ return status;
+ }
+
+
+ inline DatagramSocket::DatagramSocket(oslAddrFamily Family,
+ oslProtocol Protocol,
+ oslSocketType Type)
+ : Socket( Type, Family, Protocol )
+ {}
+
+
+ inline sal_Int32 DatagramSocket::recvFrom(void* pBuffer,
+ sal_uInt32 BufferSize,
+ SocketAddr* pSenderAddr,
+ oslSocketMsgFlag Flag )
+ {
+ sal_Int32 nByteRead;
+ if( pSenderAddr )
+ {
+ // TODO : correct the out-parameter pSenderAddr outparameter
+ nByteRead = osl_receiveFromSocket( m_handle, pSenderAddr->getHandle() , pBuffer,
+ BufferSize, Flag);
+ }
+ else
+ {
+ nByteRead = osl_receiveFromSocket( m_handle, NULL , pBuffer , BufferSize , Flag );
+ }
+ return nByteRead;
+ }
+
+
+ inline sal_Int32 DatagramSocket::sendTo( const SocketAddr& ReceiverAddr,
+ const void* pBuffer,
+ sal_uInt32 BufferSize,
+ oslSocketMsgFlag Flag )
+ {
+ return osl_sendToSocket( m_handle, ReceiverAddr.getHandle(), pBuffer, BufferSize, Flag );
+ }
+}
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */