TPlayer.C

// -*- 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.
 
// TPlayer.C
//
// Implementation of Transport Class 0 and 2 (for RFC 2126 et. al)
//
// @VERSION@
 
#include "../include/TPlayer.h"
 
#include "../include/EventSvc.h"
 
#include <isode/messages/ioevent.h>
 
// Default TPDU max sizes
 
#define MINMAXTPDU 128
#define MAXTPDU0 2048
#define MAXTPDU2 8192
 
namespace Transport {
#if defined(__clang__)
    const unsigned TPbuffer::TPBINC;
#endif
 
    enum TPPDUcode {
        PDU_CR = 0xE0,
        PDU_CC = 0xD0,
        PDU_DR = 0x80,
        PDU_DC = 0xC0,
        PDU_DT = 0xF0,
        PDU_ED = 0x10,
        PDU_AK = 0x60,
        PDU_EA = 0x20,
        PDU_RJ = 0x50,
        PDU_ER = 0x70
    };
 
    enum PARAMcode {
        PARAM_tpdusize     = 0xC0,
        PARAM_calling_tsel = 0xC1, // CR
        PARAM_invalid_tpdu = 0xC1, // ER
        PARAM_called_tsel  = 0xC2, // CR
        PARAM_respond_tsel = 0xC2, // CC
        PARAM_checksum     = 0xC3,
        PARAM_version      = 0xC4,
        PARAM_protection   = 0xC5,
        PARAM_additional   = 0xC6,
        PARAM_altclasses   = 0xC7,
        PARAM_acktime      = 0x85,
        PARAM_residerr     = 0x86,
        PARAM_priority     = 0x87,
        PARAM_transitdelay = 0x88,
        PARAM_throughput   = 0x89,
        PARAM_sequenceno   = 0x8A, // in AK
        PARAM_reasstime    = 0x8B,
        PARAM_flowctrl     = 0x8C, // in AK
        PARAM_selectack    = 0x8F, // in AK
        PARAM_addinfo      = 0xE0, // in DR
        PARAM_prefmaxtpdu  = 0xF0,
        PARAM_inacttime    = 0xF2,
 
        EOT_FLAG = 0x80
    };
 
    pthread_mutex_t Layer::refmutex = PTHREAD_MUTEX_INITIALIZER;
    unsigned Layer::refvalue = 0;
 
    Layer::~Layer()
    {
        free (connect.data);
    }
 
