xref: /trunk/main/vos/source/socket.cxx (revision e8c8fa4bdcac50a8fe6c60960dd164b285c48c7e)

/**************************************************************
 *
 * 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
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



#include <stdio.h>

#include <rtl/memory.h>
#include <osl/time.h>
#include <vos/socket.hxx>
#include <vos/diagnose.hxx>
//#include <osl/tools.h>

using namespace vos;


VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OSocketAddr, vos),
                        VOS_NAMESPACE(OSocketAddr, vos),
                        VOS_NAMESPACE(OObject, vos), 0);


/*****************************************************************************/
// OSocketAddr()
/*****************************************************************************/
OSocketAddr::OSocketAddr()
{
    m_SockAddr= 0;
}

/*****************************************************************************/
// OSocketAddr()
/*****************************************************************************/
OSocketAddr::OSocketAddr(oslSocketAddr Addr)
{
    m_SockAddr= Addr;
}

/*****************************************************************************/
// OSocketAddr()
/*****************************************************************************/
OSocketAddr::OSocketAddr(const OSocketAddr& Addr) :
ISocketAddr(), OObject()
{
    m_SockAddr= osl_copySocketAddr((oslSocketAddr)Addr);
}

/*****************************************************************************/
// ~OSocketAddr()
/*****************************************************************************/
OSocketAddr::~OSocketAddr()
{
    osl_destroySocketAddr(m_SockAddr);
}


/*****************************************************************************/
// getFamily()
/*****************************************************************************/
OSocketAddr::TAddrFamily OSocketAddr::getFamily() const
{
    return (TAddrFamily)osl_getFamilyOfSocketAddr(m_SockAddr);
}

/*****************************************************************************/
// operator oslSocketAddr ()
/*****************************************************************************/
OSocketAddr::operator oslSocketAddr() const
{
    return m_SockAddr;
}

/*****************************************************************************/
// getHostname()
/*****************************************************************************/
OSocketAddr::TResult OSocketAddr::getHostname(rtl::OUString& rBuffer ) const
{
    return (TResult)osl_getHostnameOfSocketAddr(m_SockAddr, &rBuffer.pData );
}

/*****************************************************************************/
// getLocalHostname()
/*****************************************************************************/
OSocketAddr::TResult OSocketAddr::getLocalHostname( rtl::OUString& pBuffer )
{
    return (TResult)osl_getLocalHostname( &pBuffer.pData );
}

/*****************************************************************************/
// resolveHostname()
/*****************************************************************************/
oslSocketAddr OSocketAddr::resolveHostname(const rtl::OUString& ustrHostname)
{
    return osl_resolveHostname( ustrHostname.pData );
}

/*****************************************************************************/
// operator= (oslSocketAddr Addr)
/*****************************************************************************/
void OSocketAddr::operator= (oslSocketAddr Addr)
{
    if(m_SockAddr) {
        osl_destroySocketAddr(m_SockAddr);
    }

    m_SockAddr= Addr;
}

/*****************************************************************************/
// operator== (oslSocketAddr Addr)
/*****************************************************************************/
sal_Bool OSocketAddr::operator== (oslSocketAddr Addr)
{
    return (osl_isEqualSocketAddr(m_SockAddr, Addr));
}

/*****************************************************************************/
// operator=(const OSocketAddr& Addr)
/*****************************************************************************/
OSocketAddr& OSocketAddr::operator=(const OSocketAddr& Addr)
{
    if(m_SockAddr) {
        osl_destroySocketAddr(m_SockAddr);
    }

    m_SockAddr= osl_copySocketAddr((oslSocketAddr)Addr);

    return *this;
}


VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OInetSocketAddr, vos),
                        VOS_NAMESPACE(OInetSocketAddr, vos),
                        VOS_NAMESPACE(OSocketAddr, vos), 0);



/*****************************************************************************/
// OInetSocketAddr
// creates arbitrary inet-address (INADDR_ANY)
/*****************************************************************************/
OInetSocketAddr::OInetSocketAddr()
{
    m_SockAddr= osl_createEmptySocketAddr(osl_Socket_FamilyInet);
}

/*****************************************************************************/
// OInetSocketAddr
// uses the given oslSocketAddr as its own
/*****************************************************************************/
OInetSocketAddr::OInetSocketAddr(oslSocketAddr Addr) :
    OSocketAddr(Addr)
{
    VOS_ASSERT(osl_getFamilyOfSocketAddr(Addr) == osl_Socket_FamilyInet);
}

/*****************************************************************************/
// OInetSocketAddr
// Create a socket address either from a dotted decimal address
//(e.g. 141.99.128.50) or a hostname (e.g. www.stardiv.de).
/*****************************************************************************/
OInetSocketAddr::OInetSocketAddr(const rtl::OUString& ustrAddrOrHostname, sal_Int32 Port)
{
    // first try as dotted address.
    m_SockAddr= osl_createInetSocketAddr(ustrAddrOrHostname.pData, Port);

    // create failed, maybe it's an hostname
    if(m_SockAddr == 0)
    {
        m_SockAddr= osl_resolveHostname(ustrAddrOrHostname.pData);

        // host found?
        if(m_SockAddr)
        {
            // set port will fail if addrtype is not osl_Socket_FamilyInet
            VOS_VERIFY(osl_setInetPortOfSocketAddr(m_SockAddr, Port));
        }
    }
}

