tcppacketsocket.h

Go to the documentation of this file.

/*
    
  This file is a part of ENUt, a library containing network
  programming utilities.
  
  Copyright (C) 2006-2008  Hasselt University - Expertise Centre for
                      Digital Media (EDM) (http://www.edm.uhasselt.be)

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  
  USA

*/

#ifndef NUT_TCPPACKETSOCKET_H

#define NUT_TCPPACKETSOCKET_H

#include "nutconfig.h"
#include "tcpsocket.h"
#include <time.h>
#include <list>

namespace nut
{

class TCPSocket;
class Packet;
        
class ENUT_IMPORTEXPORT TCPPacketSocket : public Socket
{
public:
        TCPPacketSocket(TCPSocket *pSock, bool deleteSocket, bool sixteenBit = false, uint32_t maxReceiveLength = 0xffffffff, size_t idLength = 0, uint32_t id = 0);
        
        ~TCPPacketSocket();

        bool poll();

        bool getAvailableDataLength(size_t &length)                                             { if (!m_pBaseSocket->getAvailableDataLength(length)) { setErrorString(m_pBaseSocket->getErrorString()); return false; } return true; }

        bool isPacketAvailable()                                                                { return !m_packetQueue.empty(); }
        
        bool read(Packet &packet);
        
        bool write(const void *pData, size_t length);

        time_t getLastReadTime() const                                                          { return m_lastReadTime; }
        time_t getLastWriteTime() const                                                         { return m_lastWriteTime; }
        TCPSocket *getBaseSocket()                                                              { return m_pBaseSocket; }
protected:
#if (defined(WIN32) || defined(_WIN32_WCE))
        SOCKET getSocketDescriptor()                                                            { return m_pBaseSocket->getSocketDescriptor(); }
#else
        int getSocketDescriptor()                                                               { return m_pBaseSocket->getSocketDescriptor(); }
#endif // WIN32 || _WIN32_WCE
private:
        // make sure we can't copy the socket
        TCPPacketSocket(const TCPPacketSocket &s) : Socket(s)                                   { }
        TCPPacketSocket &operator=(const TCPPacketSocket &s)                                    { return *this; }

        TCPSocket *m_pBaseSocket;
        uint32_t m_maximumSendLength;
        uint32_t m_maximumReceiveLength;
        uint32_t m_id, m_idNBO;
        int m_idLength;
        int m_lengthBytes;
        int m_prefixLength;
        bool m_deleteSocket;

        std::list<Packet *> m_packetQueue;

        uint8_t m_sizeBuffer[sizeof(uint32_t)*2]; // one for the length field, the other one for an optional 32-bit identifier
        size_t m_sizeBufferPosition;
        
        uint8_t *m_pBuffer;
        uint32_t m_bufferLength;
        uint32_t m_bufferPosition;

        time_t m_lastReadTime;
        time_t m_lastWriteTime;
};

} // end namespace

#endif // NUT_TCPPACKETSOCKET_H