Session.h

Go to the documentation of this file.

/****
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2015 by Skurydin Alexey
 * http://github.com/SmingHub/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * Session.h
 *
 ****/

#pragma once

#include "Context.h"
#include "KeyCertPair.h"
#include "ValidatorList.h"
#include <Platform/System.h>
#include <memory>

class TcpConnection;

namespace Ssl
{
enum class MaxBufferSize {
    Default = 0, 
    B512,        
    K1,          
    K2,
    K4,
    K8,
    K16,
};

__forceinline size_t maxBufferSizeToBytes(MaxBufferSize value)
{
    return (value == MaxBufferSize::Default) ? 0 : 256U << size_t(value);
}

struct Options {
    bool sessionResume : 1; 
    bool clientAuthentication : 1;
    bool verifyLater : 1; 
    bool freeKeyCertAfterHandshake : 1;

    Options() : sessionResume(false), clientAuthentication(false), verifyLater(false), freeKeyCertAfterHandshake(false)
    {
    }

    String toString() const;
};

__forceinline String toString(const Options& options)
{
    return options.toString();
}

class Session
{
public:
    using InitDelegate = Delegate<void(Session& session)>;

    String hostName;

    KeyCertPair keyCert;

    Options options;

    MaxBufferSize maxBufferSize = MaxBufferSize::Default;

    const CipherSuites::Array* cipherSuites = &CipherSuites::basic;

    int cacheSize = 10;

    ValidatorList validators;

public:
    ~Session()
    {
        close();
    }

    const SessionId* getSessionId() const
    {
        return sessionId.get();
    }

    bool onAccept(TcpConnection* client, tcp_pcb* tcp);

    void setConnection(Connection* connection)
    {
        assert(!this->connection);
        this->connection.reset(connection);
    }

    Connection* getConnection()
    {
        return connection.get();
    }

    bool onConnect(tcp_pcb* tcp);

    bool isConnected() const
    {
        return connection ? connection->isHandshakeDone() : false;
    }

    void close();

    int read(InputBuffer& input, uint8_t*& output);

    int write(const uint8_t* data, size_t length);

    bool validateCertificate();

    void handshakeComplete(bool success);

    size_t printTo(Print& p) const;

private:
    void beginHandshake();
    void endHandshake();

private:
    std::unique_ptr<Context> context;
    std::unique_ptr<Connection> connection;
    std::unique_ptr<SessionId> sessionId;
    CpuFrequency curFreq = CpuFrequency(0);
};

}; // namespace Ssl