/*****************************************************************************/
// OInetSocketAddr(const OInetSocketAddr&)
/*****************************************************************************/
OInetSocketAddr::OInetSocketAddr(const OInetSocketAddr& sa) :
    OSocketAddr(sa)
{
    VOS_ASSERT(getFamily() == TFamily_Inet);
}

/*****************************************************************************/
// OInetSocketAddr(const OSocketAddr&)
/*****************************************************************************/
OInetSocketAddr::OInetSocketAddr(const OSocketAddr& sa) :
    OSocketAddr(sa)
{
    VOS_ASSERT(sa.getFamily() == TFamily_Inet);
}

/*****************************************************************************/
// ~OInetSocketAddr
/*****************************************************************************/
OInetSocketAddr::~OInetSocketAddr()
{
}

/*****************************************************************************/
// operator= (oslSocketAddr Addr)
/*****************************************************************************/
void OInetSocketAddr::operator= (oslSocketAddr Addr)
{
    VOS_PRECOND(osl_getFamilyOfSocketAddr(Addr) == osl_Socket_FamilyInet,
                "oslSocketAddr not of type osl_Socket_FamilyInet!");

    OSocketAddr::operator=(Addr);
}

/*****************************************************************************/
// operator== (oslSocketAddr Addr)
/*****************************************************************************/
sal_Bool OInetSocketAddr::operator== (oslSocketAddr Addr)
{
    return (osl_isEqualSocketAddr(m_SockAddr, Addr));
}

/*****************************************************************************/
// operator=(const OInetSocketAddr& Addr)
/*****************************************************************************/
OInetSocketAddr& OInetSocketAddr::operator=(const OInetSocketAddr& Addr)
{
    VOS_ASSERT(Addr.getFamily() == TFamily_Inet);

    OSocketAddr::operator=(Addr);

    return *this;
}

/*****************************************************************************/
// operator=(const OSocketAddr& Addr)
/*****************************************************************************/
OInetSocketAddr& OInetSocketAddr::operator=(const OSocketAddr& Addr)
{
    VOS_ASSERT(Addr.getFamily() == TFamily_Inet);

    OSocketAddr::operator=(Addr);

    return *this;
}

/*****************************************************************************/
// getServicePort()
/*****************************************************************************/
sal_Int32 OInetSocketAddr::getServicePort(const rtl::OUString& ustrServiceName,
                                    const rtl::OUString& ustrProtocolName)
{
    return osl_getServicePort(ustrServiceName.pData, ustrProtocolName.pData);
}


/*****************************************************************************/
// getPort()
/*****************************************************************************/
sal_Int32 OInetSocketAddr::getPort () const
{
    return osl_getInetPortOfSocketAddr(m_SockAddr);
}


/*****************************************************************************/
// setPort()
/*****************************************************************************/
sal_Bool OInetSocketAddr::setPort (sal_Int32 Port)
{
    return osl_setInetPortOfSocketAddr(m_SockAddr, Port);
}


/*****************************************************************************/
// getDottedAddr()
/*****************************************************************************/
OSocketAddr::TResult OInetSocketAddr::getDottedAddr( rtl::OUString& pBuffer ) const
{
    return (TResult)osl_getDottedInetAddrOfSocketAddr(m_SockAddr, &pBuffer.pData );
}

/*****************************************************************************/
// setAddr()
/*****************************************************************************/
sal_Bool OInetSocketAddr::setAddr(const rtl::OUString& ustrAddrOrHostname)
{
    sal_Int32 Port = 0;

    if(m_SockAddr) {

        // retrieve old port
        Port= getPort();

        // free old address
        osl_destroySocketAddr(m_SockAddr);
        m_SockAddr= 0;
    }

    // first try as dotted address.
    m_SockAddr= osl_createInetSocketAddr(ustrAddrOrHostname.pData, Port);

    // create failed, maybe it's an hostname
    if(m_SockAddr == 0)
    {

        m_SockAddr= osl_resolveHostname( ustrAddrOrHostname.pData );

        // host found?
        if(m_SockAddr==0)
        {
            return sal_False;
        }

        // set port will fail if addrtype is not osl_Socket_FamilyInet
        VOS_VERIFY(osl_setInetPortOfSocketAddr(m_SockAddr, Port));

    }

    return sal_True;
}

///////////////////////////////////////////////////////////////////////////////
// OIpxSocketAddr

VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OIpxSocketAddr, vos),
                        VOS_NAMESPACE(OIpxSocketAddr, vos),
                        VOS_NAMESPACE(OSocketAddr, vos), 0);


/*****************************************************************************/
// OIpxSocketAddr()
/*****************************************************************************/
OIpxSocketAddr::OIpxSocketAddr()
{
    m_SockAddr= osl_createEmptySocketAddr(osl_Socket_FamilyIpx);
}

/*****************************************************************************/
// OIpxSocketAddr(oslSocketAddr)
/*****************************************************************************/
OIpxSocketAddr::OIpxSocketAddr(oslSocketAddr Addr) :
    OSocketAddr(Addr)
{
    VOS_ASSERT(osl_getFamilyOfSocketAddr(Addr) == osl_Socket_FamilyIpx);
}

/*****************************************************************************/
// OIpxSocketAddr()
/*****************************************************************************/
OIpxSocketAddr::OIpxSocketAddr(const rtl::OUString&,
                               const rtl::OUString&,
                               sal_uInt32 )
{
    // jbu : functionality removed from vos
}

/*****************************************************************************/
// OIpxSocketAddr(OIpxSocketAddr&)
/*****************************************************************************/
OIpxSocketAddr::OIpxSocketAddr(const OIpxSocketAddr& sa) :
    OSocketAddr(sa)
{
    VOS_ASSERT(sa.getFamily() == TFamily_Ipx);
}


/*****************************************************************************/
// OIpxSocketAddr(OSocketAddr&)
/*****************************************************************************/
OIpxSocketAddr::OIpxSocketAddr(const OSocketAddr& sa) :
    OSocketAddr(sa)
{
    VOS_ASSERT(sa.getFamily() == TFamily_Ipx);
}

/*****************************************************************************/
// ~OIpxSocketAddr()
/*****************************************************************************/
OIpxSocketAddr::~OIpxSocketAddr()
{
}


/*****************************************************************************/
// operator=()
/*****************************************************************************/
void OIpxSocketAddr::operator= (oslSocketAddr Addr)
{
    VOS_PRECOND(osl_getFamilyOfSocketAddr(Addr) == osl_Socket_FamilyIpx,
            "oslSocketAddr not of type osl_Socket_FamilyIpx!");

    OSocketAddr::operator=(Addr);
}

/*****************************************************************************/
// operator== (oslSocketAddr Addr)
/*****************************************************************************/
sal_Bool OIpxSocketAddr::operator== (oslSocketAddr Addr)
{
    return (osl_isEqualSocketAddr(m_SockAddr, Addr));
}

/*****************************************************************************/
// operator=(const OIpxSocketAddr& Addr)
/*****************************************************************************/
OIpxSocketAddr& OIpxSocketAddr::operator=(const OIpxSocketAddr& Addr)
{
    VOS_ASSERT(Addr.getFamily() == TFamily_Ipx);

    OSocketAddr::operator=(Addr);

    return *this;
}

/*****************************************************************************/
// operator=(const OSocketAddr& Addr)
/*****************************************************************************/
OIpxSocketAddr& OIpxSocketAddr::operator=(const OSocketAddr& Addr)
{
    VOS_ASSERT(Addr.getFamily() == TFamily_Ipx);

    OSocketAddr::operator=(Addr);

    return *this;
}

/*****************************************************************************/
// getNetNumber()
/*****************************************************************************/
OSocketAddr::TResult OIpxSocketAddr::getNetNumber(TIpxNetNumber&) const
{
    // jbu : functionality removed from vos
    return (TResult)0;
}

/*****************************************************************************/
// getNodeNumber()
/*****************************************************************************/
OSocketAddr::TResult OIpxSocketAddr::getNodeNumber(TIpxNodeNumber& ) const
{
    // jbu : functionality removed from vos
    return (TResult)0;
}

/*****************************************************************************/
// getSocketNumber()
/*****************************************************************************/
sal_uInt32 OIpxSocketAddr::getSocketNumber() const
{
//      return osl_getIpxSocketNumber(m_SockAddr);
    return (TResult)0;
}


/*****************************************************************************/
// getAddressString()
/*****************************************************************************/
//void OIpxSocketAddr::getAddressString(sal_Char* Buffer, sal_uInt32 Len) const
void OIpxSocketAddr::getAddressString( rtl::OUString& ) const
{
    // jbu : functionality removed from vos
}


///////////////////////////////////////////////////////////////////////////////
// Socket


VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OSocket, vos),
                        VOS_NAMESPACE(OSocket, vos),
                        VOS_NAMESPACE(OObject, vos), 0);

/*****************************************************************************/
// OSocket()
/*****************************************************************************/
OSocket::OSocket()
{
    m_pRecvTimeout = 0;
    m_pSendTimeout = 0;

    m_pSockRef= 0;
}


/*****************************************************************************/
// OSocket()
/*****************************************************************************/
OSocket::OSocket(TSocketType Type,
                 TAddrFamily Family,
                 TProtocol   Protocol)
{
    m_pRecvTimeout = 0;
    m_pSendTimeout = 0;

    m_pSockRef=
        new SockRef(osl_createSocket((oslAddrFamily)Family,
                                     (oslSocketType)Type,
                                     (oslProtocol)Protocol));

    VOS_POSTCOND(m_pSockRef != 0, "OSocket(): new failed.\n");
    VOS_POSTCOND((*m_pSockRef)(), "OSocket(): creation of socket failed!\n");
}

/*****************************************************************************/
// OSocket()
/*****************************************************************************/
OSocket::OSocket(const OSocket& sock) :
ISocketTypes(), OReference(), OObject()
{
    m_pRecvTimeout = 0;
    m_pSendTimeout = 0;
    m_pSockRef=0;

    VOS_ASSERT(sock.m_pSockRef != 0);

    if ( sock.m_pSockRef !=0 )
    {
        m_pSockRef= sock.m_pSockRef;

        setRecvTimeout(sock.m_pRecvTimeout);
        setSendTimeout(sock.m_pSendTimeout);

        m_pSockRef->acquire();
    }
}

/*****************************************************************************/
// OSocket()
/*****************************************************************************/
OSocket::OSocket(oslSocket Socket)
{
    m_pRecvTimeout = 0;
    m_pSendTimeout = 0;

    m_pSockRef = new SockRef(Socket);
}


/*****************************************************************************/
// ~OSocket()
/*****************************************************************************/
OSocket::~OSocket()
{
    close();

    delete m_pRecvTimeout;
    delete m_pSendTimeout;
}


