test-q781.c

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

        case SIO2: case SIN2: case SIE2: case SIOS2: case SIPO2: case SIB2: case SIX2:
            pt_buf[0] = pt_bib|pt_bsn;
            pt_buf[1] = pt_fib|pt_fsn;
            pt_buf[2] = 2;
            pt_buf[3] = 0;
            pt_buf[4] = msg - 100;
            len = 5;
            switch ( msg ) {
                case SIO2:  if ( !cntmsg ) printf("    SIO  (%02x/%02x)[2]-------------->\n", pt_bib|pt_bsn, pt_fib|pt_fsn); break;
                case SIN2:  if ( !cntmsg ) printf("    SIN  (%02x/%02x)[2]-------------->\n", pt_bib|pt_bsn, pt_fib|pt_fsn); break;
                case SIE2:  if ( !cntmsg ) printf("    SIE  (%02x/%02x)[2]-------------->\n", pt_bib|pt_bsn, pt_fib|pt_fsn); break;
                case SIOS2: if ( !cntmsg ) printf("    SIOS (%02x/%02x)[2]-------------->\n", pt_bib|pt_bsn, pt_fib|pt_fsn); break;
                case SIPO2: if ( !cntmsg ) printf("    SIPO (%02x/%02x)[2]-------------->\n", pt_bib|pt_bsn, pt_fib|pt_fsn); break;
                case SIB2:  if ( !cntmsg ) printf("    SIB  (%02x/%02x)[2]-------------->\n", pt_bib|pt_bsn, pt_fib|pt_fsn); break;
                case SIX2:  if ( !cntmsg ) printf("    LSSU (%02x/%02x)[2](corrupt)----->\n", pt_bib|pt_bsn, pt_fib|pt_fsn); break;
            }
            FFLUSH(stdout);
            break;
        case SIB_S:
            pt_buf[0] = pt_bib|pt_bsn;
            pt_buf[1] = pt_fib|pt_fsn;
            pt_buf[2] = 1;
            pt_buf[3] = SIB;
            len = 4;
            break;
        case COUNT:
            printf("    Ct=%d\n", count);
            FFLUSH(stdout);
            return SUCCESS;
        case TRIES:
            printf("    %d iterations\n", tries);
            FFLUSH(stdout);
            return SUCCESS;
        case ETC:
            printf("      .\n");
            printf("      .\n");
            printf("      .\n");
            FFLUSH(stdout);
            return SUCCESS;
        case FISU:
            if ( !cntmsg ) {
                printf("    FISU (%02x/%02x) ---------------->\n", pt_bib|pt_bsn, pt_fib|pt_fsn);
                FFLUSH(stdout);
            }
        case FISU_S:
            pt_buf[0] = pt_bib|pt_bsn;
            pt_buf[1] = pt_fib|pt_fsn;
            pt_buf[2] = 0;
            len = 3;
            break;
        case FISU_BAD_FIB:
            if ( !cntmsg ) {
                printf("    FISU (%02x/%02x) (bad fib)------->\n", pt_bib|pt_bsn, (pt_fib|pt_fsn)^0x80);
                FFLUSH(stdout);
            }
            pt_buf[0] = pt_bib|pt_bsn;
            pt_buf[1] = (pt_fib|pt_fsn)^0x80;
            pt_buf[2] = 0;
            len = 3;
            break;
        case LSSU_CORRUPT:
            if ( !cntmsg ) {
                printf("    LSSU (%02x/%02x) (corrupt)------->\n", pt_bib|pt_bsn, pt_fib|pt_fsn);
                FFLUSH(stdout);
            }
        case LSSU_CORRUPT_S:
            pt_buf[0] = pt_bib|pt_bsn;
            pt_buf[1] = pt_fib|pt_fsn;
            pt_buf[2] = 0xff;
            pt_buf[3] = 0xff;
            len = 4;
            break;
        case FISU_CORRUPT:
            if ( !cntmsg ) {
                printf("    FISU (%02x/%02x) (corrupt)------->\n", pt_bib|pt_bsn, pt_fib|pt_fsn);
                FFLUSH(stdout);
            }
        case FISU_CORRUPT_S:
            pt_buf[0] = pt_bib|pt_bsn;
            pt_buf[1] = pt_fib|pt_fsn;
            pt_buf[2] = 0xff;
            len = 3;
            break;
        case MSU:
            if ( msu_len > BUFSIZE-10 ) msu_len = BUFSIZE-10;
            pt_fsn = (pt_fsn+1)&0x7f;
            pt_buf[0] = pt_bib|pt_bsn;
            pt_buf[1] = pt_fib|pt_fsn;
            pt_buf[2] = msu_len;
            memset(&pt_buf[3], 'B', msu_len);
            len = msu_len+3;
            if ( !cntmsg ) {
                printf("    MSU  (%02x/%02x) ---------------->\n", pt_bib|pt_bsn, pt_fib|pt_fsn);
                FFLUSH(stdout);
            }
            break;
        case MSU_TOO_LONG:
            pt_fsn = (pt_fsn+1)&0x7f;
            pt_buf[0] = pt_bib|pt_bsn;
            pt_buf[1] = pt_fib|pt_fsn;
            pt_buf[2] = 63;
            memset(&pt_buf[3], 'A', 280);
            len = 283;
            if ( !cntmsg ) {
                printf("    MSU  (%02x/%02x) (too long)------>\n", pt_bib|pt_bsn, pt_fib|pt_fsn);
                FFLUSH(stdout);
            }
            break;
        case MSU_SEVEN_ONES:
            pt_fsn = (pt_fsn+1)&0x7f;
            pt_buf[0] = pt_bib|pt_bsn;
            pt_buf[1] = pt_fib|pt_fsn;
            len = 2;
            if ( !cntmsg ) {
                printf("    MSU  (%02x/%02x) (7 ones)-------->\n", pt_bib|pt_bsn, pt_fib|pt_fsn);
                FFLUSH(stdout);
            }
            ret = FAILURE; /* can't do this */
            break;
        case MSU_TOO_SHORT:
            pt_fsn = (pt_fsn+1)&0x7f;
            pt_buf[0] = pt_bib|pt_bsn;
            pt_buf[1] = pt_fib|pt_fsn;
            len = 2;
            if ( !cntmsg ) {
                printf("    MSU  (%02x/%02x) (too short)----->\n", pt_bib|pt_bsn, pt_fib|pt_fsn);
                FFLUSH(stdout);
            }
            break;
        case TX_BREAK:
            printf("   :break Tx\n");
            FFLUSH(stdout);
            return FAILURE; /* can't do this */
            ioc.ic_cmd    = DEV_IOCCDISCTX;
            ioc.ic_timout = 0;
            ioc.ic_len    = 0;
            ioc.ic_dp     = NULL;
            if ( ioctl(pt_fd, I_STR, &ioc) < 0 ) {
                printf("    ****ERROR: ioctl failed!\n");
                printf("               %s: %s\n",__FUNCTION__,strerror(errno));
                return FAILURE;
            }
            return FAILURE; /* can't do this */
        case TX_MAKE:
            printf("   :reconnect Tx\n");
            FFLUSH(stdout);
            return FAILURE; /* can't do this */
            ioc.ic_cmd    = DEV_IOCCCONNTX;
            ioc.ic_timout = 0;
            ioc.ic_len    = 0;
            ioc.ic_dp     = NULL;
            if ( ioctl(pt_fd, I_STR, &ioc) < 0 ) {
                printf("    ****ERROR: ioctl failed!\n");
                printf("               %s: %s\n",__FUNCTION__,strerror(errno));
                return FAILURE;
            }
            return FAILURE; /* can't do this */
        case FISU_FISU_1FLAG:
            printf("    FISU (%02x/%02x) ---FISU-F-FISU-->\n", pt_bib|pt_bsn, pt_fib|pt_fsn);
            FFLUSH(stdout);
            return FAILURE; /* can't do this */
        case FISU_FISU_2FLAG:
            printf("    FISU (%02x/%02x) --FISU-F-F-FISU->\n", pt_bib|pt_bsn, pt_fib|pt_fsn);
            FFLUSH(stdout);
            return FAILURE; /* can't do this */
        case MSU_MSU_1FLAG:
            printf("    MSU  (%02x/%02x) ----MSU-F-MSU--->\n", pt_bib|pt_bsn, pt_fib|pt_fsn);
            FFLUSH(stdout);
            return FAILURE; /* can't do this */
        case MSU_MSU_2FLAG:
            printf("    MSU  (%02x/%02x) ---MSU-F-F-MSU-->\n", pt_bib|pt_bsn, pt_fib|pt_fsn);
            FFLUSH(stdout);
            return FAILURE; /* can't do this */
        case POWER_ON:  label = "power on";                goto dummy_command;
        case START:     label = "start";                   goto dummy_command;
        case STOP:      label = "stop";                    goto dummy_command;
        case LPO:       label = "set lpo";                 goto dummy_command;
        case LPR:       label = "clear lpo";               goto dummy_command;
        case EMERG:     label = "set emerg";               goto dummy_command;
        case CEASE:     label = "clear emerg";             goto dummy_command;
        case CONG_A:    label = "make congestion state";   goto dummy_command;
        case CONG_D:    label = "make congestion state";   goto dummy_command;
        case NO_CONG:   label = "clear congestion state";  goto dummy_command;
dummy_command:
            printf("   :%s\n", label);
            FFLUSH(stdout);
            return SUCCESS;
        default:
            if ( !cntmsg ) {
                printf("    ???? (--/--) ---------------->\n");
                FFLUSH(stdout);
            }
            return FAILURE;
    }
    ctrl.maxlen = BUFSIZE;
    ctrl.len    = sizeof(p->daedt_transmission_req);
    ctrl.buf    = cbuf;
    data.maxlen = BUFSIZE;
    data.len    = len;
    data.buf    = pt_buf;
    p->daedt_transmission_req.sdl_primitive = SDL_DAEDT_TRANSMISSION_REQ;
    if ( putmsg(pt_fd, NULL, &data, 0) < 0 ) {
        printf("    ****ERROR: putmsg failed!\n");
        printf("               %s: %s\n",__FUNCTION__,strerror(errno));
        return FAILURE;
    }
    return ret;
}

#define signal iut_signal

static int signal(int action) {
    int ret;
    char cbuf[BUFSIZE];
    char dbuf[BUFSIZE];
    struct strbuf ctrl = { sizeof(*cbuf), 0, cbuf };
    struct strbuf data = { sizeof(*dbuf), 0, dbuf };
    union SL_primitives *p = (union SL_primitives *)cbuf;
    ctrl.maxlen = BUFSIZE;
    ctrl.buf    = cbuf;
    if ( action != oldact ) {
        oldact = action;
//      if ( cntact ) {
//          printf("                                   Ct=%d\n", cntact+1);
//          FFLUSH(stdout);
//      }
        cntact = 0;
    }
    else if ( !expand ) cntact++;
    switch ( action ) {
        case POWER_ON:
            printf("                                  :power on\n");
            FFLUSH(stdout);
            p->sl_primitive = SL_POWER_ON_REQ;
            ctrl.len = SL_POWER_ON_REQ_SIZE;
            goto signal_iut_putmsg;
        case START:
            printf("                                  :start\n");
            FFLUSH(stdout);
            p->sl_primitive = SL_START_REQ;
            ctrl.len = SL_START_REQ_SIZE;
            goto signal_iut_putmsg;
        case STOP:
            printf("                                  :stop\n");
            FFLUSH(stdout);
            p->sl_primitive = SL_STOP_REQ;
            ctrl.len = SL_STOP_REQ_SIZE;
            goto signal_iut_putmsg;
        case LPO:
            printf("                                  :set lpo\n");
            FFLUSH(stdout);
            p->sl_primitive = SL_LOCAL_PROCESSOR_OUTAGE_REQ;
            ctrl.len = SL_LOCAL_PROC_OUTAGE_REQ_SIZE;
            goto signal_iut_putmsg;
        case LPR:
            printf("                                  :clear lpo\n");
            FFLUSH(stdout);
            p->sl_primitive = SL_RESUME_REQ;
            ctrl.len = SL_RESUME_REQ_SIZE;
            goto signal_iut_putmsg;
        case CONG_A:
            printf("                                  :make congestion state\n");
            FFLUSH(stdout);
            p->sl_primitive = SL_CONGESTION_ACCEPT_REQ;
            ctrl.len = SL_CONG_ACCEPT_REQ_SIZE;
            goto signal_iut_putmsg;
        case CONG_D:
            printf("                                  :make congestion state\n");
            FFLUSH(stdout);
            p->sl_primitive = SL_CONGESTION_DISCARD_REQ;
            ctrl.len = SL_CONG_DISCARD_REQ_SIZE;
            goto signal_iut_putmsg;
        case NO_CONG:
            printf("                                  :clear congestion state\n");
            FFLUSH(stdout);
            p->sl_primitive = SL_NO_CONGESTION_REQ;
            ctrl.len = SL_NO_CONG_REQ_SIZE;
            goto signal_iut_putmsg;
        case CLEARB:
            printf("                                  :clear buffers\n");
            FFLUSH(stdout);
            p->sl_primitive = SL_CLEAR_BUFFERS_REQ;
            ctrl.len = SL_CLEAR_BUFFERS_REQ_SIZE;
            goto signal_iut_putmsg;
        case EMERG:
            printf("                                  :set emerg\n");
            FFLUSH(stdout);
            p->sl_primitive = SL_EMERGENCY_REQ;
            ctrl.len = SL_EMERGENCY_REQ_SIZE;
            goto signal_iut_putmsg;
        case CEASE:
            printf("                                  :clear emerg\n");
            FFLUSH(stdout);
            p->sl_primitive = SL_EMERGENCY_CEASES_REQ;
            ctrl.len = SL_EMERGENCY_CEASES_REQ_SIZE;
signal_iut_putmsg:
            if ( (ret = putmsg(iut_fd, &ctrl, NULL, RS_HIPRI)) < 0 ) {
                printf("                                   ****ERROR: putmsg failed!\n");
                printf("                                              %s: %s\n",__FUNCTION__,strerror(errno));
                return FAILURE;
            }
            return SUCCESS;
        case COUNT:
            printf("                                   Ct=%d\n",count);
            FFLUSH(stdout);
            return SUCCESS;
        case TRIES:
            printf("                                   %d iterations\n",tries);
            FFLUSH(stdout);
            return SUCCESS;
        case ETC:
            printf("                                     .\n");
            printf("                                     .\n");
            printf("                                     .\n");
            FFLUSH(stdout);
            return SUCCESS;
        case SEND_MSU:
            if ( !cntact ) {
                printf("                                  :msu\n");
                FFLUSH(stdout);
            }
        case SEND_MSU_S:
            if ( msu_len > BUFSIZE-10 ) msu_len = BUFSIZE-10;
            p->sl_primitive = SL_PDU_REQ;
            ctrl.len = SL_PDU_REQ_SIZE;
            memset(dbuf, 'B', msu_len);
            data.len = msu_len;
            if ( (ret = putmsg(iut_fd, NULL, &data, 0)) < 0 ) {
                printf("                                   ****ERROR: putmsg failed!\n");
                printf("                                              %s: %s\n",__FUNCTION__,strerror(errno));
                return FAILURE;
            }
            return SUCCESS;
        default:
            if ( !cntact ) {
                printf("                                  :????\n");
                FFLUSH(stdout);
            }
            return FAILURE;
    }
}

static int show_msus  = 1;
static int show_fisus = 1;

static int pt_decode_data(void) {
    int ret;
//  printf("pt decode data:\n"); FFLUSH(stdout);
//  FFLUSH(stdout);
    iut_bib = pt_buf[0]&0x80;
    iut_bsn = pt_buf[0]&0x7f;
    iut_fib = pt_buf[1]&0x80;
    iut_fsn = pt_buf[1]&0x7f;
    iut_li  = pt_buf[2]&0x3f;
    iut_sio = pt_buf[3]&0x7;
     pt_bsn = iut_fsn;
    switch ( iut_li ) {
        case 0:
            ret = FISU; break;
        case 1:
            ret = iut_sio = pt_buf[3]&0x7;
            switch ( iut_sio ) {
                case SIO: case SIN: case SIE: case SIOS: case SIPO: case SIB: break;
                default: ret = SIX; break;
            } break;
        case 2:
            ret = iut_sio = pt_buf[4]&0x7;
            switch ( iut_sio ) {
                case SIO: case SIN: case SIE: case SIOS: case SIPO: case SIB: break;
                default: ret = SIX2; break;
            } break;
        default:
            ret = MSU; break;
    }
    if ( show_fisus || ret != FISU ) {
        if ( ret != oldret || oldisb != (((iut_bib|iut_bsn)<<8)|(iut_fib|iut_fsn)) ) {
//          if ( oldisb == (((iut_bib|iut_bsn)<<8)|(iut_fib|iut_fsn)) &&
//                  ( ( ret == FISU && oldret == MSU ) || ( ret == MSU && oldret == FISU ) ) ) {
//              if ( ret == MSU && !expand ) cntmsg++;
//          } else 
//              cntret = 0;
            oldret = ret;
            oldisb = ((iut_bib|iut_bsn)<<8)|(iut_fib|iut_fsn);
    //      if ( cntret ) {
    //          printf("                                   Ct=%d\n", cntret+1);
    //          FFLUSH(stdout);
    //      }
            cntret = 0;
        }
        else if ( !expand ) cntret++;
    }
    if ( !cntret ) {
        char* label = NULL;