test-m2pa.c

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

				FFLUSH(stdout);
			}
			return SUCCESS;
		case DISABLE_REQ:
			if ( verbose )
			{
				printf("               :disable                                             \n");
				FFLUSH(stdout);
			}
			return SUCCESS;
		case DISCON_REQ:
			printf("            :disconnect                                             \n");
			FFLUSH(stdout);
			p->npi.type = N_DISCON_REQ;
			p->npi.discon_req.DISCON_reason = 0;
			p->npi.discon_req.RES_length = 0;
			p->npi.discon_req.RES_offset = 0;
			p->npi.discon_req.SEQ_number = 0;
			ctrl.len = sizeof(N_discon_req_t);
			goto pt_control_putmsg;
		case BIND_REQ:
			if ( verbose )
			{
				printf("                  :bind                                             \n");
				FFLUSH(stdout);
			}
			p->npi.type = N_BIND_REQ;
			p->npi.bind_req.ADDR_length = sizeof(ptconf.loc);
			p->npi.bind_req.ADDR_offset = sizeof(p->npi.bind_req);
			p->npi.bind_req.CONIND_number = 0;
			p->npi.bind_req.BIND_flags = TOKEN_REQUEST;
			p->npi.bind_req.PROTOID_length = 0;
			p->npi.bind_req.PROTOID_offset = 0;
			bcopy(&ptconf.loc, (&p->npi.bind_req+1), sizeof(ptconf.loc));
			ctrl.len = sizeof(N_bind_req_t)+sizeof(ptconf.loc);
			goto pt_control_putmsg;
		case OPTMGMT_REQ:
			if ( verbose )
			{
				printf("           :optmgmt req                                             \n");
				FFLUSH(stdout);
			}
			p->npi.type = N_OPTMGMT_REQ;
			p->npi.optmgmt_req.QOS_length = sizeof(ptconf.qos);
			p->npi.optmgmt_req.QOS_offset = sizeof(p->npi.optmgmt_req);
			p->npi.optmgmt_req.OPTMGMT_flags = 0;
			bcopy(&ptconf.qos, (&p->npi.optmgmt_req+1), sizeof(ptconf.qos));
			ctrl.len = sizeof(N_optmgmt_req_t)+sizeof(ptconf.qos);
			goto pt_control_putmsg;
pt_control_putmsg:
			if ( putmsg(pt_fd, &ctrl, NULL, 0) < 0 )
			{
				printf("****ERROR: putmsg failed!\n");
				printf("           %s: %s\n",__FUNCTION__,strerror(errno));
				FFLUSH(stdout);
				return FAILURE;
			}
			return SUCCESS;
		default:
			if ( verbose || !cntmsg )
			{
				printf("              :????????                                             \n");
				FFLUSH(stdout);
			}
			return FAILURE;
	}
}

/*
 *  -------------------------------------------------------------------------
 *
 *  Signal commands to the Implementation Under Test
 *
 *  -------------------------------------------------------------------------
 */
#define signal iut_signal
static int signal(int action)
{
	char cbuf[BUFSIZE];
	char dbuf[BUFSIZE];
	struct strbuf ctrl = { sizeof(*cbuf), 0, cbuf };
	struct strbuf data = { sizeof(*dbuf), 0, dbuf };
	union primitives *p = (union primitives *)cbuf;
	if ( action != oldact )
	{
		oldact = action;
		if ( verbose )
		{
		if ( cntact )
		{
			printf("                                                     Ct=%5d       \n",cntact+1);
			FFLUSH(stdout);
		}
		}
		cntact = 0;
	}
	else
		if ( !expand ) cntact++;
	switch ( action )
	{
		case POWER_ON:
			printf("                                             :power on              \n");
			FFLUSH(stdout);
			p->sl.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.sl_primitive = SL_START_REQ;
			ctrl.len = SL_START_REQ_SIZE;
			goto signal_iut_putmsg;
		case STOP:
			printf("                                             :stop                  \n");
			FFLUSH(stdout);
			p->sl.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.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.sl_primitive = SL_RESUME_REQ;
			ctrl.len = SL_RESUME_REQ_SIZE;
			goto signal_iut_putmsg;
		case CONG_A:
			printf("                                             :make cong accept      \n");
			FFLUSH(stdout);
			p->sl.sl_primitive = SL_CONGESTION_ACCEPT_REQ;
			ctrl.len = SL_CONG_ACCEPT_REQ_SIZE;
			goto signal_iut_putmsg;
		case CONG_D:
			printf("                                             :make cong discard     \n");
			FFLUSH(stdout);
			p->sl.sl_primitive = SL_CONGESTION_DISCARD_REQ;
			ctrl.len = SL_CONG_DISCARD_REQ_SIZE;
			goto signal_iut_putmsg;
		case NO_CONG:
			printf("                                             :clear congestion      \n");
			FFLUSH(stdout);
			p->sl.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.sl_primitive = SL_CLEAR_BUFFERS_REQ;
			ctrl.len = SL_CLEAR_BUFFERS_REQ_SIZE;
			goto signal_iut_putmsg;
		case EMERG:
			printf("                                             :set emergency         \n");
			FFLUSH(stdout);
			p->sl.sl_primitive = SL_EMERGENCY_REQ;
			ctrl.len = SL_EMERGENCY_REQ_SIZE;
			goto signal_iut_putmsg;
		case CEASE:
			printf("                                             :clear emergency       \n");
			FFLUSH(stdout);
			p->sl.sl_primitive = SL_EMERGENCY_CEASES_REQ;
			ctrl.len = SL_EMERGENCY_CEASES_REQ_SIZE;
signal_iut_putmsg:
			if ( 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=%5d       \n",count);
			FFLUSH(stdout);
			return SUCCESS;
		case TRIES:
			printf("                                                     %4d 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.sl_primitive = SL_PDU_REQ;
			ctrl.len = SL_PDU_REQ_SIZE;
			memset(dbuf, 'B', msu_len);
			data.len = msu_len;
			if ( putmsg(iut_fd, NULL, &data, 0) < 0 )
			{
				printf("                                  ****ERROR: putmsg failed!\n");
				printf("                                             %s: %s\n",__FUNCTION__,strerror(errno));
				FFLUSH(stdout);
				return FAILURE;
			}
			return SUCCESS;
		case ENABLE_REQ:
			if ( verbose )
			{
				printf("                                             :enable                \n");
				FFLUSH(stdout);
			}
			p->lmi.enable_req.lmi_primitive = LMI_ENABLE_REQ;
			ctrl.len = sizeof(p->lmi.enable_req);
			goto iut_lmi_putmsg;
		case DISABLE_REQ:
			if ( verbose )
			{
				printf("                                             :disable               \n");
				FFLUSH(stdout);
			}
			p->lmi.disable_req.lmi_primitive = LMI_DISABLE_REQ;
			ctrl.len = sizeof(p->lmi.disable_req);
			goto iut_lmi_putmsg;
iut_lmi_putmsg:
			if ( putmsg(iut_fd, &ctrl, NULL, RS_HIPRI) < 0 )
			{
				printf("                                  ****ERROR: putmsg failed!\n");
				printf("                                             %s: %s\n",__FUNCTION__,strerror(errno));
				FFLUSH(stdout);
				return FAILURE;
			}
			return SUCCESS;
		case CONN_REQ:
			printf("                                             :connect               \n");
			FFLUSH(stdout);
			p->npi.type = N_CONN_REQ;
			p->npi.conn_req.DEST_length = sizeof(iutconf.rem);
			p->npi.conn_req.DEST_offset = sizeof(p->npi.conn_req);
			p->npi.conn_req.CONN_flags = REC_CONF_OPT|EX_DATA_OPT;
			p->npi.conn_req.QOS_length = 0;
			p->npi.conn_req.QOS_offset = 0;
			bcopy(&iutconf.rem, (&p->npi.conn_req+1), sizeof(iutconf.rem));
			ctrl.len = sizeof(N_conn_req_t)+sizeof(iutconf.rem);
			goto iut_control_putmsg;
		case BIND_REQ:
			if ( verbose )
			{
				printf("                                             <bind req              \n");
				FFLUSH(stdout);
			}
			p->npi.type = N_BIND_REQ;
			p->npi.bind_req.ADDR_length = sizeof(iutconf.loc);
			p->npi.bind_req.ADDR_offset = sizeof(p->npi.bind_req);
			p->npi.bind_req.CONIND_number = 0;
			p->npi.bind_req.BIND_flags = TOKEN_REQUEST;
			p->npi.bind_req.PROTOID_length = 0;
			p->npi.bind_req.PROTOID_offset = 0;
			bcopy(&iutconf.loc, (&p->npi.bind_req+1), sizeof(iutconf.loc));
			ctrl.len = sizeof(N_bind_req_t)+sizeof(iutconf.loc);
			goto iut_control_putmsg;
		case DISCON_REQ:
			if ( verbose )
			{
				printf("                                             :disconnect            \n");
				FFLUSH(stdout);
			}
			p->npi.type = N_DISCON_REQ;
			p->npi.discon_req.DISCON_reason = 0;
			p->npi.discon_req.RES_length = 0;
			p->npi.discon_req.RES_offset = 0;
			p->npi.discon_req.SEQ_number = 0;
			ctrl.len = sizeof(N_discon_req_t);
			goto iut_control_putmsg;
		case OPTMGMT_REQ:
			if ( verbose )
			{
				printf("                                             <optmgmt req           \n");
				FFLUSH(stdout);
			}
			p->npi.type = N_OPTMGMT_REQ;
			p->npi.optmgmt_req.QOS_length = sizeof(iutconf.qos);
			p->npi.optmgmt_req.QOS_offset = sizeof(p->npi.optmgmt_req);
			p->npi.optmgmt_req.OPTMGMT_flags = 0;
			bcopy(&iutconf.qos, (&p->npi.optmgmt_req+1), sizeof(iutconf.qos));
			ctrl.len = sizeof(N_optmgmt_req_t)+sizeof(iutconf.qos);
			goto iut_control_putmsg;
iut_control_putmsg:
			if ( putmsg(iut_fd, &ctrl, NULL, 0) < 0 )
			{
				printf("                                  ****ERROR: putmsg failed!\n");
				printf("                                             %s: %s\n",__FUNCTION__,strerror(errno));
				FFLUSH(stdout);
				return FAILURE;
			}
			return SUCCESS;
		default:
			if ( !cntact )
			{
				printf("                                             <????????              \n");
				FFLUSH(stdout);
			}
			return FAILURE;
	}
}

/*
 *  -------------------------------------------------------------------------
 *
 *  Control commands given to management stream.
 *
 *  -------------------------------------------------------------------------
 */
#define control mgm_control
static int control(int prim)
{
	char cbuf[BUFSIZE];
	struct strbuf ctrl = { sizeof(*cbuf), 0, cbuf };
	union primitives *p = (union primitives *)cbuf;
	if ( prim != oldmgm )
	{
		oldmgm = prim;
		if ( cntmgm )
		{
			printf("             Ct=%5d                                               \n",cntmgm+1);
			FFLUSH(stdout);
		}
		cntmgm = 0;
	}
	else
		if ( !expand ) cntmgm++;
	switch ( prim )
	{
		case CONN_RES:
			if ( verbose )
			{
				printf("              >conn res                                             \n");
				FFLUSH(stdout);
			}
			p->npi.type = N_CONN_RES;
			p->npi.conn_res.TOKEN_value = pt_tok;
			p->npi.conn_res.RES_length = 0;
			p->npi.conn_res.RES_offset = 0;
			p->npi.conn_res.SEQ_number = mgm_seq;
			p->npi.conn_res.CONN_flags = REC_CONF_OPT|EX_DATA_OPT;
			p->npi.conn_res.QOS_length = 0;
			p->npi.conn_res.QOS_offset = 0;
			ctrl.len = sizeof(N_conn_res_t);
			goto mgm_control_putmsg;
		case BIND_REQ:
			if ( verbose )
			{
				printf("              >bind req |                        \n");
				FFLUSH(stdout);
			}
			p->npi.type = N_BIND_REQ;
			p->npi.bind_req.ADDR_length = sizeof(mgmconf.loc);
			p->npi.bind_req.ADDR_offset = sizeof(p->npi.bind_req);
			p->npi.bind_req.CONIND_number = 2;
			p->npi.bind_req.BIND_flags = TOKEN_REQUEST;
			p->npi.bind_req.PROTOID_length = 0;
			p->npi.bind_req.PROTOID_offset = 0;
			bcopy(&mgmconf.loc, (&p->npi.bind_req+1), sizeof(mgmconf.loc));
			ctrl.len = sizeof(N_bind_req_t)+sizeof(mgmconf.loc);
			goto mgm_control_putmsg;
		case OPTMGMT_REQ:
			if ( verbose )
			{
				printf("           >optmgmt req |                        \n");
				FFLUSH(stdout);
			}
			p->npi.type = N_OPTMGMT_REQ;
			p->npi.optmgmt_req.QOS_length = sizeof(mgmconf.qos);
			p->npi.optmgmt_req.QOS_offset = sizeof(p->npi.optmgmt_req);
			p->npi.optmgmt_req.OPTMGMT_flags = 0;
			bcopy(&mgmconf.qos, (&p->npi.optmgmt_req+1), sizeof(mgmconf.qos));
			ctrl.len = sizeof(N_optmgmt_req_t)+sizeof(mgmconf.qos);
			goto mgm_control_putmsg;
mgm_control_putmsg:
			if ( putmsg(mgm_fd, &ctrl, NULL, 0) < 0 )
			{
				printf("****ERROR: putmsg failed!\n");
				printf("           %s: %s\n",__FUNCTION__,strerror(errno));
				FFLUSH(stdout);
				return FAILURE;
			}
			return SUCCESS;
		default:
			if ( !cntmgm )
			{
				printf("              >???????? |                        \n");
				FFLUSH(stdout);
			}
			return FAILURE;
	}
	return SUCCESS;
}

/*
 *  =========================================================================
 *
 *  DECODE DATA and CTRL
 *
 *  =========================================================================
 */
static int show_msus  = 1;
static int show_fisus = 1;

/*
 *  -------------------------------------------------------------------------
 *
 *  Decode data at Protocol Tester
 *
 *  -------------------------------------------------------------------------
 */
static int pt_decode_data(void)
{
	int ret;
	if ( debug && verbose )
	{
		printf("pt decode data...       .    .        .    .                        \n");
		FFLUSH(stdout);
	}
	switch ( ((uint32_t *)pt_buf)[0] )
	{
		case M2PA_STATUS_MESSAGE:
			switch ( ((uint32_t *)pt_buf)[2] )
			{
				case M2PA_STATUS_OUT_OF_SERVICE:
					ret = OUT_OF_SERVICE;
					break;
				case M2PA_STATUS_IN_SERVICE:
					ret = IN_SERVICE;
					break;
				case M2PA_STATUS_PROVING_NORMAL:
					ret = PROVING_NORMAL;
					break;
				case M2PA_STATUS_PROVING_EMERGENCY:
					ret = PROVING_EMERG;
					break;
				case M2PA_STATUS_ALIGNMENT:
					ret = ALIGNMENT;
					break;
				case M2PA_STATUS_PROCESSOR_OUTAGE:
					ret = PROCESSOR_OUTAGE;
					break;
				case M2PA_STATUS_BUSY:
					ret = BUSY;
					break;
				case M2PA_STATUS_PROCESSOR_OUTAGE_ENDED:
					ret = PROCESSOR_ENDED;
					break;
				case M2PA_STATUS_BUSY_ENDED:
					ret = BUSY_ENDED;
					break;
				default:
					ret = INVALID_STATUS;
					break;
			}
			break;
		case M2PA_ACK_MESSAGE: