ss7_mtp2.cpp

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

            TXC_FSNF = 0; // FSN of the oldest MSU in the RTB 
            Cm = 0; // Counter of MSU in TB

            txcState = TXCStateInService;
            break;
        default:
            break;
        }

        break;

    case TXCStateInService:
        if( event_in != TXCEventTransmissionRequest )
        {
            printf("SS7_MTP2::TXC() - State = TXCStateInService!\n" );
        }

        switch( event )
        {
        case TXCEventSendSIOS:
        case TXCEventSendSIPO: // LSC 
            // Stop T7
            timers[6].started = false;

            LSSUAvailable = true;
            
            // populate the LSSU for SIOS/SIPO
            lssu.suHeader.LI = 1;
            if( event == TXCEventSendSIOS )
            {
                printf("SS7_MTP2::TXC() - Event = TXCEventSendSIOS!\n" );
                lssu.SF = LSSUTypeSIOS;
            }
            else
            {
                printf("SS7_MTP2::TXC() - Event = TXCEventSendSIPO!\n" );
                lssu.SF = LSSUTypeSIPO;
            }

            // store into the LSSUBuffer
            LSSUBuffer.write( (unsigned char *)& lssu, sizeof(lssu) );
            // printf("LSSUBuffer.write() - len=%d, LI=%d!\n", sizeof(lssu), lssu.suHeader.LI );
            break;

        case TXCEventSendSIO:
        case TXCEventSendSIN:
        case TXCEventSendSIE: // IAC 

            LSSUAvailable = true;

            // populate the LSSU for SIO/SIN/SIE
            lssu.suHeader.LI = 1;
            if( event == TXCEventSendSIO )
            {
                printf("SS7_MTP2::TXC() - Event = TXCEventSendSIO!\n" );
                lssu.SF = LSSUTypeSIO; // 000
            }
            else if( event == TXCEventSendSIN )
            {
                printf("SS7_MTP2::TXC() - Event = TXCEventSendSIN!\n" );
                lssu.SF = LSSUTypeSIN; // 001
            }
            else
            {
                printf("SS7_MTP2::TXC() - Event = TXCEventSendSIE!\n" );
                lssu.SF = LSSUTypeSIE; // 010
            }

            // store into the LSSUBuffer
            LSSUBuffer.write((unsigned char *) & lssu, sizeof(lssu) );
            // printf("LSSUBuffer.write() - len=%d, LI=%d!\n", sizeof(lssu), lssu.suHeader.LI );

            break;

        case TXCEventSendSIB: // CC 
            printf("SS7_MTP2::TXC() - Event = TXCEventSendSIB!\n" );
            LSSUAvailable = true;

            // populate the LSSU for SIO/SIN/SIE
            lssu.suHeader.LI = 1;
            lssu.SF = LSSUTypeSIB; // 101

            // store into the LSSUBuffer
            LSSUBuffer.write( (unsigned char *)& lssu, sizeof(lssu) );
            // printf("LSSUBuffer.write() - len=%d, LI=%d!\n", sizeof(lssu), lssu.suHeader.LI );
            break;

        case TXCEventT6Expired:
            printf("SS7_MTP2::TXC() - Event = TXCEventT6Expired!\n" );

            AppendEvent( MTP2_FSM_LSC, LSCEventLinkFailure );
            SIBreceived = false;
            // Stop T7
            timers[6].started = false;
            break;

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

            SIBreceived = false; // Status Indicator "Busy"
            RTBfull = false; // Retransmission Buffer Full
            MSUinhibited = false;

            TXC_FSNL = 127; // FSN of the last MSU in the RTB
            TXC_FSNT = 127; // FSN of the last MSU transmitted
            TXC_FSNX = 0; // FSN expected
            TXC_FIB = 1; // Forward indicator bit
            TXC_BIB = 1; // backward indicator bit

            TXC_FSNF = 0; // FSN of the oldest MSU in the RTB 
            Cm = 0; // Counter of MSU in TB
            //TODO: seems need to clear the sendBuffer
            break;

        case TXCEventTransmissionRequest: // DAEDT 
            // printf("SS7_MTP2::TXC() - event = TXCEventTransmissionRequest!\n" );

            if( LSSUAvailable )
            {
                TXC_SendLSSU();
            }
            else if( MSUinhibited )
            {
                TXC_SendFISU();
            }
            else if( TXC_FSNT == TXC_FSNL )  
            {
                // FSN of the last MSU transmitted == FSN of the last MSU in the RTB
                if( Cm == 0 ) // No MSU in TB
                {
                    TXC_SendFISU();
                }
                else if( RTBfull ) // No "space" in RTB, although there are MSUs in TB
                {
                    TXC_SendFISU();
                }
                else
                {
                    // Fetch MSU from TB
                    sendBuffer.read( (unsigned char *)& pSUWithLen->len,
                                     sizeof(unsigned short) );
                    sendBuffer.read( (unsigned char *)& pSUWithLen->header,
                                     (int)pSUWithLen->len );

                    Cm = Cm - 1;
                    TXC_FSNL = (TXC_FSNL + 1) % 128;
                    TXC_FSNT = TXC_FSNL;
                    printf("SS7_MTP2::TXC() - New Cm=%d, FSNL=%d, FSNT=%d, FSNF=%d!\n",
                            Cm, TXC_FSNL, TXC_FSNT, TXC_FSNF );
                    if( TXC_FSNL == TXC_FSNF )
                    {
                        // FSNF: The next FSN to be confirmed
                        // FSNL: The latest FSN to be confirmed
                        // So it means it's the 1st message in RTB
                        // If T7 expires before MSU is confirmed, we'll handle such condition

                        // Start T7
                        time( & timers[6].start_time );
                        timers[6].started = true;
                        printf("SS7_MTP2::TXC() - FSNL=FSNF=%d, Start T7!\n", TXC_FSNL );
                    }

                    if( TXC_FSNL == ((TXC_FSNF - 2 + 128) % 128) ) // mod 128
                    {
                        printf("SS7_MTP2::TXC() - RTBFull: FSNL=%d,FSNF=%d!\n",
                               TXC_FSNL, TXC_FSNF );
                        RTBfull = true;
                    }

                    BIBT = TXC_BIB;
                    BSNT = (TXC_FSNX - 1 + 128) % 128;
                    FIBT = TXC_FIB;

                    pSUWithLen->header.FSN = TXC_FSNT;
                    pSUWithLen->header.FIB = FIBT;
                    pSUWithLen->header.BSN = BSNT;
                    pSUWithLen->header.BIB = FIBT;

                    printf("SS7_MTP2::TXC() - Sending with FSN=%d,BSN=%d!\n",
                           pSUWithLen->header.FSN, pSUWithLen->header.BSN );

                    // Store MSU in RTB -- where to set the FSN, etc?
                    resendBuffer.write( (unsigned char *) pSUWithLen,
                                   sizeof(unsigned short) + pSUWithLen->len );

                    AppendEventWithParam( MTP2_FSM_RC, RCEventFSNTValue, TXC_FSNT );

                    // populate the SndSigUnit, MSU has no fixed length

                    pSndSigUnit->Length = SND_SU_HEADER_SIZE + pSUWithLen->len;
                    pSndSigUnit->Type = 0;
//                    pSndSigUnit->TimeStamp[0] = 0; // It's for L1 or L2 to populate?
                    pSndSigUnit->ChName = (unsigned short)portNumber;
                    memcpy( (unsigned char *)pSndSigUnit->PktBuf,
                            (unsigned char *) & pSUWithLen->header, pSUWithLen->len );

                    writeSUDowntoL1( pSndSigUnit );
                    // update the last MSU transmitting time for FISU timeout checking
                    gettimeofday( & FISUTimer, NULL );

                    AppendEvent( MTP2_FSM_DAEDT, DAEDTEventSignalUnit );
                }
            }
            else // resending from RTB
            {
                printf("SS7_MTP2::TXC() - resend from RTB, FSNT=%d!\n", TXC_FSNT );
                TXC_FSNT = (TXC_FSNT + 1) % 128;
                // featch MSU from RTB;
                resendBuffer.read( (unsigned char *)& pSUWithLen->len,
                                     sizeof(unsigned short) );
                resendBuffer.read( (unsigned char *)& pSUWithLen->header,
                                     (int)pSUWithLen->len );

                AppendEventWithParam( MTP2_FSM_RC, RCEventFSNTValue, TXC_FSNT );

                BIBT = TXC_BIB;
                BSNT = (TXC_FSNX - 1 + 128) % 128;
                FIBT = TXC_FIB;

                pSUWithLen->header.FSN = TXC_FSNT;
                pSUWithLen->header.FIB = FIBT;
                pSUWithLen->header.BSN = BSNT;
                pSUWithLen->header.BIB = FIBT;

                printf("SS7_MTP2::TXC() - MSU's FSN=%d,BSN=%d!\n",
                       pSUWithLen->header.FSN, pSUWithLen->header.BSN );

                // populate the SndSigUnit, MSU has no fixed length

                pSndSigUnit->Length = SND_SU_HEADER_SIZE + pSUWithLen->len;
                pSndSigUnit->Type = 0;
//                pSndSigUnit->TimeStamp[0] = 0; // It's for L1 or L2 to populate?
                pSndSigUnit->ChName = (unsigned short)portNumber;
                memcpy( (unsigned char *)pSndSigUnit->PktBuf,
                        (unsigned char *)& pSUWithLen->header, pSUWithLen->len );

                writeSUDowntoL1( pSndSigUnit );
                // update the last MSU transmitting time for FISU timeout checking
                gettimeofday( & FISUTimer, NULL );

                AppendEvent( MTP2_FSM_DAEDT, DAEDTEventSignalUnit );
            }
            break;

        case TXCEventSendFISU: // LSC 
            printf("SS7_MTP2::TXC() - Event = TXCEventSendFISU - stop T7!\n" );

            timers[6].started = false; // Stop T7;
            MSUinhibited = false;
            LSSUAvailable = false; // so that we could send FISU
            break;

        case TXCEventSendMSU:
            printf("SS7_MTP2::TXC() - Event = TXCEventSendMSU!\n" );

            if( TXC_FSNL != ((TXC_FSNF-1+128) % 128) ) // RTB is not empty
            {
                printf("SS7_MTP2::TXC() - FSNL=%d, FSNF=%d, start T7!\n",
                       TXC_FSNL, TXC_FSNF );
                // Start T7
                time( & timers[6].start_time );
                timers[6].started = true;
            }
            MSUinhibited = false;
            LSSUAvailable = false;
            break;

        case TXCEventT7Expired:
            printf("SS7_MTP2::TXC() - T7 TXCEventT7Expired!\n" );

            AppendEvent( MTP2_FSM_LSC, LSCEventLinkFailure ); 
            timers[5].started = false; // Stop T6;
            SIBreceived = false;
            break;

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

            TXC_BIB = (TXC_BIB + 1) % 2;
            break;

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

            if( ! SIBreceived )
            {
                // Start T6;
                time( & timers[5].start_time );
                timers[5].started = true;
                
                SIBreceived = true;
                
                // Start T7;
                time( & timers[6].start_time );
                timers[6].started = true;
            }
            break;

        case TXCEventMsg4Transmission: // L3 
            printf("SS7_MTP2::TXC() - Event = TXCEventMsg4Transmission!\n" );
            
            // The functionality is implemented in sendMessage(unsigned *,int);

            // ???? (blank box) in Q.703 Cm += 1;
            break;

        case TXCEventBSNRAndBIBR: // RC 
            printf("SS7_MTP2::TXC() - event=TXCEventBSNRAndBIBR - BSNR=%d,BIBR=%d!\n",
                   (unsigned int)(param & 0xff), (unsigned int)(param >> 16) & 0xff );

            tmpBSNR = param & 0xff;
            tmpBIBR = (param >> 16) & 0xff;
            if( TXC_FSNF == ((tmpBSNR + 1) % 128) ) //
            {
                if( TXC_FIB == tmpBIBR )
                {
                    printf("SS7_MTP2::TXC() - FIB=BIBR, do nothing!\n" );
                    // do nothing
                }
                else
                {
                    printf("SS7_MTP2::TXC() - FIB=%d,BIBR=%d!\n", TXC_FIB, tmpBIBR );
                    if( SIBreceived )
                    {
                        SIBreceived = false;
                        timers[5].started = false; // Stop T6;
                    }

                    TXC_FIB = tmpBIBR;
                    TXC_FSNT = (TXC_FSNF - 1 + 128) % 128; // send from RTB
                }
            }
            else
            {
                if( SIBreceived )
                {
                    SIBreceived = false;
                    timers[5].started = false; // Stop T6;
                }

                // Erase in RTB MSUs up to FSN = BSNR;
                EraseRTBMSU( tmpBSNR );
                TXC_FSNF = (tmpBSNR + 1) % 128;

                printf("SS7_MTP2::TXC() - FSNF updated to %d,!\n", TXC_FSNF );

                if( TXC_FSNL == ((TXC_FSNF-1+128) % 128) ) // RTB empty?
                {
                    timers[6].started = false; // Stop T7;
                    printf("SS7_MTP2::TXC() - stop T7!\n");
                }
                else
                {
                    // Start T7;
                    printf("SS7_MTP2::TXC() - start T7!\n");
                    time( & timers[6].start_time );
                    timers[6].started = true;
                }
                RTBfull = false;
                if( TXC_FIB == tmpBIBR )
                {
                    // do nothing
                }
                else
                {
                    if( SIBreceived )
                    {
                        SIBreceived = false;
                        timers[5].started = false; // Stop T6;
                    }
                    TXC_FIB = tmpBIBR;
                    TXC_FSNT = (TXC_FSNF - 1 + 128) % 128;
                }
            }
            break;

        case TXCEventFSNXValue: // RC 

            printf("SS7_MTP2::TXC() - event=TXCEventFSNXValue, new FSNX=%d!\n", param );
            TXC_FSNX = param; // param == FSNX

            break;

        case TXCEventRetrievalRequestAndFSNC: // LSC 

            //TODO: Erase in RTB MSUs up to FSN = FSNC;
            TXC_FSNF = (FSNC + 1) % 128;
            // Retrieval messages; // TXC --> L3
            RTBfull = false;
            // Retrieval complete; // TXC --> L3
            Cm = 0;
            TXC_FSNL = FSNC;
            TXC_FSNT = TXC_FSNL;
            break;

        case TXCEventFlushBuffers: // LSC