CryptoSocket.h

/*NB_REVISION*/
 
/*NB_COPYRIGHT*/
 
#ifndef _CRYPTO_SOCKET_H_
#define _CRYPTO_SOCKET_H_
 
#include <basictypes.h>
#include <buffers.h>
#include <netinterface.h>
#include <iointernal.h>
 
#define NUM_WOLF_CRYPTO_SOCKETS (16)
#define NUM_WOLF_CRYPTO_SESSIONS (16)
#define CRYPTO_BUFFER_SEGMENTS TCP_BUFFER_SEGMENTS
 
#define CRYPTO_OBJ_FLAG_WNOTIFY_IGNORE (0x0001)
#define CRYPTO_OBJ_FLAG_USER_CLOSED (0x0002)   // User program called close on the SSL/ExtraFd.
#define CRYPTO_OBJ_FLAG_DOINGSHUTDOWN (0x0004)
#define CRYPTO_OBJ_FLAG_DOINGCONNECT (0x0008)
#define CRYPTO_OBJ_FLAG_DOINGACCEPT (0x0010)
#define CRYPTO_OBJ_FLAG_HAVEERROR (0x0020)
#define CRYPTO_OBJ_FLAG_OTHER_SIDE_CLOSED (0x0040)
#define CRYPTO_OBJ_FLAG_RESET_SOCKET \
    (0x0080)   // If we fail during negotiation, we need to go ahead and reset the full socket as the user won't get
               // a valid FD to close, which will result in a socket leak.
#define CRYPTO_OBJ_FLAG_ERROR_RETURNED \
    (0x0100)   // If we are resetting the socket in the asynch task, we want to make sure we don't do so until the
               // connection has returned any errors.
#define CRYPTO_OBJ_FLAG_TCP_RESET (0x0200)   // We recieved a reset or abort on the tcp conneciton.
 
// Time stuff
#define SHUTDOWN_RETRY_INTERVAL_IMMEDIATE \
    (1)   // Because of our asynchronous connections, we will generally have to try at least twice to completely
          // shutdown with WolfSSL. However, the time between these calls can be extremely short.
#define SHUTDOWN_RETRY_INTERVAL (TICKS_PER_SECOND)
#define CONNECT_RETRY_INTERVAL (TICKS_PER_SECOND)
 
enum SocketType_t : unsigned char
{
    SocketType_Default = 0,
    SocketType_Tls = 1,
    SocketType_Ssh = 2,
    SocketType_UNKNOWN = 0xFF
};
 
enum SocketHasData_t : int
{
    SocketHasData_NoData = 0,
    SocketHasData_HasData = 1,
    SocketHasData_PendingData = 2
};
 
class CryptoSocket
{
protected:
    class Pool;
public:
    // Member variables
    Pool  *m_socketPool = NULL;
 
    OS_CRIT m_Crit;      // Critical seciton to keep wolf multithread safe
    int m_error = 0;     // The error value
    int m_options = 0;   // Options like push etc ...
 
    PoolPtr m_NoPushbuffer;
    fifo_buffer_storage m_dataTcpOverflow;   // Used to hold overflow on outbound data to tcp
 
    // Will either be a WOLFSSL* or WOLFSSH*
    void *m_wolfCtx = nullptr;
 
    // Volatile becasue they can be touched from multiple places
    volatile int m_tcpFd = 0;                       // The underlyign tcp socket
    volatile int m_cryptoExtraFd = 0;               // The ExtraFd the user code uses to interact with thei socket
    OS_FLAGS m_OS_Flags; //State flags
 
    volatile uint32_t m_TimeTickOfNextAction = 0;   // Time tick to do some time releated thing
 
    // This is an index that gets incrmented every time a socket is reset.
    // This is used to detect race conditions on the worker queue to keep
    // messages from sockets already closed from getting reused.
    volatile uint8_t m_IndexOfReuse;
    volatile uint8_t m_RetryCount;
 
    CryptoSocket();
    virtual ~CryptoSocket();
 
    SocketType_t GetSocketType();
    int GetPoolNum();
    bool InUse();
 
    // Virtual Fuctions
    // when push gets turned off or the socket gets closed with data to be written we cleanup here
    void CleanupUnWritten();
 
    // Called from wolf loop mostly to handle notifications and
    // time out stuff for all async process except read. Needs to be
    // defined for each socket type.
    virtual void ProcessAsyncStuff() = 0;
 
    virtual int CheckSocketRecv() = 0;
 
    // Final clean up when we are done usign this socket.
    virtual void ResetSocket();
 
    // Called when the underlying TCP socket got closed
    virtual void CleanupTcpClose();
 
