ecx.cpp

CICS简单入门例程 CICS环境构架 1 安装服务器 1） 建立用户CICSTEST（要用超户权） 2）用CICSTEST用户登录 3）安装DB2指定CICSTEST为管理用户

char *p0, *p1, *p2;

for(i=1, p0=TableLst; i<nt; i++, p0++){
	p0= strchr( p0, ';' );
	if(!p0)return 0;
}

	p1= strchr( p0, ':' );
	if(!p1)return 0;

	p1++;
	p2= strchr( p1, ';' );
	if(!p2)return 0;

	if( p1!=p2 )
	return atoi(p1);
	else
	return 0;
}



/*
 */
void CEcx::RsSetColNameList(char *ColName){
	SetValue0( "_C_N", ColName );
}



/*******************************************************************************/
/***Connect Server***/

/*
 */
void CEcx::EcInit(){

	memset(pComm, 0, BUF_SIZE);
	*TableLst = *SysId1 = '\0';
 
	RsRowNum=RsColNum=0;
	BlockNum=BlockSize=0;
        RsBlkCli=0;

	EciLuwToken=ECI_LUW_NEW;
	EciCallSyncType=ECI_SYNC;
}



/*
 */
void CEcx::BeginWrite(){

	memset(pComm, 0, BUF_SIZE);
	*TableLst = *SysId1 = '\0';

	RsRowNum=RsColNum=0;
	BlockNum=BlockSize=0;

	SetValue0( "_CA", "2.1" );
}



/*
 */
int CEcx::GetCommLen(){

	return strlen(pComm);
}



/*
 */
void CEcx::DisConnect(){
}



/*
 */
void CEcx::ConnectServer0(char *ServerName, char *UserName, char *Password){
	EcInit();

	strncpy( Server, ServerName, 8 );
	strncpy( UserID, UserName, 8 );
	strncpy( PassWd, Password, 8 );
	Server[8] = '\0';
	UserID[8] = '\0';
	PassWd[8] = '\0';
	*Trans = '\0';
	eci_version=ECI_VERSION_1;
}



/*
 */
int CEcx::ConnectServer(char *ServerName, char *UserName, char *Password){
	int r=-1;
	char c_a[ECI_STATUS_LENGTH];
	ECI_STATUS eci_sta;

	ConnectServer0(ServerName, UserName, Password);

	memset( c_a, '\0', ECI_STATUS_LENGTH );
	memset( &EciParms, 0, sizeof(ECI_PARMS) );

	EciParms.eci_version =eci_version;
	EciParms.eci_call_type =ECI_STATE_SYNC;
	memcpy( &EciParms.eci_userid, UserID, 8 );
	memcpy( &EciParms.eci_password, PassWd, 8 );
	memcpy( &EciParms.eci_system_name, Server, 8 );
	EciParms.eci_commarea =c_a;
	EciParms.eci_commarea_length =ECI_STATUS_LENGTH;
	EciParms.eci_extend_mode =ECI_STATE_IMMEDIATE;
	EciParms.eci_luw_token =ECI_LUW_NEW;
	EciParms.eci_timeout =EciTimeOut;
if( *Trans ){
        memcpy( EciParms.eci_tpn, Trans, 4 );
        memcpy( EciParms.eci_transid, Trans, 4 );
}

	r= CICS_ExternalCall(&EciParms);

if( r==ECI_NO_ERROR ){
	memcpy (&eci_sta, c_a, ECI_STATUS_LENGTH);

 switch(eci_sta.CicsServerStatus){
 case ECI_SERVERSTATE_UP:
        r=0;
        break;
 case ECI_SERVERSTATE_UNKNOWN:
	r=1;
        break;
 case ECI_SERVERSTATE_DOWN:
        r=-1;
        break;
 default:
	r=-2;
 }
}

	return r;
}



/*
 */
int CEcx::ConnectServer2(char *ServerName1, char *ServerName2, char *UserName, char *Password){
int r=-1;

	r= ConnectServer(ServerName1, UserName, Password);
	if(r<0)
	r= ConnectServer(ServerName2, UserName, Password);

	return r;
}



/*
 */
void CEcx::SetCaBeforeCall(){

if(RsRowNum){
	RsNewTable(0);

	if(*TableLst)
	SetValue0( "_TL", TableLst );
}

}



/*
 */
short CEcx::CallProgramAndCommit0(char *ProgramName){
short rc;


	SetCaBeforeCall();
	EciCallSyncType=ECI_SYNC;
	strcpy(PrgName,ProgramName);

        memset (&EciParms, 0, sizeof (ECI_PARMS));

        EciParms.eci_version =eci_version;
        EciParms.eci_call_type =ECI_SYNC;
        memcpy(&EciParms.eci_program_name, PrgName, 8);
        memcpy(&EciParms.eci_userid, UserID, 8);
        memcpy(&EciParms.eci_password, PassWd, 8);
        memcpy(&EciParms.eci_system_name, Server, 8);
        EciParms.eci_commarea =pComm;
        EciParms.eci_commarea_length =BUF_SIZE;
        EciParms.eci_extend_mode =ECI_NO_EXTEND;
        EciParms.eci_luw_token =ECI_LUW_NEW;
        EciParms.eci_timeout =EciTimeOut;
if( *Trans ){
        memcpy( EciParms.eci_tpn, Trans, 4 );
        memcpy( EciParms.eci_transid, Trans, 4 );
}

	rc= CICS_ExternalCall(&EciParms);
if( rc==ECI_NO_ERROR ){
	pComm[BUF_SIZE-1]= '\0';
}

	return rc;
}



/*
 */
short CEcx::CallProgramAndCommit(char *ProgramName){
short rc;
int n;


	SetCaBeforeCall();
	EciCallSyncType=ECI_SYNC;
	strcpy(PrgName,ProgramName);

	n= strlen(pComm);
        memset ( pComm+n, '\0', BUF_SIZE-n );
        memset (&EciParms, 0, sizeof (ECI_PARMS));

        EciParms.eci_version =eci_version;
        EciParms.eci_call_type =ECI_SYNC;
        memcpy(&EciParms.eci_program_name, PrgName, 8);
        memcpy(&EciParms.eci_userid, UserID, 8);
        memcpy(&EciParms.eci_password, PassWd, 8);
        memcpy(&EciParms.eci_system_name, Server, 8);
        EciParms.eci_commarea =pComm;
        EciParms.eci_commarea_length =BUF_SIZE;
        EciParms.eci_extend_mode =ECI_NO_EXTEND;
        EciParms.eci_luw_token =ECI_LUW_NEW;
        EciParms.eci_timeout =EciTimeOut;
if( *Trans ){
        memcpy( EciParms.eci_tpn, Trans, 4 );
        memcpy( EciParms.eci_transid, Trans, 4 );
}

	rc= CICS_ExternalCall(&EciParms);
if( rc==ECI_NO_ERROR ){
	pComm[BUF_SIZE-1]= '\0';
	GetValue( "_SYSID", SysId1 );
	if( !strcmp( SysId1, "ISC0" ) )
	*SysId1 = '\0';
}

	return rc;
}



/*
 */
short CEcx::CallProgramAndCommit1(char *ProgramName){
short rc;
int n;


	SetCaBeforeCall();
	EciCallSyncType=ECI_SYNC;
	strcpy(PrgName,ProgramName);

	n= strlen(pComm);
        memset ( pComm+n, '\0', BUF_SIZE-n );
        memset (&EciParms, 0, sizeof (ECI_PARMS));

        EciParms.eci_version =eci_version;
        EciParms.eci_call_type =ECI_SYNC;
        memcpy(&EciParms.eci_program_name, PrgName, 8);
        memcpy(&EciParms.eci_userid, UserID, 8);
        memcpy(&EciParms.eci_password, PassWd, 8);
        memcpy(&EciParms.eci_system_name, Server, 8);
        EciParms.eci_commarea =pComm;
        EciParms.eci_commarea_length =BUF_SIZE;
        EciParms.eci_extend_mode =ECI_EXTENDED;
        EciParms.eci_luw_token =EciLuwToken;
        EciParms.eci_timeout =EciTimeOut;
if( *Trans ){
        memcpy( EciParms.eci_tpn, Trans, 4 );
        memcpy( EciParms.eci_transid, Trans, 4 );
}

	rc= CICS_ExternalCall(&EciParms);
if( rc==ECI_NO_ERROR ){
	pComm[BUF_SIZE-1]= '\0';

	GetValue( "_SYSID", SysId1 );

	if( !strcmp( SysId1, "ISC0" ) )
	*SysId1 = '\0';

        EciLuwToken= EciParms.eci_luw_token;

        memset (&EciParms, 0, sizeof (ECI_PARMS));

        EciParms.eci_version =eci_version;
        EciParms.eci_call_type =EciCallSyncType;
        memcpy(&EciParms.eci_program_name, PrgName, 8);
        memcpy(&EciParms.eci_userid, UserID, 8);
        memcpy(&EciParms.eci_password, PassWd, 8);
        memcpy(&EciParms.eci_system_name, Server, 8);
        EciParms.eci_commarea =0;
        EciParms.eci_commarea_length =0;
        EciParms.eci_extend_mode =ECI_COMMIT;
        EciParms.eci_luw_token =EciLuwToken;
        EciParms.eci_timeout =EciTimeOut;
 if( *Trans ){
        memcpy( EciParms.eci_tpn, Trans, 4 );
        memcpy( EciParms.eci_transid, Trans, 4 );
 }

	rc= CICS_ExternalCall(&EciParms);
}
else{
        EciLuwToken= EciParms.eci_luw_token;

        memset (&EciParms, 0, sizeof (ECI_PARMS));

        EciParms.eci_version =eci_version;
        EciParms.eci_call_type =EciCallSyncType;
        memcpy(&EciParms.eci_program_name, PrgName, 8);
        memcpy(&EciParms.eci_userid, UserID, 8);
        memcpy(&EciParms.eci_password, PassWd, 8);
        memcpy(&EciParms.eci_system_name, Server, 8);
        EciParms.eci_commarea =0;
        EciParms.eci_commarea_length =0;
        EciParms.eci_extend_mode =ECI_BACKOUT;
        EciParms.eci_luw_token =EciLuwToken;
        EciParms.eci_timeout =EciTimeOut;
 if( *Trans ){
        memcpy( EciParms.eci_tpn, Trans, 4 );
        memcpy( EciParms.eci_transid, Trans, 4 );
 }

	CICS_ExternalCall(&EciParms);
}

        EciLuwToken=ECI_LUW_NEW;

	return rc;
}



/*
 */
short CEcx::CallProgram(char *ProgramName){
short rc;
int n;


	SetCaBeforeCall();
	EciCallSyncType=ECI_SYNC;
	strcpy(PrgName,ProgramName);

	n= strlen(pComm);
        memset ( pComm+n, '\0', BUF_SIZE-n );
        memset (&EciParms, 0, sizeof (ECI_PARMS));

        EciParms.eci_version =eci_version;
        EciParms.eci_call_type =ECI_SYNC;
        memcpy(&EciParms.eci_program_name, PrgName, 8);
        memcpy(&EciParms.eci_userid, UserID, 8);
        memcpy(&EciParms.eci_password, PassWd, 8);
        memcpy(&EciParms.eci_system_name, Server, 8);
        EciParms.eci_commarea =pComm;
        EciParms.eci_commarea_length =BUF_SIZE;
        EciParms.eci_extend_mode =ECI_EXTENDED;
        EciParms.eci_luw_token =EciLuwToken;
        EciParms.eci_timeout =EciTimeOut;
if( *Trans ){
        memcpy( EciParms.eci_tpn, Trans, 4 );
        memcpy( EciParms.eci_transid, Trans, 4 );
}

	rc= CICS_ExternalCall(&EciParms);
if( rc==ECI_NO_ERROR ){
	pComm[BUF_SIZE-1]= '\0';
        EciLuwToken= EciParms.eci_luw_token;
}

	return rc;
}


/*
 */
short CEcx::Commit(){
short rc;


        memset (&EciParms, 0, sizeof (ECI_PARMS));

        EciParms.eci_version =eci_version;
        EciParms.eci_call_type =EciCallSyncType;
        memcpy(&EciParms.eci_program_name, PrgName, 8);
        memcpy(&EciParms.eci_userid, UserID, 8);
        memcpy(&EciParms.eci_password, PassWd, 8);
        memcpy(&EciParms.eci_system_name, Server, 8);
        EciParms.eci_commarea =0;
        EciParms.eci_commarea_length =0;
        EciParms.eci_extend_mode =ECI_COMMIT;
        EciParms.eci_luw_token =EciLuwToken;
        EciParms.eci_timeout =EciTimeOut;
if( *Trans ){
        memcpy( EciParms.eci_tpn, Trans, 4 );
        memcpy( EciParms.eci_transid, Trans, 4 );
}

	rc= CICS_ExternalCall(&EciParms);
if( rc==ECI_NO_ERROR ){
        EciLuwToken=ECI_LUW_NEW;
}

	return rc;
}


/*
 */
short CEcx::RollBack(){
short rc;


        memset (&EciParms, 0, sizeof (ECI_PARMS));

        EciParms.eci_version =eci_version;
        EciParms.eci_call_type =EciCallSyncType;
        memcpy(&EciParms.eci_program_name, PrgName, 8);
        memcpy(&EciParms.eci_userid, UserID, 8);
        memcpy(&EciParms.eci_password, PassWd, 8);
        memcpy(&EciParms.eci_system_name, Server, 8);
        EciParms.eci_commarea =0;
        EciParms.eci_commarea_length =0;
        EciParms.eci_extend_mode =ECI_BACKOUT;
        EciParms.eci_luw_token =EciLuwToken;
        EciParms.eci_timeout =EciTimeOut;
if( *Trans ){
        memcpy( EciParms.eci_tpn, Trans, 4 );
        memcpy( EciParms.eci_transid, Trans, 4 );
}

	rc= CICS_ExternalCall(&EciParms);
if( rc==ECI_NO_ERROR ){
        EciLuwToken=ECI_LUW_NEW;
}

	return rc;
}


/*
 */
short CEcx::CallProgramDSyncAndCommit(char *ProgramName){
short rc;
int n;


	SetCaBeforeCall();
	EciCallSyncType=ECI_ASYNC;
	strcpy(PrgName,ProgramName);

	n= strlen(pComm);
        memset ( pComm+n, '\0', BUF_SIZE-n );
        memset (&EciParms, 0, sizeof (ECI_PARMS));

        EciParms.eci_version =eci_version;
        EciParms.eci_call_type =ECI_ASYNC;
        memcpy(&EciParms.eci_program_name, PrgName, 8);
        memcpy(&EciParms.eci_userid, UserID, 8);
        memcpy(&EciParms.eci_password, PassWd, 8);
        memcpy(&EciParms.eci_system_name, Server, 8);
        EciParms.eci_commarea =pComm;
        EciParms.eci_commarea_length =BUF_SIZE;
        EciParms.eci_extend_mode =ECI_NO_EXTEND;
        EciParms.eci_luw_token =ECI_LUW_NEW;
        EciParms.eci_timeout =EciTimeOut;
if( *Trans ){
        memcpy( EciParms.eci_tpn, Trans, 4 );
        memcpy( EciParms.eci_transid, Trans, 4 );
}

	rc= CICS_ExternalCall(&EciParms);

	return rc;
}


/*
 */
short CEcx::CallProgramDSync(char *ProgramName){
short rc;
int n;


	SetCaBeforeCall();
	EciCallSyncType=ECI_ASYNC;
	strcpy(PrgName,ProgramName);

	n= strlen(pComm);
        memset ( pComm+n, '\0', BUF_SIZE-n );
        memset (&EciParms, 0, sizeof (ECI_PARMS));

        EciParms.eci_version =eci_version;
        EciParms.eci_call_type =ECI_ASYNC;
        memcpy(&EciParms.eci_program_name, PrgName, 8);
        memcpy(&EciParms.eci_userid, UserID, 8);
        memcpy(&EciParms.eci_password, PassWd, 8);
        memcpy(&EciParms.eci_system_name, Server, 8);
        EciParms.eci_commarea =pComm;
        EciParms.eci_commarea_length =BUF_SIZE;
        EciParms.eci_extend_mode =ECI_EXTENDED;
        EciParms.eci_luw_token =EciLuwToken;
        EciParms.eci_timeout =EciTimeOut;
if( *Trans ){
        memcpy( EciParms.eci_tpn, Trans, 4 );
        memcpy( EciParms.eci_transid, Trans, 4 );
}

	rc= CICS_ExternalCall(&EciParms);
if( rc==ECI_NO_ERROR ){
        EciLuwToken= EciParms.eci_luw_token;
}

	return rc;
}


/*
 */
short CEcx::GetReply(void){
short rc;


        memset ( pComm, '\0', BUF_SIZE );
        memset (&EciParms, 0, sizeof (ECI_PARMS));

        EciParms.eci_version =eci_version;
        EciParms.eci_call_type =ECI_GET_REPLY;
        memcpy(&EciParms.eci_program_name, PrgName, 8);
        memcpy(&EciParms.eci_userid, UserID, 8);
        memcpy(&EciParms.eci_password, PassWd, 8);
        memcpy(&EciParms.eci_system_name, Server, 8);
        EciParms.eci_commarea =pComm;
        EciParms.eci_commarea_length =BUF_SIZE;
        EciParms.eci_extend_mode =ECI_NO_EXTEND;
        EciParms.eci_luw_token =ECI_LUW_NEW;
        EciParms.eci_timeout =EciTimeOut;
if( *Trans ){
        memcpy( EciParms.eci_tpn, Trans, 4 );
        memcpy( EciParms.eci_transid, Trans, 4 );
}

	rc= CICS_ExternalCall(&EciParms);
if( rc==ECI_NO_ERROR ){
	pComm[BUF_SIZE-1]= '\0';
}

	return rc;
}



/*******************************************************************************/
/*** etc ***/

/*
 */
void CEcx::BinaryToAscii(char *bs, char *as, int n){
int nn, i, bi;
char *p;


	memset( as, '\0', (n+2)/3*4 );

for( i=0, p=bs, bi=0; i<n; i++, p++, bi++ ){
	if(bi>=3)
	bi-=3;

	nn= i/3*4;
 switch(bi){
 case 0:
	as[nn] |= *p & 0x3f;
	as[nn] |= 0x40; 

	as[nn+1] |= (*p & 0xc0) >>6;
	as[nn+1] |= 0x40; 

	break;
 case 1:
	as[nn+1] |= (*p & 0xf) <<2; 
	as[nn+1] |= 0x40; 

	as[nn+2] |= (*p & 0xf0) >>4; 
	as[nn+2] |= 0x40; 

	break;
 case 2:
	as[nn+2] |= (*p & 0x3) <<4; 
	as[nn+2] |= 0x40; 

	as[nn+3] |= (*p & 0xfc) >>2; 
	as[nn+3] |= 0x40; 

	break;
 }

}

}



/*
 */
int CEcx::AsciiToBinary(char *as, char *bs){
int n, n1, nn, i, bi;
char *p;


	n= strlen(as);
	n1= n/4;
switch(n-n1*4){
case 0:
	n= n1*3;

	break;
case 1:
case 2:
	n= n1*3+1;

	break;
case 3:
	n= n1*3+2;
}

	memset( bs, '\0', n );

	nn=-1;
for( p=as, i=0, bi=0; *p; p++, i++, bi++ ){
	if(bi>=4)
	bi-=4;

	*p &= 0x3f;

	nn= i/4*3;
 switch(bi){
 case 0:
	bs[nn] |= *p;

	break;
 case 1:
	bs[nn] |= *p <<6;
	bs[nn+1] |= *p >>2;

	break;
 case 2:
	bs[nn+1] |= *p <<4;
	bs[nn+2] |= *p >>4;

	break;
 case 3:
	bs[nn+2] |= *p <<2;

	break;
 }
}

	return n;
}



/*
 */
int CEcx::GetBlockSize(){
char s[1024];

	GetValue( "_BSIZE", s );
	BlockSize= atoi(s);

	GetValue( "_BNUM", s );
	BlockNum= atoi(s);

	if( BlockNum == (BlockSize+BLOCK_SIZE-1) /BLOCK_SIZE )
	return BlockSize;
	else
	return -1;
}



/*
 */
int CEcx::LoadBlock(char *blk){
int i, n, r;
char tsq1[32], s[32], *p;


	if(!BlockSize)
	GetBlockSize();

        GetValue( "_TSQ1", tsq1 );
for( i=1, p=blk, n=BlockSize; i<=BlockNum; i++, p+=BLOCK_SIZE, n-=BLOCK_SIZE ){
	memset(pComm, 0, BUF_SIZE);

        SetValue( "_TSQ1", tsq1 );

	sprintf( s, "%d", BlockNum );
        SetValue( "_BNUM", s );

	sprintf( s, "%d", i );
        SetValue( "_BNO", s );
	if(*SysId1)
        SetValue( "_SYSID", SysId1 );

	r= CallProgramAndCommit0(PrgName);
	if(r) return r;

 if(n>=BLOCK_SIZE){
	memcpy( p, pComm, BLOCK_SIZE );
 }
 else{
	memcpy( p, pComm, n );
 }
}


	return 0;
}



/*
 */
int CEcx::Upload(char *fs, char *svr_fs){
int i, n, err;
char s[64], buf[BLOCK_SIZE];
FILE *fp;


	fp= fopen( fs, "rb" );
if(!fp){
	err=-1001;
	goto EX;
}

	fseek( fp, 0, 0 );
	n=BLOCK_SIZE;
	i=0;
while( n==BLOCK_SIZE ){
	memset(pComm, 0, BUF_SIZE);

        SetValue( "_UPF", svr_fs );
	if(!i)
	SetValue( "_UPFC", "C" );

	n= fread( buf, 1, BLOCK_SIZE, fp );
	sprintf( s, "%d", n );
        SetValue( "_UPFL", s );

	memcpy( pComm+ strlen(pComm) +1, buf, n );

	err= CallProgramAndCommit0(PrgName);
	if(err)	break;

	GetValue0( "_UPOK", s );
 if( *s != 'Y' ){
	err=-1002;
	goto EX;
 }

	i++;
}

	fclose(fp);
EX:
	return err;
}



/*
 */
void CEcx::SetEciTimeOut(int TimeOut){
	EciTimeOut=TimeOut;
}




/*
 */
void CEcx::SetTransId(char *TransId){

	if(!TransId)
	*Trans = '\0';

	strncpy(Trans, TransId, 4);

	if(*Trans)
	eci_version=ECI_VERSION_1A;
	else
	eci_version=ECI_VERSION_1;
}