TPlayer.h

Go to the documentation of this file.

// -*- C++ -*-
//  Copyright (c) 2006-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 _TPLAYER_H_
#define _TPLAYER_H_
 
#include <queue>
 
#include "../include/cdecl.h"
#include <isode/asn1/asn1.h>
#include <isode/ll/TSinterface.h>
#include <isode/messages/base.h>
#include <isode/base/util.h>
#include "EventSvc.h"
 
#define TP_CLASS_0          1
#define TP_CLASS_2          (1<<2)
 
namespace Transport {
 
    EVENTSVC_DLL void TSnotify (const User_ptr_t notifier);
 
    struct TPbuffer {
        static const unsigned TPBINC = 128;
 
        unsigned    dsize;   
        unsigned    doff;    
        unsigned    dlen;    
        int         dfd;     
        void       *mdata;   
        unsigned    mlen;    
        u_char      data[1]; 
 
        static TPbuffer *GetNew (unsigned offset) {
            TPbuffer *newbp = static_cast<TPbuffer *>
                (malloc (TPBINC + sizeof (*newbp)));
 
            if ( newbp == 0 )
                return 0;
 
            newbp->dsize = TPBINC;
            newbp->doff = offset;
            newbp->dlen = 0;
            newbp->dfd  = -1;
            newbp->mdata = NULL;
            newbp->mlen = 0;
 
            return newbp;
        }
 
        void Free() {
            if ( dfd > 0 ) close (dfd);
            if ( mdata != NULL )
                isode_munmap(mdata, mlen);
            free (this);
        }
 
        // returns NULL if no memory
        static inline TPbuffer *Add (TPbuffer *bufp,
                                     const u_char *bytes,
                                     unsigned len) {
            unsigned newlen = bufp->doff + bufp->dlen + len;
 
            if ( bufp->dsize < newlen ) {
                unsigned newsize = bufp->dsize + TPBINC;
                if ( newsize < newlen )
                    newsize = newlen + TPBINC;
 
                TPbuffer *newbp = static_cast<TPbuffer *>
                    (realloc (bufp, sizeof (*bufp) + newsize));
 
                if ( newbp == 0 ) {
                    MSG_Base_Nomem_LOG (sizeof (*bufp) + newsize);
                    free (bufp);
                    return 0;
                }
 
                bufp = newbp;
                bufp->dsize = newsize;
            }
 
            memcpy (bufp->data + bufp->doff + bufp->dlen, bytes, len);
 
            bufp->dlen += len;
 
            return bufp;
        }
    };
 
    class TStimer : public Event::AsyncEvent {
    private:
        Provider       *provider;
 
    public:
        virtual ~TStimer() { Cancel(); }
 
        void Init (Provider *p) {
            provider = p;
        }
 
        virtual void Deliver () {
            provider->Deliver (this);
        }
 
        void Send (int secs) {
            if ( secs > 0 )
                Event::Manager::GetManager()->QueueAt (this, 1000*secs);
            else
                Event::Manager::GetManager()->Queue (this);
        }
    };
 
 
    class Layer2Net {
    public:
        virtual ~Layer2Net() {}
 
        virtual void ConnectRequest (
            struct NSAPaddr &calling,
            struct NSAPaddr &called) = 0;
 
        virtual void Deliver (TPbuffer **data) = 0;
 
        virtual void DisconnectRequest (bool force = true) = 0;
    };
 
    // Limited to the facilities needed for RFC 2126
 
    class Layer {
    public:
        enum State {
            CLOSED,                     
            WFNC,                       
            WFCR,                       
            WFCC,                       
            WBCL,                       
            OPEN,                       
            CLOSING,                    
            WFTRESP                     
        };
 
    private:
        static EVENTSVC_DLL pthread_mutex_t  refmutex;
        static EVENTSVC_DLL unsigned         refvalue;
 
        Layer2Net     *net;             
        Provider      *provider;        
 
        ConnectRequest connect;         
 
        unsigned       classes;         
        unsigned       maxtpdu;         
        unsigned       offset;          
        unsigned       srcref;          
        unsigned       dstref;          
 
        bool           useprefsize;     
 
        enum State     state;           
 
        void TDISind (DisconnectIndication &disind) {
            if ( provider->GetUser () ) {
                TSnotify (provider->GetUser()->Deliver (&disind));
                provider->ClearUser();
            }
        }
 