    // TCONreq
    void Layer::Deliver (ConnectRequest *req)
    {
        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);
    }
 
    //---------------
    // TCONresp
    void Layer::Deliver (ConnectResponse *req)
    {
        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 ();
    }
 
    //---------------
    // TDTreq/TEXreq
    void Layer::Deliver (DataRequest *req)
    {
        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);
    }
 
    //---------------
    // TDISreq
    void Layer::Deliver (DisconnectRequest *data)
    {
        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);
    }
 
    //---------------
    void Layer::NetworkRead (struct qbuf *qb)
    {
        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);
    }
 
    // Network disconnect indication
    bool Layer::NetworkStatus (MSGstruct *msp)
    {
        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;
    }
 
    //-------------
    void Layer::ProtocolError (struct qbuf *qb,
                               int poffset,
                               enum RejectCause cause)
    {
        if ( net != 0 ) {
            makeER (cause, reinterpret_cast<u_char *>(qb->qb_data), poffset);
            CloseNetwork();
        }
    }
 
 
    //-------------
    void Layer::SendUserDR (enum DRreason reason, const char *text)
    {
        DisconnectIndication disind;
 
        switch ( reason ) {
        case DR_waitclose:
        case DR_notspecified:
            MSG_Tsap_NotSpecified_SET (&disind.msg);
            break;
 
        case DR_congestion:
            MSG_Tsap_Congestion_SET (&disind.msg);
            break;
 
        case DR_nosession:
            MSG_Tsap_NoSession_SET (&disind.msg);
            break;
 
        case DR_address:
            MSG_Tsap_AddressUnknown_SET (&disind.msg);
            break;
 
        case DR_normal:
            MSG_Tsap_NormalDisconnect_SET (&disind.msg);
            break;
 
        case DR_remcongested:
            MSG_Tsap_RemoteCongestion_SET (&disind.msg);
            break;
 
        case DR_negotiation:
            MSG_Tsap_Negotiation_SET (&disind.msg);
            break;
 
        case DR_duplicate:
            MSG_Tsap_Duplicate_SET (&disind.msg);
            break;
 
        case DR_mismatched:
            MSG_Tsap_Mismatch_SET (&disind.msg);
            break;
 
        case DR_protocol:
            MSG_Tsap_Protocol_SET (&disind.msg);
            break;
 
        case DR_reference:
            MSG_Tsap_Overflow_SET (&disind.msg);
            break;
 
        case DR_network:
            MSG_Tsap_NetRefused_SET (&disind.msg);
            break;
 
        case DR_invalidlen:
            MSG_Tsap_InvalidLength_SET (&disind.msg);
            break;
        }
 
        if ( text != 0 ) {
            MSGstruct addmsg;
 
            MSG_Tsap_UserData_SET (&addmsg, text);
 
            MSGappend (&disind.msg, &addmsg);
        }
 
        if ( provider->GetUser() == 0 ) {
            // If no user, then log the message here
            LOGmessage (&disind.msg);
        } else {
            TDISind (disind);
        }
    }
 
    //-------------
    void Layer::InternalError (enum DRreason reason, const char *text)
    {
        if ( state != CLOSED && net != 0 ) {
            if ( classes & TP_CLASS_0 ) {
                net->DisconnectRequest();
                net = 0;
                state = CLOSED;
            } else {
                makeDR (reason, 0, 0);
                state = CLOSING;
            }
        }
 
        SendUserDR (reason, text);
    }
 
    //-------------
    static void SaveAddr (const tsapADDR &ta, char *selbuf, char *addbuf)
    {
        if ( ta.ta_selectlen > 0 )
            selbuf[explode (selbuf,
                            (const u_char *)ta.ta_selector,
                            ta.ta_selectlen)] = '\0';
        else
            strcpy (selbuf, "0");
 
        addbuf[explode (addbuf,
                        (const u_char *)ta.ta_addr.na_address,
                        ta.ta_addr.na_addrlen)] = '\0';
    }
 
    //-------------
    static void RestoreAddr (tsapADDR &ta, const char *selbuf, const char *addbuf)
    {
        ta.ta_selectlen = implode ((u_char *)ta.ta_selector,
                                   selbuf,
                                   strlen(selbuf));
 
        ta.ta_addr.na_addrlen = implode ((u_char *)ta.ta_addr.na_address,
                                         addbuf,
                                         strlen(addbuf));
    }
 
    //-------------
    void Layer::GetSaveInfo (char *buffer, size_t buflen)
    {
        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';
    }
 
    //-------------
    bool Layer::SetSaveInfo (const char *buffer)
    {
        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;
    }
 
    //--------------------------------------------------------------------
    // TPDU handling
 
    void Layer::getCR (struct qbuf *qb)
    {
        if ( state != WFCR ) {
            LOG_DEBUG (("Ignore CR in state %d", state));
            return;
        }
 
        if ( provider->GetUser() == 0 ) {
            MSG_Tsap_NoUser_LOG("Layer:getCR");
            ProtocolError (qb, 1, Reject_NotSpecified);
            return;
        }
 
        const u_char *dp = reinterpret_cast<const u_char *>(qb->qb_data);
 
        if ( dp[0] < 6 ) {
            MSG_Tsap_RejectUnspecified_LOG ("Bad length field in CR");
            ProtocolError (qb, 1, Reject_NotSpecified);
            return;
        }
 
        if ( dp[2] != 0 || dp[3] != 0 ) {
            MSG_Tsap_RejectBadValue_LOG ("dst-ref");
            ProtocolError (qb, 4, Reject_InvalidParameterValue);
            return;
        }
 
        // Their SRC-REF is our DST-REF
        dstref = (dp[4]<<8) | dp[5];
 
        classes = (1U<<(dp[6]>>4));
 
        unsigned options = dp[6] & 0xF;
 
        if ( options & 0xC ) {
            MSG_Tsap_RejectBadValue_LOG ("options");
            ProtocolError (qb, 7, Reject_InvalidParameterValue);
            return;
        }
 
        // Initialize non-network fields in connect data structure
        connect.calling.ta_selectlen = 0;
        connect.called.ta_selectlen = 0;
        connect.expedited = false;
        connect.data = 0;
        connect.cc = 0;
        memset (&connect.qos, 0, sizeof (connect.qos));
 
        const u_char *pp = dp + 7;
        const u_char *ud = dp + dp[0] + 1;
 
        unsigned maxsize = MINMAXTPDU;
 
        while ( pp < ud - 2 ) {
            unsigned plen = pp[1];
 
            if ( pp + plen > ud - 2 ) {
                MSG_Tsap_RejectUnspecified_LOG ("Bad parameter length field");
                ProtocolError (qb, pp - dp + 2, Reject_NotSpecified);
                return;
            }
 
            switch ( pp[0] ) {
            case PARAM_calling_tsel: // Calling TSEL
                if ( plen <= TSSIZE ) {
                    memcpy (connect.calling.ta_selector, pp+2, plen);
                    connect.calling.ta_selectlen = plen;
                }
                break;
 
            case PARAM_called_tsel: // Called TSEL
                if ( plen <= TSSIZE ) {
                    memcpy (connect.called.ta_selector, pp+2, plen);
                    connect.called.ta_selectlen = plen;
                }
                break;
 
            case PARAM_tpdusize: // TPDU size
            {
                if ( pp[2] < 7 || 13 < pp[2] ) {
                    MSG_Tsap_RejectBadValue_LOG ("TPDU size");
 
                    // Limit to max valid size
                    maxsize = 1U<<13;
                } else {
                    maxsize = 1U<<pp[2];
                }
                break;
            }
 
            case PARAM_prefmaxtpdu: // Preferred MAX TPDU size
            {
                unsigned psize = 0;
                for ( unsigned i = 0; i < plen; i++ ) {
                    psize <<= 8;
                    psize |= pp[2+i];
                }
 
                // Parameter value is size /128
                psize <<= 7;
 
                if ( psize < MINMAXTPDU || 65530 < psize ) {
                    MSG_Tsap_RejectBadValue_LOG ("Preferred TPDU size");
                    ProtocolError (qb, pp - dp + 2 + plen,
                                   Reject_InvalidParameterValue);
                    return;
                }
 
                maxsize = psize;
                useprefsize = true;
                break;
            }
 
            case PARAM_version: // Version number
                if ( pp[2] != 1 ) {
                    MSG_Tsap_RejectBadValue_LOG ("Version number");
                    ProtocolError (qb, pp - dp + 2 + plen,
                                   Reject_InvalidParameterValue);
                    return;
                }
                break;
 
            case PARAM_additional: // Additional option selection
                // No action at present
                break;
 
            case PARAM_altclasses: // Alternative protocol classes
            {
                for ( unsigned i = 0; i < plen; i++ )
                    classes |= (1U<<(pp[i+2]>>4));
 
                break;
            }
 
            case PARAM_protection:   // Protection parameters
            case PARAM_acktime:      // Acknowledgement time
            case PARAM_throughput:   // Throughput
            case PARAM_residerr:     // Residual error rate
            case PARAM_priority:     // Priority
            case PARAM_transitdelay: // Transit delay
            case PARAM_reasstime:    // Reassignment time
            case PARAM_inacttime:    // Inactivity timer
            default:
                // Known parameters which are ignored
                LOG_DEBUG (("Ignore parameter type 0x%2.2X", pp[0]));
                break;
            }
 
            pp += plen + 2;
        }
 
        // Set the size to be used to the smaller of the local limit and
        // the proposed size.
        if ( maxsize < maxtpdu )
            maxtpdu = maxsize;
 
        // Set the state so that DRs will be sent even if generated locally
        state = WFTRESP;
 
        // Reject CR No suitable classes
        classes &= (TP_CLASS_2|TP_CLASS_0);
 
        if ( classes == 0 ) {
            InternalError (DR_negotiation, "No suitable classes");
            return;
        }
 
        if ( classes & TP_CLASS_2 )
            classes = TP_CLASS_2;
        else
            classes = TP_CLASS_0;
 
        SendConnectIndication();
    }
 
    //-------------
    void Layer::SendConnectIndication() {
        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);
    }
 
    //-------------
    void Layer::getCC (struct qbuf *qb)
    {
        switch ( state ) {
        default:
            ProtocolError (qb, 2, Reject_NotSpecified);
            return;
 
        case CLOSING:
            LOG_DEBUG (("CC received in state closing"));
            return;
 
        case CLOSED:
            SendUserDR (DR_protocol, "CC received when closed");
            return;
 
        case WFCC:
        case WBCL:
            // Handled later
            break;
        }
 
        const u_char *dp = reinterpret_cast<const u_char *>(qb->qb_data);
 
        if ( dp[0] < 6 ) {
            MSG_Tsap_RejectUnspecified_LOG ("Bad length field in CC");
            ProtocolError (qb, 1, Reject_NotSpecified);
            return;
        }
 
        if ( !DstRefOK (qb) ) return;
 
        classes = (1U<<(dp[6]>>4));
 
        unsigned options = dp[6] & 0xF;
 
        if ( options & 0xC ) {
            MSG_Tsap_RejectBadValue_LOG ("options");
            ProtocolError (qb, 7, Reject_InvalidParameterValue);
            return;
        }
 
        const u_char *pp = dp + 7;
        const u_char *ud = dp + dp[0] + 1;
 
        unsigned maxsize = MINMAXTPDU; // Default if no size parameters
 
        while ( pp < ud - 2 ) {
            unsigned plen = pp[1];
 
            if ( pp + plen > ud - 2 ) {
                MSG_Tsap_RejectUnspecified_LOG ("Bad parameter length field");
                ProtocolError (qb, pp - dp + 2, Reject_NotSpecified);
                return;
            }
 
            switch ( pp[0] ) {
            case PARAM_respond_tsel: // Responsing TSEL
                if ( plen <= TSSIZE ) {
                    memcpy (connect.called.ta_selector, pp+2, plen);
                }
                break;
 
            case PARAM_tpdusize: // TPDU size
            {
                if ( pp[2] < 7 || 13 < pp[2] ) {
                    MSG_Tsap_RejectBadValue_LOG ("TPDU size");
                    ProtocolError (qb, pp - dp + 2 + plen,
                                   Reject_InvalidParameterValue);
                    return;
                }
 
                unsigned psize = 1U<<pp[2];
                if ( psize > maxsize )
                    maxsize = psize;
 
                break;
            }
 
            case PARAM_prefmaxtpdu: // Preferred MAX TPDU size
            {
                unsigned psize = 0;
                for ( unsigned i = 0; i < plen; i++ ) {
                    psize <<= 8;
                    psize |= pp[2+i];
                }
 
                // Parameter value is size /128
                psize <<= 7;
 
                if ( psize < MINMAXTPDU || 65530 < psize ) {
                    MSG_Tsap_RejectBadValue_LOG ("Preferred TPDU size");
                    ProtocolError (qb, pp - dp + 2 + plen,
                                   Reject_InvalidParameterValue);
                    return;
                }
 
                if ( psize > maxsize )
                    maxsize = psize;
                break;
            }
 
            case PARAM_additional: // Additional option selection
                // No action at present
                break;
 
            case PARAM_calling_tsel: // Calling TSel
            case PARAM_protection:   // Protection parameters
            case PARAM_acktime:      // Acknowledgement time
            case PARAM_throughput:   // Throughput
            case PARAM_residerr:     // Residual error rate
            case PARAM_priority:     // Priority
            case PARAM_transitdelay: // Transit delay
            case PARAM_reasstime:    // Reassignment time
            case PARAM_inacttime:    // Inactivity timer
                // Known parameters which are ignored
                LOG_DEBUG (("Ignore parameter type 0x%2.2X", pp[0]));
                break;
 
            default:
                MSG_Tsap_RejectBadParam_LOG (pp[0]);
                ProtocolError (qb, pp - dp + 1, Reject_InvalidParameterCode);
                return;
            }
 
            pp += plen + 2;
        }
 
        maxtpdu = maxsize;
 
        if ( state == WBCL || provider->GetUser() == 0 ) {
            if ( classes & TP_CLASS_0 ) {
                CloseNetwork();
 
            } else {
                makeDR (DR_nosession, 0, 0);
                state = CLOSING;
            }
            return;
        }
 
        bool CCOK = true;
 
        if ( (options & 1) == 0 && (classes & TP_CLASS_0) == 0 )
            CCOK = false;
 
        if ( CCOK ) {
            ConnectConfirm conconf;
 
            conconf.responding = connect.called;
            conconf.expedited  = connect.expedited;
 
            conconf.tsdusize = maxtpdu - ((classes & TP_CLASS_0) ? 3 : 5);
 
            // Check for user data
            if ( static_cast<unsigned>(dp[0] + 1) < qb->qb_len ) {
 
                conconf.cc = qb->qb_len - dp[0] - 1;
 
                char *userdata = static_cast<char *>(malloc (conconf.cc));
                if ( userdata != 0 )
                    memcpy (userdata, dp + dp[0] + 1, conconf.cc );
                else
                    conconf.cc = 0;
 
                conconf.data = userdata;
 
            } else {
                conconf.cc = 0;
                conconf.data = 0;
            }
 
            state = OPEN;
 
            TSnotify (provider->GetUser()->Deliver(&conconf));
 
        } else {
            if ( classes & TP_CLASS_0 ) {
                CloseNetwork();
 
            } else {
                makeDR (DR_negotiation, 0, 0);
                state = CLOSING;
            }
 
            DisconnectIndication disind;
 
            MSG_Tsap_Negotiation_SET (&disind.msg);
            TDISind (disind);
        }
    }
 
    //-------------
    void Layer::getDR (struct qbuf *qb)
    {
        const u_char *dp = reinterpret_cast<const u_char *>(qb->qb_data);
 
        if ( dp[0] < 6 ) {
            MSG_Tsap_RejectUnspecified_LOG ("Bad length field in DR");
            ProtocolError (qb, 1, Reject_NotSpecified);
            return;
        }
 
        if ( !DstRefOK (qb) ) return;
 
        uint16_t sourceref = (dp[4]<<8) | dp[5];
 
        bool sendTDISind = true;
 
        LOG_DEBUG (("getDR (reason=%d)", dp[6]));
 
        switch ( state ) {
        case CLOSING:
            CloseNetwork ();
            return;
 
        case OPEN:
            // Note: should fault DR in Class 0, but RFC 1006
            // can send it, so allow, but no DC
            if ( (classes & TP_CLASS_0) == 0 ) {
                makeDC();
            }
            break;
 
        case WFNC: // (should not occur!)
        case WFCR:
        case WFCC:
        case WFTRESP:
            break;
 
        case WBCL:
            sendTDISind = false;
            break;
 
        case CLOSED:
            if ( (classes & TP_CLASS_0) == 0 && sourceref != 0 ) {
                dstref = sourceref;
                makeDC();
            }
            break;
        }
 
        state = CLOSED;
        CloseNetwork();
 
        if ( sendTDISind ) {
            // ignore additional information and user data
            SendUserDR (static_cast<enum DRreason>(dp[6]), 0);
        }
    }
 
    //-------------
    void Layer::getDC (struct qbuf *qb)
    {
        const u_char *dp = reinterpret_cast<const u_char *>(qb->qb_data);
 
        if ( dp[0] < 6 ) {
            MSG_Tsap_RejectUnspecified_LOG ("Bad length field");
            ProtocolError (qb, 1, Reject_NotSpecified);
            return;
        }
 
        if ( !DstRefOK (qb) ) return;
 
        if ( state == CLOSED || state == CLOSING ) {
            CloseNetwork();
        } else {
            ProtocolError (qb, 1, Reject_NotSpecified);
            return;
        }
    }
 
    //-------------
    void Layer::getDT (struct qbuf *qb)
    {
        const u_char *dp = reinterpret_cast<const u_char *>(qb->qb_data);
 
        unsigned poffset;
 
        DataIndication dataind;
 
        dataind.expedited = false;
 
        if ( classes & TP_CLASS_0 ) {
            LOG_DEBUG (("getDT (0) (%d %2.2x) %ld",
                        dp[0], dp[2] & 0xFF, (long)qb->qb_len - 3));
 
            if ( dp[0] < 2 ) {
                MSG_Tsap_RejectUnspecified_LOG ("Bad length field");
                ProtocolError (qb, 1, Reject_NotSpecified);
                qb_free (qb);
                return;
            }
 
            dataind.eot = (dp[2] & 0x80) != 0;
 
            poffset = 3;
 
        } else {
            LOG_DEBUG (("getDT (2) (%d %2.2x) %ld",
                        dp[0], dp[4] & 0xFF, (long)qb->qb_len - 5));
 
            if ( dp[0] < 4 ) {
                MSG_Tsap_RejectUnspecified_LOG ("Bad length field");
                ProtocolError (qb, 1, Reject_NotSpecified);
                qb_free (qb);
                return;
            }
 
            if ( !DstRefOK (qb) ) return;
 
            dataind.eot = (dp[4] & 0x80) != 0;
 
            poffset = 5;
        }
 
        qb->qb_data += poffset;
        qb->qb_len  -= poffset;
 
        dataind.data = qb;
 
        if ( provider->GetUser() != 0 ) {
            TSnotify (provider->GetUser()->Deliver (&dataind));
 
        } else {
            qb_free (qb);
            InternalError (DR_nosession, "Missing user for DT");
        }
    }
 
    //-------------
    void Layer::getED (struct qbuf *qb)
    {
        // ED not supported at the moment
        ProtocolError (qb, 1, Reject_NotSpecified);
 
        // This routine responsible for qbuf
        qb_free (qb);
    }
 
    //-------------
    void Layer::getER (struct qbuf *qb)
    {
        const u_char *dp = reinterpret_cast<const u_char *>(qb->qb_data);
        
        if ( dp[0] > 3 )
            MSG_Tsap_RejectReceived_LOG (dp[4]);
 
        switch ( state ) {
        case CLOSED:
        case WFNC:
            return;
 
        case WBCL:
            CloseNetwork ();
            return;
 
        case WFCC:
            SendUserDR (DR_negotiation, "ER while in WFCC");
            CloseNetwork ();
            return;
 
        default:
            break;
        }
 
        SendUserDR (DR_protocol, "ER when open");
        CloseNetwork ();
    }
 
    //--------------------------------------------------------------------
    // TPDU creation
 
    //-------------
    void Layer::makeCR ()
    {
        u_char fixed[128]; // Total maximum length allowed
        u_char *dp = fixed + 1;
 
        *dp++ = PDU_CR; // CR+CDT (No initial credit as no explicit control flow)
        *dp++ = 0;    // DST-REF always zero
        *dp++ = 0;
 
        *dp++ = srcref>>8; // SRC-REF
        *dp++ = srcref;
 
        // Class Option
        if ( classes & TP_CLASS_2 ) {
            *dp++ = (2<<4) | 1; // Class 2, Normal formats, no explicit flow
        } else {
            *dp++ = 0;
        }
 
        // Set TPDU size
        unsigned logi;
        for ( logi = 7; logi < 13; logi++ )
            if ( (1U<<logi) >= maxtpdu )
                break;
 
        *dp++ = PARAM_tpdusize;
        *dp++ = 1;
        *dp++ = logi;
 
        // Note: could set Preferred Max TPDU size, but this parameter is
        // not in early X.224, and is not supported in the older ISODE TS
 
        // Set version number (unless using Class 0)
        if ( classes & TP_CLASS_2 ) {
            *dp++ = PARAM_version;
            *dp++ = 1;
            *dp++ = 1;
        }
 
        // Set additional options
        if ( connect.expedited ) {
            *dp++ = PARAM_additional;
            *dp++ = 1;
            *dp++ = 1;
        }
 
        // Set alternative protocol classes
        if ((classes & TP_CLASS_2) && (classes & TP_CLASS_0)) {
            *dp++ = PARAM_altclasses;
            *dp++ = 1;
            *dp++ = 0;
        }
 
        // Called selector
        if ( connect.called.ta_selectlen > 0 &&
             connect.called.ta_selectlen + (dp-fixed) < (int)sizeof fixed - 2){
            *dp++ = PARAM_called_tsel;
            *dp++ = connect.called.ta_selectlen;
            memcpy (dp, connect.called.ta_selector, connect.called.ta_selectlen);
            dp += connect.called.ta_selectlen;
        }
 
        // Calling selector
        if ( connect.calling.ta_selectlen > 0 &&
             connect.calling.ta_selectlen + (dp-fixed) < (int)sizeof fixed - 2){
            *dp++ = PARAM_calling_tsel;
            *dp++ = connect.calling.ta_selectlen;
            memcpy (dp, connect.calling.ta_selector, connect.calling.ta_selectlen);
            dp += connect.calling.ta_selectlen;
        }
 
        // Set LI
        unsigned len = dp - fixed;
        fixed[0] = len - 1;
 
        TPbuffer *bufp = GetBuffer();
        if ( bufp == 0 ) return;
 
        bufp = TPbuffer::Add (bufp, fixed, len);
        if ( bufp == 0 ) return;
 
        if ( connect.cc != 0 && (len + connect.cc) <= 128 )
            bufp = TPbuffer::Add (bufp,
                                  reinterpret_cast<const u_char *>(connect.data),
                                  connect.cc);
 
        WritePDU (bufp);
    }
 
    //-------------
    void Layer::makeCC ()
    {
        u_char fixed[128]; // Total maximum length allowed
        u_char *dp = fixed + 1;
 
        *dp++ = PDU_CC; // CC+CDT (No initial credit as no explicit flow control)
 
        *dp++ = dstref>>8; // DST-REF
        *dp++ = dstref;
 
        *dp++ = srcref>>8; // SRC-REF
        *dp++ = srcref;
 
        // Class Option
        if ( classes & TP_CLASS_2 ) {
            *dp++ = (2<<4) | 1; // Class 2, Normal formats, no explicit flow
        } else {
            *dp++ = 0;
        }
 
        // Set TPDU size
        if ( useprefsize ) {
            // Parameter value is number of 128 byte chunks
            // Cannot be more than 2 bytes in size
            unsigned pval = maxtpdu >> 7;
 
            *dp++ = PARAM_prefmaxtpdu;
            if ( pval & 0xFF00 ) {
                *dp++ = 2;
                *dp++ = pval>>8;
                *dp++ = pval;
            } else {
                *dp++ = 1;
                *dp++ = pval;
            }
 
        } else {
            unsigned logi;
            for ( logi = 7; logi < 13; logi++ )
                if ( (1U<<logi) >= maxtpdu )
                    break;
 
            *dp++ = PARAM_tpdusize;
            *dp++ = 1;
            *dp++ = logi;
        }
 
        // Set additional options
        if ( connect.expedited ) {
            *dp++ = PARAM_additional;
            *dp++ = 1;
            *dp++ = 1;
        }
 
        // Should not be alternative protocol classes
 
        // Called selector
        if ( connect.called.ta_selectlen > 0 &&
             connect.called.ta_selectlen + (dp-fixed) < (int)sizeof fixed - 2){
            *dp++ = PARAM_called_tsel;
            *dp++ = connect.called.ta_selectlen;
            memcpy (dp, connect.called.ta_selector, connect.called.ta_selectlen);
            dp += connect.called.ta_selectlen;
        }
 
        // Set LI
        unsigned len = dp - fixed;
        fixed[0] = len - 1;
 
        TPbuffer *bufp = GetBuffer();
        if ( bufp == 0 ) return;
 
        bufp = TPbuffer::Add (bufp, fixed, len);
        if ( bufp == 0 ) return;
 
        if ( connect.cc != 0 && (len + connect.cc) <= 128 )
            bufp = TPbuffer::Add (bufp,
                                  reinterpret_cast<const u_char *>(connect.data),
                                  connect.cc);
 
        WritePDU (bufp);
    }
 
    //-------------
    void Layer::makeDR (enum DRreason reason,
                             const char *data,
                             unsigned cc)
    {
        u_char fixed[128];
        u_char *dp = fixed + 1;
 
        *dp++ = PDU_DR; // DR
 
        *dp++ = dstref>>8; // DST-REF
        *dp++ = dstref;
 
        *dp++ = srcref>>8; // SRC-REF
        *dp++ = srcref;
 
        if ( state != CLOSED && (classes & TP_CLASS_2) == 0 ) {
            // If up and running and class 0, make valid reason code
            switch ( reason ) {
            case DR_notspecified:
            case DR_congestion:
            case DR_nosession:
            case DR_address:
                break;
 
            case DR_remcongested:
                reason = DR_congestion;
                break;
 
            case DR_normal:
            case DR_negotiation:
            case DR_duplicate:
            case DR_mismatched:
            case DR_protocol:
            case DR_reference:
            case DR_network:
            case DR_invalidlen:
            case DR_waitclose:
                reason = DR_notspecified;
                break;
            }
        }
 
        *dp++ = reason;    // Reason
 
        fixed[0] = dp - fixed - 1;
 
        if ( 0 < cc && cc <= 64 ) {
            memcpy (dp, data, cc);
            dp += cc;
        }
 
        TPbuffer *bufp = GetBuffer();
        if ( bufp == 0 ) return;
 
        WritePDU (TPbuffer::Add (bufp, fixed, dp - fixed));
    }
 
    //-------------
    void Layer::makeDC ()
    {
        u_char fixed[16];
        u_char *dp = fixed + 1;
 
        *dp++ = PDU_DC; // DC
 
        *dp++ = dstref>>8; // DST-REF
        *dp++ = dstref;
 
        *dp++ = srcref>>8; // SRC-REF
        *dp++ = srcref;
 
        fixed[0] = dp - fixed - 1;
 
        TPbuffer *bufp = GetBuffer();
        if ( bufp == 0 ) return;
 
        WritePDU (TPbuffer::Add (bufp, fixed, dp - fixed));
    }
 
    //-------------
    void Layer::makeDT (const struct udvec *uv, bool eot)
    {
        if ( uv == 0 || uv->uv_base == 0 ) return;
 
        u_char fixed[16];
        u_char *dp = fixed + 1;
 
        *dp++ = PDU_DT; // DT (no ack request)
 
        // No DST-REF in class 0
        if ( classes & TP_CLASS_2 ) {
            *dp++ = dstref>>8; // DST-REF
            *dp++ = dstref;
        }
 
        // TPDU-NR and EOT set later
        unsigned eotoff = dp - fixed;
 
        *dp++ = 0;
 
        fixed[0] = dp - fixed - 1;
 
        TPbuffer *bufp = GetBuffer();
        if ( bufp == 0 ) return;
        bufp = TPbuffer::Add (bufp, fixed, dp - fixed);
        if ( bufp == 0 ) return;
 
        for ( ; uv->uv_base ; uv++ ) {
            const u_char *datap = reinterpret_cast<const u_char *>(uv->uv_base);
            unsigned dlen = uv->uv_len;
 
            while ( dlen > 0 ) {
                unsigned dcopy = dlen;
 
                if ( bufp->dlen + dcopy > maxtpdu )
                    dcopy = maxtpdu - bufp->dlen;
 
                bufp = TPbuffer::Add (bufp, datap, dcopy);
                if ( bufp == 0 ) {
                    InternalError (DR_congestion, "out of memory");
                    return;
                }
 
                datap += dcopy;
                dlen  -= dcopy;
 
                if ( dlen > 0 ) {
                    // Must have filled the TPDU, so send it and get another
                    // as there is more data to send
 
                    // If we were to set the TPDU-NR, it should be set here
                    // EOT is only ever set on the last one of the group
                    WritePDU (bufp);
 
                    bufp = GetBuffer();
                    if ( bufp == 0 ) return;
                    bufp = TPbuffer::Add (bufp, fixed, dp - fixed);
                    if ( bufp == 0 ) return;                
                }
            }
        }
 
        if ( eot )
            bufp->data[bufp->doff+eotoff] |= EOT_FLAG;
 
        WritePDU (bufp);
    }
 
    //-------------
    void Layer::makeED (const u_char *data, unsigned len)
    {
        u_char fixed[32];
        u_char *dp = fixed + 1;
 
        *dp++ = PDU_ED; // ED
 
        *dp++ = dstref>>8; // DST-REF
        *dp++ = dstref;
 
        // Set ED-TPDU-NR + EOT
        *dp++ = EOT_FLAG;
 
        fixed[0] = dp - fixed - 1;
 
        TPbuffer *bufp = GetBuffer();
        if ( bufp == 0 ) return;
 
        bufp = TPbuffer::Add (bufp, fixed, dp - fixed);
 
        WritePDU (TPbuffer::Add (bufp,
                                 static_cast<const u_char *>(data),
                                 len));
    }
 
    //-------------
    void Layer::makeER (enum RejectCause cause,
                        const u_char *tpdu, unsigned len)
    {
        u_char fixed[256];
        u_char *dp = fixed + 1;
 
        *dp++ = PDU_ER; // ER
 
        *dp++ = dstref>>8; // DST-REF
        *dp++ = dstref;
 
        *dp++ = cause; // REJECT CAUSE
 
        if ( len > 0 ) {
            if ( len > 250 ) len = 250;
            *dp++ = PARAM_invalid_tpdu;
            *dp++ = len;
            memcpy (dp, tpdu, len);
            dp += len;
        }
 
        fixed[0] = dp - fixed - 1;
 
        TPbuffer *bufp = GetBuffer();
        if ( bufp == 0 ) return;
 
        WritePDU (TPbuffer::Add (bufp, fixed, dp - fixed));
    }
 
    //-----------------------------------------------------------------------
 
    class NotifyEvent : public Event::AsyncEvent {
        User_ptr_t    notifier;
 
    public:
        NotifyEvent (User_ptr_t np) : notifier(np) {}
 
        virtual void Deliver () {
            notifier->Notify();
            delete this;
        }
    };
 
    void TSnotify (User_ptr_t notifier)
    {
        if ( !notifier ||
             !notifier.get() ||
             !notifier.get()->ShouldNotify()) return;
 
        NotifyEvent *nevent = new NotifyEvent (notifier);
 
        Event::Manager::GetManager()->Queue (nevent);
    }
}