socket_decl.hxx

Go to the documentation of this file.

/* -*- 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_DECL_HXX
#define INCLUDED_OSL_SOCKET_DECL_HXX

#include "sal/config.h"

#include <cstddef>

#include "osl/socket.h"
#include "rtl/ustring.hxx"
#include "rtl/byteseq.hxx"

namespace osl
{
    enum __osl_socket_NoCopy { SAL_NO_COPY };

    class SocketAddr
    {
    protected:
        oslSocketAddr m_handle;
    public:

        inline SocketAddr();

        inline SocketAddr(const SocketAddr& Addr);

#if defined LIBO_INTERNAL_ONLY
        inline SocketAddr(SocketAddr && other) noexcept;
#endif

        inline SocketAddr(const oslSocketAddr Addr, __osl_socket_NoCopy nocopy );

        inline SocketAddr(oslSocketAddr Addr);

        inline SocketAddr(const ::rtl::OUString& strAddrOrHostName, sal_Int32 nPort);

        inline ~SocketAddr();

        inline bool is() const;

        inline ::rtl::OUString SAL_CALL getHostname(oslSocketResult *pResult = NULL) const;

        inline bool SAL_CALL setHostname(const ::rtl::OUString &sDottedIpOrHostname);

        inline sal_Int32 SAL_CALL getPort() const;

        inline bool SAL_CALL setPort(sal_Int32 nPort);

        inline bool SAL_CALL setAddr(const ::rtl::ByteSequence & address);

        inline ::rtl::ByteSequence SAL_CALL getAddr(oslSocketResult *pResult = NULL) const;

        inline SocketAddr & SAL_CALL operator= (oslSocketAddr Addr);

        inline SocketAddr & SAL_CALL operator= (const SocketAddr& Addr);

#if defined LIBO_INTERNAL_ONLY
        inline SocketAddr & operator =(SocketAddr && other) noexcept;
#endif

        inline SocketAddr & SAL_CALL assign( oslSocketAddr Addr, __osl_socket_NoCopy nocopy );

        inline bool SAL_CALL operator== (oslSocketAddr Addr) const;

        inline bool SAL_CALL operator== (const SocketAddr & Addr) const;

        inline oslSocketAddr SAL_CALL getHandle() const;

        static inline ::rtl::OUString SAL_CALL getLocalHostname( oslSocketResult *pResult = NULL);

        static inline void SAL_CALL resolveHostname(
            const ::rtl::OUString & strHostName , SocketAddr & Addr );

        static inline sal_Int32 SAL_CALL getServicePort(
            const ::rtl::OUString& strServiceName,
            const ::rtl::OUString & strProtocolName= ::rtl::OUString("tcp") );
    };


    class Socket
    {
    protected:
        oslSocket m_handle;
    protected:
        inline Socket(oslSocketType Type,
                      oslAddrFamily Family = osl_Socket_FamilyInet,
                      oslProtocol   Protocol = osl_Socket_ProtocolIp);
    public:
        inline Socket( );

        inline Socket( const Socket & socket );

        inline Socket( oslSocket socketHandle );

        inline Socket( oslSocket socketHandle, __sal_NoAcquire noacquire );

        inline ~Socket();

        inline Socket& SAL_CALL operator= ( oslSocket socketHandle);

        inline Socket& SAL_CALL operator= (const Socket& sock);

        inline bool SAL_CALL operator==( const Socket& rSocket ) const ;

        inline bool SAL_CALL operator==( const oslSocket socketHandle ) const;

        inline void SAL_CALL shutdown( oslSocketDirection Direction = osl_Socket_DirReadWrite );

        inline void SAL_CALL close();

        inline void SAL_CALL getLocalAddr( SocketAddr &Addr ) const;

        inline sal_Int32    SAL_CALL getLocalPort() const;

        inline ::rtl::OUString SAL_CALL getLocalHost() const;

        inline void SAL_CALL getPeerAddr( SocketAddr & Addr) const;

        inline sal_Int32    SAL_CALL getPeerPort() const;

        inline ::rtl::OUString SAL_CALL getPeerHost() const;

        inline bool SAL_CALL bind(const SocketAddr& LocalInterface);

        inline bool SAL_CALL isRecvReady(const TimeValue *pTimeout = NULL) const;

        inline bool SAL_CALL isSendReady(const TimeValue *pTimeout = NULL) const;


        inline bool SAL_CALL isExceptionPending(const TimeValue *pTimeout = NULL) const;


        inline oslSocketType    SAL_CALL getType() const;

        inline sal_Int32 SAL_CALL getOption(
            oslSocketOption Option,
            void* pBuffer,
            sal_uInt32 BufferLen,
            oslSocketOptionLevel Level= osl_Socket_LevelSocket) const;

        inline bool SAL_CALL setOption( oslSocketOption Option,
                                            void* pBuffer,
                                            sal_uInt32 BufferLen,
                                            oslSocketOptionLevel Level= osl_Socket_LevelSocket ) const;

        inline bool setOption( oslSocketOption option, sal_Int32 nValue  );

        inline sal_Int32 getOption( oslSocketOption option ) const;

        inline bool SAL_CALL enableNonBlockingMode( bool bNonBlockingMode);

        inline bool SAL_CALL isNonBlockingMode() const;


        inline void SAL_CALL clearError() const;

        inline oslSocketError getError() const;

        inline ::rtl::OUString getErrorAsString( ) const;

        inline oslSocket getHandle() const;
    };


    class StreamSocket : public Socket
    {
    public:
          inline StreamSocket(oslAddrFamily Family = osl_Socket_FamilyInet,
                            oslProtocol Protocol = osl_Socket_ProtocolIp,
                            oslSocketType   Type = osl_Socket_TypeStream);

        inline StreamSocket( oslSocket Socket , __sal_NoAcquire noacquire );

        inline StreamSocket( oslSocket Socket );

        inline sal_Int32 SAL_CALL read(void* pBuffer, sal_uInt32 n);

        inline sal_Int32 SAL_CALL write(const void* pBuffer, sal_uInt32 n);


        inline sal_Int32 SAL_CALL recv(void* pBuffer,
                                       sal_uInt32 BytesToRead,
                                       oslSocketMsgFlag flags= osl_Socket_MsgNormal);

        sal_Int32 SAL_CALL send(const void* pBuffer,
                                sal_uInt32 BytesToSend,
                                oslSocketMsgFlag= osl_Socket_MsgNormal);
    };

    class ConnectorSocket : public StreamSocket
    {
    public:
          ConnectorSocket(oslAddrFamily Family = osl_Socket_FamilyInet,
                        oslProtocol Protocol = osl_Socket_ProtocolIp,
                        oslSocketType   Type = osl_Socket_TypeStream);


        oslSocketResult SAL_CALL connect(const SocketAddr& TargetHost, const TimeValue* pTimeout = NULL);
    };

    class AcceptorSocket : public Socket
    {
    public:
        inline AcceptorSocket(oslAddrFamily Family = osl_Socket_FamilyInet,
                              oslProtocol   Protocol = osl_Socket_ProtocolIp,
                              oslSocketType Type = osl_Socket_TypeStream);

        inline bool SAL_CALL listen(sal_Int32 MaxPendingConnections= -1);

        inline oslSocketResult SAL_CALL acceptConnection( StreamSocket& Connection);

        inline oslSocketResult SAL_CALL acceptConnection( StreamSocket& Connection, SocketAddr & PeerAddr);
    };


    class DatagramSocket : public Socket
    {
    public:

        inline DatagramSocket(oslAddrFamily Family= osl_Socket_FamilyInet,
                              oslProtocol   Protocol= osl_Socket_ProtocolIp,
                              oslSocketType Type= osl_Socket_TypeDgram);

        inline sal_Int32 SAL_CALL recvFrom(void*  pBuffer,
                                           sal_uInt32 BufferSize,
                                           SocketAddr* pSenderAddr= NULL,
                                           oslSocketMsgFlag Flag= osl_Socket_MsgNormal);

        inline sal_Int32    SAL_CALL sendTo( const SocketAddr& ReceiverAddr,
                                             const void* pBuffer,
                                             sal_uInt32 BufferSize,
                                             oslSocketMsgFlag Flag= osl_Socket_MsgNormal);
    };

}

#endif

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */