test-q784.c

OpenSS7 This the fourth public release of the OpenSS7 Master Package. See README in the release for

	case RES:
		return ("RES");
	case RLC:
		return ("RLC");
	case CCR:
		return ("CCR");
	case RSC:
		return ("RSC");
	case BLO:
		return ("BLO");
	case UBL:
		return ("UBL");
	case BLA:
		return ("BLA");
	case UBA:
		return ("UBA");
	case GRS:
		return ("GRS");
	case CGB:
		return ("CGB");
	case CGU:
		return ("CGU");
	case CGBA:
		return ("CGBA");
	case CGUA:
		return ("CGUA");
	case CMR:
		return ("CMR");
	case CMC:
		return ("CMC");
	case CMRJ:
		return ("CMRJ");
	case FAR:
		return ("FAR");
	case FAA:
		return ("FAA");
	case FRJ:
		return ("FRJ");
	case FAD:
		return ("FAD");
	case FAI:
		return ("FAI");
	case LPA:
		return ("LPA");
	case DRS:
		return ("DRS");
	case PAM:
		return ("PAM");
	case GRA:
		return ("GRA");
	case CQM:
		return ("CQM");
	case CQR:
		return ("CQR");
	case CPG:
		return ("CPC");
	case USR:
		return ("USR");
	case UCIC:
		return ("UCIC");
	case CFN:
		return ("CFN");
	case OLM:
		return ("OLN");
	case CRG:
		return ("CRG");
	case NRM:
		return ("NRM");
	case FAC:
		return ("FAC");
	case UPT:
		return ("UPT");
	case UPA:
		return ("UPA");
	case IDR:
		return ("IDR");
	case IRS:
		return ("IRS");
	case SGM:
		return ("SGM");
	case CRA:
		return ("CRA");
	case CRM:
		return ("CRM");
	case CVR:
		return ("CVR");
	case CVT:
		return ("CVT");
	case EXM:
		return ("EXM");
	case NON:
		return ("NON");
	case LLM:
		return ("LLM");
	case CAK:
		return ("CAK");
	case TCM:
		return ("TCM");
	case MCP:
		return ("MCP");
	case PAUSE:
		return ("MTP-PAUSE");
	case RESUME:
		return ("MTP-RESUME");
	case RESTART_COMPLETE:
		return ("MTP-RESTART-COMPLETE");
	case USER_PART_UNKNOWN:
		return ("MTP-STATUS(Unknown)");
	case USER_PART_UNEQUIPPED:
		return ("MTP-STATUS(Unequiped)");
	case USER_PART_UNAVAILABLE:
		return ("MTP-STATUS(Unavailable)");
	case CONGESTION:
		return ("MTP-STATUS(Congestion)");
	default:
		return ("???");
	}
}

#define BUFSIZE 300

static int state = 0;
int count = 0;
int tries = 0;
int expand = 0;
static long beg_time = 0;

int pt_fd = 0;
int pt_lnk_fd = 0;
int pt_lnk_id = 0;
unsigned char pt_dat[BUFSIZE];
unsigned char pt_ctl[BUFSIZE];

int iut_cpc_fd = 0;
int iut_mgm_fd = 0;
int iut_tst_fd = 0;
int iut_mnt_fd = 0;
unsigned char iut_dat[BUFSIZE];
unsigned char iut_ctl[BUFSIZE];

#define send pt_send

extern size_t strnlen(__const char *, size_t);

