nevrax.org : docs

00001 
00007 /* Copyright, 2001 Nevrax Ltd.
00008  *
00009  * This file is part of NEVRAX NEL.
00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
00011  * it under the terms of the GNU General Public License as published by
00012  * the Free Software Foundation; either version 2, or (at your option)
00013  * any later version.
00014 
00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00018  * General Public License for more details.
00019 
00020  * You should have received a copy of the GNU General Public License
00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00023  * MA 02111-1307, USA.
00024  */
00025 
00026 #include "stdnet.h"
00027 
00028 #include "nel/misc/hierarchical_timer.h"
00029 
00030 #include "nel/net/buf_sock.h"
00031 #include "nel/net/buf_server.h"
00032 
00033 #ifdef NL_OS_WINDOWS
00034 #include <winsock2.h>
00035 #elif defined NL_OS_UNIX
00036 #include <netinet/in.h>
00037 #endif
00038 
00039 using namespace NLMISC;
00040 using namespace std;
00041 
00042 
00043 namespace NLNET {
00044 
00045 
00046 NLMISC::CMutex nettrace_mutex("nettrace_mutex");
00047 
00048 
00049 /*
00050  * Constructor
00051  */
00052 CBufSock::CBufSock( CTcpSock *sock ) :
00053         SendNextValue(0),
00054         ReceiveNextValue(0),
00055         Sock( sock ),
00056         _KnowConnected( false ),
00057         _LastFlushTime( 0 ),
00058         _TriggerTime( 20 ),
00059         _TriggerSize( -1 ),
00060         _RTSBIndex( 0 ),
00061         _AppId( 0 ),
00062         _ConnectedState( false )
00063 {
00064         nlnettrace( "CBufSock::CBufSock" ); // don't define a global object
00065 
00066         if ( Sock == NULL )
00067           {
00068                 Sock = new CTcpSock();
00069           }
00070 
00071 #ifdef NL_DEBUG
00072         _FlushTrigger = FTManual;
00073 #endif
00074         _LastFlushTime = CTime::getLocalTime();
00075 }
00076 
00077 
00078 /*
00079  * Destructor
00080  */
00081 CBufSock::~CBufSock()
00082 {
00083         nlassert (this != InvalidSockId);       // invalid bufsock
00084 
00085         nlnettrace( "CBufSock::~CBufSock" );
00086         
00087         delete Sock; // the socket disconnects automatically if needed
00088         
00089         // destroy the structur to be sure that other people will not access to this anymore
00090         AuthorizedCallback = "";
00091         Sock = NULL;
00092         _KnowConnected = false;
00093         _LastFlushTime = 0;
00094         _TriggerTime = 0;
00095         _TriggerSize = 0;
00096         _ReadyToSendBuffer.clear ();
00097         _RTSBIndex = 0;
00098         _AppId = 0;
00099         _ConnectedState = false;
00100 }
00101 
00102 
00103 /*
00104  * Returns a readable string from a vector of bytes, beginning from pos, limited to 'len' characters. '\0' are replaced by ' '
00105  */
00106 string stringFromVectorPart( const vector<uint8>& v, uint32 pos, uint32 len )
00107 {
00108         nlassertex( pos+len <= v.size(), ("pos=%u len=%u size=%u", pos, len, v.size()) );
00109 
00110         string s;
00111         if ( (! v.empty()) && (len!=0) )
00112         {
00113                 // Copy contents
00114                 s.resize( len );
00115                 memcpy( &*s.begin(), &*v.begin()+pos, len );
00116 
00117                 // Replace '\0' characters
00118                 string::iterator is;
00119                 for ( is=s.begin(); is!=s.end(); ++is )
00120                 {
00121                         if ( ! isprint((uint8)(*is)) || (*is) == '%' )
00122                         {
00123                                 (*is) = '?';
00124                         }
00125                 }
00126         }
00127 
00128         return s;
00129 }
00130 
00131 
00132 /*
00133  * Force to send all data pending in the send queue
00134  * Note: this method is used by clients (blocking sockets) and servers (non-blocking sockets)
00135  * so it works in both cases.
00136  * Precond: the send queue should not contain an empty block
00137  */
00138 bool CBufSock::flush()
00139 {
00140         nlassert (this != InvalidSockId);       // invalid bufsock
00141         //nlnettrace( "CBufSock::flush" );
00142 
00143         // Copy data from the send queue to _ReadyToSendBuffer
00144         TBlockSize netlen;
00145 //      vector<uint8> tmpbuffer;
00146 
00147         // Process each element in the send queue
00148         while ( ! SendFifo.empty() )
00149         {
00150                 uint8 *tmpbuffer;
00151                 uint32 size;
00152                 SendFifo.front( tmpbuffer, size );
00153 
00154                 // Compute the size and add it into the beginning of the buffer
00155                 netlen = htonl( (TBlockSize)size );
00156                 uint32 oldBufferSize = _ReadyToSendBuffer.size();
00157                 _ReadyToSendBuffer.resize (oldBufferSize+sizeof(TBlockSize)+size);
00158                 *(TBlockSize*)&(_ReadyToSendBuffer[oldBufferSize])=netlen;
00159 
00160                 // Append the temporary buffer to the global buffer
00161                 CFastMem::memcpy (&_ReadyToSendBuffer[oldBufferSize+sizeof(TBlockSize)], tmpbuffer, size);
00162                 SendFifo.pop();
00163         }
00164 
00165         // Actual sending of _ReadyToSendBuffer
00166         //if ( ! _ReadyToSendBuffer.empty() )
00167         if ( _ReadyToSendBuffer.size() != 0 )
00168         {               
00169                 // Send
00170                 CSock::TSockResult res;
00171                 TBlockSize len = _ReadyToSendBuffer.size() - _RTSBIndex;
00172 
00173                 res = Sock->send( _ReadyToSendBuffer.getPtr()+_RTSBIndex, len, false );
00174 
00175                 if ( res == CSock::Ok )
00176                 {
00177 /*                      // Debug display
00178                         switch ( _FlushTrigger )
00179                         {
00180                         case FTTime : nldebug( "LNETL1: Time triggered flush for %s:", asString().c_str() ); break;
00181                         case FTSize : nldebug( "LNETL1: Size triggered flush for %s:", asString().c_str() ); break;
00182                         default:          nldebug( "LNETL1: Manual flush for %s:", asString().c_str() );
00183                         }
00184                         _FlushTrigger = FTManual;
00185                         nldebug( "LNETL1: %s sent effectively a buffer (%d on %d B)", asString().c_str(), len, _ReadyToSendBuffer.size() );
00186 */                      
00187                         
00188                         // TODO OPTIM remove the nldebug for speed
00189                         //commented for optimisation nldebug( "LNETL1: %s sent effectively %u/%u bytes (pos %u wantedsend %u)", asString().c_str(), len, _ReadyToSendBuffer.size(), _RTSBIndex, realLen/*, stringFromVectorPart(_ReadyToSendBuffer,_RTSBIndex,len).c_str()*/ );
00190 
00191                         if ( _RTSBIndex+len == _ReadyToSendBuffer.size() ) // for non-blocking mode (server)
00192                         {
00193                                 // If sending is ok, clear the global buffer
00194                                 _ReadyToSendBuffer.clear();
00195                                 _RTSBIndex = 0;
00196                         }
00197                         else
00198                         {
00199                                 // Or clear only the data that was actually sent
00200                                 nlassertex( _RTSBIndex+len < _ReadyToSendBuffer.size(), ("index=%u len=%u size=%u", _RTSBIndex, len, _ReadyToSendBuffer.size()) );
00201                                 _RTSBIndex += len;
00202                                 if ( _ReadyToSendBuffer.size() > 20480 ) // if big, clear data already sent
00203                                 {
00204                                         uint nbcpy = _ReadyToSendBuffer.size() - len;
00205                                         for (uint i = 0; i < nbcpy; i++)
00206                                         {
00207                                                 _ReadyToSendBuffer[i] = _ReadyToSendBuffer[i+len];
00208                                         }
00209                                         _ReadyToSendBuffer.resize(nbcpy);
00210                                         //_ReadyToSendBuffer.erase( _ReadyToSendBuffer.begin(), _ReadyToSendBuffer.begin()+len );
00211                                         _RTSBIndex = 0;
00212                                 }
00213                         }
00214                 }
00215                 else
00216                 {
00217 #ifdef NL_DEBUG
00218                         // can happen in a normal behavior if, for example, the other side is not connect anymore
00219                         nldebug( "LNETL1: %s failed to send effectively a buffer of %d bytes", asString().c_str(), _ReadyToSendBuffer.size() );
00220 #endif
00221                         return false;
00222                 }
00223         }
00224 
00225         return true;
00226 }
00227 
00228 
00229 /* Sets the time flush trigger (in millisecond). When this time is elapsed,
00230  * all data in the send queue is automatically sent (-1 to disable this trigger)
00231  */
00232 void CBufSock::setTimeFlushTrigger( sint32 ms )
00233 {
00234         nlassert (this != InvalidSockId);       // invalid bufsock
00235         _TriggerTime = ms;
00236         _LastFlushTime = CTime::getLocalTime();
00237 }
00238 
00239 
00240 /*
00241  * Update the network sending (call this method evenly). Returns false if an error occured.
00242  */
00243 bool CBufSock::update()
00244 {
00245         nlassert (this != InvalidSockId);       // invalid bufsock
00246 //      nlnettrace( "CBufSock::update-BEGIN" );
00247         // Time trigger
00248 
00249         if ( _TriggerTime != -1 )
00250         {
00251                 TTime now = CTime::getLocalTime();
00252                 if ( (sint32)(now-_LastFlushTime) >= _TriggerTime )
00253                 {
00254 #ifdef NL_DEBUG
00255                         _FlushTrigger = FTTime;
00256 #endif
00257                         if ( flush() )
00258                         {
00259                                 _LastFlushTime = now;
00260 //                              nlnettrace ( "CBufSock::update-END time 1" );
00261                                 return true;
00262                         }
00263                         else
00264                         {
00265 //                              nlnettrace ( "CBufSock::update-END time 0" );
00266                                 return false;
00267                         }
00268                 }
00269         }
00270         // Size trigger
00271         if ( _TriggerSize != -1 )
00272         {
00273                 if ( (sint32)SendFifo.size() > _TriggerSize )
00274                 {
00275 #ifdef NL_DEBUG
00276                         _FlushTrigger = FTSize;
00277 #endif
00278 //                      nlnettrace( "CBufSock::update-END size" );
00279                         return flush();
00280                 }
00281         }
00282 //      nlnettrace( "CBufSock::update-END nosend" );
00283         return true;
00284 }
00285 
00286 
00287 /*
00288  * Connects to the specified addr; set connectedstate to true if no connection advertising is needed
00289  * Precond: not connected
00290  */
00291 void CBufSock::connect( const CInetAddress& addr, bool nodelay, bool connectedstate )
00292 {
00293         nlassert (this != InvalidSockId);       // invalid bufsock
00294         nlassert( ! Sock->connected() );
00295 
00296         SendNextValue = ReceiveNextValue = 0;
00297         
00298         Sock->connect( addr );
00299         _ConnectedState = connectedstate;
00300         _KnowConnected = connectedstate;
00301         if ( nodelay )
00302         {
00303                 Sock->setNoDelay( true );
00304         }
00305 }
00306 
00307 
00308 /*
00309  * Disconnects; set connectedstate to false if no disconnection advertising is needed
00310  */
00311 void CBufSock::disconnect( bool connectedstate )
00312 {
00313         nlassert (this != InvalidSockId);       // invalid bufsock
00314         Sock->disconnect();
00315         _ConnectedState = connectedstate;
00316         _KnowConnected = connectedstate;
00317 
00318         SendNextValue = ReceiveNextValue = 0;
00319 }
00320 
00321 
00322 /*
00323  * Returns a string with the characteristics of the object
00324  */
00325 string CBufSock::asString() const
00326 {
00327         stringstream ss;
00328         if (this == InvalidSockId) // tricky
00329                 ss << "<Null>";
00330         else
00331         {
00332                 // if it crashs here, it means that the CBufSock was deleted and you try to access to the virtual table that is empty
00333                 // because the object is destroyed.
00334                 ss << typeStr();
00335                 ss << hex << this << dec << " (socket ";
00336                 
00337                 if (Sock == NULL)
00338                         ss << "<Null>";
00339                 else
00340                         ss << Sock->descriptor();
00341 
00342                 ss << ")";
00343         }
00344         return ss.str();
00345 }
00346 
00347 
00348 /*
00349  * Constructor with an existing socket (created by an accept())
00350  */
00351 CServerBufSock::CServerBufSock( CTcpSock *sock ) :
00352         CBufSock( sock ),
00353         _Advertised( false ),
00354         _NowReadingBuffer( false ),
00355         _BytesRead( 0 ),
00356         _Length( 0 ),
00357         _OwnerTask( NULL )
00358 {
00359         nlassert (this != InvalidSockId);       // invalid bufsock
00360         nlnettrace( "CServerBufSock::CServerBufSock" );
00361 }
00362 
00363 
00364 // In Receive Threads:
00365 
00366 
00367 /*
00368  * Receives a part of a message (nonblocking socket only)
00369  */
00370 bool CServerBufSock::receivePart()
00371 {
00372         nlassert (this != InvalidSockId);       // invalid bufsock
00373         nlnettrace( "CServerBufSock::receivePart" );
00374 
00375         TBlockSize actuallen;
00376         if ( ! _NowReadingBuffer )
00377         {
00378                 // Receiving length prefix
00379                 actuallen = sizeof(_Length)-_BytesRead;
00380                 Sock->receive( (uint8*)(&_Length)+_BytesRead, actuallen );
00381                 _BytesRead += actuallen;
00382                 if ( _BytesRead == sizeof(_Length ) )
00383                 {
00384                         if ( _Length != 0 )
00385                         {
00386                                 _Length = ntohl( _Length );
00387 
00388                                 // Test size limit
00389                                 if ( _Length > _OwnerTask->server()->maxExpectedBlockSize() )
00390                                 {
00391                                         nlwarning( "LNETL1: Socket %s received length exceeding max expected, in block header... Disconnecting", asString().c_str() );
00392                                         throw ESocket( "Received length exceeding max expected", false );
00393                                 }
00394 
00395                                 _NowReadingBuffer = true;
00396                                 _ReceiveBuffer.resize( _Length );
00397                         }
00398                         else
00399                         {
00400                                 nlwarning( "LNETL1: Socket %s received null length in block header", asString().c_str() );
00401                         }
00402                         _BytesRead = 0;
00403                 }
00404         }
00405 
00406         if ( _NowReadingBuffer )
00407         {
00408                 // Receiving payload buffer
00409                 actuallen = _Length-_BytesRead;
00410                 Sock->receive( &*_ReceiveBuffer.begin()+_BytesRead, actuallen );
00411                 _BytesRead += actuallen;
00412 
00413                 if ( _BytesRead == _Length )
00414                 {
00415 #ifdef NL_DEBUG
00416                         nldebug( "LNETL1: %s received buffer (%u bytes): [%s]", asString().c_str(), _ReceiveBuffer.size(), stringFromVector(_ReceiveBuffer).c_str() );
00417 #endif
00418                         _NowReadingBuffer = false;
00419                         _BytesRead = 0;
00420                         return true;
00421                 }
00422         }
00423 
00424         return false;
00425 }
00426 
00427 } // NLNET
buf_sock.cpp
