DatagramInterface.h

Go to the documentation of this file.

// -*- C++ -*-
//  Copyright (c) 2005-2024, 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 _DATAGRAMINTERFACE_H_
#define _DATAGRAMINTERFACE_H_
 
#include <isode/ll/internet.h>
#include <isode/messages/ioevent.h>
 
// Design Note: the Datagram user owns read and write buffers
 
namespace Datagram {
 
    class User;
    class Provider;
 
    // Provider interface
 
    struct External {
        endpoint_t fd;     
    };
 
    // Often the address will be the 'any' address, but the port will be
    // chosen.
    struct ListenRequest {
        const struct sockaddr *laddr; 
        socklen_t              lalen; 
    };
 
    struct ReadRequest {
        char                  *buf;   
        size_t                 len;   
        struct sockaddr       *saddr; 
        socklen_t              salen; 
    };
 
    struct DataRequest {
        const char            *buf;   
        size_t                 len;   
        const struct sockaddr *daddr; 
        socklen_t              dalen; 
        void                  *pduref;
        bool                   usearq;
        bool                   inorder;
        enum {
            DC_NONE,            
            DC_NODE_CONF,       
            DC_CLIENT_CONF      
        } confmode;             
        DataRequest() : buf(0), len(0), daddr(0), dalen(0),
                        pduref(0), usearq(false), inorder(false), confmode(DC_NONE)
            {}
    };
 
    // Note: will associate the multicast address with the same IP address
    // as used for the listening.
    struct MulticastRequest {
        struct in_addr        maddr;  
        bool                  listen; 
    };
 
 
    struct MulticastParams {
        unsigned         ttl;    
        int              loop;   
                                 //  -1: off, 1: on
    };
 
    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; }
 
        virtual void Die () = 0;
 
        // Enables the user to set the FD from some external source
        virtual void Deliver (External *ext) = 0;
 
        virtual void Deliver (ListenRequest *req) = 0;
 
        virtual void Deliver (DataRequest *req) = 0;
 
        virtual void Deliver (ReadRequest *req) = 0;
 
        virtual void Deliver (MulticastRequest *req) = 0;
 
        virtual void Deliver (MulticastParams *req) = 0;
 
        virtual void Deliver (LengthFnxRequest *req) = 0;
 
        static EVENTSVC_DLL Provider *ProviderFactory (const char *type, MSGstruct *msp);
    };
 
    // User interface
 
    struct DataIndication {
        Provider  *provider;          
        char      *buf;               
        ssize_t    len;               
        const struct sockaddr *saddr; 
        socklen_t              salen; 
        bool       arq;               
    };
 
    struct ReleaseBuf {
        Provider   *provider; 
        const char *buf;      
        ssize_t     len;      
    };
 
    struct StatusIndication {
    Provider  *provider; 
    void      *pduref;   
    MSGstruct  msg;      
    int        info;     
 
    StatusIndication () : provider(0), pduref(0), info(-1) { msg.data = NULL; msg.dlen = 0; }
    StatusIndication (const StatusIndication& src) {
        this->pduref   = src.pduref;
        this->info     = src.info;
        this->provider = src.provider;
        this->msg.dlen = src.msg.dlen;
        if (src.msg.data == src.msg.dbuf) {
            this->msg.data = this->msg.dbuf;
        }
        else {
            this->msg.data = (unsigned char*)smalloc(src.msg.dlen);
        }
        memcpy (this->msg.data, src.msg.data, src.msg.dlen);
    }
 
        ~StatusIndication () { MSGfree (&msg); }
 
        // Need assignment, as need to change data pointer if points to self
        StatusIndication & operator= (const StatusIndication &src) {
            this->provider = src.provider;
            this->msg.dlen = src.msg.dlen;
            if ( src.msg.data == src.msg.dbuf ) {
                this->msg.data = this->msg.dbuf;
            } else {
                this->msg.data = (unsigned char *)
                    smalloc (src.msg.dlen);
            }
            memcpy (this->msg.data, src.msg.data, src.msg.dlen);
 
            return *this;
        }
    };
 
    // User can associate with many providers, so no specific provider field
    class User {
    public:
 
        virtual ~User () {}
 
        virtual void Deliver (DataIndication *data) = 0;
 
        virtual void Deliver (ReleaseBuf *release) = 0;
 
        virtual void Deliver (StatusIndication *error) = 0;
    };
 
}
 
#endif /* __DATAGRAMINTERFACE_H_ */