Event_p.h

// -*- C++ -*-
 
//  Copyright (c) 2005-2011, Isode Limited, London, England.
//  All rights reserved.
//                                                                       
//  Acquisition and use of this software and related materials for any      
//  purpose requires a written licence agreement from Isode Limited,
//  or a written licence from an organisation licenced by Isode Limited
//  to grant such a licence.
 
// 
//
// Event_p.h
//
// Internal interfaces for library
//
// @VERSION@
 
#include <isode/messages/ioevent.h>
 
#ifdef __cplusplus
 
#include "../include/timeutil.h"
#include "../include/EventSvc.h"
#include "../include/PollInterface.h"
#include "../include/SSLconfig.h"
#include "../include/StreamInterface.h"
#include "../include/DatagramInterface.h"
#include <openssl/ssl.h>
#include <vector>
 
struct X509_CERT_CTX;
 
namespace Event {
 
    extern Manager *CreateThreadManager ();
 
    extern Manager *CreatePollManager ();
}
 
namespace Poll {
    extern Provider *CreatePollpollProvider ();
 
    extern Provider *CreatePollepollProvider ();
 
    extern Provider *CreatePollselectProvider ();
 
    extern Provider *CreatePollportProvider ();
}
 
namespace Stream {
    extern Provider *CreateSocketPollProvider ();
}
 
namespace Datagram {
    extern Provider *CreateSocketPollProvider ();
}
 
namespace SSLTLS {
    static inline TLS_CipherSuite cipher_id(const SSL_CIPHER*c) {
        return SSL_CIPHER_get_id(c) & 0xffffff;
    }
 
    class OpenSSLContext : public Context {
    private:
        ICrypto::Environment::ptr_t envptr; 
        SSL_CTX                     *ctx;    
        tls_verify_client_choice    choice; 
        bool                        have_tls_id; 
        std::list<std::string>      id_uris; 
        std::list<std::string>      trust_anchor_uris; 
        bool                        dontTrustIdentities;
 
        static pthread_mutex_t globalmutex; 
        static bool globalinit;  
 
        static cipher_suites_t available_suites;
        static cipher_suites_t default_suites;
 
        void loadCAsfromPEM (const char *name);
 
        void loadCertsFromFiles (
        Config *confobj, std::list<std::string>& DER_files, bool ista);
 
        void convertLookupFlags (int lookup_flags);
 
        std::list<X509*> PullCertificates (const std::list<std::string>& uris);
        
    public:
        OpenSSLContext () : ctx(0), have_tls_id(false) {}
 
        virtual ~OpenSSLContext ();
 
        virtual const cipher_suites_t & AvailableSuites () {
            return available_suites;
        }
 
        virtual const cipher_suites_t & DefaultSuites () {
            return default_suites;
        }
 
        virtual bool HaveTLSIdentity () {
            return ctx && SSL_CTX_get0_certificate (ctx) &&
                SSL_CTX_get0_privatekey (ctx);
        }
 
        int Configure (Config *confobj, MSGstruct *msp);
 
        SSL *GetSSL (tls_verify_client_choice &verifychoice);
 
        bool IsUsable ();
 
        std::list<X509*> ServerCertificates (void);
 
        static int Initialize (MSGstruct *msp);
 
        std::list<X509*> GetTrustAnchors () const;
 
        int GetTlsInfo (const ICryptoKeyType keyType, 
                        EVP_PKEY** key, 
                        std::vector<std::string>& san,
                        std::vector<std::vector<unsigned char>>& cert_chain) const;
 
        size_t GetNbIdentities() const;
    };
 
    extern int CheckHostname (X509 *cert, const char *hostname, MSGstruct *msp);
 
    extern int SSLError (MSGstruct *msp, int msgno, const char *ctx);
 
    inline static void LogSSLError (int msgno, const char *ctx) {
        if ( LOGGING_ID(msgno) ) {
            MSGstruct lmsg;
            SSLError (&lmsg, msgno, ctx);
            LOGmessage (&lmsg);
        }
    }
}
 
#endif