/*****************************************************************************/
// create
/*****************************************************************************/
sal_Bool OSocket::create(TSocketType Type,
                        TAddrFamily Family,
                        TProtocol   Protocol)
{
    // if this was a valid socket, decrease reference
    if ((m_pSockRef) && (m_pSockRef->release() == 0))
    {
        osl_releaseSocket((*m_pSockRef)());
        delete m_pSockRef;
        m_pSockRef= 0;
    }

    m_pSockRef=
        new SockRef(osl_createSocket((oslAddrFamily)Family,
                                     (oslSocketType)Type,
                                     (oslProtocol)Protocol));

    VOS_POSTCOND(m_pSockRef != 0, "OSocket(): new failed.\n");

    return (*m_pSockRef)() != 0;
}

/*****************************************************************************/
// operator=
/*****************************************************************************/
OSocket& OSocket::operator= (const OSocket& sock)
{
    VOS_PRECOND(sock.m_pSockRef != 0, "OSocket::operator=: tried to assign an empty/invalid socket\n");

    if (m_pSockRef == sock.m_pSockRef)
        return *this;

    // if this was a valid socket, decrease reference
    if ((m_pSockRef) && (m_pSockRef->release() == 0))
    {
        osl_releaseSocket((*m_pSockRef)());
        delete m_pSockRef;
        m_pSockRef= 0;
    }

    m_pSockRef= sock.m_pSockRef;

    setRecvTimeout(sock.m_pRecvTimeout);
    setSendTimeout(sock.m_pSendTimeout);

    m_pSockRef->acquire();

    return *this;
}

/*****************************************************************************/
// operator oslSocket()
/*****************************************************************************/
OSocket::operator oslSocket() const
{
    VOS_ASSERT(m_pSockRef);
    return (*m_pSockRef)();
}

/*****************************************************************************/
// isValid()
/*****************************************************************************/
sal_Bool OSocket::isValid() const
{
    return m_pSockRef != 0 && (*m_pSockRef)() != 0;
}


/*****************************************************************************/
// close
/*****************************************************************************/
void OSocket::close()
{
    if (m_pSockRef && (*m_pSockRef)() && (m_pSockRef->release() == 0))
    {
        osl_releaseSocket((*m_pSockRef)());
        delete m_pSockRef;
    }

    m_pSockRef= 0;
}

/*****************************************************************************/
// getLocalAddr
/*****************************************************************************/
void OSocket::getLocalAddr(OSocketAddr& sa) const
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        sa= osl_getLocalAddrOfSocket((*m_pSockRef)());
    }
}

/*****************************************************************************/
// getLocalPort
/*****************************************************************************/
sal_Int32 OSocket::getLocalPort() const
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    sal_Int32 Port= OSL_INVALID_PORT;

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        oslSocketAddr Addr= osl_getLocalAddrOfSocket((*m_pSockRef)());

        if(Addr)
        {
            Port= osl_getInetPortOfSocketAddr(Addr);
            osl_destroySocketAddr(Addr);
        }
    }

    return Port;
}

/*****************************************************************************/
// getLocalHost
/*****************************************************************************/
OSocket::TResult OSocket::getLocalHost( rtl::OUString& pBuffer) const
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        oslSocketAddr Addr= osl_getLocalAddrOfSocket((*m_pSockRef)());

        if(Addr)
        {
//          TResult Result= (TResult)osl_getHostnameOfSocketAddr(Addr,
//                                                      pBuffer, BufferSize);
            TResult Result= (TResult)osl_getHostnameOfSocketAddr(Addr,
                                                             &pBuffer.pData );

            osl_destroySocketAddr(Addr);

            return Result;
        }
    }

    return TResult_Error;
}

/*****************************************************************************/
// getPeerAddr
/*****************************************************************************/
void OSocket::getPeerAddr(OSocketAddr& sa) const
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        sa= osl_getPeerAddrOfSocket((*m_pSockRef)());
    }
}

/*****************************************************************************/
// getPeerPort
/*****************************************************************************/
sal_Int32 OSocket::getPeerPort() const
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    sal_Int32 Port= OSL_INVALID_PORT;

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        oslSocketAddr Addr= osl_getPeerAddrOfSocket((*m_pSockRef)());

        if(Addr)
        {
            Port= osl_getInetPortOfSocketAddr(Addr);
            osl_destroySocketAddr(Addr);
        }
    }

    return Port;
}

/*****************************************************************************/
// getPeerHost
/*****************************************************************************/
OSocket::TResult OSocket::getPeerHost( rtl::OUString& pBuffer ) const
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        oslSocketAddr Addr= osl_getPeerAddrOfSocket((*m_pSockRef)());

        if(Addr)
        {
//          TResult Result= (TResult)osl_getHostnameOfSocketAddr(Addr,
//                                                      pBuffer, BufferSize);
            TResult Result= (TResult)osl_getHostnameOfSocketAddr(Addr,
                                                             &pBuffer.pData );

            osl_destroySocketAddr(Addr);

            return Result;
        }
    }

    return TResult_Error;
}

/*****************************************************************************/
// bind
/*****************************************************************************/
sal_Bool OSocket::bind(const OSocketAddr& Addr)
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        return osl_bindAddrToSocket((*m_pSockRef)(), (oslSocketAddr)Addr);
    }

    return sal_False;
}


/*****************************************************************************/
// setSendTimeout
/*****************************************************************************/
void OSocket::setSendTimeout(const TimeValue* pTimeout)
{
    delete m_pSendTimeout;

    if (pTimeout)
        m_pSendTimeout = new TimeValue(*pTimeout);
    else
        m_pSendTimeout = 0;
}