        TPbuffer *GetBuffer () {
            TPbuffer *bufp = TPbuffer::GetNew (offset);
            if ( bufp == 0 ) {
                InternalError (DR_congestion, "out of memory");
                return 0;
            } else {
                return bufp;
            }
        }
 
        void WritePDU (TPbuffer *bufp) {
            // As writes from Transport are not synchronized,
            // it could happen that net changes between the test and use.
            Layer2Net *tmpn = net;
            if ( state != CLOSED && tmpn != 0 )
                tmpn->Deliver (&bufp);
            else
                bufp->Free();
        }
 
        // PDU generation
        // Uses data in already in object
        void makeCR ();
 
        // Uses data in already in object
        void makeCC ();
 
        // Not able to specify additional information at the moment
        void makeDR (enum DRreason reason,
                          const char *data,
                          unsigned cc);
 
        void makeDC ();
 
        void makeDT (const struct udvec *uv, bool eot);
 
        void makeED (const u_char *data, unsigned len);
 
        enum RejectCause {
            Reject_NotSpecified          = 0,
            Reject_InvalidParameterCode  = 1,
            Reject_InvalidTPDUtype       = 2,
            Reject_InvalidParameterValue = 3
        };
 
        void makeER (enum RejectCause cause,
                     const u_char *tpdu, unsigned len);
 
        // PDU handling
        void getCR (struct qbuf *qb);
        void getCC (struct qbuf *qb);
        void getDR (struct qbuf *qb);
        void getDC (struct qbuf *qb);
        void getDT (struct qbuf *qb);
        void getED (struct qbuf *qb);
        void getER (struct qbuf *qb);
 
        void ProtocolError (struct qbuf *qb,
                            int offset,
                            enum RejectCause cause);
 
        void InternalError (enum DRreason reason, const char *text);
 
        void SendUserDR (enum DRreason reason,const char *text);
 
        bool DstRefOK (struct qbuf *qb) {
            uint16_t ref = ((qb->qb_data[2] &0xFF)<<8)|(qb->qb_data[3]&0xFF);
            if ( ref == srcref ) return true;
            InternalError (DR_reference, "Invalid DST-REF in TPDU");
            return false;
        }
 
        void CloseNetwork () {
            if ( net == 0 ) return;
            net->DisconnectRequest(false);
            net = 0;
            state = CLOSED;
        }
 
    public:
        Layer (int off) :
            net(0), provider(0),
            classes (TP_CLASS_0), maxtpdu(8192), offset(off),
            useprefsize(false), state(CLOSED) {
            pthread_mutex_lock (&refmutex);
            ++refvalue;
            if (refvalue > 0xFFFF)
                refvalue = 1; // reset
            srcref = refvalue;
            pthread_mutex_unlock (&refmutex);
            memset (&connect, 0, sizeof connect);
        }
 
        EVENTSVC_DLL ~Layer();
 
        void SetInbound() { state = WFCR; }
 
        void SetLink (Provider *pp, Layer2Net *np) {
            net = np;
            provider = pp;
        }
 
        void Configure (unsigned maxt, unsigned cls) {
            if ( maxtpdu != 0 )
                maxtpdu = maxt;
 
            if ( cls != 0 )
                classes = cls & (TP_CLASS_0|TP_CLASS_2);
        }
 
        EVENTSVC_DLL void Deliver (ConnectRequest *req);
 
        EVENTSVC_DLL void Deliver (ConnectResponse *req);
 
        EVENTSVC_DLL void Deliver (DataRequest *req);
 
        EVENTSVC_DLL void Deliver (DisconnectRequest *data);
 
        void NetworkConnect (NSAPaddr &calling, NSAPaddr &called) {
            connect.calling.ta_addr = calling;
            connect.called.ta_addr  = called;
        }
 
        EVENTSVC_DLL void NetworkRead (struct qbuf *qb);
 
        // returns true if network closed or closing
        EVENTSVC_DLL bool NetworkStatus (MSGstruct *msp);
 
        EVENTSVC_DLL void GetSaveInfo (char *buffer, size_t buflen);
 
        // returns false if failed
        EVENTSVC_DLL bool SetSaveInfo (const char *buffer);
 
        EVENTSVC_DLL void SendConnectIndication ();
    };
}
 
 
#endif /* _TPLAYER_H_ */