    // Flag Functions
    inline void SetFlag(uint32_t flag) { m_OS_Flags.Set(flag); }
    inline void ClrFlag(uint32_t flag) { m_OS_Flags.Clear(flag); }
    inline bool GetFlag(uint32_t flag) { return (m_OS_Flags.State()&flag)!=0;}
    inline uint32_t GetFlags() { return m_OS_Flags.State();}
    inline void ClrAllFlags() { m_OS_Flags.Clear(0xFFFFFFFF); }
    inline bool PendFlagUntil(uint32_t flag, uint32_t Time) {return (m_OS_Flags.PendAnyUntil(flag,Time)!=OS_TIMEOUT);}
    inline bool PendFlagDly(uint32_t flag, uint32_t Delay){return (m_OS_Flags.PendAny(flag,Delay)!=OS_TIMEOUT);};
 
    // Options functions
    inline int GetOptions() { return m_options; }
    inline void SetOptions(int option) { m_options |= option; }
    inline void ClrOptions(int option) { m_options &= ~option; }
 
    uint32_t GetCheckableIndexFromSocket();
    virtual uint32_t SocketRead(char *buf, uint32_t len) = 0;
    virtual uint32_t SocketWrite(const char *buf, uint32_t len) = 0;
    virtual SocketHasData_t SocketHasData() = 0;
 
    inline int GetTcpFd() { return m_tcpFd; }
    inline int GetCryptoExtraFd() { return m_cryptoExtraFd; }
    inline int GetError() { return m_error; }
    inline void SetError(int err) { m_error = err; }
    inline uint32_t GetTimeOfNextAction() { return m_TimeTickOfNextAction; }
    inline OS_CRIT &GetSockCrit() { return m_Crit; }
 
    // Buffer Handling
    inline fifo_buffer_storage &GetTcpOverflow() { return m_dataTcpOverflow; }
    inline PoolPtr GetNoPushBuffer() { return m_NoPushbuffer; }
    inline void SetNewNoPushBuffer() { m_NoPushbuffer = GetBuffer(); }
    inline bool IsNoPushBufferNull() { return (m_NoPushbuffer == 0); }
 
    void SetCryptoExtraFd(int cpExFd) { m_cryptoExtraFd = cpExFd; }
 
    static CryptoSocket *GetSocketFromCheckableIndex(uint32_t index);
    static CryptoSocket *GetSocketFromTcpFd(int tcpFd);
    static CryptoSocket *GetSocketFromCryptoFd(int cryptoFd, const Pool *usePool = NULL);
    static bool IsCryptoSocket(int cryptoFd, const Pool *usePool = NULL);
    static void ProcessSockets(uint32_t &lowest_next);
 
   protected:
    void InitSocket(int tcpFd, IoExpandStruct *ioExpStr);
 
    bool CloseTcpFd(IPADDR &remoteAddr, int &remotePort);
 
    // Static Member Functions
 
    // The following should be defined for each class type
    virtual void WriteUnwrittenData() = 0;
    virtual bool PendOnHandshake() { return false; }
 
    void ClearNextActionTimeTick() { m_TimeTickOfNextAction = 0; };
    void SetNextActionTimeTick(uint32_t time);
    void SetSocketError(int error, bool setTcpClose, bool resetSocket);
    void ResetSequence(bool success);
 
   protected:
    class Pool {
 
        Pool *pNextPool;
        const uint8_t *pPool;
        const size_t  poolCount;
        const size_t  elemSize;
        const size_t  poolNum;
        const IoExpandStruct *pIoExp;
        const SocketType_t type;
        static size_t nextPoolNum;
        public:
        Pool(CryptoSocket *pool, size_t sockCount, size_t sockSize, SocketType_t sockType, IoExpandStruct *iox);
        inline CryptoSocket &GetSock(int idx) const { return *((CryptoSocket*)(pPool+idx*elemSize)); }
        inline CryptoSocket &operator[](int idx) const { return GetSock(idx); }
        inline CryptoSocket *operator+(int idx) const  { return ((CryptoSocket*)(pPool+idx*elemSize)); }
        inline size_t Size() const         { return poolCount; }
        inline size_t PoolNum() const      { return poolNum; }
        inline SocketType_t SocketType() const   { return type; }
        inline const Pool *GetNext() const { return pNextPool; }
        inline bool Contains(const CryptoSocket *sck) const
            { return (((uint8_t*)sck) >= pPool) && (((uint8_t*)sck) < (pPool+poolCount*elemSize)); }
        inline uint32_t SockIdx(CryptoSocket *sck) const
        {
            if (!Contains(sck))
                return 0xFFFFFFFFul;
            return (((uint8_t*)sck)-pPool)/elemSize;
        }
        inline const IoExpandStruct * GetIoExpandStruct() const { return pIoExp; }
 
        bool SocketsAvail() const;
        int FreeSockets() const;
    };
    static CryptoSocket *FindNextEmptySocket(Pool &pool);
    static Pool *poolList;
};
 
inline SocketType_t CryptoSocket::GetSocketType()
{
    return (m_socketPool ? m_socketPool->SocketType() : SocketType_UNKNOWN);
}
inline int CryptoSocket::GetPoolNum()
{ return (m_socketPool ? m_socketPool->PoolNum() : -1); }
 
#endif   // _CRYPTO_SOCKET_H_