static int
send(int msg)
{
	int ret = SUCCESS;
	int i;
	char cbuf[BUFSIZE];
	struct strbuf ctrl = { sizeof(*cbuf), 0, cbuf };
	struct strbuf data = { sizeof(*pt_dat), 0, (char *)pt_dat };
	union MTP_primitives *m = (typeof(m)) cbuf;
	unsigned char *d = pt_dat;
	unsigned char *p = pt_dat;
	/* precharge buffer */
	*d++ = pmsg.cic;
	*d++ = pmsg.cic >> 8;
	switch (msg) {
	case IAM:
		printf
		    ("                    |<-+---------------------%3ld--IAM--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_IAM;
		*d++ = pmsg.nci;
		*d++ = pmsg.fci;
		*d++ = pmsg.fci >> 8;
		*d++ = pmsg.cpc;
		*d++ = pmsg.tmr;
		p = d + 2;
		*d = p - d; d++;	/* pointer to cdpn */
		pmsg.cdpn.len = strnlen(pmsg.cdpn.num, 24);
		*p++ = 3 + ((pmsg.cdpn.len + 1) >> 1) + 1;	/* pointer to optional parameters */
		*p++ = 2 + ((pmsg.cdpn.len + 1) >> 1);	/* cdpn len */
		*p++ = pmsg.cdpn.nai | ((pmsg.cdpn.len & 0x1) ? 0x80 : 0);	/* nai and o/e */
		*p++ = 0x10;	/* inn allowed E.164 */
		for (i = 0; i < pmsg.cdpn.len; i += 2)
			*p++ = (pmsg.cdpn.num[i] & 0x0f) | ((pmsg.cdpn.num[i + 1] & 0x0f) << 4);
		/* optional parameters */
		*d = p - d; d++;
		/* O cgpn */
		*p++ = ISUP_PT_CGPN;
		pmsg.cdpn.len = strnlen(pmsg.cgpn.num, 24);
		*p++ = 2 + ((pmsg.cgpn.len + 1) >> 1);	/* cgpn len */
		*p++ = pmsg.cgpn.nai | ((pmsg.cgpn.len & 0x1) ? 0x80 : 0);	/* nai and o/e */
		*p++ = 0x13;	/* E.164, presentation allowed, user prov verified */
		for (i = 0; i < pmsg.cgpn.len; i += 2)
			*p++ = (pmsg.cgpn.num[i] & 0x0f) | ((pmsg.cgpn.num[i + 1] & 0x0f) << 4);
		if (pmsg.cgpn.len & 0x1) ;	/* filler correct */
		*p++ = 0;	/* end of optional parameters */
		goto send_isup;
	case SAM:
		printf
		    ("                    |<-+---------------------%3ld--SAM--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_SAM;
		p = d + 2;
		*d = p - d; d++;	/* pointer to subn */
		pmsg.subn.len = strnlen(pmsg.subn.num, 100) + 1;
		*p++ = 1 + ((pmsg.subn.len + 1) >> 1);	/* subn len */
		*p++ = (pmsg.subn.len & 0x1) ? 0x80 : 0x00;
		for (i = 0; i < pmsg.subn.len; i += 2)
			*p++ = (pmsg.subn.num[i] & 0x0f) | ((pmsg.subn.num[i + 1] & 0x0f) << 4);
		if (pmsg.subn.len & 0x1) ;	/* filler correct */
		/* optional parameters */
		*d++ = 0;	/* eop */
		goto send_isup;
	case INR:
		printf
		    ("                    |<-+---------------------%3ld--INR--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_INR;
		*d++ = pmsg.inri;
		*d++ = 0;	/* eop */
		goto send_isup;
	case INF:
		printf
		    ("                    |<-+---------------------%3ld--INF--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_INF;
		*d++ = pmsg.infi;
		*d++ = 0;	/* eop */
		goto send_isup;
	case COT:
		*d++ = ISUP_MT_COT;
		*d++ = pmsg.coti;	/* success = 1, failure = 0 */
		if (pmsg.coti) {
			printf
			    ("                    |<-+---------------------%3ld--COT--| (success)          (%d)\n",
			     pmsg.cic, state);
			FFLUSH(stdout);
		} else {
			printf
			    ("                    |<-+---------------------%3ld--COT--| (failure)          (%d)\n",
			     pmsg.cic, state);
			FFLUSH(stdout);
		}
		goto send_isup;
	case ACM:
		printf
		    ("                    |<-+---------------------%3ld--ACM--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_ACM;
		*d++ = pmsg.bci;
		*d++ = pmsg.bci >> 8;
		*d++ = 0;	/* eop */
		goto send_isup;
	case CON:
		printf
		    ("                    |<-+---------------------%3ld--CON--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_CON;
		*d++ = pmsg.bci;
		*d++ = pmsg.bci >> 8;
		*d++ = 0;	/* eop */
		goto send_isup;
	case FOT:
		printf
		    ("                    |<-+---------------------%3ld--FOT--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_FOT;
		*d++ = 0;	/* eop */
		goto send_isup;
	case ANM:
		printf
		    ("                    |<-+---------------------%3ld--ANM--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_ANM;
		*d++ = 0;	/* eop */
		goto send_isup;
	case REL:
		printf
		    ("                    |<-+---------------------%3ld--REL--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_REL;
		*d++ = 2;	/* causv pointer */
		*d++ = 0;	/* eop */
		*d++ = pmsg.caus.len;
		for (i = 0; i < pmsg.caus.len; i++)
			*d++ = pmsg.caus.buf[i];
		goto send_isup;
	case SUS:
		printf
		    ("                    |<-+---------------------%3ld--SUS--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_SUS;
		*d++ = pmsg.sris;
		*d++ = 0;	/* eop */
		goto send_isup;
	case RES:
		printf
		    ("                    |<-+---------------------%3ld--RES--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_RES;
		*d++ = pmsg.sris;
		*d++ = 0;	/* eop */
		goto send_isup;
	case RLC:
		printf
		    ("                    |<-+---------------------%3ld--RLC--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_RLC;
		*d++ = 0;	/* eop */
		goto send_isup;
	case CCR:
		printf
		    ("                    |<-+---------------------%3ld--CCR--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_CCR;
		goto send_isup;
	case RSC:
		printf
		    ("                    |<-+---------------------%3ld--RSC--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_RSC;
		goto send_isup;
	case BLO:
		printf
		    ("                    |<-+---------------------%3ld--BLO--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_BLO;
		goto send_isup;
	case UBL:
		printf
		    ("                    |<-+---------------------%3ld--UBL--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_UBL;
		goto send_isup;
	case BLA:
		printf
		    ("                    |<-+---------------------%3ld--BLA--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_BLA;
		goto send_isup;
	case UBA:
		printf
		    ("                    |<-+---------------------%3ld--UBA--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_UBA;
		goto send_isup;
	case GRS:
		printf
		    ("                    |<-+---------------------%3ld--GRS--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_GRS;
		*d++ = 1;
		*d++ = pmsg.rs.len;
		for (i = 0; i < pmsg.rs.len; i++)
			*d++ = pmsg.rs.buf[i];
		goto send_isup;
	case CGB:
		printf
		    ("                    |<-+---------------------%3ld--CGB--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_CGB;
		*d++ = pmsg.cgi;
		*d++ = 1;
		*d++ = pmsg.rs.len;
		for (i = 0; i < pmsg.rs.len; i++)
			*d++ = pmsg.rs.buf[i];
		goto send_isup;
	case CGU:
		printf
		    ("                    |<-+---------------------%3ld--CGU--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_CGU;
		*d++ = pmsg.cgi;
		*d++ = 1;
		*d++ = pmsg.rs.len;
		for (i = 0; i < pmsg.rs.len; i++)
			*d++ = pmsg.rs.buf[i];
		goto send_isup;
	case CGBA:
		printf
		    ("                    |<-+---------------------%3ld--CGBA-|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_CGBA;
		*d++ = pmsg.cgi;
		*d++ = 1;
		*d++ = pmsg.rs.len;
		for (i = 0; i < pmsg.rs.len; i++)
			*d++ = pmsg.rs.buf[i];
		goto send_isup;
	case CGUA:
		printf
		    ("                    |<-+---------------------%3ld--CGUA-|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_CGUA;
		*d++ = pmsg.cgi;
		*d++ = 1;
		*d++ = pmsg.rs.len;
		for (i = 0; i < pmsg.rs.len; i++)
			*d++ = pmsg.rs.buf[i];
		goto send_isup;
	case CMR:
		printf
		    ("                    |<-+---------------------%3ld--CMR--|                    (%d)\n",
		     pmsg.cic, state);
		FFLUSH(stdout);
		*d++ = ISUP_MT_CMR;
		*d++ = pmsg.cmi;
		*d++ = 0;	/* eop */
		goto send_isup;
	case CMC: