NetTcpSocket.hpp

//------------------------------------------------------------------------------
//This file is part of embKernel. 
//See license.txt for the full license governing this code.
//------------------------------------------------------------------------------

#ifndef NET_TCP_SOCKET_HPP_
#define NET_TCP_SOCKET_HPP_

#include "NetDefs.hpp"
#include "LibLinkedList.hpp"
#include "LibStreamOut.hpp"
#include "LibStreamIn.hpp"
#include "RtosSemaphore.hpp"
#include "RtosMsgBox.hpp"
#include "LibStringFormat.hpp"

class NetTcpSocket: public LIB_LINKED_LIST_ITERABLE<NetTcpSocket>, public LibStreamIn, public LibStreamOut {
    friend class NetTcp;

private:
    static uint32_t sStartSequenceCounter;
    static uint16_t sAutomaticPort;

    typedef enum
        :uint8_t {
            STATE_CLOSED = 0,
        STATE_LISTEN,
        STATE_SYN_SENT,
        STATE_SYN_RCVD,
        STATE_EST,
        STATE_CLOSE_WAIT,
        STATE_LAST_ACK,
        STATE_FIN_WAIT_1,
        STATE_FIN_WAIT_2,
        STATE_CLOSING,
        STATE_TIME_WAIT,
        STATE_RESET
    } STATE;

    typedef struct {
        uint16_t dataLen;
        uint16_t index;
    }__attribute__((packed)) RX_SEGMENT_HEADER;

    typedef struct {
        RX_SEGMENT_HEADER hdr;
        uint8_t data[NetDefs::TCP_MAX_DATA_LEN]; //
    }__attribute__((packed)) RX_SEGMENT;

    typedef struct {
        uint32_t seq;
        uint32_t dataChecksum;
        uint16_t len;
        uint16_t maxLen;
        uint8_t timeout;
        uint8_t retries;
        uint8_t flushed;
        uint8_t spare;
    } TX_SEGMENT_HEADER;

    typedef struct tagTX_SEGMENT {
        tagTX_SEGMENT* next;
        TX_SEGMENT_HEADER hdr;
        NetDefs::FRAME frame; //
    }__attribute__((packed)) TX_SEGMENT;

public:
    NetTcpSocket();
    virtual ~NetTcpSocket();

    bool connect(NetDefs::IP_ADDR& remoteIpAddr, uint16_t remotePort, uint16_t localPort = 0);
    void listen(NetDefs::TCP_PORT localPort);
    bool accept(Rtos::TICK timeout);
    void autoListenAndAccept(NetDefs::TCP_PORT localPort);
    bool isConnected();
    void close();
    void setWindowSize(uint16_t windowsSize);
    void setMaxTxSegmentDataLen(uint16_t maxTxSegmentDataLen);
    void flush();
    void discardAllTxSegments();
    void discardAllRxSegments();

    virtual int read(void* buffer, int len, Rtos::TICK timeout = Rtos::TICK_INFINITE);
    virtual int skip(int len, Rtos::TICK timeout = Rtos::TICK_INFINITE);
    virtual int write(const void* buffer, int len, Rtos::TICK timeout = Rtos::TICK_INFINITE);
private:
    static const int MAX_QUEUED_TX_SEGMENTS = 8;
    static const size_t MAX_TX_FRAGMENT_DATA_SIZE = 512;
    NetDefs::TCP_PORT mLocalPort;
    NetDefs::TCP_PORT mRemotePort;
    NetDefs::IP_ADDR mRemoteIpAddr;
    NetDefs::MAC_ADDR mRemoteMacAddr;
    uint32_t mRecvCount;
    uint32_t mSentCount;
    uint16_t mWindowSize;
    uint16_t mMaxTxSegmentDataLen;

    RX_SEGMENT* mRxCurrentSegment;
    TX_SEGMENT* mTxFirstSegment;
    TX_SEGMENT* mTxCurrentSegment;

    RtosSemaphore mSemaEvent;
    RtosMsgBox<RX_SEGMENT*, 4> mRxMsgBox;

    uint16_t mTimer;
    uint8_t mRetries;
    STATE mState;

    bool mIsRxDataFinished;
    bool mIsAutoListenAndAccept;
};

#endif /* NET_TCP_SOCKET_HPP_ */