/*****************************************************************************/
// setRecvTimeout
/*****************************************************************************/
void OSocket::setRecvTimeout(const TimeValue* pTimeout)
{
    delete m_pRecvTimeout;

    if (pTimeout)
        m_pRecvTimeout = new TimeValue(*pTimeout);
    else
        m_pRecvTimeout = 0;
}

/*****************************************************************************/
// isRecvReady
/*****************************************************************************/
sal_Bool OSocket::isRecvReady(const TimeValue* pTimeout) const
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        return osl_isReceiveReady((*m_pSockRef)(), pTimeout);
    }

    return sal_False;
}

/*****************************************************************************/
// isSendReady
/*****************************************************************************/
sal_Bool OSocket::isSendReady(const TimeValue* pTimeout) const
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        return osl_isSendReady((*m_pSockRef)(), pTimeout);
    }

    return sal_False;
}

/*****************************************************************************/
// isExceptionPending
/*****************************************************************************/
sal_Bool OSocket::isExceptionPending(const TimeValue* pTimeout) const
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        return osl_isExceptionPending((*m_pSockRef)(), pTimeout);
    }

    return sal_False;
}


/*****************************************************************************/
// getOption
/*****************************************************************************/
sal_Int32 OSocket::getOption(TSocketOption Option,
                           void* pBuffer,
                           sal_uInt32 BufferLen,
                           TSocketOptionLevel Level) const
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        return osl_getSocketOption((*m_pSockRef)(),
                                   (oslSocketOptionLevel)Level,
                                   (oslSocketOption)Option,
                                   pBuffer,
                                   BufferLen);
    }

    return sal_False;
}

/*****************************************************************************/
// setOption
/*****************************************************************************/
sal_Bool OSocket::setOption(TSocketOption Option,
                           void* pBuffer,
                           sal_uInt32 BufferLen,
                           TSocketOptionLevel Level) const
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        return osl_setSocketOption((*m_pSockRef)(),
                                   (oslSocketOptionLevel)Level,
                                   (oslSocketOption)Option,
                                   pBuffer,
                                   BufferLen);
    }

    return sal_False;
}


/*****************************************************************************/
// enableNonBlockingMode
/*****************************************************************************/
sal_Bool OSocket::enableNonBlockingMode(sal_Bool On)
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        return osl_enableNonBlockingMode((*m_pSockRef)(), On);
    }

    return sal_False;
}

/*****************************************************************************/
// isNonBlockingMode
/*****************************************************************************/
sal_Bool OSocket::isNonBlockingMode() const
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        return osl_isNonBlockingMode((*m_pSockRef)());
    }

    return sal_False;
}

/*****************************************************************************/
// getType
/*****************************************************************************/
OSocket::TSocketType OSocket::getType() const
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        return (TSocketType)osl_getSocketType((*m_pSockRef)());
    }

    return TType_Invalid;
}

/*****************************************************************************/
// clearError
/*****************************************************************************/
sal_Int32 OSocket::clearError() const
{
    sal_Int32 err = 0;

    getOption(TOption_Error, &err, sizeof(err));

    return err;
}

/*****************************************************************************/
// setDebug
/*****************************************************************************/
sal_Int32 OSocket::setDebug(sal_Int32 opt) const
{
    sal_Int32 old= 0;

    getOption(TOption_Debug, &old, sizeof(old));

    if (opt != -1)
        setOption(TOption_Debug, &opt, sizeof(opt));

    return old;
}

/*****************************************************************************/
// setReuseAddr
/*****************************************************************************/
sal_Int32 OSocket::setReuseAddr(sal_Int32 opt) const
{
    sal_Int32 old = 0;

    getOption(TOption_ReuseAddr, &old, sizeof(old));

    if (opt != -1)
        setOption(TOption_ReuseAddr, &opt, sizeof(opt));

    return (old);
}

/*****************************************************************************/
// setKeepAlive
/*****************************************************************************/
sal_Int32 OSocket::setKeepAlive(sal_Int32 opt) const
{
    sal_Int32 old = 0;

    getOption(TOption_KeepAlive, &old, sizeof(old));

    if (opt != -1)
        setOption(TOption_KeepAlive, &opt, sizeof(opt));

    return (old);
}

/*****************************************************************************/
// setDontRoute
/*****************************************************************************/
sal_Int32 OSocket::setDontRoute(sal_Int32 opt) const
{
    sal_Int32 old = 0;

    getOption(TOption_DontRoute, &old, sizeof(old));

    if (opt != -1)
        setOption(TOption_DontRoute, &opt, sizeof(opt));

    return (old);
}

/*****************************************************************************/
// setBroadcast
/*****************************************************************************/
sal_Int32 OSocket::setBroadcast(sal_Int32 opt) const
{
    sal_Int32 old = 0;

    getOption(TOption_Broadcast, &old, sizeof(old));

    if (opt != -1)
        setOption(TOption_Broadcast, &opt, sizeof(opt));

    return (old);
}

/*****************************************************************************/
// setOobinline
/*****************************************************************************/
sal_Int32 OSocket::setOobinline(sal_Int32 opt) const
{
    sal_Int32 old = 0;

    getOption(TOption_OOBinLine, &old, sizeof(old));

    if (opt != -1)
        setOption(TOption_OOBinLine, &opt, sizeof(opt));

    return (old);
}

/*****************************************************************************/
// setLinger
/*****************************************************************************/
sal_Int32 OSocket::setLinger(sal_Int32 time) const
{
    /* local decl. of linger-struct */
    struct SockLinger
    {
        sal_Int32 m_onoff;    // option on/off
        sal_Int32 m_linger;   // linger time
    };


    SockLinger  old = { 0, 0 };

    getOption(TOption_Linger, &old, sizeof(old));

    if (time > 0) // enable linger with wait-times > 0
    {
        SockLinger nw = { 1, time };
        setOption(TOption_Linger, &nw, sizeof(nw));
    }
    else if (time == 0) // disable linger with wait-time == 0
    {
        SockLinger nw = { 0, old.m_linger };
        setOption(TOption_Linger, &nw, sizeof(nw));
    }

    // returns 0 if linger was off, else the linger-time
    return (old.m_onoff ? old.m_linger : 0);
}

/*****************************************************************************/
// setSendBufSize
/*****************************************************************************/
sal_Int32 OSocket::setSendBufSize(sal_Int32 sz) const
{
    sal_Int32 old = 0;

    getOption(TOption_SndBuf, &old, sizeof(old));

    if (sz >= 0)
        setOption(TOption_SndBuf, &sz, sizeof(sz));

    return (old);
}

/*****************************************************************************/
// setRecvBufSize
/*****************************************************************************/
sal_Int32 OSocket::setRecvBufSize(sal_Int32 sz) const
{
    sal_Int32 old = 0;

    getOption(TOption_RcvBuf, &old, sizeof(old));

    if (sz >= 0)
        setOption(TOption_RcvBuf, &sz, sizeof(sz));

    return (old);
}

/*****************************************************************************/
// setTcpNoDelay
/*****************************************************************************/
sal_Int32 OSocket::setTcpNoDelay(sal_Int32 sz) const
{
    sal_Int32 old = 0;

    getOption(TOption_TcpNoDelay, &old, sizeof(old), TLevel_Tcp);

    if (sz >= 0)
        setOption(TOption_TcpNoDelay, &sz, sizeof(sz), TLevel_Tcp);

    return (old);
}

/*****************************************************************************/
// getError
/*****************************************************************************/
//void OSocket::getError(sal_Char* pBuffer, sal_uInt32 nSize) const
void OSocket::getError( rtl::OUString& pBuffer ) const
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if (m_pSockRef && (*m_pSockRef)())
        osl_getLastSocketErrorDescription((*m_pSockRef)(), &pBuffer.pData );
    else
        osl_getLastSocketErrorDescription(NULL, &pBuffer.pData );
}

/*****************************************************************************/
// getError
/*****************************************************************************/
OSocket::TSocketError OSocket::getError() const
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if (m_pSockRef && (*m_pSockRef)())
        return (TSocketError)osl_getLastSocketError((*m_pSockRef)());
    else
        return (TSocketError)osl_getLastSocketError(NULL);
}



VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OAcceptorSocket, vos),
                        VOS_NAMESPACE(OAcceptorSocket, vos),
                        VOS_NAMESPACE(OSocket, vos), 0);


/*****************************************************************************/
// OAcceptorSocket
/*****************************************************************************/
OAcceptorSocket::OAcceptorSocket(TAddrFamily Family,
                                 TProtocol   Protocol,
                                 TSocketType Type) :
    OSocket(Type, Family, Protocol)
{
}

/*****************************************************************************/
// OAcceptorSocket
/*****************************************************************************/
OAcceptorSocket::OAcceptorSocket(const OAcceptorSocket& sock) :
    OSocket(sock)
{
}

/*****************************************************************************/
// ~OAcceptorSocket
/*****************************************************************************/
OAcceptorSocket::~OAcceptorSocket()
{
    if (m_pSockRef && (*m_pSockRef)() && (m_pSockRef->release() == 0))
    {
        /* mfe: prepare for forthcoming api change */
        osl_closeSocket((*m_pSockRef)());
        osl_releaseSocket((*m_pSockRef)());
        delete m_pSockRef;
        m_pSockRef = 0;
    }
}

/*****************************************************************************/
// close
/*****************************************************************************/
void OAcceptorSocket::close()
{
    if (m_pSockRef && (*m_pSockRef)() && (m_pSockRef->release() == 0))
    {
        osl_closeSocket((*m_pSockRef)());
    }

    m_pSockRef= 0;
}

/*****************************************************************************/
// listen
/*****************************************************************************/
sal_Bool OAcceptorSocket::listen(sal_Int32 MaxPendingConnections)
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        return osl_listenOnSocket((*m_pSockRef)(), MaxPendingConnections);
    }

    return sal_False;
}


/*****************************************************************************/
// acceptConnection
/*****************************************************************************/
OSocket::TResult OAcceptorSocket::acceptConnection(OStreamSocket& connection)
{
    if (m_pRecvTimeout && ! isRecvReady(m_pRecvTimeout))
        return TResult_TimedOut;

    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());
    OStreamSocket aSocket;

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        aSocket = osl_acceptConnectionOnSocket((*m_pSockRef)(), 0);
    }

    if( aSocket.isValid() )
    {
        connection = aSocket;
        return TResult_Ok;
    }
    else
    {
        return TResult_Error;
    }

}

/*****************************************************************************/
// acceptConnection
/*****************************************************************************/
OSocket::TResult OAcceptorSocket::acceptConnection(OStreamSocket& connection,
                                                   OSocketAddr& sa)
{
    oslSocketAddr PeerAddr = 0;
    oslSocket     Socket = 0;

    if (m_pRecvTimeout && ! isRecvReady(m_pRecvTimeout))
        return TResult_TimedOut;

    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        Socket= osl_acceptConnectionOnSocket((*m_pSockRef)(), &PeerAddr);
    }

    if (Socket)
    {
        sa= PeerAddr;
        connection= Socket;
        return TResult_Ok;
    }
    else
    {
        return TResult_Error;
    }
}


VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OStreamSocket, vos),
                        VOS_NAMESPACE(OStreamSocket, vos),
                        VOS_NAMESPACE(OSocket, vos), 0);



/*****************************************************************************/
// OStreamSocket
/*****************************************************************************/
OStreamSocket::OStreamSocket()
{
}

/*****************************************************************************/
// OStreamSocket
/*****************************************************************************/
OStreamSocket::OStreamSocket(TAddrFamily Family,
                             TProtocol   Protocol,
                             TSocketType Type) :
    OSocket(Type, Family, Protocol)
{
}


/*****************************************************************************/
// OStreamSocket
/*****************************************************************************/
OStreamSocket::OStreamSocket(oslSocket Socket) :
    OSocket(Socket)
{
}

/*****************************************************************************/
// OStreamSocket
// copy constructor
/*****************************************************************************/
OStreamSocket::OStreamSocket(const OStreamSocket& sock) :
    OSocket(sock), IStream()
{
}

/*****************************************************************************/
// OStreamSocket
// copy constructor
/*****************************************************************************/
OStreamSocket::OStreamSocket(const OSocket& sock) :
    OSocket(sock)
{
}

/*****************************************************************************/
// ~OStreamSocket
/*****************************************************************************/
OStreamSocket::~OStreamSocket()
{
}

/*****************************************************************************/
// close
/*****************************************************************************/
void OStreamSocket::close()
{
    if (m_pSockRef && (*m_pSockRef)() && (m_pSockRef->release() == 0))
    {
        shutdown();
        osl_releaseSocket((*m_pSockRef)());
        delete m_pSockRef;
    }

    m_pSockRef= 0;
}


/*****************************************************************************/
// operator=(oslSocket)
/*****************************************************************************/
OStreamSocket& OStreamSocket::operator=(oslSocket Socket)
{
    OSocket::operator=(Socket);

    return *this;
}

/*****************************************************************************/
// operator=
/*****************************************************************************/
OStreamSocket& OStreamSocket::operator= (const OSocket& sock)
{
    OSocket::operator=(sock);

    return *this;
}

/*****************************************************************************/
// operator=
/*****************************************************************************/
OStreamSocket& OStreamSocket::operator= (const OStreamSocket& sock)
{
    OSocket::operator=(sock);

    return *this;
}

/*****************************************************************************/
// read
/*****************************************************************************/
sal_Int32 OStreamSocket::read(void* pBuffer, sal_uInt32 n) const
{
    sal_uInt8 *Ptr = (sal_uInt8  *)pBuffer;

    if (m_pRecvTimeout && ! isRecvReady(m_pRecvTimeout))
        return 0;

    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( ! ( m_pSockRef && (*m_pSockRef)() ) )
    {
        return -1;
    }

    /* loop until all desired bytes were read or an error occured */
    sal_uInt32 BytesRead= 0;
    sal_uInt32 BytesToRead= n;
    while (BytesToRead > 0)
    {
        sal_Int32 RetVal;
        RetVal= osl_receiveSocket((*m_pSockRef)(),
                                   Ptr,
                                   BytesToRead,
                                   osl_Socket_MsgNormal);

        /* error occured? */
        if(RetVal <= 0)
        {
            break;
        }

        BytesToRead -= RetVal;
        BytesRead += RetVal;
        Ptr += RetVal;

        /* wait for next available data or timeout */
        if ( BytesToRead > 0 && m_pRecvTimeout && ! isRecvReady(m_pRecvTimeout))
            break;

    }

    return BytesRead;
}

/*****************************************************************************/
// write
/*****************************************************************************/
sal_Int32 OStreamSocket::write(const void* pBuffer, sal_uInt32 n)
{
    sal_uInt8 *Ptr = (sal_uInt8 *)pBuffer;

    if (m_pSendTimeout && ! isSendReady(m_pSendTimeout))
        return 0;

    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( ! ( m_pSockRef && (*m_pSockRef)() ) )
    {
        return -1;
    }

    /* loop until all desired bytes were send or an error occured */
    sal_uInt32 BytesSend= 0;
    sal_uInt32 BytesToSend= n;
    while (BytesToSend > 0)
    {
        sal_Int32 RetVal;

        RetVal= osl_sendSocket((*m_pSockRef)(),
                                Ptr,
                                BytesToSend,
                                osl_Socket_MsgNormal);

        /* error occured? */
        if(RetVal <= 0)
        {
            break;
        }

        BytesToSend -= RetVal;
        BytesSend += RetVal;
        Ptr += RetVal;

        /* wait till new data is available or timeout occures */
        if ( BytesToSend > 0 && m_pSendTimeout && ! isSendReady(m_pSendTimeout))
            break;
    }

    return BytesSend;
}

sal_Bool OStreamSocket::isEof() const
{
    return isValid();
    // BHO not enough
}

/*****************************************************************************/
// recv
/*****************************************************************************/
sal_Int32 OStreamSocket::recv(void* pBuffer,
                            sal_uInt32 BytesToRead,
                            TSocketMsgFlag Flag)
{
    if (m_pRecvTimeout && ! isRecvReady(m_pRecvTimeout))
        return 0;

    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( ! ( m_pSockRef && (*m_pSockRef)() ) )
    {
        return -1;
    }

    return osl_receiveSocket((*m_pSockRef)(),
                             pBuffer,
                             BytesToRead,
                             (oslSocketMsgFlag)Flag);
}

/*****************************************************************************/
// send
/*****************************************************************************/
sal_Int32 OStreamSocket::send(const void* pBuffer,
                            sal_uInt32 BytesToSend,
                            TSocketMsgFlag Flag)
{
    if (m_pSendTimeout && ! isSendReady(m_pSendTimeout))
        return 0;

    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( ! ( m_pSockRef && (*m_pSockRef)() ) )
    {
        return -1;
    }

    return osl_sendSocket((*m_pSockRef)(),
                          pBuffer,
                          BytesToSend,
                          (oslSocketMsgFlag)Flag);
}

/*****************************************************************************/
// shutdown
/*****************************************************************************/
sal_Bool OStreamSocket::shutdown(TSocketDirection Direction)
{
    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        return osl_shutdownSocket((*m_pSockRef)(), (oslSocketDirection)Direction);
    }

    return sal_False;
}



VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(OConnectorSocket, vos),
                        VOS_NAMESPACE(OConnectorSocket, vos),
                        VOS_NAMESPACE(OStreamSocket, vos), 0);



/*****************************************************************************/
// OConnectorSocket
/*****************************************************************************/
OConnectorSocket::OConnectorSocket(TAddrFamily Family,
                                   TProtocol   Protocol,
                                   TSocketType Type) :
    OStreamSocket(Family, Protocol, Type)
{
}

/*****************************************************************************/
// OConnectorSocket
/*****************************************************************************/
OConnectorSocket::OConnectorSocket(const OConnectorSocket& sock) :
    OStreamSocket(sock)
{
}

/*****************************************************************************/
// ~OConnectorSocket
/*****************************************************************************/
OConnectorSocket::~OConnectorSocket()
{
}

/*****************************************************************************/
// connect
/*****************************************************************************/
OSocket::TResult OConnectorSocket::connect(const OSocketAddr& Addr,
                                           const TimeValue* pTimeout)
{

    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( m_pSockRef && (*m_pSockRef)() )
    {
        return (TResult)osl_connectSocketTo((*m_pSockRef)(),
                                            (oslSocketAddr)Addr,
                                            pTimeout);
    }

    return TResult_Error;
}


VOS_IMPLEMENT_CLASSINFO(VOS_CLASSNAME(ODatagramSocket, vos),
                        VOS_NAMESPACE(ODatagramSocket, vos),
                        VOS_NAMESPACE(OSocket, vos), 0);


/*****************************************************************************/
// ODatagramSocket
/*****************************************************************************/
ODatagramSocket::ODatagramSocket(TAddrFamily Family,
                                 TProtocol   Protocol,
                                 TSocketType Type) :
    OSocket(Type, Family, Protocol)
{
}

/*****************************************************************************/
// ODatagramSocket
/*****************************************************************************/
ODatagramSocket::ODatagramSocket(const ODatagramSocket& sock) :
    OSocket(sock)
{
}

/*****************************************************************************/
// ~ODatagramSocket
/*****************************************************************************/
ODatagramSocket::~ODatagramSocket()
{
}


/*****************************************************************************/
// recvFrom
/*****************************************************************************/
sal_Int32 ODatagramSocket::recvFrom(void* pBuffer,
                                  sal_uInt32 BufferSize,
                                  OSocketAddr* pSenderAddr,
                                  TSocketMsgFlag Flag)
{

    if (m_pRecvTimeout && ! isRecvReady(m_pRecvTimeout))
        return 0;

    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( ! ( m_pSockRef && (*m_pSockRef)() ) )
    {
        return -1;
    }

    sal_Int32 BytesRead;

    if(pSenderAddr)
    {
        // we are interested in the senders address
        oslSocketAddr SenderAddr= osl_createEmptySocketAddr(osl_Socket_FamilyInet);

        BytesRead=
            osl_receiveFromSocket((*m_pSockRef)(),
                                   SenderAddr,
                                   pBuffer,
                                   BufferSize,
                                   (oslSocketMsgFlag)Flag);

        *pSenderAddr= SenderAddr;
    }
    else
    {
        // we don't want to know the senders address

        BytesRead=
            osl_receiveFromSocket((*m_pSockRef)(),
                                   0,
                                   pBuffer,
                                   BufferSize,
                                   (oslSocketMsgFlag)Flag);
    }

    return BytesRead;
}


/*****************************************************************************/
// sendTo
/*****************************************************************************/
sal_Int32 ODatagramSocket::sendTo(const OSocketAddr& ReceiverAddr,
                                const void* pBuffer,
                                sal_uInt32 BufferSize,
                                TSocketMsgFlag Flag)
{
    if (m_pSendTimeout && ! isSendReady(m_pSendTimeout))
        return 0;

    VOS_ASSERT(m_pSockRef && (*m_pSockRef)());

    if ( ( m_pSockRef && (*m_pSockRef)() ) )
    {

        return osl_sendToSocket((*m_pSockRef)(),
                                (oslSocketAddr)ReceiverAddr,
                                pBuffer,
                                BufferSize,
                                (oslSocketMsgFlag)Flag);
    }

    return -1;
}