wartransfersocket.h

ftpserver very good sample

/** 
*/

#ifndef WAR_TRANSFER_SOCKET_H
#define WAR_TRANSFER_SOCKET_H

/* SYSTEM INCLUDES */


/* PROJECT INCLUDES */

#ifndef WAR_SOCKET_H
#   include "WarSocket.h"
#endif

#ifndef WAR_SVR_FILE_H
#   include "WarSvrFile.h"
#endif

/* LOCAL INCLUDES */


/* FORWARD REFERENCES */



#ifdef __cplusplus
extern "C" 
{
#endif
/****************** BEGIN OLD STYLE C spesific ********/


/****************** END OLD STYLE C spesific **********/
#ifdef __cplusplus 
}
#endif

/****************** BEGIN C++ spesific ****************/

#ifdef __cplusplus

class WarTransferSocket :
public WarSocket
{
public:
	typedef std::list<war_transfer_buffer_ptr_t> bufq_t;
    typedef std::set<war_transfer_buffer_ptr_t> bufq_set_t;

    // LIFECYCLE
    enum DirecionE
    {
        D_SENDING,
        D_RECEIVING,
        D_INVALID
    };

	enum TransferModeE
	{
		TM_NORMAL,	// Small buffers, like FTP Control, HHTP errors
		TM_FAST		// Use WarTransferSocket::SendFile() 
					// to start data transfer.
	};

    // LIFECYCLE
    
    /**
    * Default constructor.
    */
    WarTransferSocket(war_socket_io_ptr_t& companionPtr);
     
    /**
    * Destructor.
    */
    ~WarTransferSocket();
    
    // OPERATORS    
    // OPERATIONS
	
	virtual void QueueOutputData(war_transfer_buffer_ptr_t buf)
		throw(WarException);
	virtual void SendFile(war_svrfile_ptr_t& filePtr);
	virtual void ReceiveFile(war_svrfile_ptr_t& filePtr);
	virtual void Abort(const war_error_definitions errReason);

	void SetTransferMode(const TransferModeE mode) 
		throw(WarException); 
	
    // CALLBACK
    // ACCESS
    // INQUIRY
	// Checks if the dataconnection has exeeded the time limit
	bool IsTimeOut() const;
	bool HasFinished() const;

	TransferModeE GetTransferMode() const;

	war_uint32_t GetFileFlags() const throw(WarException);

	WarCriticalSection mSvrLock; // Lock for server-level functions
    
protected:
	virtual void StartTransfer(war_svrfile_ptr_t& filePtr);
	virtual void OnTransferDone(const WarError& status);
    void PumpData();
    void KillBuffers();
	int GetNumBuffers();

	void Reset();
	
	virtual void PreOnAccept(const WarError& status,
        war_socket_t newSocket,
        const WarNetAddress& remoteAddress,
        const WarNetAddress& localAddress);
	virtual void PreOnConnect(const WarError& status);
    virtual void PreOnReceived(const WarError& status, 
        war_transfer_buffer_ptr_t& buffer);
    virtual void PreOnSent(const WarError& status,
        war_transfer_buffer_ptr_t& buffer);

    static void CallbackFunc(
        war_cptr_t ptrToObject, 
        const WarError&, 
        war_transfer_buffer_ptr_t& bufferPtr);

    void QueueToFreeBuffer(WarTransferBuffer *buffer);

    void OnFileIo(const WarError&, 
        war_transfer_buffer_ptr_t& bufferPtr);
    void WriteToFile(war_transfer_buffer_ptr_t& buffer);
    void ProcessPendingBuffers();
   
    bool QueueNetRead();
    void QueueNetWrite(war_transfer_buffer_ptr_t& buffer);
    bool QueueFileRead();
    void QueueFileWrite(war_transfer_buffer_ptr_t& buffer);

	war_svrfile_ptr_t mFilePtr; // The file we wortk with
    DirecionE mDirection;
    bufq_t mFreeQueue; // Free buffers
    bufq_set_t mPendingInQueue; // Input fragments that are received out of order
    bool mHaveSeenEof;
    int mIoSerialLast; // Higest number in use
    int mIoSerialFirst; // Lowest number in use
    int mNumBuffers; // Buffers in use
    int mNumBufSegments; // Segments in data buffer
    int mBufferLen; // Lenggth of data buffers
    int mSegmentLen; // Length of eachh buffer segment
    int mTimeOutSeconds;
	war_socket_ptr_t mLockOwner; // Used to keep the lock object in memory if we use a friends lock!
	WarCriticalSection *pmLock; // Points to own or masters (FTP Conytrol connection) lock object

private:

	bool mHasFinished;
    bool mUseFileCallback;
    bool mIsInitialized;

    int mNumPendingNetIoRequests;
    int mNumPendingFileIoRequests;
	TransferModeE mTransferMode;
	bufq_t mPendingOutputQueue; // Must be sent before file transfer starts.
	int mNumExtraBuffers;
};

/* INLINE METHODS */

/* EXTERNAL REFERENCES */

template <class outT>
outT& operator << (outT& out, WarTransferSocket::TransferModeE& mode)
{
	if (WarTransferSocket::TM_NORMAL == mode)
		out << "TM_NORMAL";
	else if (WarTransferSocket::TM_FAST == mode)
		out << "TM_FAST";
	else
		out << "*** INVALID ***";
	return out;
}

#endif /* __cplusplus */

/****************** END C++ spesific ******************/

#endif  /* WAR_TRANSFER_SOCKET_H_ */