Source/Base/Network/Socket/OSGPointSockConnection.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 //---------------------------------------------------------------------------
  40 //  Includes
  41 //---------------------------------------------------------------------------
  42 #include <cstdlib>
  43 #include <cstdio>
  44 #include <cassert>
  45
  46 #include "OSGConfig.h"
  47 #include "OSGLog.h"
  48 #include "OSGSocketSelection.h"
  49 #include "OSGPointSockConnection.h"
  50 #include "OSGGroupSockConnection.h"
  51 #include "OSGConnectionType.h"
  52
  53 OSG_USING_NAMESPACE
  54
  55 /** \class OSG::PointSockConnection
  56  **/
  57
  58 /*-------------------------------------------------------------------------*/
  59 /*                            constructor destructor                       */
  60
  61 /*! Constructor
  62  */
  63
  64 PointSockConnection::PointSockConnection():
  65      Inherited        (0),
  66     _acceptSocket     ( ),
  67     _socket           ( ),
  68     _remoteAddress    ( ),
  69     _socketReadBuffer ( ),
  70     _socketWriteBuffer( )
  71 {
  72     _acceptSocket.open();
  73     _acceptSocket.setReusePort(true);
  74
  75     _socketReadBuffer.resize(131071);
  76     _socketWriteBuffer.resize( _socketReadBuffer.size() );
  77     // reserve first bytes for buffer size
  78     readBufAdd (&_socketReadBuffer [sizeof(SocketBufferHeader)],
  79                 _socketReadBuffer.size() -sizeof(SocketBufferHeader));
  80     writeBufAdd(&_socketWriteBuffer[sizeof(SocketBufferHeader)],
  81                 _socketWriteBuffer.size()-sizeof(SocketBufferHeader));
  82 }
  83
  84 /*! Destructor
  85  */
  86 PointSockConnection::~PointSockConnection(void)
  87 {
  88     _acceptSocket.close();
  89 }
  90
  91 /*! get connection type
  92  */
  93 const ConnectionType *PointSockConnection::getType()
  94 {
  95     return &_type;
  96 }
  97
  98 /*-------------------------------------------------------------------------*/
  99 /*                            connection                                   */
 100
 101 /*! connect to the given point. If timeout is reached, -1 is
 102     returned
 103  */
 104 Connection::Channel PointSockConnection::connectPoint(
 105     const std::string &address,
 106     Time               timeout)
 107 {
 108     StreamSocket socket;
 109     if(GroupSockConnection::connectSocket( socket,
 110                                            address,
 111                                           _remoteAddress,
 112                                            timeout))
 113     {
 114         _socket = socket;
 115         _pointToPoint = true;
 116         return 0;
 117     }
 118     else
 119     {
 120         return -1;
 121     }
 122 }
 123
 124 /*! connect to the given group. If timeout is reached, -1 is
 125     returned
 126  */
 127 Connection::Channel PointSockConnection::connectGroup(
 128     const std::string &address,
 129     Time               timeout)
 130 {
 131     StreamSocket socket;
 132     if(GroupSockConnection::connectSocket( socket,
 133                                            address,
 134                                           _remoteAddress,
 135                                            timeout))
 136     {
 137         _socket = socket;
 138         _pointToPoint = false;
 139         return 0;
 140     }
 141     else
 142     {
 143         return -1;
 144     }
 145 }
 146
 147 /*! disconnect the given channel
 148  */
 149 void PointSockConnection::disconnect(void)
 150 {
 151     _socket.close();
 152 }
 153
 154 /*! accept an icomming point connection. If timeout is reached,
 155     -1 is returned. If timeout is -1 then wait without timeout
 156  */
 157 Connection::Channel PointSockConnection::acceptPoint(Time timeout)
 158 {
 159     if(GroupSockConnection::acceptSocket(_acceptSocket,
 160                                          _socket,
 161                                          _remoteAddress,
 162                                           timeout))
 163     {
 164         _pointToPoint = true;
 165         return 0;
 166     }
 167     else
 168     {
 169         return -1;
 170     }
 171 }
 172
 173 /*! accept an icomming grop connection. If timeout is reached,
 174     -1 is returned. If timeout is -1 then wait without timeout
 175  */
 176 Connection::Channel PointSockConnection::acceptGroup(Time timeout)
 177 {
 178     if(GroupSockConnection::acceptSocket(_acceptSocket,
 179                                          _socket,
 180                                          _remoteAddress,
 181                                           timeout))
 182     {
 183         _pointToPoint = false;
 184         return 0;
 185     }
 186     else
 187     {
 188         return -1;
 189     }
 190 }
 191
 192 /*! bind the connection to a network interface. The address is
 193     returned, on wich the port could be connected. The interface
 194     is determined by the connection interface filed and the
 195     address parameter. Address can be empty, wich means to use
 196     a free port or address can contain a port number.
 197  */
 198 std::string PointSockConnection::bind(const std::string &address)
 199 {
 200     int         port=0;
 201     char        localhost[256];
 202     char        portStr[256];
 203     std::string interf;
 204
 205     // get local host name
 206     osgGetHostname(localhost,255);
 207     if(!getInterface().empty())
 208         interf = getInterface();
 209     else
 210         interf = localhost;
 211
 212     // parse address
 213     if(!address.empty())
 214         if(sscanf(address.c_str(),"%*[^:]:%d",&port) != 1)
 215             if(sscanf(address.c_str(),":%d",&port) != 1)
 216                 port = 0;
 217     // bind port
 218     _acceptSocket.setReusePort(true);
 219     if(!getInterface().empty())
 220         _acceptSocket.bind(SocketAddress(getInterface().c_str(),port));
 221     else
 222         _acceptSocket.bind(SocketAddress(SocketAddress::ANY,port));
 223
 224     SINFO << "Connection bound to "
 225           << _acceptSocket.getAddress().getHost() << ":"
 226           << _acceptSocket.getAddress().getPort() << std::endl;
 227     _acceptSocket.listen();
 228     // create address
 229     sprintf(portStr,"%d",_acceptSocket.getAddress().getPort());
 230     return interf + ":" + portStr;
 231 }
 232
 233 /*-------------------------------------------------------------------------*/
 234 /*                              channel handling                           */
 235
 236 /*! select the next channel for reading. If timeout is not -1
 237     then -1 is returned if timeout is reached
 238 */
 239 Connection::Channel PointSockConnection::selectChannel(Time timeout)
 240     OSG_THROW (ReadError)
 241 {
 242     try
 243     {
 244         if(_socket.waitReadable(timeout))
 245             return 0;
 246     }
 247     catch(SocketError &e)
 248     {
 249         throw ReadError(e.what());
 250     }
 251     return -1;
 252 }
 253
 254 /*-------------------------------------------------------------------------*/
 255 /*                            sync                                         */
 256
 257 /*! wait for signal
 258  */
 259 bool PointSockConnection::wait(Time timeout) OSG_THROW (ReadError)
 260 {
 261     UInt32 tag;
 262     try
 263     {
 264         if(!_socket.waitReadable(timeout))
 265             return false;
 266         if(!_socket.recv(&tag,sizeof(tag)))
 267             throw ReadError("Channel closed");
 268
 269         tag = osgNetToHost<UInt32>(tag);
 270         if(tag != 314156)
 271         {
 272             FFATAL(("Stream out of sync in SockConnection\n"));
 273             throw ReadError("Stream out of sync");
 274         }
 275     }
 276     catch(SocketError &e)
 277     {
 278         throw ReadError(e.what());
 279     }
 280     return true;
 281 }
 282
 283 /*! send signal
 284  */
 285 void PointSockConnection::signal(void) OSG_THROW (WriteError)
 286 {
 287     UInt32 tag = osgHostToNet<UInt32>(314156);
 288     try
 289     {
 290         _socket.send(&tag,sizeof(tag));
 291     }
 292     catch(SocketError &e)
 293     {
 294         throw WriteError(e.what());
 295     }
 296 }
 297
 298 /*-------------------------- create ---------------------------------------*/
 299
 300 /** \brief create conneciton
 301  */
 302
 303 PointConnection *PointSockConnection::create(void)
 304 {
 305     return new PointSockConnection();
 306 }
 307
 308 /*-------------------------------------------------------------------------*/
 309 /*                              read write                                 */
 310
 311 /** Read data into given memory
 312  *
 313  * Read data form the current read socket. The read socket is that
 314  * socket, that was selectet in selectChannel.
 315  *
 316  **/
 317
 318 void PointSockConnection::read(MemoryHandle mem,UInt32 size)
 319 {
 320     int len;
 321
 322     // read data
 323     len=_socket.recv(mem,size);
 324     if(len==0)
 325     {
 326         throw ReadError("read got 0 bytes!");
 327     }
 328 }
 329
 330 /** Read next data block
 331  *
 332  * The stream connection uses only BinaryDataHandler buffer. If more
 333  * then one buffer is present, then this methode must be changed!
 334  *
 335  */
 336
 337 void PointSockConnection::readBuffer() OSG_THROW (ReadError)
 338 {
 339     int size;
 340     int len;
 341
 342     // read buffer header
 343     len=_socket.recv(&_socketReadBuffer[0],sizeof(SocketBufferHeader));
 344     if(len==0)
 345         throw ReadError("peek got 0 bytes!");
 346     // read remaining data
 347     size=osgNetToHost<UInt32>((reinterpret_cast<SocketBufferHeader*>(&_socketReadBuffer[0]))->size);
 348     len=_socket.recv(&_socketReadBuffer[sizeof(SocketBufferHeader)],
 349                      size);
 350     if(len==0)
 351         throw ReadError("read got 0 bytes!");
 352     readBufBegin()->setDataSize(size);
 353 }
 354
 355 /** Write data to destinations
 356  *
 357  * \param mem   Pointer to data buffer
 358  * \param size  Size of bytes to write
 359  *
 360  **/
 361
 362 void PointSockConnection::write(MemoryHandle mem,UInt32 size)
 363 {
 364     _socket.send(mem,size);
 365 }
 366
 367 /** Write buffer
 368  *
 369  * Write blocksize and data.
 370  *
 371  **/
 372 void PointSockConnection::writeBuffer(void)
 373 {
 374     UInt32 size = writeBufBegin()->getDataSize();
 375
 376     // write size to header
 377     (reinterpret_cast<SocketBufferHeader*>(&_socketWriteBuffer[0]))->size =
 378         osgHostToNet<UInt32>(size);
 379
 380     if(size)
 381     {
 382         // write whole block
 383         _socket.send(&_socketWriteBuffer[0],
 384                      size+sizeof(SocketBufferHeader));
 385     }
 386 }
 387
 388 /*-------------------------------------------------------------------------*/
 389 /*                              static type                                */
 390
 391 ConnectionType PointSockConnection::_type(
 392     &PointSockConnection::create,
 393     "StreamSock");