vlInetSocketMgr.h

Go to the documentation of this file.

/********************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
*********************************************************************/
#pragma once

#include <vlutil/vlInet.h>
#include <vlutil/vlInetSocket.h>
#include <vlutil/vlInetEndpoint.h>
#include <list>
#include <vector>
#include <map>

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

class DtInetTcpSocket;
class DtInetUdpSocket;

typedef std::multimap<DtInetEndpoint, DtInetSocket*> DtInetSocketList;
typedef std::vector<DtInetEndpoint*>                 DtInetDestList;

// Forward declaration to facilitate declaration of socket creation callback
// prototype
class DtInetSocketMgr;

typedef DtInetSocket* (*DtSocketCreationCallback)(void* creator, DtInetSocketMgr * mgr);

typedef bool (*DtInetSocketAdditionCallback)(DtInetSocket* sock, void* usr);
typedef DtInetSocketAdditionCallback DtInetSocketRemovalCallback;
class DtInetSocketCbInfo
{
public:

   DtInetSocketCbInfo(DtInetSocketAdditionCallback cb, void* usr, int order)
   {
      myCb = cb;
      myUsr = usr;
      myCallOrder = order;
   }

   DtInetSocketAdditionCallback myCb;
   void* myUsr;
   int   myCallOrder;
};

class DT_DLL_VLUTIL DtInetSocketMgr
{
public:
   DtInetSocketMgr( DtU32 connectionFlags = DtDefaultSockOpts );

   DtInetSocketMgr( DtInetEndpoint& serverEndpoint,
      DtInetDevice* hostIf = NULL,
      DtU32 serverFlags = (DtDefaultSockOpts | DtSockOptNonBlocking), 
      DtU32 connectionFlags = DtDefaultSockOpts,
      DtInetUtils::DtInetAddrFamily family = DtInetUtils::DtInetAddrFamily_IPv4);

   virtual ~DtInetSocketMgr();

   virtual int processConnections();

   virtual DtInetSocket* addConnection( const DtInetEndpoint& peerEp,
                                        DtU16 localPort = 0,
                                        DtInetDevice* hostIf = NULL,
                                        bool openImmediately = true,
                                        bool connectUdpSocket = false );

   virtual DtInetSocket* addConnection( const DtInetSocket* socket );

   virtual bool removeConnection( const DtInetEndpoint& peerEndpoint );
   virtual bool removeConnection( const DtInetSocket* socket );

   virtual DtInetSocket* serverSocket() const;

   virtual const DtInetSocketList& socketList() const;

   virtual DtInetSocket* peerSocket( const DtInetEndpoint& peer ) const;
   
   virtual int sendTo( caddr_t buff, int buffSize, DtInetDestList& dest, 
                       DtU32 flags = 0 );
   virtual int sendTo( DtInetBufferChain packets, DtInetDestList& dest, 
                       DtU32 flags = 0 );

   virtual DtInetSockRcvStatus recvFrom( caddr_t buff, size_t buffSize,
                                         DtInetEndpoint& peer,
                                         DtU32 flags = 0 );
   virtual DtInetSockRcvStatus recvToChainFrom( DtInetBufferChain& packets,
                                                DtInetEndpoint& peer,
                                                DtU32 flags = 0 );

   virtual void addSocketAdditionCallback( DtInetSocketAdditionCallback cb,
                                           void* usr, int order );
   virtual void removeSocketAdditionCallback( DtInetSocketAdditionCallback cb, 
                                              void* usr );
   
   virtual void addSocketRemovalCallback( DtInetSocketRemovalCallback cb, 
                                          void* usr, int order );
   virtual void removeSocketRemovalCallback( DtInetSocketRemovalCallback cb, 
                                             void* usr);

   virtual DtU32 getServerFlags() const;
   virtual DtU32 getConnectionFlags() const;

   virtual int      getLastError();
   virtual DtString getLastErrorString();
   virtual void     clearError();

   virtual void addSocketCreationCallback( DtSocketCreationCallback cb, 
                                           void* socketCreator );

protected:
   DtInetSocketMgr(const DtInetSocketMgr&);

   DtInetSocketMgr& operator=(const DtInetSocketMgr &);

   virtual int processNewTcpConnections();
   virtual int processNewUdpConnections();

   virtual DtInetSocket* removeByKey( const DtInetEndpoint& key, 
                                      DtInetSocketList& list );
   virtual bool removeByItem( const DtInetSocket* item, 
                              DtInetSocketList& list );

protected:
   DtInetSocket*    myServerSocket;
   DtInetTcpSocket* myTcpServerSocket;
   DtInetUdpSocket* myUdpServerSocket;
   DtInetSocketList mySockets;

   std::pair<DtInetEndpoint, DtInetSocket*> myLastSocketReadFrom;

   std::map<int, DtInetSocketCbInfo*> myAdditionCallbacks;
   std::map<int, DtInetSocketCbInfo*> myRemovalCallbacks;

   DtSocketCreationCallback mySocketCreateCallback;
   void * mySocketCreator;

   DtU32 myServerFlags;
   DtU32 myConnectionFlags;

   int      myErrorCode;
   DtString myErrorString;

   DtInetTcpSocket* myPeerSocket;
};

#ifdef DtUSE_UTILITIES_NAMESPACE
} 
#endif