diff --git a/Socket/FileHandle.cci b/Socket/FileHandle.cci
index 62b93049e743d0cfc20a904128671bbf05560c8a..62cbfaf5881abd6fa517ceadeef2f01f8570a449 100644
--- a/Socket/FileHandle.cci
+++ b/Socket/FileHandle.cci
@@ -67,6 +67,11 @@ prefix_ void senf::FileBody::terminate()
}
}
+prefix_ senf::FileHandle senf::FileBody::handle()
+{
+ return FileHandle(ptr(this));
+}
+
prefix_ int senf::FileBody::fd()
const
{
@@ -194,6 +199,10 @@ prefix_ senf::FileHandle::FileHandle(std::auto_ptr<FileBody> body)
: body_(body.release())
{}
+prefix_ senf::FileHandle::FileHandle(FileBody::ptr body)
+ : body_(body)
+{}
+
prefix_ senf::FileBody & senf::FileHandle::body()
{
BOOST_ASSERT(body_);
diff --git a/Socket/FileHandle.hh b/Socket/FileHandle.hh
index 0091552206f1d4c4c9d894e5e779184f8c771a4f..8afbd486fb1af09a0b2ded49a62998cc75b3caf8 100644
--- a/Socket/FileHandle.hh
+++ b/Socket/FileHandle.hh
@@ -182,6 +182,8 @@ namespace senf {
\c new. To configure the FileHandle behavior, A derived class
may provide any class derived from FileBody here. */
+ explicit FileHandle(FileBody::ptr body);
+
FileBody & body(); ///< Access body
FileBody const & body() const; ///< Access body in const context
static FileBody & body(FileHandle & handle); ///< Access body of another FileHandle instance
@@ -192,6 +194,8 @@ namespace senf {
private:
FileBody::ptr body_;
+
+ friend class FileBody;
};
/** \brief Adapt FileHandle to senf::Scheduler
diff --git a/Socket/FileHandle.ih b/Socket/FileHandle.ih
index bd5b1c7efda4df898d5134962535431741af87e7..02c6b71e82ee2555ad46a4a601e80741eff407c2 100644
--- a/Socket/FileHandle.ih
+++ b/Socket/FileHandle.ih
@@ -36,6 +36,7 @@
namespace senf {
+ class FileHandle;
/** \brief FileHandle referenced body
@@ -90,6 +91,8 @@ namespace senf {
///@}
///////////////////////////////////////////////////////////////////////////
+ FileHandle handle();
+
int fd() const;
void fd(int fd);
diff --git a/Socket/Protocols/BSDSocketProtocol.cc b/Socket/Protocols/BSDSocketProtocol.cc
index 56fd6a4af701c579fee5424c0c3bfe3e1aa71a82..543f119a2e6a3baea24e9c1518b7896dac972c36 100644
--- a/Socket/Protocols/BSDSocketProtocol.cc
+++ b/Socket/Protocols/BSDSocketProtocol.cc
@@ -42,7 +42,7 @@ prefix_ std::pair<bool,unsigned> senf::BSDSocketProtocol::linger()
struct linger ling;
socklen_t len = sizeof(ling);
::memset(&ling,sizeof(ling),0);
- if (::getsockopt(body().fd(),SOL_SOCKET,SO_LINGER,&ling,&len) < 0)
+ if (::getsockopt(fd(),SOL_SOCKET,SO_LINGER,&ling,&len) < 0)
throwErrno();
return std::make_pair(ling.l_onoff, ling.l_linger);
}
@@ -53,7 +53,7 @@ prefix_ void senf::BSDSocketProtocol::linger(bool enable, unsigned timeout)
struct linger ling;
ling.l_onoff = enable;
ling.l_linger = timeout;
- if (::setsockopt(body().fd(),SOL_SOCKET,SO_LINGER,&ling,sizeof(ling)) < 0)
+ if (::setsockopt(fd(),SOL_SOCKET,SO_LINGER,&ling,sizeof(ling)) < 0)
throwErrno();
}
@@ -61,7 +61,7 @@ prefix_ struct timeval senf::BSDSocketProtocol::timestamp()
const
{
struct timeval tv;
- if (::ioctl(body().fd(), SIOCGSTAMP, &tv) < 0)
+ if (::ioctl(fd(), SIOCGSTAMP, &tv) < 0)
throwErrno();
return tv;
}
@@ -73,7 +73,7 @@ prefix_ bool senf::AddressableBSDSocketProtocol::reuseaddr()
{
int value;
socklen_t len (sizeof(value));
- if (::getsockopt(body().fd(),SOL_SOCKET,SO_REUSEADDR,&value,&len) < 0)
+ if (::getsockopt(fd(),SOL_SOCKET,SO_REUSEADDR,&value,&len) < 0)
throwErrno();
return value;
}
@@ -82,7 +82,7 @@ prefix_ void senf::AddressableBSDSocketProtocol::reuseaddr(bool value)
const
{
int ivalue (value);
- if (::setsockopt(body().fd(),SOL_SOCKET,SO_REUSEADDR,&ivalue,sizeof(ivalue)) < 0)
+ if (::setsockopt(fd(),SOL_SOCKET,SO_REUSEADDR,&ivalue,sizeof(ivalue)) < 0)
throwErrno();
}
diff --git a/Socket/Protocols/DVB/DVBDemuxHandles.cc b/Socket/Protocols/DVB/DVBDemuxHandles.cc
index c24a40ffb9017b565f91615c52ccf68911d1168b..3d473eca4db2884ee4dff94bdd2828091467fdf8 100644
--- a/Socket/Protocols/DVB/DVBDemuxHandles.cc
+++ b/Socket/Protocols/DVB/DVBDemuxHandles.cc
@@ -45,10 +45,10 @@ prefix_ void senf::DVBDemuxSectionProtocol::init_client(unsigned short adapter,
{
std::string devDemux = str( boost::format(
"/dev/dvb/adapter%d/demux%d") % adapter % device);
- int fd = open(devDemux.c_str(), O_RDONLY | O_NONBLOCK);
- if (fd < 0)
+ int f = open(devDemux.c_str(), O_RDONLY | O_NONBLOCK);
+ if (f < 0)
throwErrno();
- body().fd(fd);
+ fd(f);
}
prefix_ unsigned senf::DVBDemuxSectionProtocol::available()
@@ -66,7 +66,7 @@ prefix_ std::auto_ptr<senf::SocketProtocol> senf::DVBDemuxSectionProtocol::clone
prefix_ void senf::DVBDemuxSectionProtocol::setSectionFilter(struct dmx_sct_filter_params *filter)
const
{
- if (::ioctl(body().fd(), DMX_SET_FILTER, filter) < 0)
+ if (::ioctl(fd(), DMX_SET_FILTER, filter) < 0)
throwErrno();
}
@@ -77,10 +77,10 @@ prefix_ void senf::DVBDemuxPESProtocol::init_client(unsigned short adapter, unsi
{
std::string devDemux = str( boost::format(
"/dev/dvb/adapter%d/demux%d") % adapter % device);
- int fd = open(devDemux.c_str(), O_RDONLY | O_NONBLOCK);
- if (fd < 0)
+ int f = open(devDemux.c_str(), O_RDONLY | O_NONBLOCK);
+ if (f < 0)
throwErrno();
- body().fd(fd);
+ fd(f);
}
prefix_ unsigned senf::DVBDemuxPESProtocol::available()
@@ -98,7 +98,7 @@ prefix_ std::auto_ptr<senf::SocketProtocol> senf::DVBDemuxPESProtocol::clone()
prefix_ void senf::DVBDemuxPESProtocol::setPESFilter(struct dmx_pes_filter_params *filter)
const
{
- if (::ioctl(body().fd(), DMX_SET_PES_FILTER, filter) < 0)
+ if (::ioctl(fd(), DMX_SET_PES_FILTER, filter) < 0)
throwErrno();
}
@@ -109,10 +109,10 @@ prefix_ void senf::DVBDvrProtocol::init_client(unsigned short adapter, unsigned
{
std::string devDvr = str( boost::format(
"/dev/dvb/adapter%d/dvr%d") % adapter % device);
- int fd = open(devDvr.c_str(), O_RDONLY | O_NONBLOCK);
- if (fd < 0)
+ int f = open(devDvr.c_str(), O_RDONLY | O_NONBLOCK);
+ if (f < 0)
throwErrno();
- body().fd(fd);
+ fd(f);
}
prefix_ unsigned senf::DVBDvrProtocol::available()
diff --git a/Socket/Protocols/DVB/DVBDemuxProtocol.cc b/Socket/Protocols/DVB/DVBDemuxProtocol.cc
index 1a2c70e5431ce106483d6cd10172ca9c91a260e1..21745b876b9732ec47d8e9cb3426e9e20f17fef9 100644
--- a/Socket/Protocols/DVB/DVBDemuxProtocol.cc
+++ b/Socket/Protocols/DVB/DVBDemuxProtocol.cc
@@ -41,21 +41,21 @@
prefix_ void senf::DVBDemuxProtocol::setBufferSize(unsigned long size)
const
{
- if (::ioctl(body().fd(), DMX_SET_BUFFER_SIZE, size) < 0)
+ if (::ioctl(fd(), DMX_SET_BUFFER_SIZE, size) < 0)
throwErrno();
}
prefix_ void senf::DVBDemuxProtocol::startFiltering()
const
{
- if (::ioctl(body().fd(), DMX_START) < 0)
+ if (::ioctl(fd(), DMX_START) < 0)
throwErrno();
}
prefix_ void senf::DVBDemuxProtocol::stopFiltering()
const
{
- if (::ioctl(body().fd(), DMX_STOP) < 0)
+ if (::ioctl(fd(), DMX_STOP) < 0)
throwErrno();
}
diff --git a/Socket/Protocols/DVB/DVBFrontendHandle.cc b/Socket/Protocols/DVB/DVBFrontendHandle.cc
index 7b121eb61e7e0f7d66796247e34c0f7cf5b37c18..43dcd1cfd342c59315af4d628e294021c8edc4a2 100644
--- a/Socket/Protocols/DVB/DVBFrontendHandle.cc
+++ b/Socket/Protocols/DVB/DVBFrontendHandle.cc
@@ -45,10 +45,10 @@ prefix_ void senf::DVBFrontendProtocol::init_client(uint8_t adapter, boost::uint
{
std::string devFrontend = str( boost::format(
"/dev/dvb/adapter%d/frontend%d") % adapter % device);
- int fd = open(devFrontend.c_str(), O_RDONLY | O_NONBLOCK);
- if (fd < 0)
+ int f = open(devFrontend.c_str(), O_RDONLY | O_NONBLOCK);
+ if (f < 0)
throwErrno();
- body().fd(fd);
+ fd(f);
}
prefix_ unsigned senf::DVBFrontendProtocol::available()
@@ -73,7 +73,7 @@ prefix_ std::auto_ptr<senf::SocketProtocol> senf::DVBFrontendProtocol::clone()
prefix_ void senf::DVBFrontendProtocol::signalStrength(int16_t *strength)
const
{
- if (::ioctl(body().fd(), FE_READ_SIGNAL_STRENGTH, strength) < 0)
+ if (::ioctl(fd(), FE_READ_SIGNAL_STRENGTH, strength) < 0)
throwErrno();
}
diff --git a/Socket/Protocols/INet/ConnectedRawInetSocketHandle.cc b/Socket/Protocols/INet/ConnectedRawInetSocketHandle.cc
index 3963ccdbc7a376365ae6826f591ce5a41bc30584..79f00cd7a6ef5df3cd75443793db3dd288b86966 100644
--- a/Socket/Protocols/INet/ConnectedRawInetSocketHandle.cc
+++ b/Socket/Protocols/INet/ConnectedRawInetSocketHandle.cc
@@ -47,7 +47,7 @@ senf::ConnectedRawV4SocketProtocol::init_client(int const & protocol)
int sock = ::socket(PF_INET, SOCK_RAW, protocol);
if (sock < 0)
throwErrno();
- body().fd(sock);
+ fd(sock);
}
prefix_ void
@@ -79,7 +79,7 @@ prefix_ void senf::ConnectedRawV6SocketProtocol::init_client(int const & protoco
int sock = ::socket(PF_INET6,SOCK_RAW,protocol);
if (sock < 0)
throwErrno();
- body().fd(sock);
+ fd(sock);
}
prefix_ void
@@ -98,3 +98,15 @@ prefix_ std::auto_ptr<senf::SocketProtocol> senf::ConnectedRawV6SocketProtocol::
///////////////////////////////cc.e////////////////////////////////////////
#undef prefix_
+//#include "ConnectedRawInetSocketHandle.mpp"
+
+
+// Local Variables:
+// mode: c++
+// fill-column: 100
+// comment-column: 40
+// c-file-style: "senf"
+// indent-tabs-mode: nil
+// ispell-local-dictionary: "american"
+// compile-command: "scons -u test"
+// End:
diff --git a/Socket/Protocols/INet/ConnectedUDPSocketHandle.cc b/Socket/Protocols/INet/ConnectedUDPSocketHandle.cc
index ef74194cb7f686caafe154d9961f2a7c101ed699..84b665cafef7931813f70de0160670bf5de9e2b2 100644
--- a/Socket/Protocols/INet/ConnectedUDPSocketHandle.cc
+++ b/Socket/Protocols/INet/ConnectedUDPSocketHandle.cc
@@ -47,7 +47,7 @@ prefix_ void senf::ConnectedUDPv4SocketProtocol::init_client()
int sock = ::socket(PF_INET,SOCK_DGRAM,0);
if (sock < 0)
throwErrno();
- body().fd(sock);
+ fd(sock);
}
prefix_ void
@@ -73,7 +73,7 @@ prefix_ void senf::ConnectedUDPv6SocketProtocol::init_client()
int sock = ::socket(PF_INET6,SOCK_DGRAM,0);
if (sock < 0)
throwErrno();
- body().fd(sock);
+ fd(sock);
}
prefix_ void
diff --git a/Socket/Protocols/INet/INetAddressing.hh b/Socket/Protocols/INet/INetAddressing.hh
index 9fd12817d9a20f651facf93d06d6a56f50cc2e07..e1095fdd381bc320923a6c68f6516dea44f444c3 100644
--- a/Socket/Protocols/INet/INetAddressing.hh
+++ b/Socket/Protocols/INet/INetAddressing.hh
@@ -83,7 +83,7 @@ namespace senf {
INet4Address address() const; ///< Return address
unsigned port() const; ///< Return port number
- bool boolean_test() const; ///< \c true, if address is empty (i.e. 0.0.0.0:0)
+ bool boolean_test() const; ///< \c true, if address is not empty (i.e. 0.0.0.0:0)
void clear(); ///< Clear address/port to 0.0.0.0:0
diff --git a/Socket/Protocols/INet/INetProtocol.cc b/Socket/Protocols/INet/INetProtocol.cc
index 477e9ac8a52449f878bf46434c7440f35eafe17e..6ddc307a12c3fc2a42f6a2cd164f936329f76b0c 100644
--- a/Socket/Protocols/INet/INetProtocol.cc
+++ b/Socket/Protocols/INet/INetProtocol.cc
@@ -41,14 +41,14 @@
prefix_ void senf::IPv4Protocol::connect(INet4SocketAddress const & address)
const
{
- if (::connect(body().fd(),address.sockaddr_p(), address.sockaddr_len()) < 0)
+ if (::connect(fd(),address.sockaddr_p(), address.sockaddr_len()) < 0)
throwErrno();
}
prefix_ void senf::IPv4Protocol::bind(INet4SocketAddress const & address)
const
{
- if (::bind(body().fd(),address.sockaddr_p(), address.sockaddr_len()) < 0)
+ if (::bind(fd(),address.sockaddr_p(), address.sockaddr_len()) < 0)
throwErrno();
}
@@ -59,14 +59,14 @@ prefix_ void senf::IPv4Protocol::bind(INet4SocketAddress const & address)
prefix_ void senf::IPv6Protocol::connect(INet6SocketAddress const & address)
const
{
- if (::connect(body().fd(),address.sockaddr_p(), address.sockaddr_len()) < 0)
+ if (::connect(fd(),address.sockaddr_p(), address.sockaddr_len()) < 0)
throwErrno();
}
prefix_ void senf::IPv6Protocol::bind(INet6SocketAddress const & address)
const
{
- if (::bind(body().fd(),address.sockaddr_p(), address.sockaddr_len()) < 0)
+ if (::bind(fd(),address.sockaddr_p(), address.sockaddr_len()) < 0)
throwErrno();
}
diff --git a/Socket/Protocols/INet/RawInetProtocol.cc b/Socket/Protocols/INet/RawInetProtocol.cc
index 1603bf424daf8fb0d7d985793289d62815d7f3e6..80fe9f7a100e832035050749298638fd9f8f5fe2 100644
--- a/Socket/Protocols/INet/RawInetProtocol.cc
+++ b/Socket/Protocols/INet/RawInetProtocol.cc
@@ -37,7 +37,7 @@ prefix_ unsigned senf::RawInetProtocol::available()
const
{
int n;
- if (::ioctl(body().fd(),SIOCINQ,&n) < 0)
+ if (::ioctl(fd(),SIOCINQ,&n) < 0)
throwErrno();
return n;
}
@@ -47,4 +47,18 @@ prefix_ bool senf::RawInetProtocol::eof()
{
return false;
}
+
+///////////////////////////////cc.e////////////////////////////////////////
#undef prefix_
+//#include "UDPProtocol.mpp"
+
+
+// Local Variables:
+// mode: c++
+// fill-column: 100
+// comment-column: 40
+// c-file-style: "senf"
+// indent-tabs-mode: nil
+// ispell-local-dictionary: "american"
+// compile-command: "scons -u test"
+// End:
diff --git a/Socket/Protocols/INet/RawInetSocketHandle.cc b/Socket/Protocols/INet/RawInetSocketHandle.cc
index 720a785eb695491f690ce7694c86582f63c68cb3..c623ed70cfc5c5dcc78b6371b3f0e287c4f9c18d 100644
--- a/Socket/Protocols/INet/RawInetSocketHandle.cc
+++ b/Socket/Protocols/INet/RawInetSocketHandle.cc
@@ -47,7 +47,7 @@ senf::RawV4SocketProtocol::init_client(int const & protocol)
int sock = ::socket(PF_INET, SOCK_RAW, protocol);
if (sock < 0)
throwErrno();
- body().fd(sock);
+ fd(sock);
}
prefix_ void
@@ -79,7 +79,7 @@ prefix_ void senf::RawV6SocketProtocol::init_client(int const & protocol)
int sock = ::socket(PF_INET6,SOCK_RAW,protocol);
if (sock < 0)
throwErrno();
- body().fd(sock);
+ fd(sock);
}
prefix_ void
@@ -98,3 +98,15 @@ prefix_ std::auto_ptr<senf::SocketProtocol> senf::RawV6SocketProtocol::clone()
///////////////////////////////cc.e////////////////////////////////////////
#undef prefix_
+//#include "RawInetSocketHandle.mpp"
+
+
+// Local Variables:
+// mode: c++
+// fill-column: 100
+// comment-column: 40
+// c-file-style: "senf"
+// indent-tabs-mode: nil
+// ispell-local-dictionary: "american"
+// compile-command: "scons -u test"
+// End:
diff --git a/Socket/Protocols/INet/TCPProtocol.cc b/Socket/Protocols/INet/TCPProtocol.cc
index 79646be488e2c7a46ac7da845f35ccc4884fc25e..c1431e4b13f2b13319ed7b73d55f153db2353b6d 100644
--- a/Socket/Protocols/INet/TCPProtocol.cc
+++ b/Socket/Protocols/INet/TCPProtocol.cc
@@ -44,7 +44,7 @@ prefix_ bool senf::TCPProtocol::nodelay()
{
int value;
socklen_t len (sizeof(value));
- if (::getsockopt(body().fd(),SOL_TCP,TCP_NODELAY,&value,&len) < 0)
+ if (::getsockopt(fd(),SOL_TCP,TCP_NODELAY,&value,&len) < 0)
throwErrno();
return value;
}
@@ -53,7 +53,7 @@ prefix_ void senf::TCPProtocol::nodelay(bool value)
const
{
int ivalue (value);
- if (::setsockopt(body().fd(),SOL_TCP,TCP_NODELAY,&ivalue,sizeof(ivalue)) < 0)
+ if (::setsockopt(fd(),SOL_TCP,TCP_NODELAY,&ivalue,sizeof(ivalue)) < 0)
throwErrno();
}
@@ -61,7 +61,7 @@ prefix_ unsigned senf::TCPProtocol::siocinq()
const
{
int n;
- if (::ioctl(body().fd(),SIOCINQ,&n) < 0)
+ if (::ioctl(fd(),SIOCINQ,&n) < 0)
throwErrno();
return n;
}
@@ -70,7 +70,7 @@ prefix_ unsigned senf::TCPProtocol::siocoutq()
const
{
int n;
- if (::ioctl(body().fd(),SIOCOUTQ,&n) < 0)
+ if (::ioctl(fd(),SIOCOUTQ,&n) < 0)
throwErrno();
return n;
}
@@ -84,7 +84,7 @@ prefix_ unsigned senf::TCPProtocol::available()
prefix_ bool senf::TCPProtocol::eof()
const
{
- return body().readable() && available()==0;
+ return fh().readable() && available()==0;
}
diff --git a/Socket/Protocols/INet/TCPSocketHandle.cc b/Socket/Protocols/INet/TCPSocketHandle.cc
index 082529500025e394573507899fc9b836d75db897..ccc9b78acc8e604c08eb0c3440e01b212ca3ced1 100644
--- a/Socket/Protocols/INet/TCPSocketHandle.cc
+++ b/Socket/Protocols/INet/TCPSocketHandle.cc
@@ -47,7 +47,7 @@ prefix_ void senf::TCPv4SocketProtocol::init_client()
int sock = ::socket(PF_INET,SOCK_STREAM,0);
if (sock < 0)
throwErrno();
- body().fd(sock);
+ fd(sock);
}
prefix_ void
@@ -64,7 +64,7 @@ prefix_ void senf::TCPv4SocketProtocol::init_server()
int sock = ::socket(PF_INET,SOCK_STREAM,0);
if (sock < 0)
throwErrno();
- body().fd(sock);
+ fd(sock);
}
prefix_ void senf::TCPv4SocketProtocol::init_server(INet4SocketAddress const & address,
@@ -74,7 +74,7 @@ prefix_ void senf::TCPv4SocketProtocol::init_server(INet4SocketAddress const & a
init_server();
bind(address);
reuseaddr(true);
- if (::listen(body().fd(),backlog) < 0)
+ if (::listen(fd(),backlog) < 0)
throwErrno();
}
@@ -93,7 +93,7 @@ prefix_ void senf::TCPv6SocketProtocol::init_client()
int sock = ::socket(PF_INET6,SOCK_STREAM,0);
if (sock < 0)
throwErrno();
- body().fd(sock);
+ fd(sock);
}
prefix_ void
@@ -110,7 +110,7 @@ prefix_ void senf::TCPv6SocketProtocol::init_server()
int sock = ::socket(PF_INET6,SOCK_STREAM,0);
if (sock < 0)
throwErrno();
- body().fd(sock);
+ fd(sock);
}
prefix_ void senf::TCPv6SocketProtocol::init_server(INet6SocketAddress const & address,
@@ -120,7 +120,7 @@ prefix_ void senf::TCPv6SocketProtocol::init_server(INet6SocketAddress const & a
init_server();
bind(address);
reuseaddr(true);
- if (::listen(body().fd(),backlog) < 0)
+ if (::listen(fd(),backlog) < 0)
throwErrno();
}
diff --git a/Socket/Protocols/INet/TCPSocketHandle.hh b/Socket/Protocols/INet/TCPSocketHandle.hh
index b6ffa81a4cef91b36b7230eeb5e72ed6a793b0c2..5e11cdd26ebe902e427e28905316c68080e6ea4c 100644
--- a/Socket/Protocols/INet/TCPSocketHandle.hh
+++ b/Socket/Protocols/INet/TCPSocketHandle.hh
@@ -62,16 +62,16 @@ namespace senf {
/** \brief IPv4 TCP Socket Protocol
\par Socket Handle typedefs:
- \ref TCPv4ClientSocketHandle (ProtocolClientSocketHandle), \ref TCPv4ServerSocketHandle
- (ProtocolServerSocketHandle)
-
+ \ref TCPv4ClientSocketHandle (ProtocolClientSocketHandle), \ref TCPv4ServerSocketHandle
+ (ProtocolServerSocketHandle)
+
\par Policy Interface:
- ClientSocketHandle::read(), ClientSocketHandle::write(), ClientSocketHandle::bind(),
- ClientSocketHandle::local(), ClientSocketHandle::connect(), ClientSocketHandle::peer(),
- ClientSocketHandle::rcvbuf(), ClientSocketHandle::sndbuf()
+ ClientSocketHandle::read(), ClientSocketHandle::write(), ClientSocketHandle::bind(),
+ ClientSocketHandle::local(), ClientSocketHandle::connect(), ClientSocketHandle::peer(),
+ ClientSocketHandle::rcvbuf(), ClientSocketHandle::sndbuf()
\par Address Type:
- INet4Address
+ INet4Address
TCPv4SocketProtocol provides an internet protocol stream socket based on the TCP protocol
and IPv4 addressing.
diff --git a/Socket/Protocols/INet/UDPProtocol.cc b/Socket/Protocols/INet/UDPProtocol.cc
index 22f1ac5ccf0dc85f091111ec1337277204c2fcbe..fa3c5e70d4c3be8db47990d1ba37f973b1dac676 100644
--- a/Socket/Protocols/INet/UDPProtocol.cc
+++ b/Socket/Protocols/INet/UDPProtocol.cc
@@ -44,7 +44,7 @@ prefix_ unsigned senf::UDPProtocol::available()
const
{
int n;
- if (::ioctl(body().fd(),SIOCINQ,&n) < 0)
+ if (::ioctl(fd(),SIOCINQ,&n) < 0)
throwErrno();
return n;
}
@@ -60,7 +60,7 @@ prefix_ bool senf::UDPProtocol::mcLoop()
{
int value;
socklen_t len (sizeof(value));
- if (::getsockopt(body().fd(),SOL_IP,IP_MULTICAST_LOOP,&value,&len) < 0)
+ if (::getsockopt(fd(),SOL_IP,IP_MULTICAST_LOOP,&value,&len) < 0)
throwErrno();
return value;
}
@@ -69,7 +69,7 @@ prefix_ void senf::UDPProtocol::mcLoop(bool value)
const
{
int ivalue (value);
- if (::setsockopt(body().fd(),SOL_IP,IP_MULTICAST_LOOP,&ivalue,sizeof(ivalue)) < 0)
+ if (::setsockopt(fd(),SOL_IP,IP_MULTICAST_LOOP,&ivalue,sizeof(ivalue)) < 0)
throwErrno();
}
@@ -80,7 +80,7 @@ prefix_ void senf::UDPProtocol::mcAddMembership(INet4SocketAddress const & mcAdd
mreqn.imr_multiaddr = reinterpret_cast<struct sockaddr_in const *>(mcAddr.sockaddr_p())->sin_addr;
mreqn.imr_address.s_addr = htons(INADDR_ANY);
mreqn.imr_ifindex = 0;
- if (::setsockopt(body().fd(),SOL_IP,IP_ADD_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
+ if (::setsockopt(fd(),SOL_IP,IP_ADD_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
throwErrno();
}
@@ -92,7 +92,7 @@ prefix_ void senf::UDPProtocol::mcAddMembership(INet4SocketAddress const & mcAdd
mreqn.imr_multiaddr = reinterpret_cast<struct sockaddr_in const *>(mcAddr.sockaddr_p())->sin_addr;
mreqn.imr_address = reinterpret_cast<struct sockaddr_in const *>(localAddr.sockaddr_p())->sin_addr;
mreqn.imr_ifindex = 0;
- if (::setsockopt(body().fd(),SOL_IP,IP_ADD_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
+ if (::setsockopt(fd(),SOL_IP,IP_ADD_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
throwErrno();
}
@@ -103,7 +103,7 @@ prefix_ void senf::UDPProtocol::mcDropMembership(INet4SocketAddress const & mcAd
mreqn.imr_multiaddr = reinterpret_cast<struct sockaddr_in const *>(mcAddr.sockaddr_p())->sin_addr;
mreqn.imr_address.s_addr = htons(INADDR_ANY);
mreqn.imr_ifindex = 0;
- if (::setsockopt(body().fd(),SOL_IP,IP_DROP_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
+ if (::setsockopt(fd(),SOL_IP,IP_DROP_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
throwErrno();
}
@@ -115,7 +115,7 @@ prefix_ void senf::UDPProtocol::mcDropMembership(INet4SocketAddress const & mcAd
mreqn.imr_multiaddr = reinterpret_cast<struct sockaddr_in const *>(mcAddr.sockaddr_p())->sin_addr;
mreqn.imr_address = reinterpret_cast<struct sockaddr_in const *>(localAddr.sockaddr_p())->sin_addr;
mreqn.imr_ifindex = 0;
- if (::setsockopt(body().fd(),SOL_IP,IP_DROP_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
+ if (::setsockopt(fd(),SOL_IP,IP_DROP_MEMBERSHIP,&mreqn,sizeof(mreqn)) < 0)
throwErrno();
}
@@ -129,7 +129,7 @@ prefix_ void senf::UDPProtocol::mcIface(std::string const & iface)
if (mreqn.imr_ifindex == 0)
throwErrno(EINVAL);
}
- if (::setsockopt(body().fd(),SOL_IP,IP_MULTICAST_IF,&mreqn,sizeof(mreqn)) < 0)
+ if (::setsockopt(fd(),SOL_IP,IP_MULTICAST_IF,&mreqn,sizeof(mreqn)) < 0)
throwErrno();
}
@@ -138,7 +138,7 @@ prefix_ unsigned senf::UDPProtocol::mcTTL()
{
int value;
socklen_t len (sizeof(value));
- if (::getsockopt(body().fd(),SOL_IP,IP_MULTICAST_TTL,&value,&len) < 0)
+ if (::getsockopt(fd(),SOL_IP,IP_MULTICAST_TTL,&value,&len) < 0)
throwErrno();
return value;
}
@@ -146,7 +146,7 @@ prefix_ unsigned senf::UDPProtocol::mcTTL()
prefix_ void senf::UDPProtocol::mcTTL(unsigned value)
const
{
- if (::setsockopt(body().fd(),SOL_IP,IP_MULTICAST_TTL,&value,sizeof(value)) < 0)
+ if (::setsockopt(fd(),SOL_IP,IP_MULTICAST_TTL,&value,sizeof(value)) < 0)
throwErrno();
}
diff --git a/Socket/Protocols/INet/UDPSocketHandle.cc b/Socket/Protocols/INet/UDPSocketHandle.cc
index 3d7f3d2b57ff913fe4a56dd67c700728281684f3..9079f812d441b6405f2dbf5903b8dd3e5fc91958 100644
--- a/Socket/Protocols/INet/UDPSocketHandle.cc
+++ b/Socket/Protocols/INet/UDPSocketHandle.cc
@@ -47,7 +47,7 @@ prefix_ void senf::UDPv4SocketProtocol::init_client()
int sock = ::socket(PF_INET,SOCK_DGRAM,0);
if (sock < 0)
throwErrno();
- body().fd(sock);
+ fd(sock);
}
prefix_ void
@@ -73,7 +73,7 @@ prefix_ void senf::UDPv6SocketProtocol::init_client()
int sock = ::socket(PF_INET6,SOCK_DGRAM,0);
if (sock < 0)
throwErrno();
- body().fd(sock);
+ fd(sock);
}
prefix_ void
diff --git a/Socket/Protocols/Raw/PacketSocketHandle.cc b/Socket/Protocols/Raw/PacketSocketHandle.cc
index ca9a07a51beb85833ec4aa9e6b905f94900453c5..d0f8e5ae99a41676236228c9923b8ecd1b3beb53 100644
--- a/Socket/Protocols/Raw/PacketSocketHandle.cc
+++ b/Socket/Protocols/Raw/PacketSocketHandle.cc
@@ -51,7 +51,7 @@ prefix_ void senf::PacketProtocol::init_client(SocketType type, int protocol)
int sock = ::socket(PF_PACKET, socktype, htons(protocol));
if (sock < 0)
throwErrno();
- body().fd(sock);
+ fd(sock);
}
prefix_ std::auto_ptr<senf::SocketProtocol> senf::PacketProtocol::clone()
@@ -63,9 +63,9 @@ prefix_ std::auto_ptr<senf::SocketProtocol> senf::PacketProtocol::clone()
prefix_ unsigned senf::PacketProtocol::available()
const
{
- if (! body().readable())
+ if (! fh().readable())
return 0;
- ssize_t l = ::recv(body().fd(),0,0,MSG_PEEK | MSG_TRUNC);
+ ssize_t l = ::recv(fd(),0,0,MSG_PEEK | MSG_TRUNC);
if (l < 0)
throwErrno();
return l;
@@ -100,14 +100,14 @@ prefix_ void senf::PacketProtocol::mcAdd(std::string const & interface,
MACAddress const & address)
const
{
- do_mc(body().fd(),interface,address,true);
+ do_mc(fd(),interface,address,true);
}
prefix_ void senf::PacketProtocol::mcDrop(std::string const & interface,
MACAddress const & address)
const
{
- do_mc(body().fd(),interface,address,false);
+ do_mc(fd(),interface,address,false);
}
///////////////////////////////cc.e////////////////////////////////////////
diff --git a/Socket/Protocols/Raw/TunTapSocketHandle.cc b/Socket/Protocols/Raw/TunTapSocketHandle.cc
index 81ef80d9c3d369014e77647673c9471659e7cac3..80d72bcc2522efa92b35de848bd65905b136bbd4 100644
--- a/Socket/Protocols/Raw/TunTapSocketHandle.cc
+++ b/Socket/Protocols/Raw/TunTapSocketHandle.cc
@@ -48,8 +48,8 @@ prefix_ void senf::TapProtocol::init_client()
prefix_ void senf::TapProtocol::init_client(std::string const & interface_name, bool const NO_PI)
const
{
- int fd;
- if ( (fd = ::open("/dev/net/tun", O_RDWR)) < 0 )
+ int f;
+ if ( (f = ::open("/dev/net/tun", O_RDWR)) < 0 )
throwErrno();
struct ifreq ifr;
::memset( &ifr, 0, sizeof(ifr));
@@ -57,9 +57,9 @@ prefix_ void senf::TapProtocol::init_client(std::string const & interface_name,
if (NO_PI)
ifr.ifr_flags |= IFF_NO_PI;
interface_name.copy( ifr.ifr_name, IFNAMSIZ);
- if (::ioctl(fd, TUNSETIFF, (void *) &ifr) < 0 )
+ if (::ioctl(f, TUNSETIFF, (void *) &ifr) < 0 )
throwErrno();
- body().fd(fd);
+ fd(f);
}
prefix_ std::auto_ptr<senf::SocketProtocol> senf::TapProtocol::clone()
@@ -71,9 +71,9 @@ prefix_ std::auto_ptr<senf::SocketProtocol> senf::TapProtocol::clone()
prefix_ unsigned senf::TapProtocol::available()
const
{
- if (! body().readable())
+ if (! fh().readable())
return 0;
- ssize_t l = ::recv(body().fd(),0,0,MSG_PEEK | MSG_TRUNC);
+ ssize_t l = ::recv(fd(),0,0,MSG_PEEK | MSG_TRUNC);
if (l < 0)
//throwErrno();
return 1588;
diff --git a/Socket/Protocols/UN/UNAddress.cc b/Socket/Protocols/UN/UNAddress.cc
deleted file mode 100644
index feb9570b3c8782fcfa54fc829f21c9aa3b3989ce..0000000000000000000000000000000000000000
--- a/Socket/Protocols/UN/UNAddress.cc
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright (C) 2007
-// Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
-// Kompetenzzentrum NETwork research (NET)
-// David Wagner <david.wagner@fokus.fraunhofer.de>
-//
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the
-// Free Software Foundation, Inc.,
-// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-/** \file
- \brief UNAddress non-inline non-template implementation */
-
-#include "UNAddress.hh"
-//#include "UNAddress.ih"
-
-// Custom includes
-
-//#include "UNAddress.mpp"
-#define prefix_
-///////////////////////////////cc.p////////////////////////////////////////
-
-prefix_ senf::UNAddress::UNAddress()
- //:path("")
-{
- path = "";
-}
-
-prefix_ senf::UNAddress::UNAddress(std::string p)
-{
- path = p;
-}
-
-
-prefix_ senf::UNAddress::UNAddress senf::UNAddress::fromString(std::string & s)
-{
- return senf::UNAddress::UNAddress(s);
-}
-
-
-prefix_ std::string senf::UNAddress::pathString()
- const
-{
- return path;
-}
-
-prefix_ senf::UNAddress::UNAddress senf::UNAddress::clone()
-{
- senf::UNAddress::UNAddress local_addr = senf::UNAddress::UNAddress(pathString());
- return local_addr;
-}
-
-prefix_ std::ostream & senf::operator<<(std::ostream & os, UNAddress const & addr)
-{
- os << addr.pathString();
- return os;
-}
-
-///////////////////////////////cc.e////////////////////////////////////////
-#undef prefix_
-//#include "UNAddress.mpp"
-
-
-// Local Variables:
-// mode: c++
-// fill-column: 100
-// comment-column: 40
-// c-file-style: "senf"
-// indent-tabs-mode: nil
-// ispell-local-dictionary: "american"
-// compile-command: "scons -u test"
-// End:
diff --git a/Socket/Protocols/UN/UNAddress.hh b/Socket/Protocols/UN/UNAddress.hh
deleted file mode 100644
index 1dfdeeabffd50d46051782a6756f09367c4df109..0000000000000000000000000000000000000000
--- a/Socket/Protocols/UN/UNAddress.hh
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright (C) 2007
-// Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
-// Kompetenzzentrum NETwork research (NET)
-// David Wagner <david.wagner@fokus.fraunhofer.de>
-//
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the
-// Free Software Foundation, Inc.,
-// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-/** \file
- \brief UNAddress public header */
-
-#ifndef HH_UNAddress_
-#define HH_UNAddress_ 1
-
-// Custom includes
-#include <string>
-#include <boost/operators.hpp>
-#include "../../../Utils/safe_bool.hh"
-
-//#include "UNAddress.mpp"
-///////////////////////////////hh.p////////////////////////////////////////
-namespace senf {
- /** \brief Unix domain address
-
- UNAddress represents a simple unix domain address which is given by a path to a socket.
- It is modelled as a boost::filesystem::path.
-
- \ingroup addr_group
- */
- class UNAddress
- : public comparable_safe_bool<UNAddress>
- {
- public:
- UNAddress(); ///< Construct an empty address
- explicit UNAddress(std::string);///< Construct an address constant from given path
- static UNAddress fromString(std::string & s); ///< Convert string to address by interpreting the string as path
- UNAddress clone(); ///< Clone object
- std::string pathString() const; ///< Return the path of the address as string
-
- /** \brief Base-class for UNAddress exceptions */
- struct AddressException : public std::exception {};
-
- private:
- std::string path;
- };
-
-std::ostream & operator<<(std::ostream & os, UNAddress const & addr);
-}
-
-///////////////////////////////hh.e////////////////////////////////////////
-//#include "UNAddress.cci"
-//#include "UNAddress.ct"
-//#include "UNAddress.cti"
-#endif
-
-
-// Local Variables:
-// mode: c++
-// fill-column: 100
-// comment-column: 40
-// c-file-style: "senf"
-// indent-tabs-mode: nil
-// ispell-local-dictionary: "american"
-// compile-command: "scons -u test"
-// End:
diff --git a/Socket/Protocols/UN/UNAddress.test.cc b/Socket/Protocols/UN/UNAddress.test.cc
deleted file mode 100644
index d21e706794c2e3d9455f71e6d49da7b6ca7934b4..0000000000000000000000000000000000000000
--- a/Socket/Protocols/UN/UNAddress.test.cc
+++ /dev/null
@@ -1,60 +0,0 @@
-// Copyright (C) 2007
-// Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
-// Kompetenzzentrum NETwork research (NET)
-// David Wagner <david.wagner@fokus.fraunhofer.de>
-//
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation; either version 2 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program; if not, write to the
-// Free Software Foundation, Inc.,
-// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-/** \file
- \brief UNAddress.test unit tests */
-
-//#include "UNAddress.test.hh"
-//#include "UNAddress.test.ih"
-
-// Custom includes
-#include "UNAddress.hh"
-#include <boost/filesystem/path.hpp>
-#include "../../../Utils/auto_unit_test.hh"
-#include <boost/test/test_tools.hpp>
-
-#include <iostream>
-#define prefix_
-///////////////////////////////cc.p////////////////////////////////////////
-
-BOOST_AUTO_UNIT_TEST(unAddress)
-{
-// TODO: muss wieder rein.
-// std::string testS = "/tmp/senfTestSocket";
-// boost::filesystem::path testp = boost::filesystem::path(testS);
-// senf::UNAddress addr1 = senf::UNAddress::fromString(testS);
-// senf::UNAddress addr2 = senf::UNAddress::fromPath(testp);
-// BOOST_CHECK( testS == addr1.pathString());
-// BOOST_CHECK( testS == addr2.pathString());
-}
-
-///////////////////////////////cc.e////////////////////////////////////////
-#undef prefix_
-
-
-// Local Variables:
-// mode: c++
-// fill-column: 100
-// comment-column: 40
-// c-file-style: "senf"
-// indent-tabs-mode: nil
-// ispell-local-dictionary: "american"
-// compile-command: "scons -u test"
-// End:
diff --git a/Socket/Protocols/UN/UNAddressing.cc b/Socket/Protocols/UN/UNAddressing.cc
index 9a98b10b0c39c4a474f6449448b3a64b26f7b7c7..4af13c092583563fc8de8fd008429f660f7b642c 100644
--- a/Socket/Protocols/UN/UNAddressing.cc
+++ b/Socket/Protocols/UN/UNAddressing.cc
@@ -30,55 +30,70 @@
#define prefix_
///////////////////////////////cc.p////////////////////////////////////////
+
+prefix_ senf::UNSocketAddress::UNSocketAddress()
+{}
+
prefix_ senf::UNSocketAddress::UNSocketAddress(std::string p)
{
- sockAddr.sun_family = AF_UNIX;
- strcpy(sockAddr.sun_path, p.c_str());
+ clear();
+ ::strncpy(addr_.sun_path, p.c_str(), sizeof(addr_.sun_path));
+ addr_.sun_path[sizeof(addr_.sun_path)-1] = 0;
}
-prefix_ senf::UNSocketAddress fromString(std::string s) {
+prefix_ senf::UNSocketAddress fromString(std::string s)
+{
return senf::UNSocketAddress::UNSocketAddress(s);
}
+prefix_ bool senf::UNSocketAddress::operator==(UNSocketAddress const & other)
+ const
+{
+ return path() == other.path();
+}
prefix_ std::string senf::UNSocketAddress::path()
const
{
- return std::string(sockAddr.sun_path);
+ return std::string(addr_.sun_path);
}
-prefix_ sockaddr_un senf::UNSocketAddress::sockaddr()
+prefix_ bool senf::UNSocketAddress::boolean_test()
+ const
{
- struct sockaddr_un out;
- out.sun_family = sockAddr.sun_family;
- strncpy(out.sun_path, sockAddr.sun_path, sizeof( out.sun_path));
- return out;
+ return addr_.sun_path[0] != 0;
}
-prefix_ sockaddr * senf::UNSocketAddress::sockaddr_p()
+prefix_ void senf::UNSocketAddress::clear()
{
- return reinterpret_cast <struct sockaddr *> (&sockAddr);
+ ::memset(&addr_, 0, sizeof(addr_));
+ addr_.sun_family = AF_UNIX;
}
+prefix_ sockaddr * senf::UNSocketAddress::sockaddr_p()
+{
+ return reinterpret_cast <struct sockaddr *> (&addr_);
+}
prefix_ sockaddr const * senf::UNSocketAddress::sockaddr_p()
const
{
- return reinterpret_cast <struct sockaddr const *> (&sockAddr);
+ return reinterpret_cast <struct sockaddr const *> (&addr_);
}
prefix_ unsigned senf::UNSocketAddress::sockaddr_len()
const
{
- return sizeof(sockAddr);
+ return sizeof(addr_);
}
-prefix_ std::ostream & operator<<(std::ostream & os, senf::UNSocketAddress::UNSocketAddress const & addr){
+prefix_ std::ostream & operator<<(std::ostream & os,
+ senf::UNSocketAddress::UNSocketAddress const & addr)
+{
os << addr.path();
return os;
}
-
///////////////////////////////cc.e////////////////////////////////////////
#undef prefix_
//#include "UNAddressing.mpp"
diff --git a/Socket/Protocols/UN/UNAddressing.hh b/Socket/Protocols/UN/UNAddressing.hh
index 837adb79a5fd8c3b8090d481e09c9803cb3cd5c4..22e16712022e5b0e59c7ebc10a47a2e46531cf11 100644
--- a/Socket/Protocols/UN/UNAddressing.hh
+++ b/Socket/Protocols/UN/UNAddressing.hh
@@ -36,11 +36,12 @@
#include "../../../Socket/CommunicationPolicy.hh"
#include "../../../Socket/Protocols/GenericAddressingPolicy.hh"
#include "../../../Utils/safe_bool.hh"
-#include "UNAddress.hh"
//#include "UNAddressing.mpp"
///////////////////////////////hh.p////////////////////////////////////////
+
namespace senf {
+
/** \brief Unix domain socket address
UNSocketAddress wraps the standard sockaddr_un datatype. It provides simple accessor methods
@@ -49,26 +50,37 @@ namespace senf {
\implementation This implementation is based on sockaddr_un.
\ingroup addr_group
+
+ \fixme Why both std::string constructor and from_string member ?
*/
class UNSocketAddress
: public comparable_safe_bool<UNSocketAddress>
{
public:
-
- //UNSocketAddress();
+ UNSocketAddress();
explicit UNSocketAddress(std::string p);
///< Construct an address constant from given path
- static UNSocketAddress from_string(std::string const s); ///< Create UNSocketAddress from string
- std::string path() const ; ///< Return path as string
- struct sockaddr_un sockaddr();
+ static UNSocketAddress from_string(std::string const s);
+ ///< Create UNSocketAddress from string
+
+ bool operator==(UNSocketAddress const & other) const;
+ ///< Compare UNSocketAddress for equality
+
+ std::string path() const ; ///< Return path as string
+
+ bool boolean_test() const; ///< \c true, if address is not empty
+
+ void clear(); ///< Clear address
+
struct sockaddr * sockaddr_p() ;
struct sockaddr const * sockaddr_p() const;
unsigned sockaddr_len() const;
+
private:
- struct sockaddr_un sockAddr;
+ struct sockaddr_un addr_;
};
- /** \brief Write path os
+ /** \brief Write path to os
\related UNSocketAddress
*/
@@ -100,7 +112,10 @@ namespace senf {
using GenericAddressingPolicy<UNSocketAddress>::connect;
using GenericAddressingPolicy<UNSocketAddress>::bind;
};
+
+ ///@}
}
+
///////////////////////////////hh.e////////////////////////////////////////
//#include "UNAddressing.cci"
//#include "UNAddressing.ct"
diff --git a/Socket/Protocols/UN/UNDatagramSocketHandle.cc b/Socket/Protocols/UN/UNDatagramSocketHandle.cc
index a91f49e535f2bcdeb28c99bb213eb05a9945248c..4d21aec01746d07ea46e3124bdba6804958a7173 100644
--- a/Socket/Protocols/UN/UNDatagramSocketHandle.cc
+++ b/Socket/Protocols/UN/UNDatagramSocketHandle.cc
@@ -40,7 +40,7 @@ prefix_ void senf::UNDatagramSocketProtocol::init_client() const
int sock = ::socket(PF_UNIX,SOCK_DGRAM,0);
if (sock < 0)
throwErrno();
- body().fd(sock);
+ fd(sock);
}
prefix_ void senf::UNDatagramSocketProtocol::init_client(UNSocketAddress const & address) const
diff --git a/Socket/Protocols/UN/UNDatagramSocketHandle.hh b/Socket/Protocols/UN/UNDatagramSocketHandle.hh
index 30e7b6b459b2176a838a7698df42f9c71237070f..606c43bb4499b094ed06ce9d753d727e981550e3 100644
--- a/Socket/Protocols/UN/UNDatagramSocketHandle.hh
+++ b/Socket/Protocols/UN/UNDatagramSocketHandle.hh
@@ -64,11 +64,11 @@ namespace senf {
\par Address Type:
UNAddress
- UNDatagramSocketProtocol provides an datagram protocol socket based on the unix domain addressing.
-
- This class is utilized as the protocol class of the ProtocolClientSocketHandle
- via the Socket Handle typedefs above.
+ UNDatagramSocketProtocol provides an datagram protocol socket based on the unix domain
+ addressing.
+ This class is utilized as the protocol class of the ProtocolClientSocketHandle via the
+ Socket Handle typedefs above.
*/
class UNDatagramSocketProtocol
: public ConcreteSocketProtocol<UNDatagramSocket_Policy>,
@@ -106,6 +106,8 @@ namespace senf {
typedef ProtocolClientSocketHandle<UNDatagramSocketProtocol> UNDatagramClientSocketHandle;
+ ///@}
+
}
///////////////////////////////hh.e////////////////////////////////////////
//#include "UNDatagramSocketHandle.cci"
diff --git a/Socket/Protocols/UN/UNProtocol.cc b/Socket/Protocols/UN/UNProtocol.cc
index 7e2f49ebf8ce59691aff1c5aa17135c8fda56fab..c0bab258becb77150cc80316b0240b0092ad7438 100644
--- a/Socket/Protocols/UN/UNProtocol.cc
+++ b/Socket/Protocols/UN/UNProtocol.cc
@@ -38,7 +38,7 @@ prefix_ unsigned senf::UNProtocol::available()
const
{
int n;
- if (::ioctl(body().fd(),SIOCINQ,&n) < 0)
+ if (::ioctl(fd(),SIOCINQ,&n) < 0)
throwErrno();
return n;
}
@@ -52,14 +52,14 @@ prefix_ bool senf::UNProtocol::eof()
prefix_ void senf::UNProtocol::connect(UNSocketAddress const & address)
const
{
- if(::connect(body().fd(), address.sockaddr_p(), sizeof(sockaddr_un)) < 0)
+ if(::connect(fd(), address.sockaddr_p(), sizeof(sockaddr_un)) < 0)
throwErrno();
}
prefix_ void senf::UNProtocol::bind(UNSocketAddress const & address)
const
{
- if(::bind(body().fd(), address.sockaddr_p(), sizeof(sockaddr_un)) < 0)
+ if(::bind(fd(), address.sockaddr_p(), sizeof(sockaddr_un)) < 0)
throwErrno();
}
@@ -85,27 +85,35 @@ prefix_ void senf::UNProtocol::terminate()
prefix_ void senf::UNProtocol::check_and_unlink()
const
{
-// struct sockaddr_un test;
-// socklen_t len;
-// memset( (char*)&test, 0xff, sizeof( test));
-// int fd = inputSocket.fd() ;
-//// printf( "fd: %d\n", fd);
-//
-// int r = getsockname( fd, (struct sockaddr *)&test, &len);
-// if( r < 0){
-// perror( "bla:");
-// }
-// else{
-// printf( "name: %d %d %s\n", r, len , test.sun_path);
-// unsigned char *p = (unsigned char*) &test;for( r=0; r< len; r++) printf( "%2.2x ", (int)(p[r])); printf ("\n");
-// }
- struct sockaddr_un test;
- socklen_t len = sizeof( test);
- int r = ::getsockname( body().fd(), (struct sockaddr *)&test, &len);
- if( r == 0 && ::strlen(test.sun_path) > 0){
- ::unlink( test.sun_path);
+ typedef ClientSocketHandle<MakeSocketPolicy<UNAddressingPolicy>::policy> UNSocketHandle;
+ try {
+ UNSocketAddress una (static_socket_cast<UNSocketHandle>(fh()).local());
+ ::unlink(una.path().c_str());
+ }
+ catch (SystemException & e) {
}
}
+
+// // struct sockaddr_un test;
+// // socklen_t len;
+// // memset( (char*)&test, 0xff, sizeof( test));
+// // int fd = inputSocket.fd() ;
+// //// printf( "fd: %d\n", fd);
+// //
+// // int r = getsockname( fd, (struct sockaddr *)&test, &len);
+// // if( r < 0){
+// // perror( "bla:");
+// // }
+// // else{
+// // printf( "name: %d %d %s\n", r, len , test.sun_path);
+// // unsigned char *p = (unsigned char*) &test;for( r=0; r< len; r++) printf( "%2.2x ", (int)(p[r])); printf ("\n");
+// // }
+// struct sockaddr_un test;
+// socklen_t len = sizeof( test);
+// int r = ::getsockname(fd(), (struct sockaddr *)&test, &len);
+// if( r == 0 && ::strlen(test.sun_path) > 0){
+// ::unlink( test.sun_path);
+// }
///////////////////////////////cc.e////////////////////////////////////////
#undef prefix_
diff --git a/Socket/Protocols/UN/all_includes.hh b/Socket/Protocols/UN/all_includes.hh
deleted file mode 100644
index 16d8a1ff64a0cf85cd068b8c3437d374fadc4e53..0000000000000000000000000000000000000000
--- a/Socket/Protocols/UN/all_includes.hh
+++ /dev/null
@@ -1,4 +0,0 @@
-#include "UNAddress.hh"
-#include "UNAddressing.hh"
-#include "UNDatagramSocketHandle.hh"
-#include "UNProtocol.hh"
diff --git a/Socket/SocketHandle.cc b/Socket/SocketHandle.cc
index 3878a362c77c57d833ad09716d45ce5022a9113e..64735f2d227f3485be058d34555ab68db6d42308 100644
--- a/Socket/SocketHandle.cc
+++ b/Socket/SocketHandle.cc
@@ -54,11 +54,11 @@ prefix_ bool senf::SocketBody::v_eof()
prefix_ void senf::SocketBody::state(SocketStateMap & map, unsigned lod)
{
- map["file.handle"] = fd();
- map["file.refcount"] = refcount();
- map["socket.server"] = isServer();
- map["socket.protocol"] = prettyName(typeid(protocol()));
- map["socket.policy"] = prettyName(typeid(protocol().policy()));
+ map["file.handle"] << fd();
+ map["file.refcount"] << refcount();
+ map["socket.server"] << isServer();
+ map["socket.protocol"] << prettyName(typeid(protocol()));
+ map["socket.policy"] << prettyName(typeid(protocol().policy()));
protocol().state(map,lod);
}
diff --git a/Socket/SocketHandle.cci b/Socket/SocketHandle.cci
index a465f19bf7baed0346cea45e41144c53f91e14a5..20d3a9d687eec1ac6c983d3e30a86d71ddfc6a27 100644
--- a/Socket/SocketHandle.cci
+++ b/Socket/SocketHandle.cci
@@ -61,14 +61,12 @@ prefix_ bool senf::SocketBody::isServer()
}
///////////////////////////////////////////////////////////////////////////
-// senf::detail::ConvertibleString
+// senf::detail::StreamableString
-prefix_ senf::detail::ConvertibleString::ConvertibleString()
-{}
-
-prefix_ senf::detail::ConvertibleString::ConvertibleString(bool v)
- : std::string(v ? "true" : "false")
-{}
+prefix_ senf::detail::StreamableString & senf::detail::StreamableString::operator<<(bool v)
+{
+ return (*this) << std::string(v ? "true" : "false");
+}
///////////////////////////////cci.e///////////////////////////////////////
#undef prefix_
diff --git a/Socket/SocketHandle.ct b/Socket/SocketHandle.ct
index 96c5b131d8fdaa01e1e8f430291ba2548cfb2108..56f93461999b1ad8df7adb3b2287f58f1dbc4a0c 100644
--- a/Socket/SocketHandle.ct
+++ b/Socket/SocketHandle.ct
@@ -32,13 +32,16 @@
#define prefix_
///////////////////////////////ct.p////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+// senf::detail::StreamableString
+
template <class T>
-prefix_ senf::detail::ConvertibleString &
-senf::detail::ConvertibleString::operator+=(ConvertibleString const & other)
+prefix_ senf::detail::StreamableString &
+senf::detail::StreamableString::operator<<(T const & other)
{
if (!empty())
- this->std::string::operator+=(", ");
- this->std::string::operator+=(other);
+ (*this) += ", ";
+ (*this) += boost::lexical_cast<std::string>(other);
return *this;
}
diff --git a/Socket/SocketHandle.cti b/Socket/SocketHandle.cti
index aa618bcb8b1cfe36c68cbe43a90e7bef7bd73afd..604f45650b53428f8c65b12d6494f8711d02694f 100644
--- a/Socket/SocketHandle.cti
+++ b/Socket/SocketHandle.cti
@@ -169,7 +169,7 @@ prefix_ void senf::SocketHandle<SocketPolicy>::state(SocketStateMap & map, unsig
// automatically include the SocketPolicy template parameter in
// the type name and therefore show the \e static policy of the
// socket handle.
- map["handle"] = prettyName(typeid(*this));
+ map["handle"] << prettyName(typeid(*this));
body().state(map,lod);
}
@@ -181,14 +181,6 @@ prefix_ std::string senf::SocketHandle<SocketPolicy>::dumpState(unsigned lod)
return detail::dumpState(map);
}
-///////////////////////////////////////////////////////////////////////////
-// senf::detail::ConvertibleString
-
-template <class T>
-prefix_ senf::detail::ConvertibleString::ConvertibleString(T const & other)
- : std::string(boost::lexical_cast<std::string>(other))
-{}
-
///////////////////////////////cti.e///////////////////////////////////////
#undef prefix_
diff --git a/Socket/SocketHandle.hh b/Socket/SocketHandle.hh
index 808b3c1ba9835a028f81e9a8e0344209b3f79a58..be6e23af43bd4005a731d2b785be04cf71807151 100644
--- a/Socket/SocketHandle.hh
+++ b/Socket/SocketHandle.hh
@@ -126,8 +126,8 @@ namespace senf {
\param map string to string mapping to be filled with
state information
- \param lod level of detail requested. The interpretation
- of this value is protocol specific
+ \param lod level of detail requested. The
+ interpretation of this value is protocol specific
\implementation This member will be re-implemented in
every derived class. This is very important since
@@ -139,9 +139,9 @@ namespace senf {
/**< Formats the complete state map value and returns it as
a single multi-line string.
- param lod level of detail requested. The interpretation
- of this value is protocol specific
-
+ \param lod level of detail requested. The
+ interpretation of this value is protocol specific
+
\implementation This member will be re-implemented in
every derived class. See the state()
documentation. */
@@ -169,8 +169,7 @@ namespace senf {
\param isChecked has to be \c true
\todo Answer, why the heck I need the \c isChecked
- parameter ??
- */
+ parameter ?? */
SocketBody & body(); ///< Access socket body
/**< This member replaces the corresponding FileHandle
diff --git a/Socket/SocketHandle.ih b/Socket/SocketHandle.ih
index 5e9fae41cf89c3098647aab466e605d41db62b03..3e3663a3226145be17df2811069da5d91636a68c 100644
--- a/Socket/SocketHandle.ih
+++ b/Socket/SocketHandle.ih
@@ -44,8 +44,8 @@ namespace senf {
/** \brief String supporting automatic type conversion
- The ConvertibleString class is used to simplify creating a text representation of
- arbitrary values. ConvertibleString is an ordinary string with an additional constructor
+ The StreamableString class is used to simplify creating a text representation of
+ arbitrary values. StreamableString is an ordinary string with an additional constructor
which allows constructing the string from any arbitrary, streamable type.
\note It is generally not advisable to derive from the standard library container
@@ -53,36 +53,30 @@ namespace senf {
additional functionality is added. It is absolutely safe to convert the derived class
back to the base type.
*/
- class ConvertibleString : public std::string
+ class StreamableString : public std::string
{
public:
- ConvertibleString();
- ConvertibleString(bool v); ///< Bool conversion constructor
- /**< The bool conversion is defined explicitly to use a
- specialized representation (the strings 'true' and
- 'false') */
- template <class T>
- ConvertibleString(T const & other);
- ///< Conversion constructor
- /**< This constructor will assign the string from any
- arbitrary type. It will use boost::lexical_cast to
- convert the argument to its string representation. */
+ using std::string::operator=;
template <class T>
- ConvertibleString & operator+= (ConvertibleString const & other);
- ///< Add additional values with separator
- /**< This operator facilitates the representation of
- multiple values in a single string. Each value is first
- converted to a string (using the type conversion
- machinery of C++ and the ConvertibleString conversion
- constructors). It is then appended to the current string
- with ', ' as a separator (if the current string is
- non-empty). */
+ StreamableString & operator<<(T const & other);
+ ///< Value assigment
+ /**< This operator will assign the string from any
+ arbitrary type. It will use boost::lexical_cast to
+ convert the argument to its string representation.
+
+ If the string is non-empty, an additional separating
+ comma is added to the string. */
+
+ StreamableString & operator<<(bool v); ///< Bool assignment
+ /**< The bool assignment is defined explicitly to use a
+ specialized representation (the strings 'true' and
+ 'false'). */
};
}
- typedef std::map< std::string, detail::ConvertibleString > SocketStateMap;
+ typedef std::map< std::string, detail::StreamableString > SocketStateMap;
namespace detail {
/** \brief Helper to convert SocketStateMap to multiline string representation
diff --git a/Socket/SocketPolicy.ct b/Socket/SocketPolicy.ct
index 6a56e31c76bb4596e8ea136ecdbb24b1515c00f9..3488d53f85f38a4db821a1579412ff508dfab6e3 100644
--- a/Socket/SocketPolicy.ct
+++ b/Socket/SocketPolicy.ct
@@ -41,8 +41,13 @@ checkBaseOf(SocketPolicyBase const & other)
// check, wether each policy of other is (dynamically!) convertible
// to the corresponding (static) policy of this class. Throws
// std::bad_cast on failure
-# define SP_CheckPolicy(x1,x2,SomePolicy) (void) dynamic_cast<BOOST_PP_CAT(SomePolicy,_) const &>(other.BOOST_PP_CAT(the,SomePolicy)());
+
+# define SP_CheckPolicy(x1,x2,SomePolicy) \
+ (void) dynamic_cast<BOOST_PP_CAT(SomePolicy,_) const &>( \
+ other.BOOST_PP_CAT(the,SomePolicy)());
+
BOOST_PP_SEQ_FOR_EACH( SP_CheckPolicy, , SENF_SOCKET_POLICIES )
+
# undef SP_CheckPolicy
}
diff --git a/Socket/SocketPolicy.hh b/Socket/SocketPolicy.hh
index e4cf253741eb77f33647f2f17ef3f8c50c97e6f2..859686e92be9c8310115fda39908aa67f01de3d9 100644
--- a/Socket/SocketPolicy.hh
+++ b/Socket/SocketPolicy.hh
@@ -505,10 +505,15 @@ namespace senf {
{
/** \brief Check dynamic policy compatibility
- This method will check the socket policy \a other against this policy. It will check,
- whether \a other is a base policy (or the same) of this policy. This check is done
- against the \e dynamic type of \a other using RTTI. It will throw \c std::bad_cast, if
- the policy is not compatible.
+ This check will validate, that a socket with \a other as it's policy is convertible to a
+ socket with the current SocketPolicy as it's policy. This is true, if for each policy
+ axis, the policy class of that axis as defined in the \a other policy is convertible to
+ the policy class of that same axis in the current SocketPolicy instance (as is defined
+ by the template arguments). This again is true, if the \a other policy class is derived
+ from (or is the same as) the policy class taken from the current SocketPolicy instance.
+
+ In other words, this call checks, that the current SocketPolicy (as defined via the
+ template arguments) is more generic than the \a other socket policy.
\param[in] other SocketPolicy to check
\throws std::bad_cast if \a other is not a compatible policy
diff --git a/Socket/SocketProtocol.cci b/Socket/SocketProtocol.cci
index 7ecf0b04c83155e4587b7630aaf56c25753ed51c..1a55451f10fd8ff055f8478b7640a21105694921 100644
--- a/Socket/SocketProtocol.cci
+++ b/Socket/SocketProtocol.cci
@@ -32,6 +32,28 @@
#define prefix_ inline
///////////////////////////////cci.p///////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+// senf::SocketProtocol
+
+prefix_ senf::FileHandle senf::SocketProtocol::fh()
+ const
+{
+ return body().handle();
+}
+
+prefix_ int senf::SocketProtocol::fd()
+ const
+{
+ return body().fd();
+}
+
+prefix_ void senf::SocketProtocol::fd(int fd)
+ const
+{
+ BOOST_ASSERT(! body().valid());
+ body().fd(fd);
+}
+
prefix_ senf::SocketProtocol::SocketProtocol()
: body_(0)
{}
diff --git a/Socket/SocketProtocol.cti b/Socket/SocketProtocol.cti
index df1c8234603fad3ec3305effa5ff9b375917210b..c474949e1729be2aa87bd62c04e291a8eee98147 100644
--- a/Socket/SocketProtocol.cti
+++ b/Socket/SocketProtocol.cti
@@ -31,6 +31,9 @@
#define prefix_ inline
///////////////////////////////cti.p///////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+// senf::ConcreteSocketProtocol<SocketPolicy>
+
template <class SocketPolicy>
prefix_ senf::ConcreteSocketProtocol<SocketPolicy>::~ConcreteSocketProtocol()
{}
diff --git a/Socket/SocketProtocol.hh b/Socket/SocketProtocol.hh
index f2046c8169d086222f485a52574a18f6b4be157f..5ca81dbf8c9810a2dcfbf6c73945e9a34717298f 100644
--- a/Socket/SocketProtocol.hh
+++ b/Socket/SocketProtocol.hh
@@ -147,11 +147,6 @@ namespace senf {
///@}
///////////////////////////////////////////////////////////////////////////
- SocketBody & body() const; ///< Access the socket body
- /**< \todo we don't need body(), we should better provide a
- handle() member which will return a simple FIleHandle
- object (we cannot return some other derived class since
- we don't know the Protocol or Policy at this point) */
virtual SocketPolicyBase const & policy() const = 0;
///< Access the policy instance
@@ -165,15 +160,25 @@ namespace senf {
\attention This member must be implemented in every \e
leaf protocol class to return a new instance of the
appropriate type. */
+
virtual unsigned available() const = 0;
///< Return number of bytes available for reading without
///< blocking
/**< This member will check in a (very, sigh) protocol
- dependent way, how many bytes are guaranteed to be
- readable from the socket without blocking even if the
- socket is blocking. If the socket does not support
- reading (viz. NotReadablePolicy is set), this member
- should always return \c 0.*/
+ dependent way, how many bytes may be read from a socket
+ in a single (non-blocking) read operation. If the
+ socket does not support reading (viz. NotReadablePolicy
+ is set), this member should always return \c 0.
+
+ Depending on the protocol, it may not be possible to
+ return a good value. In this case, an upper bound may
+ be returned (e.g.: When reading from a socket which
+ returns ethernet frames, returning 1500 from
+ available() is ok). However, this should only be done
+ as a last resort. Also beware, that this number should
+ not be to large since the socket layer will always need
+ to allocate that number of bytes for the data to be
+ read. */
virtual bool eof() const = 0; ///< Check for end-of-file condition
/**< This is another check which (like available()) is
@@ -186,12 +191,13 @@ namespace senf {
/**< This override will automatically \c shutdown() the
socket whenever it is closed.
\throws senf::SystemException */
+
virtual void terminate() const; ///< Forcibly close socket
/**< This override will automatically \c shutdown() the
socket whenever it is called. Additionally it will
disable SO_LINGER to ensure, that v_terminate will not
block. Like the overriden method, this member will ignore
- failures and will never throw. It therefore safe to be
+ failures and will never throw. It is therefore safe to be
called from a destructor. */
virtual void state(SocketStateMap & map, unsigned lod) const;
@@ -221,23 +227,43 @@ namespace senf {
assigning non-string values to the map:
\code
- map["socket.protocol.ip.address"] = peer();
- map["socket.protocol.tcp.backlog"] = backlog();
+ map["socket.protocol.ip.address"] << peer();
+ map["socket.protocol.tcp.backlog"] << backlog();
\endcode
This will work even if peer() returns an ip-address
object or backlog() returns an integer. The values are
automatically converted to their string representation.
- The operator "+=" also has been reimplemented to
- simplify adding multiple values to a single entry: It
- will automatically add a ", " separator if the string
- is non-empty. */
+ Additionally, if the slot the date is written to is not
+ empty, the <tt>\<\<</tt> operator will add add a comma
+ as separator. */
protected:
+ FileHandle fh() const; ///< Get a FileHandle for this instance
+ /**< This member will re turn a FileHandle instance for this
+ protocol instance. You may cast this FileHandle
+ instance to a ClientSocketHandle / ServerSocketHandle
+ as long as you know some of the socket policy using
+ static_socket_cast or dynamic_socket_cast */
+
+ int fd() const; ///< Get file descriptor
+ /**< Returns the file descriptor this protocol instance
+ references. This is the same as <tt>fh().fd()</tt> but
+ is implemented here since it is needed so often. */
+
+ void fd(int) const; ///< Initialize file descriptor
+ /**< Assigns the file descriptor to the file handle, this
+ protocol instance references. Only valid, if the file
+ handle has not yet been assigned any descriptor (To
+ change the file descriptor association later, use \c
+ ::dup2()). */
private:
// backpointer to owning SocketBody instance
+
+ SocketBody & body() const;
+
SocketBody * body_;
friend class SocketBody;
};