StreamInterface.h

Go to the documentation of this file.

// -*- C++ -*-
//  Copyright (c) 2005-2010, 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.
 
 
// 
//
//
//
// @VERSION@
 
#ifndef _STREAMINTERFACE_H_
#define _STREAMINTERFACE_H_
 
#include "cdecl.h"
#include "SSLconfig.h"
#include <isode/ll/internet.h>
#include <isode/messages/ioevent.h>
#include <openssl/x509.h>
 
// Implementation notes:
//
// I could have defined a generic stream, and then subclassed a socket
// addressed stream. However, most (all?) TCP streams are addressed using
// sockaddr structures.
//
// A signficant question here is; "who owns the read buffers?"
// Eventually I decided that the Stream User owns any read buffers.
// This means that the User can, say, incrementally fill its own
// buffer with fragments as they arrive, rather than having to copy
// them into an internal buffer.
 
namespace Stream {
 
    class User;
    class Provider;
 
    // Provider interface
 
    struct External {
        endpoint_t fd;     
        bool       listen; 
    };
 
    //
    struct ConnectRequest {
        const struct sockaddr *daddr; 
        socklen_t              dalen; 
        const struct sockaddr *saddr; 
        socklen_t              salen; 
        unsigned               dscp; 
    };
 
    struct ListenRequest {
        const struct sockaddr *laddr; 
        socklen_t              lalen; 
        int                  backlog; 
                                      // 0 = default 
    };
 
    //
    struct ConnectAccept {
        const struct sockaddr *daddr; 
        socklen_t              dalen; 
    };
 
    struct ReadRequest {
        char      *buf;  
        size_t     len;  
        bool       fill; 
    };
 
    struct DataRequest {
        const char *buf;  
        size_t      len;  
    };
 
    struct DisconnectRequest {
        MSGstruct   reason;
    };
 
    struct StartTLS {
        SSLTLS::Context   *context;    
        const char        *hostname;   
        bool               client;     
    };
 
    enum StreamControlOption {
        StreamControlNoDelay,       
        StreamControlKeepAlive,     
        StreamControlTOS            
    };
 
    struct StreamControl {
        enum StreamControlOption option; 
        int                      value;  
    };
 
    typedef size_t LengthFnx (const char *buf);
 
    struct LengthFnxRequest {
        LengthFnx       *fnx;    
        size_t           minlen; 
    };
 
    class Provider {
    private:
        User       *user;     
 
    public:
        Provider () : user(0) {}
 
        virtual ~Provider () {}
 
        void SetUser (User *u) { user = u; }
 
        User *GetUser () { return user; }
 
        // by child processes and don't shutdown on close
        virtual endpoint_t GetEndpoint (bool inheriting) = 0;
 
        virtual unsigned Events () = 0;
 
        virtual int GetLocalAddress (struct sockaddr *laddr,
                                     socklen_t *lalenp,
                                     MSGstruct *msp) = 0;
 
        virtual int GetPeerAddress (struct sockaddr *paddr,
                                    socklen_t *palenp,
                                    MSGstruct *msp) = 0;
 
        virtual TLS_CipherSuite GetCipherSuite () {
            return 0;
        }
 
        virtual X509* GetPeerCertificate () {
            return 0;
        }
 
        virtual void Die () = 0;
 
        // Enables the user to set the FD from some external source
        virtual void Deliver (External *ext) = 0;
 
        // Request connection to a peer
        // The result is signalled using a status indication
        virtual void Deliver (ConnectRequest *req) = 0;
 
        // Request listening
        virtual void Deliver (ListenRequest *req) = 0;
 
        // Accept a connection
        virtual void Deliver (ConnectAccept *req) = 0;
 
        // Disconnect, or refuse an inbound connection
        virtual void Deliver (DisconnectRequest *req) = 0;
 
        virtual void Deliver (DataRequest *req) = 0;
 
        virtual void Deliver (ReadRequest *req) = 0;
 
        virtual void Deliver (StartTLS *req) = 0;
 
        virtual void Deliver (StreamControl *option) = 0;
 
        virtual void Deliver (LengthFnxRequest *req) = 0;
 
        static EVENTSVC_DLL Provider *ProviderFactory (const char *type, MSGstruct *msp);
    };
 
    // User interface
 
    struct ConnectIndication {
        Provider   *listener;         
        Provider   *newprovider;      
                                      // Allocated using 'new'
        const struct sockaddr *saddr; 
        socklen_t              salen; 
        const struct sockaddr *laddr; 
        socklen_t              lalen; 
    };
 
    struct DataIndication {
        char      *buf;  
        ssize_t    len;  
    };
 
    struct ReleaseBuf {
        const char *buf; 
        ssize_t     len;  
    };
 
    struct StatusIndication {
        MSGstruct  msg;  
        Provider  *provider; 
 
        StatusIndication () { }
 
        StatusIndication (Provider *p) : provider(p) { }
    };
 
    class User {
    private:
        Provider   *provider;    
 
    public:
        User () : provider(0) {}
 
 
        virtual ~User () {}
 
        void SetProvider (Provider *p) { provider = p; }
 
        Provider *GetProvider () { return provider; }
 
        virtual void Deliver (ConnectIndication *data) = 0;
 
        virtual void Deliver (DataIndication *data) = 0;
 
        virtual void Deliver (ReleaseBuf *release) = 0;
 
        virtual void Deliver (StatusIndication *error) = 0;
    };
 
}
 
#endif /* __STREAMINTERFACE_H_ */