/**************************************************************
 *
 * 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 occurred */
	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 occurred? */
		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 occurred */
	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 occurred? */
		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;
}