sslcontext.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/buffer.h>
#include <promeki/filepath.h>
#include <promeki/error.h>
#include <promeki/sharedptr.h>
#include <promeki/list.h>
#include <promeki/datatype.h>
#include <promeki/result.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
 
class SslContext {
        public:
                PROMEKI_DATATYPE(SslContext, DataTypeSslContext, 1)
 
                
                using List = ::promeki::List<SslContext>;
 
                enum SslProtocol {
                        TlsV1_2,        
                        TlsV1_3,        
                        SecureProtocols 
                };
 
                static bool hasTlsSupport();
 
                SslContext();
 
                ~SslContext();
 
                // The copy / move special members are defined
                // out-of-line because @ref Impl is incomplete here —
                // an inline @c =default would instantiate the
                // @c SharedPtr internals against the forward-declared
                // type, miss the @c IsSharedObject trait, and route
                // through @c SharedPtrProxy<Impl>::~SharedPtrProxy()
                // which would invoke @c delete on an incomplete type.
 
                SslContext(const SslContext &other);
 
                SslContext &operator=(const SslContext &other);
 
                SslContext(SslContext &&other) noexcept;
 
                SslContext &operator=(SslContext &&other) noexcept;
 
                bool isValid() const;
 
                bool operator==(const SslContext &other) const { return _d == other._d; }
 
                bool operator!=(const SslContext &other) const { return !(*this == other); }
 
                String toString() const;
 
                void setProtocol(SslProtocol protocol);
 
                SslProtocol protocol() const;
 
                // ----------------------------------------------------
                // Server-side credentials
                // ----------------------------------------------------
 
                Error setCertificate(const FilePath &file);
 
                Error setCertificate(const Buffer &certData);
 
                Error setPrivateKey(const FilePath &file, const String &passphrase = String());
 
                Error setPrivateKey(const Buffer &keyData, const String &passphrase = String());
 
                // ----------------------------------------------------
                // Trust store (used for peer verification on both sides)
                // ----------------------------------------------------
 
                Error setCaCertificates(const FilePath &caFile);
 
                Error setCaCertificates(const Buffer &caData);
 
                Error setSystemCaCertificates();
 
                void setVerifyPeer(bool enable);
 
                bool verifyPeer() const;
 
                void setRequireClientCert(bool require);
 
                bool requireClientCert() const;
 
                void setVerifyDepth(int depth);
 
                int verifyDepth() const;
 
                bool hasCertificate() const;
 
                bool hasCaCertificates() const;
 
                void *nativeConfig() const;
 
                Error writeToStream(DataStream &s) const;
 
                template <uint32_t V> static Result<SslContext> readFromStream(DataStream &s);
 
        private:
                struct Impl;
 
                // mutable: @c nativeConfig is a @c const accessor but
                // lazy-initializes the underlying @c mbedtls_ssl_config
                // on first call, so the @c SharedPtr handle has to be
                // reachable through a non-const @c modify() path.
                mutable SharedPtr<Impl, false> _d;
};
 
// Primary template for @ref SslContext::readFromStream: always
// reports @ref Error::NotSupported, regardless of wire version, for
// the reasons documented on the declaration.  Inline so the
// @ref PROMEKI_DATATYPE @c dispatchRead body can resolve it without
// dragging the cpp into header consumers.
template <uint32_t V> inline Result<SslContext> SslContext::readFromStream(DataStream &) {
        return Result<SslContext>(SslContext(), Error::NotSupported);
}
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE