ss7_mtp2.cpp

实现了SS7中MTP2层的基本功能

            //TODO: Erase all MSUs in RTB and TB;
            RTBfull = false;
            Cm = 0;
            TXC_FSNF = (BSNR + 1) % 128; // BSNR is common for TXC & RC
            TXC_FSNL = BSNR;
            TXC_FSNT = BSNR;
            timers[6].started = false; // Stop T7;
            break;

        default:
            break;
        }
        break;

    default:
        break;
    }

    return 0;
}

void SS7_MTP2::FISUMSURecvdBSNRBIBR(SUWithLength * _pSUWithLen)
{
    printf("SS7_MTP2::FISUMSURecvdBSNRBIBR() !\n" );

    MTP2_FSM_Event event_out;

    if( FISUMSUaccepted )
    {
        if( congestionDiscard )
        {
            if( _pSUWithLen->header.LI > 2 ) // SUTypeMSU
            {
                RTR = 1;
            }
            // discard SU;
            AppendEvent( MTP2_FSM_CC, CCEventBusy );
        }
        else
        {
            if( FSNR == RC_FSNX )
            {
                if( _pSUWithLen->header.LI > 2 ) // This is a MSU
                {
                    // report received message to L3
                    //    now we just write the message into MSU2L3Buffer for L3 accessing
                    MSU2L3Buffer.write( (unsigned char *)_pSUWithLen,
                                        _pSUWithLen->len + sizeof(unsigned short) );
                    printf("SS7_MTP2::FISUMSURecvdBSNRBIBR() - MSU2L3Buffer.write!\n" );

                    RC_FSNX = (RC_FSNX + 1) % 128; // next FSN expected from other side
                    printf("SS7_MTP2::FISUMSURecvdBSNRBIBR() - FSNX ++ to %d\n", RC_FSNX );

                    RTR = 0; // not resending
                    if( congestionAccept )
                    {
                        AppendEvent( MTP2_FSM_CC, CCEventBusy );
                    }
                    else
                    {
                        AppendEventWithParam( MTP2_FSM_TXC, TXCEventFSNXValue, RC_FSNX );
                    }
                }
                else // SU != MSU, it must be FISU
                {
                    if( congestionAccept )
                    {
                        AppendEvent( MTP2_FSM_CC, CCEventBusy );
                        // Discard SU;
                    }
                    else
                    {
                        printf("SS7_MTP2::FISUMSURecvdBSNRBIBR() - will send NACK back!\n" );
                        AppendEvent( MTP2_FSM_TXC, TXCEventNACKToBeSent );
                        RTR = 1;
                        RC_FIBX = (RC_FIBX + 1) % 2;
                        //  Discard SU;
                    }
                }
            }
            else // FSNR <> FSNX 
            {
                if( FSNR == ((RC_FSNX-1+128) % 128) ) // FSNR is common too (temporary)
                {
                    // Discard SU;
                }
                else
                {
                    if( congestionAccept )
                    {
                        AppendEvent( MTP2_FSM_CC, CCEventBusy );
                        // Discard SU;
                    }
                    else
                    {
                        AppendEvent( MTP2_FSM_TXC, TXCEventNACKToBeSent );
                        RTR = 1;
                        RC_FIBX = (RC_FIBX + 1) % 2;
                        // Discard SU;
                    }
                }
            }
        }
    }
    else // ! FISUMSUaccepted
    {
        // Discard SU;
    }
}

int SS7_MTP2::RC(int event_in, unsigned long param)
{
//    printf("SS7_MTP2::RC() - event=%d, param=%d!\n",
//            event_in, (unsigned int)param );

    RCEvent event = (RCEvent)event_in;
    MTP2_FSM_Event event_out;

    switch( rcState )
    {
    case RCStateIdle:
        printf("SS7_MTP2::RC() - State=RCStateIdle!\n" );

        switch( event )
        {
        case RCEventRetrieveBSNT: // LSC 

            BSNT = (RC_FSNX - 1 + 128) % 128;
            // report BSNT value to L3
            break;

        case RCEventStart: // LSC 
            printf("SS7_MTP2::RC() - event=RCEventStart!\n" );

            // clear the recvBuffer
            recvBuffer.reset();

            AppendEvent( MTP2_FSM_DAEDR, DAEDREventStart );

            RC_FSNX = 0;
            RC_FIBX = 1;

            RC_FSNF = 0;
            RC_FSNT = 127;
            RTR = 0; // If = 1 means retransmission expected

            FISUMSUaccepted = false;
            abnormalBSNR = false;
            abnormalFIBR = false;
            congestionDiscard = false;
            congestionAccept = false;

            rcState = RCStateInService;
            break;

        default:
            break;
        }
        break;

    case RCStateInService:
        printf("SS7_MTP2::RC() - State = RCStateInService!\n" );

        switch( event )
        {
        case RCEventStop: // LSC 
            printf("SS7_MTP2::RC() - Event = RCEventStop!\n" );

            AppendEvent( MTP2_FSM_CC, CCEventNormal );
            rcState = RCStateIdle;
            break;

        case RCEventFSNTValue: // TXC 
            printf("SS7_MTP2::RC() - Event=RCEventFSNTValue, FSNT=%d!\n", param );

            RC_FSNT = param;
            break;

        case RCEventRejectMSUFISU: // LSC 

            FISUMSUaccepted = false;
            break;

        case RCEventAcceptMSUFISU: // LSC 

            FISUMSUaccepted = true;
            break;

        case RCEventSignalUnit: // DAEDR 
            printf("SS7_MTP2::RC() - Event = RCEventSignalUnit!\n" );

            // We've put received SU (correct one) into recvBuffer,
            // now we need to read out the SU from recvBuffer

            recvBuffer.read( (unsigned char *) & pSUWithLen->len, sizeof(unsigned short) );
            recvBuffer.read( (unsigned char *) & pSUWithLen->header, pSUWithLen->len );
            // IS THERE any chance the 2 "read"s be interupted?

            // record the old BSNR            
            BSNR = pSUWithLen->header.BSN;
            BIBR = pSUWithLen->header.BIB;
            FSNR = pSUWithLen->header.FSN;
            FIBR = pSUWithLen->header.FIB;

            printf("SS7_MTP2::RC() - got SU len=%d,LI=%d, BSNR=%d,FSNR=%d,BIBR=%d,FIBR=%d!",
                   pSUWithLen->len, pSUWithLen->header.LI,
                   BSNR, FSNR, BIBR, FIBR );
            if( pSUWithLen->header.LI == 0 ) printf(", FISU");
            else if( pSUWithLen->header.LI > 2 ) printf(",  MSU");
            else printf(", LSSU, SF=%d", ((LSSU*)(&pSUWithLen->header))->SF );
            printf("\n");

            if( pSUWithLen->header.LI == 1 || pSUWithLen->header.LI == 2 ) // LSSU
            {
                LSSU * pLssu = (LSSU *) & pSUWithLen->header;
                switch( (LSSUType) (pLssu->SF & 0x07) )
                {
                case LSSUTypeSIN:
                    AppendEvent( MTP2_FSM_LSC, LSCEventGotSIN );
                    AppendEvent( MTP2_FSM_IAC, IACEventGotSIN );
                    break;
                case LSSUTypeSIE:
                    AppendEvent( MTP2_FSM_LSC, LSCEventGotSIE );
                    AppendEvent( MTP2_FSM_IAC, IACEventGotSIE );
                    break;
                case LSSUTypeSIO:
                    AppendEvent( MTP2_FSM_LSC, LSCEventGotSIO );
                    AppendEvent( MTP2_FSM_IAC, IACEventGotSIO );
                    break;
                case LSSUTypeSIOS:
                    AppendEvent( MTP2_FSM_LSC, LSCEventGotSIOS );
                    AppendEvent( MTP2_FSM_IAC, IACEventGotSIOS );
                    break;
                case LSSUTypeSIPO:
                    AppendEvent( MTP2_FSM_LSC, LSCEventGotSIPO );
                    break;
                case LSSUTypeSIB:
                    AppendEvent( MTP2_FSM_TXC, TXCEventGotSIB );
                    break;
                default:
                    break;
                }
            }
            else // SU is not LSSU, so it's FISU or MSU
            {
                // The comparison is based on 128 modulo
                bool normalBSNR = false;
                if( BSNR == (RC_FSNF - 1 + 128) % 128 ) // same with the last BSN
                {
                    normalBSNR = true;
                }
                else if( RC_FSNF <= RC_FSNT ) // normal positioin
                {
                    // if FSNF=0, FSNF-1 = -1, which satisfies the inequality
                    normalBSNR = ( (RC_FSNF - 1 <= BSNR) && ( BSNR <= RC_FSNT ) );
                }
                else // turn around, FSNF > FSNT, so FSNF > 0
                {
                    normalBSNR = ( (RC_FSNF - 1 <= BSNR) || ( BSNR <= RC_FSNT ) );
                }
                printf("SS7_MTP2::RC() - oldBSNR=%d,BSNR=%d,FSNF=%d,FSNT=%d - %s!\n",
                       (RC_FSNF - 1 + 128) % 128, BSNR, RC_FSNF, RC_FSNT,
                       normalBSNR ? "Normal" : "Abnormal" );

                if( normalBSNR )
                {
                    printf("SS7_MTP2::RC() - it's a normal BSNR(%d)!\n", BSNR );
                    if( abnormalBSNR )
                    {
                        if( UNB == 1 )
                        {
                            abnormalBSNR = false;
                            if( FIBR == RC_FIBX )
                            {
                                if( abnormalFIBR )
                                {
                                    printf("SS7_MTP2::RC() - abnormal FIBR, UNF=%d!\n", UNF );
                                    if( UNF == 1 )
                                    {
                                        abnormalFIBR = false;
                                        AppendEvent( MTP2_FSM_LSC, LSCEventFISUMSUReceived );
                                        AppendEventWithParam( MTP2_FSM_TXC,
                                              TXCEventBSNRAndBIBR, (BIBR << 16) | BSNR );
                                        RC_FSNF = (BSNR + 1) % 128;

                                        FISUMSURecvdBSNRBIBR( pSUWithLen );
                                    }
                                    else
                                    {
                                        UNF = 1;
                                        // Discard SU
                                    }

                                }
                                else
                                {
                                    AppendEvent( MTP2_FSM_LSC, LSCEventFISUMSUReceived );
                                    AppendEventWithParam( MTP2_FSM_TXC, TXCEventBSNRAndBIBR,
                                               (BIBR << 16 ) | BSNR );
                                    RC_FSNF = (BSNR + 1) % 128;

                                    FISUMSURecvdBSNRBIBR( pSUWithLen );
                                }
                            }
                        }
                        else // UNB != 1
                        {
                            UNB = 1;
                            // Discard SU;
                        }
                    }
                    else // ! abnormalBSNR
                    {
                        if( FIBR == RC_FIBX )
                        {
                            if( abnormalFIBR )
                            {
                                if( UNB == 1 )
                                {
                                    abnormalFIBR = false;
                                    AppendEvent( MTP2_FSM_LSC, LSCEventFISUMSUReceived );
                                    AppendEventWithParam( MTP2_FSM_TXC, TXCEventBSNRAndBIBR,
                                               (BIBR << 16) | BSNR );
                                    RC_FSNF = (BSNR + 1) % 128;

                                    FISUMSURecvdBSNRBIBR( pSUWithLen );
                                }
                                else // UNB != 1
                                {
                                    UNB = 1;
                                    // Discard SU;
                                }
                            }
                            else // ! abnormalFIBR
                            {
                                printf("SS7_MTP2::RC() - normal FIBR!\n" );

                                AppendEvent( MTP2_FSM_LSC, LSCEventFISUMSUReceived );
                                AppendEventWithParam( MTP2_FSM_TXC, TXCEventBSNRAndBIBR,
                                           (BIBR << 16) | BSNR );
                                RC_FSNF = (BSNR + 1) % 128;

                                FISUMSURecvdBSNRBIBR( pSUWithLen );
                            }
                        }
                        else // FIBR != FIBX
                        {
                            // Discard SU;
                            if( abnormalFIBR )
                            {
                                AppendEvent( MTP2_FSM_LSC, LSCEventLinkFailure );
                                rcState = RCStateIdle;
                            }
                            else
                            {
                                printf("SS7_MTP2::RC() - normal FIBR, RTR=%d!\n", RTR );
                                if( RTR == 1 )
                                {
                                    AppendEventWithParam( MTP2_FSM_TXC, TXCEventBSNRAndBIBR,
                                           (BIBR << 16) | BSNR );
                                    RC_FSNF = (BSNR + 1) % 128;
                                }
                                else
                                {
                                    abnormalFIBR = true;
                                    UNF = 0;
                                }
                            }
                        }
                    }
                }
            }
            break;

        case RCEventRetrieveBSNT: // LSC

            BSNT = (RC_FSNX - 1 + 128) % 128;
            // report BSNT value to L3
            break;

        case RCEventCongestionDiscard: // somewhere

            congestionDiscard = true;
            break;

        case RCEventCongestionAccept: // somewhere

            congestionAccept = true;
            break;

        case RCEventNoCongestion: // somewhere

            congestionDiscard = false;
            congestionAccept = false;

            AppendEvent( MTP2_FSM_CC, CCEventNormal );
            AppendEventWithParam( MTP2_FSM_TXC, TXCEventFSNXValue, RC_FSNX );