test-q781.c

No7信令,我需要交换类似的代码, 请店长审核,谢谢了,急着交换,谢谢

        switch ( ret ) {
            case FISU:
                if ( show_fisus ) {
                printf("                 <---------------- FISU (%02x/%02x)\n", iut_bib|iut_bsn, iut_fib|iut_fsn);
                FFLUSH(stdout); }
                break;
            case SIO:  label = "SIO "; goto show_lssu;
            case SIN:  label = "SIN "; goto show_lssu;
            case SIE:  label = "SIE "; goto show_lssu;
            case SIOS: label = "SIOS"; goto show_lssu;
            case SIPO: label = "SIPO"; goto show_lssu;
            case SIB:  label = "SIB ";
show_lssu:
                switch ( iut_li ) {
                    case 1:
                        printf("                 <---------------- %s (%02x/%02x)\n", label, iut_bib|iut_bsn, iut_fib|iut_fsn);
                        break;
                    case 2:
                        printf("                 <---------------- %s (%02x/%02x)[%d]\n", label, iut_bib|iut_bsn, iut_fib|iut_fsn, iut_li);
                        break;
                }
                FFLUSH(stdout);
                break;
            case SIX:
                printf("                 <-------(corrupt) LSSU (%02x/%02x)[%d]\n", iut_bib|iut_bsn, iut_fib|iut_fsn, iut_li);
                FFLUSH(stdout);
                break;
            case SIX2:
                printf("                 <-------(corrupt) LSSU (%02x/%02x)[%d]\n", iut_bib|iut_bsn, iut_fib|iut_fsn, iut_li);
                FFLUSH(stdout);
                break;
            case MSU:
                if ( show_msus ) {
                printf("                 <---------------- MSU  (%02x/%02x)[%d]\n", iut_bib|iut_bsn, iut_fib|iut_fsn, iut_len-3);
                FFLUSH(stdout);
                }
                break;
        }
    }
    return ret;
}

static int pt_decode_msg(unsigned char *buf) {
    union SDL_primitives *p = (union SDL_primitives *)buf;
//  printf("pt decode msg:\n"); FFLUSH(stdout);
//  FFLUSH(stdout);
    switch ( p->sdl_primitive ) {
        case SDL_DAEDR_RECEIVED_BITS_IND:
            return pt_decode_data();
        case SDL_DAEDR_CORRECT_SU_IND:
            printf("   !correct su\n");
            FFLUSH(stdout);
            break;
        case SDL_DAEDR_SU_IN_ERROR_IND:
            printf("   !error su\n");
            FFLUSH(stdout);
            break;
        case SDL_DAEDT_TRANSMISSION_REQUEST_IND:
//          printf("    (tx wakeup)\n");
//          FFLUSH(stdout);
            break;
        case LMI_INFO_ACK:
            printf("   !(info ack)\n");
            FFLUSH(stdout);
            break;
        case LMI_OK_ACK:
            printf("   !(ok ack)\n");
            FFLUSH(stdout);
            break;
        case LMI_ERROR_ACK:
            printf("   !(error ack)\n");
            FFLUSH(stdout);
            break;
        case LMI_ENABLE_CON:
            printf("   !(enable con)\n");
            FFLUSH(stdout);
            break;
        case LMI_DISABLE_CON:
            printf("   !(disable con)\n");
            FFLUSH(stdout);
            break;
        case LMI_ERROR_IND:
            printf("   !(error ind)\n");
            FFLUSH(stdout);
            break;
        case LMI_STATS_IND:
            printf("   !(stats ind)\n");
            FFLUSH(stdout);
            break;
        case LMI_EVENT_IND:
            printf("   !(event ind)\n");
            FFLUSH(stdout);
            break;
        default:
            printf("   !(unknown %ld)\n", p->sdl_primitive);
            FFLUSH(stdout);
            break;
    }
    return UNKNOWN;
}

static int iut_decode_data(void) {
    printf("                                  !msu\n");
    FFLUSH(stdout);
    return IUT_MSU;
}

