Transport::Layer Class Reference

Class for handling Class 0 and Class 2 Transport. More...

#include <TPlayer.h>

Public Types
enum	State {   CLOSED , WFNC , WFCR , WFCC ,   WBCL , OPEN , CLOSING , WFTRESP }

Public Member Functions
	Layer (int off)
void	SetInbound ()
	Set as inbound Layer.
void	SetLink (Provider *pp, Layer2Net *np)
	Set the links.
void	Configure (unsigned maxt, unsigned cls)
	Configure.
EVENTSVC_DLL void	Deliver (ConnectRequest *req)
	TCONreq.
EVENTSVC_DLL void	Deliver (ConnectResponse *req)
	TCONresp.
EVENTSVC_DLL void	Deliver (DataRequest *req)
	TDTreq/TEXreq.
EVENTSVC_DLL void	Deliver (DisconnectRequest *data)
	TDISreq.
void	NetworkConnect (NSAPaddr &calling, NSAPaddr &called)
	Initialize from network connection for inbound connection.
EVENTSVC_DLL void	NetworkRead (struct qbuf *qb)
	Handle data from network.
EVENTSVC_DLL bool	NetworkStatus (MSGstruct *msp)
	Network status indication.
EVENTSVC_DLL void	GetSaveInfo (char *buffer, size_t buflen)
	Get save information from layer.
EVENTSVC_DLL bool	SetSaveInfo (const char *buffer)
	Set state from save info.
EVENTSVC_DLL void	SendConnectIndication ()
	Send TS user a connect indication.

Detailed Description

Class for handling Class 0 and Class 2 Transport.

Definition at line 153 of file TPlayer.h.

Member Enumeration Documentation

State

enum Transport::Layer::State

Enumerator
WFNC	Closed.
WFCR	Wait for network Connect.
WFCC	Wait for CR-TPDU.
WBCL	Wait for CC-TPDU.
OPEN	Wait before releasing.
CLOSING	Transport connection is open.
WFTRESP	Release in progress. Wait for T-CONNECT response

Definition at line 155 of file TPlayer.h.

                   {
            CLOSED,                     
            WFNC,                       
            WFCR,                       
            WFCC,                       
            WBCL,                       
            OPEN,                       
            CLOSING,                    
            WFTRESP                     
        };

Constructor & Destructor Documentation

Layer()

Transport::Layer::Layer ( int  off )

inline

Definition at line 288 of file TPlayer.h.

                        :
            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);
        }

~Layer()

Transport::Layer::~Layer

(

)

Definition at line 77 of file TPlayer.C.

    {
        free (connect.data);
    }

Member Function Documentation

SetInbound()

void Transport::Layer::SetInbound ( )

inline

Set as inbound Layer.

Definition at line 304 of file TPlayer.h.

{ state = WFCR; }

References WFCR.

SetLink()

void Transport::Layer::SetLink ( Provider *  pp, Layer2Net *  np  )

inline

Set the links.

Definition at line 307 of file TPlayer.h.

                                                   {
            net = np;
            provider = pp;
        }

Configure()

void Transport::Layer::Configure ( unsigned  maxt, unsigned  cls  )

inline

Configure.

Definition at line 313 of file TPlayer.h.

                                                     {
            if ( maxtpdu != 0 )
                maxtpdu = maxt;
 
            if ( cls != 0 )
                classes = cls & (TP_CLASS_0|TP_CLASS_2);
        }

References TP_CLASS_0.

Deliver() [1/4]

void Transport::Layer::Deliver

(

ConnectRequest *

req

)

TCONreq.

Definition at line 83 of file TPlayer.C.

    {
        if ( state != CLOSED ) {
            // X.224 A.2.3 (a)
            LOG_DEBUG (("TConreq in state %d - ignored", state));
            return;
        }
 
        if ( provider->GetUser() == 0 ) {
            InternalError (DR_nosession, "No user for CR");
            return;
        }
 
        connect = *req; // struct copy
 
        if ( req->data != 0 && req->cc > 0 ) {
            connect.data = (char *) malloc (req->cc);
            if ( connect.data != 0 )
                memcpy (connect.data, req->data, req->cc);
        } else {
            connect.data = 0;
            connect.cc = 0;
        }
 
        // Check details
 
        DisconnectIndication disind;
 
        // Need called network address
        if ( connect.called.ta_addr.na_addrlen == 0 ) {
            MSG_Tsap_NoNSAPAddress_SET (&disind.msg);
            TDISind (disind);
            return;
        }
 
        // Only support classes 0 and 2
        // If none specified, then use class 0
        if ( classes & ~(TP_CLASS_0|TP_CLASS_2) ) {
            MSG_Tsap_Negotiation_SET (&disind.msg);
            TDISind (disind);
            return;
        }
 
        if ( classes == 0 )
            classes = TP_CLASS_0;
 
        if ( maxtpdu == 0 ) {
            maxtpdu =
                ( classes & TP_CLASS_2 ) ? MAXTPDU2 : MAXTPDU0;
 
        } else {
            // Can only set MAX TPDU in multiples of 128 bytes.
            maxtpdu &= ~ 0x7FU;
        }
 
        if ( maxtpdu < MINMAXTPDU || maxtpdu > MAXTPDU2 ) {
            MSG_Tsap_BadMaxTPDUsize_SET (&disind.msg, maxtpdu);
            TDISind (disind);
            return;
        }
 
        LOG_DEBUG (("TP %p:  TCONreq -> WFNC", this));
        state = WFNC;       
 
        net->ConnectRequest (connect.calling.ta_addr, connect.called.ta_addr);
    }

References Transport::Layer2Net::ConnectRequest(), TP_CLASS_0, and WFNC.

Deliver() [2/4]

void Transport::Layer::Deliver

(

ConnectResponse *

req

)

TCONresp.

Definition at line 152 of file TPlayer.C.

    {
        if ( state != WFTRESP ) {
            // X.224 A.2.3 (a)
            LOG_DEBUG (("Ignoring TCONresp in state %d", state));
            return;
        }
 
        // Must have dealt with any connect data by now.
        free (connect.data);
        connect.data = 0;
        connect.cc = 0;
 
        if ( req->responding.ta_selectlen > 0 ) {
            memcpy (connect.called.ta_selector,
                    req->responding.ta_selector,
                    req->responding.ta_selectlen);
            connect.called.ta_selectlen = req->responding.ta_selectlen;
        }
 
        LOG_DEBUG (("TP %p:  TCONresp -> OPEN", this));
        state = OPEN;
        makeCC ();
    }

References OPEN, and WFTRESP.

Deliver() [3/4]

void Transport::Layer::Deliver

(

DataRequest *

req

)

TDTreq/TEXreq.

Definition at line 179 of file TPlayer.C.

    {
        if ( state != OPEN ) {
            // X.224 A.2.3 (a)
            LOG_DEBUG (("Ignoring TDTreq in state %d", state));
            return;
        }
 
        // TEXreq not supported
        if ( req->expedited ) {
            InternalError (DR_protocol, "Expedited data not supported");
            return;
        }
 
        makeDT (req->uv, req->eot);
    }

References OPEN.

Deliver() [4/4]

void Transport::Layer::Deliver

(

DisconnectRequest *

data

)

TDISreq.

Definition at line 198 of file TPlayer.C.

    {
        switch ( state ) {
        case CLOSED:
        case CLOSING:
        case WFCR:
        case WBCL:
            // X.224 A.2.3 (a)
            LOG_DEBUG (("Ignoring TDISreq in state %d", state));
            break;
 
        case WFNC:
            state = CLOSED;
            break;
 
        case WFCC:
            if ( classes & TP_CLASS_0 ) {
                net->DisconnectRequest();
                state = CLOSED;
            } else {
                state = WBCL;
            }
            break;
 
        case WFTRESP:
            makeDR (data->reason, data->data, data->cc);
            state = CLOSED;
            break;
 
        case OPEN:
            if ( classes & TP_CLASS_0 ) {
                net->DisconnectRequest();
                state = CLOSED;
            } else {
                makeDR (data->reason, data->data, data->cc);
                state = CLOSING;
            }
            break;
        }
        // Tell the TSuser that we will not send it anything else
        DisconnectIndication disind;
        MSG_Tsap_NormalDisconnect_SET (&disind.msg);
        TDISind (disind);
    }

References CLOSING, Transport::Layer2Net::DisconnectRequest(), OPEN, TP_CLASS_0, WBCL, WFCC, WFCR, WFNC, and WFTRESP.

NetworkConnect()

void Transport::Layer::NetworkConnect ( NSAPaddr &  calling, NSAPaddr &  called  )

inline

Initialize from network connection for inbound connection.

Definition at line 334 of file TPlayer.h.

                                                                  {
            connect.calling.ta_addr = calling;
            connect.called.ta_addr  = called;
        }

NetworkRead()

void Transport::Layer::NetworkRead

(

struct qbuf *

qb

)

Handle data from network.

Definition at line 244 of file TPlayer.C.

    {
        const u_char *dp = reinterpret_cast<const u_char *>(qb->qb_data);
 
        LOG_DEBUG (("NetworkRead: %ld (%d)", (long)qb->qb_len, *dp));
        
        // Check fixed + variable part is within the overall length
        // (Note: the LI field does not include itself)
        if ( *dp >= qb->qb_len || *dp < 2 ) {
            MSG_Tsap_RejectUnspecified_LOG ("Bad length field in TPKT");
            ProtocolError (qb, 1, Reject_NotSpecified);
            return;
        }
 
        // Only the top 4 bits determine TPDU type
        switch ( dp[1] & 0xF0 ) {
        case 0xF0: // DT
            getDT (qb);
            return; // As getDT is responsible for qbuf
 
        case PDU_CR:
            getCR (qb);
            break;
 
        case PDU_CC:
            getCC (qb);
            break;
 
        case PDU_DR:
            getDR (qb);
            break;
 
        case PDU_DC:
            getDC (qb);
            break;
 
        case PDU_ED:
            getED (qb);
            return; // As getED is responsible for qbuf
 
        case PDU_ER:
            getER (qb);
            break;
 
        case PDU_AK:
        case PDU_EA:
        case PDU_RJ:
            // Ignore known but irrelevant TPDUs
            LOG_DEBUG (("Ignoring TPDU with type 0x%2.2X", dp[1]));
            break;
 
        default:
            // Unknown TPDU, protocol error
            MSG_Tsap_RejectBadType_LOG (dp[1]);
            ProtocolError (qb, 2, Reject_InvalidTPDUtype);
            break;
        }
 
        qb_free (qb);
    }

NetworkStatus()

bool Transport::Layer::NetworkStatus

(

MSGstruct *

msp

)

Network status indication.

Definition at line 306 of file TPlayer.C.

    {
        switch (MSG2LEVEL(msp)) {
        case MSGLEVEL_CRITICAL:
        case MSGLEVEL_FATAL:
        case MSGLEVEL_ERROR:
            // NRSTind (in effect)
            // Will pass network layer error upwards
            break;
 
        case MSGLEVEL_NOTICE:
            switch ( MSG2msgid_err (msp) ) {
            case MSG_IOevent_ConnectionClosed:
                // NDISind
                if ( classes & TP_CLASS_0 )
                    MSG_Tsap_NormalDisconnect_SET (msp);
                else
                    MSG_Tsap_NotSpecified_SET(msp);
                break;
 
            default:
                LOGmessage (msp);
                return false;
            }
            break;
 
        case MSGLEVEL_SUCCESS:
            switch ( MSG2msgid_err (msp) ) {
            case MSG_IOevent_Connected:
                // NCONconf
                if ( state == WFNC ) {
                    LOG_DEBUG (("TP %p NCONconf -> WFCC", this));
                    state = WFCC;
                    makeCR();
 
                } // else ignore it
                return false;
 
            default:
                LOGmessage (msp);
                return false;
            }
 
        default:
            LOGmessage (msp);
            return false;
        }
 
        // Closing down
        if ( provider->GetUser() ) {
            switch ( state ) {
            default:
            {
                DisconnectIndication disind;
                disind.msg = *msp;
                TDISind (disind);
                break;
            }
 
            case WFCR:
                // Inbound connection failed before being set up
                // User is listener so will not call Done()
                LOGmessage (msp);
                provider->Done();
                break;
 
 
            case WBCL:
            case CLOSING:
                // User should know that closing
                break;
            }
 
        } else {
            LOGmessage (msp);
        }
 
        // network should already be closed
        net = 0;
 
        state = CLOSED;
 
        return true;
    }

References CLOSING, TP_CLASS_0, WBCL, WFCC, WFCR, and WFNC.

GetSaveInfo()

void Transport::Layer::GetSaveInfo	(	char *	buffer,
		size_t	buflen
	)

Get save information from layer.

Definition at line 524 of file TPlayer.C.

    {
        char callingsel[2*TSSIZE+1];
        char callingadd[2*NASIZE+1];
        char calledsel[2*TSSIZE+1];
        char calledadd[2*NASIZE+1];
 
        SaveAddr (connect.calling, callingsel, callingadd);
        SaveAddr (connect.called, calledsel, calledadd);
 
        if ( snprintf (buffer, buflen,
                       "%u:%u:%u:%u:%d:%d:%s.%s:%s.%s",
                       classes, maxtpdu, srcref, dstref,
                       useprefsize, state,
                       callingsel, callingadd,
                       calledsel, calledadd) < 0 )
            // buffer filled on Windows; thus not NUL terminated
            buffer[buflen-1] = '\0';
    }

SetSaveInfo()

bool Transport::Layer::SetSaveInfo

(

const char *

buffer

)

Set state from save info.

Definition at line 545 of file TPlayer.C.

    {
        int istate;
        int iuse;
 
        char callingsel[2*TSSIZE+1];
        char callingadd[2*NASIZE+1];
        char calledsel[2*TSSIZE+1];
        char calledadd[2*NASIZE+1];
 
        if ( sscanf (buffer, "%u:%u:%u:%u:%d:%d"
                     ":%[0-9A-Fa-f].%[0-9A-Fa-f]"
                     ":%[0-9A-Fa-f].%[0-9A-Fa-f]",
                     &classes, &maxtpdu, &srcref, &dstref,
                     &iuse, &istate,
                     callingsel, callingadd,
                     calledsel, calledadd) != 10 )
            return false;
 
        RestoreAddr (connect.calling, callingsel, callingadd);
        RestoreAddr (connect.called, calledsel, calledadd);
 
        state = static_cast<State>(istate);
        useprefsize = (iuse != 0);
 
        return true;
    }

SendConnectIndication()

void Transport::Layer::SendConnectIndication

(

)

Send TS user a connect indication.

Definition at line 752 of file TPlayer.C.

                                      {
        ConnectIndication conind;
 
        conind.newprovider = provider;
        conind.calling = connect.calling;
        conind.called = connect.called;
        conind.expedited = false;
        conind.tsdusize = maxtpdu - ((classes & TP_CLASS_0) ? 3 : 5);
 
        // No user data at the moment
        conind.cc = 0;
        conind.data = 0;
 
        provider->GetUser()->Deliver (&conind);
    }

References TP_CLASS_0.

---

The documentation for this class was generated from the following files:

• TPlayer.h
• TPlayer.C