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