static int iut_decode_msg(unsigned char *buf) {
    char *reason;
    union SL_primitives *p = (union SL_primitives *)buf;
    if ( p->sl_primitive != oldprm ) {
        oldprm = p->sl_primitive;
        cntprm = 0;
    }
    else if ( !expand ) cntprm++;
    switch ( p->sl_primitive ) {
        case SL_REMOTE_PROCESSOR_OUTAGE_IND:
            if ( !cntprm ) {
                printf("                                  !rpo\n");
                FFLUSH(stdout);
            }
            return RPO;
        case SL_REMOTE_PROCESSOR_RECOVERED_IND:
            if ( !cntprm ) {
                printf("                                  !rpr\n");
                FFLUSH(stdout);
            }
            return RPR;
        case SL_IN_SERVICE_IND:
            printf("                                  !in service\n");
            FFLUSH(stdout);
            return IN_SERVICE;
        case SL_OUT_OF_SERVICE_IND:
            switch ( p->out_of_service_ind.sl_reason ) {
                case SL_FAIL_UNSPECIFIED:            reason = "unspec"; break;
                case SL_FAIL_CONG_TIMEOUT:           reason = "T6";     break;
                case SL_FAIL_ACK_TIMEOUT:            reason = "T7";     break;
                case SL_FAIL_ABNORMAL_BSNR:          reason = "BSNR";   break;
                case SL_FAIL_ABNORMAL_FIBR:          reason = "FIBR";   break;
                case SL_FAIL_SUERM_EIM:              reason = "SUERM";  break;
                case SL_FAIL_ALIGNMENT_NOT_POSSIBLE: reason = "AERM";   break;
                case SL_FAIL_RECEIVED_SIO:           reason = "SIO";    break;
                case SL_FAIL_RECEIVED_SIN:           reason = "SIN";    break;
                case SL_FAIL_RECEIVED_SIE:           reason = "SIE";    break;
                case SL_FAIL_RECEIVED_SIOS:          reason = "SIOS";   break;
                case SL_FAIL_T1_TIMEOUT:             reason = "T1";     break;
                default:                             reason = "???";    break;
            }
            printf("                                  !out of service (%s)\n", reason);
            FFLUSH(stdout);
            return OUT_OF_SERVICE;
        case SL_PDU_IND:
            printf("                                  !msu\n");
            FFLUSH(stdout);
            break;
        case SL_LINK_CONGESTED_IND:
            printf("                                  !congested\n");
            FFLUSH(stdout);
            break;
        case SL_LINK_CONGESTION_CEASED_IND:
            printf("                                  !congestion ceased\n");
            FFLUSH(stdout);
            break;
        case SL_RETRIEVED_MESSAGE_IND:
            printf("                                  !retrieved msg\n");
            FFLUSH(stdout);
            break;
        case SL_RETRIEVAL_COMPLETE_IND:
            printf("                                  !retrieval complete\n");
            FFLUSH(stdout);
            break;
        case SL_RB_CLEARED_IND:
            printf("                                  !rb cleared\n");
            FFLUSH(stdout);
            break;
        case SL_BSNT_IND:
            printf("                                  !bsnt\n");
            FFLUSH(stdout);
            break;
        case SL_RTB_CLEARED_IND:
            printf("                                  !rtb cleared\n");
            FFLUSH(stdout);
            break;
        case LMI_INFO_ACK:
            printf("                                  !(info ack)\n");
            FFLUSH(stdout);
            break;
        case LMI_OK_ACK:
            printf("                                  !(ok ack)\n");
            FFLUSH(stdout);
            break;
        case LMI_ERROR_ACK:
            printf("                                  !(error ack)\n");
            FFLUSH(stdout);
            break;
        case LMI_ENABLE_CON:
            printf("                                  !(enable con)\n");
            FFLUSH(stdout);
            break;
        case LMI_DISABLE_CON:
            printf("                                  !(disable con)\n");
            FFLUSH(stdout);
            break;
        case LMI_ERROR_IND:
            printf("                                  !(error ind)\n");
            FFLUSH(stdout);
            break;
        case LMI_STATS_IND:
            printf("                                  !(stats ind)\n");
            FFLUSH(stdout);
            break;
        case LMI_EVENT_IND:
            printf("                                  !(event ind)\n");
            FFLUSH(stdout);
            break;
        default:
            printf("                                  !(unknown %ld)\n", p->sl_primitive);
            FFLUSH(stdout);
            break;
    }
    return UNKNOWN;
}

static int show_timeout = 0;

static int wait_event(int wait) {
    int ret = SUCCESS;
    while (1) {
        struct pollfd pfd[] = {
            {  pt_fd, POLLIN|POLLPRI, 0 },
            { iut_fd, POLLIN|POLLPRI, 0 }
        };
        if ( timer_timeout ) {
            timer_timeout = 0;
            if ( show_timeout ) {
                printf("                 |----timeout----|\n");
                FFLUSH(stdout);
                show_timeout--;
            }
            return TIMEOUT;
        }
//      printf("polling:\n");
//      FFLUSH(stdout);
        switch ( poll(pfd, 2, wait) ) {
            case -1:
//              printf("                 = = = ERROR = = =\n");
//              FFLUSH(stdout);
                break;
            case 0:
//              printf("                 < + + + + + + + + (nothing)\n");
//              FFLUSH(stdout);
                return NO_MSG;
            case 1:
            case 2:
//              printf("polled:\n");
//              FFLUSH(stdout);
                if ( pfd[0].revents & (POLLIN|POLLPRI) ) {
                    int flags = 0;
                    unsigned char cbuf[BUFSIZE];
                    struct strbuf ctrl = { BUFSIZE, 0,   cbuf },
                                  data = { BUFSIZE, 0, pt_buf };
//                  printf("getmsg from pt:\n");
//                  FFLUSH(stdout);
                    if ( getmsg(pt_fd, &ctrl, &data, &flags) == 0 ) {
//                      printf("gotmsg from pt [%d,%d]:\n",ctrl.len,data.len);
//                      FFLUSH(stdout);
                        if ( data.len > 0 ) iut_len = data.len;
                        if ( ctrl.len > 0 &&
                                (ret = pt_decode_msg(ctrl.buf)) != UNKNOWN )
                            return ret;
                        if ( data.len > 0 &&
                                (ret = pt_decode_data()) != UNKNOWN )
                            return ret;
                    }
                }
                if ( pfd[1].revents & (POLLIN|POLLPRI) ) {
                    int flags = 0;
                    unsigned char cbuf[BUFSIZE];
                    struct strbuf ctrl = { BUFSIZE, 0,    cbuf },
                                  data = { BUFSIZE, 0, iut_buf };
//                  printf("getmsg from iut:\n");
//                  FFLUSH(stdout);
                    if ( getmsg(iut_fd, &ctrl, &data, &flags) == 0 ) {
//                      printf("gotmsg from iut [%d,%d]:\n",ctrl.len,data.len);
//                      FFLUSH(stdout);
                        if ( data.len > 0 ) iut_len = data.len;
                        if ( ctrl.len > 0 &&
                                (ret = iut_decode_msg(ctrl.buf)) != UNKNOWN )
                            return ret;
                        if ( data.len > 0 &&
                                (ret = iut_decode_data()) != UNKNOWN )
                            return ret;
                    }
                }
            default:
                break;
        }
    }
}

static int event(void) {
    return wait_event(-1);
}

static int check_snibs(unsigned char bsnib, unsigned char fsnib) {
    int ret = FAILURE;
    if ( (iut_bib|iut_bsn) == bsnib && (iut_fib|iut_fsn) == fsnib )
        ret = SUCCESS;
    printf("                 check b/f sn/ib:  ---> (%02x/%02x)\n", bsnib, fsnib);
    FFLUSH(stdout);
    return ret;
}

static int test_1_1a(void) {
    for (;;) {
        switch ( state ) {
            case 0:
                send(SIOS);
                signal(POWER_ON);
                state = 1;
                break;
            case 1:
                switch ( event() ) {
                    case SIOS:
                        return check_snibs(0xff,0xff);
                    default:
                        return FAILURE;
                }
                break;
            default:
                return SCRIPTERROR;
        }
    }
}

static int test_1_1b(void) {
    for (;;) {
        switch ( state ) {
            case 0:
                switch ( event() ) {
                    case SIOS:
                        send(POWER_ON);
                        send(SIOS);
                        return check_snibs(0xff,0xff);
                    default:
                        return FAILURE;
                }
                break;
            default:
                return SCRIPTERROR;
        }
    }
}

static int test_1_2(void) {
    for (;;) {
        switch ( state ) {
            case 0:
                switch ( event() ) {
                    case SIOS:
                        send(SIOS);
                        signal(START);
                        state = 1;
                        break;
                    default:
                        return INCONCLUSIVE;
                }
                break;
            case 1:
                switch ( event() ) {
                    case SIOS:
                        send(SIOS);
                        break;
                    case SIO:
                        send(SIOS);
                        start_tt(iutconf.sl.t2*10+200);
                        beg_time = milliseconds("T2");
                        state = 2;
                        break;
                    default:
                        return FAILURE;
                }
                break;
            case 2:
                switch ( event() ) {
                    case OUT_OF_SERVICE:
                        break;
                    case SIO:
                        send(SIOS);
                        break;
                    case SIOS:
                        return check_time("T2  ", beg_time, timer[t2].lo, timer[t2].hi);
                    default: