myapi.pc

unix 下用pro*c tuxedo 开发的东西

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*	File name		: myapi.pc				*				
*	Module ID		: MD-P16-02				*
*	Module Name		: 					*
*	Purpose			: Sub Function Used Bye Pcs_Snd_GH_P.pc	*
*	Author          	: Liu Yan Qiu (DIMPT)			*
*	Date Created		: 1999/10/28				*
*	Version			: Version 1.0				*
*	Environment		: Digital Unix				*
*	Portability		: DEC ALPHA Server			*
*	Warnings		:                 			*
*	References		:                 			*
*	Calling Syntax		:                 			*
*	Parameters		: None            			*		
*	Returns			: void             			*
*	Calling Function	:                 			*
*	Called Functions	:                 			*
*	Datastores and usages	:               			*
*        	   (a) Input                                      	*
* 	   	   (b) OutPut                 				*       
*	Report			: None             			*
*	Screens			: None              			*
*	Messages Files		: None             			*
*	Change Log		:                  			*
*	Change No. 		Date	Author	Reason For Change	*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * 
*/


#include "/usr/bkfx/include/Pcs_Snd_GH_P/Pcs_Snd_GH_P.h"

EXEC SQL INCLUDE SQLCA;

void Free_Mem()
{ 
	ProcessError(LOG_NORMAL, "Pcs_Snd_GH_P.x Is Terminated By User!",END);
	if ( buf_msg != NULL ) free( buf_msg ) ;
	MQBKClear();
	EXEC SQL RollBack RELEASE;
	exit(0);
}

/*
void sqlerror()
{
	char sql_code[10];
	char ErrMsg[10];
	int  count_init=0;	
	
	EXEC SQL WHENEVER SQLERROR CONTINUE;
	ProcessError(LOG_ERROR,   "database error:%s!", sqlca.sqlerrm.sqlerrmc );
	
	strncpy(sql_code,sqlca.sqlerrm.sqlerrmc,9);
	sql_code[9]='\0';
	if( strcmp(sql_code,"ORA-03127")==0|| strcmp(sql_code,"ORA-03114")==0||  \
	    strcmp(sql_code,"ORA-03123")==0|| strcmp(sql_code,"ORA-01034")==0||  \
	    strcmp(sql_code,"ORA-01089")==0|| strcmp(sql_code,"ORA-01012")==0||  \
	    strcmp(sql_code,"ORA-01089")==0|| strcmp(sql_code,"ORA-01033")==0 )
	{
		sleep(DB_Interval);
		
		if (count_init > 5)
		{
			ProcessError(LOG_NORMAL, "Could not connect to the database, so exit now!",END);
			MQBKClear();
			EXEC SQL ROLLBACK RELEASE;
			exit(1);
		}
		count_init++;

		InitSndGHP();
		return;
	}
	sprintf(ErrMsg, "%ld", key);
	ProcessError(LOG_ERROR,"Error occured in record which fsxh is %s!", ErrMsg);
	return;
}
*/

int InitSndGHP()
{  


	EXEC SQL BEGIN DECLARE SECTION;
      		VARCHAR  userid[20];
      		VARCHAR  password[20];
 	EXEC SQL END DECLARE SECTION; 

 
 	/*********************************
   	|   Get Process waiting interval |
   	**********************************/
 	
 	interval = GetTimeInterval("PCS_SND_GH_P");


 	/*****************************
  	| Connect to DataBase	     |
  	*****************************/
  
 	strcpy( userid.arr, "pcsdba" );
	userid.len = strlen( userid.arr );
	strcpy( password.arr, "dba" );
	password.len = strlen( password.arr );
	
 	
	EXEC SQL WHENEVER SQLERROR GOTO sqlerror;
 	EXEC SQL CONNECT :userid IDENTIFIED BY :password;

  	      
 	return(1);
 
 	sqlerror:
	EXEC SQL WHENEVER SQLERROR CONTINUE;
	ProcessError(LOG_ERROR,   "DataBase Error:%s!", sqlca.sqlerrm.sqlerrmc );
 	exit(-1);
	
}


int PCSSndGHP()
{  
   	int 	count_rec,i;
/*   	long	key;*/

 
   	EXEC SQL WHENEVER SQLERROR GOTO sqlerror;
   	
   while (1)
   {
	
   	EXEC SQL SELECT count(*) INTO :count_rec FROM T_FSRZ 
        		WHERE sjfl = '5' AND sjzt = '2';

	if ( count_rec == 0 )  sleep( interval ); 
  	else
	{
           
		EXEC SQL DECLARE gh_cursor CURSOR FOR
         		SELECT FSXH FROM T_FSRZ
	   		WHERE sjfl = '5' AND sjzt = '2';
   		
		EXEC SQL OPEN gh_cursor;

      		for (i=1; i <= count_rec; i++) 
             	{
	        	EXEC SQL FETCH gh_cursor INTO :key;
       
       			PCSSndGHP2(key);

          		rtn_code = MQBKSend_Syn(strlen(buf_msg),buf_msg,00,"GH");
           		free( buf_msg );
           		if (rtn_code <0)  
              		{
              		ProcessError(LOG_ERROR,"Pcs_Snd_GH_P.x: \
              			Sendding GH Message Error!",END);
				MQBKBack();
              		continue;
              		}
              		
              	rtn_code = MQBKCmit();
              	if ( rtn_code < 0 ) 
	       	{
	       		ProcessError(LOG_ERROR,"Pcs_Snd_GH_P.x: Commit \
	       	      			GH Message Error!",END);
				MQBKBack();
	       	      	continue;
       	      	}
       	      		
       	      		EXEC SQL UPDATE t_fsrz SET sjzt='3' WHERE fsxh = :key;
   			EXEC SQL UPDATE t_hz SET hzzt='2' WHERE fsxh = :key;   
   			
            	
      	  	} /*end of for */
              
		EXEC SQL COMMIT WORK;
         	EXEC SQL CLOSE gh_cursor;
		  
		sleep( interval );
         	
         }	/* end of else */

    }		/* end of while */
sqlerror:
	EXEC SQL WHENEVER SQLERROR CONTINUE;
	ProcessError(LOG_ERROR,   "DataBase Error:%s!", sqlca.sqlerrm.sqlerrmc );
   	ProcessError(LOG_ERROR,"Pcs_Snd_GH_P.x: Running Function PCSSndGHP() \
   				Error!",END);
 	EXEC SQL RollBack;
   	return(-1);
     	    
}


int PCSSndGHP2(long key2)
{
   	int      	count_hz;
   	long		len_buf_msg, i;
   	char		key_s[11], jssjbh[3], fssjbh[3], ghbh[4];
 
   	EXEC SQL BEGIN DECLARE SECTION;
            	VARCHAR  ghnr[ LEN_GHNR+1 ];
   	EXEC SQL END DECLARE SECTION; 
 
	EXEC SQL WHENEVER SQLERROR GOTO sqlerror;
 
 	len_buf_msg = LEN_GHNR + LEN_FSXH + LEN_FSSJBH + \
 		     LEN_JSSJBH + LEN_GHBH + LEN_GHXL + 1; 

 
	while(1)
	{

		if ( (buf_msg = (char *) malloc (len_buf_msg))==NULL )
 		{
			ProcessError(LOG_ERROR,"Pcs_Snd_GH_P.x: Malloc GH Buffer \
 					Error!",END);
			sleep(InitInterval);
		}
		else break;

 	}

	memset(buf_msg, '\0', len_buf_msg);
 
	sprintf(key_s,"%d",key);

	for( i=strlen( key_s ) ; i<LEN_FSXH; i++)
	key_s[i] = ' ';
	key_s[i]='\0';

  	memset( ghnr.arr, '\0', LEN_GHNR+1);
  
 	EXEC SQL SELECT ghbh, ghxl, ghnr INTO :ghbh, :ghxl, :ghnr 
                 	FROM T_FSGH  WHERE FSXH = :key2;

   	ghnr.len = strlen( ghnr.arr);
   	ghbh[3] ='\0';  
   	ghxl[2]='\0';
          
 	EXEC SQL SELECT count(*) INTO :count_hz FROM t_hz 
                 	WHERE FSXH = :key2;
       
	if ( count_hz ==1 )
	{
	   EXEC SQL SELECT sjbh INTO :jssjbh FROM t_hz 
         		   WHERE FSXH = :key2;
	}
	else 
	{ 
	   jssjbh[0] = '9'; 
	   jssjbh[1] = '9';  
	}
	jssjbh[2] = '\0';           

	EXEC SQL SELECT bsbh into :fssjbh FROM t_bsbh;
        fssjbh[2] = '\0';
	
	#ifdef DEBUG
	printf("Pcs_Snd_GH_P.x: fsxh and len is %s %d\n",key_s,strlen(key_s));
	printf("Pcs_Snd_GH_P.x: fssjbh, jssjbh, ghbh, ghxl is: %s, %s, %s, %s\n",\
		fssjbh,jssjbh,ghbh,ghxl);
	#endif

   	strcat(buf_msg, key_s);
	strcat(buf_msg, fssjbh);
	strcat(buf_msg, jssjbh);
   	strcat(buf_msg, ghbh);
   	strcat(buf_msg, ghxl);
   	strcat(buf_msg, ghnr.arr); 
   
	return(1);     
		 
 	sqlerror:
	EXEC SQL WHENEVER SQLERROR CONTINUE;
	ProcessError(LOG_ERROR,   "DataBase Error:%s!", sqlca.sqlerrm.sqlerrmc );
 	ProcessError(LOG_ERROR,"Pcs_Snd_GH_P.x: Running Function PCSSndGHP2() \
 				SQL Error!",END);
	if ( buf_msg != NULL ) free( buf_msg );
	EXEC SQL RollBack ;
 	return(-1);


}


/*Get the Time_Interval specified in the file and return it */
int GetTimeInterval(char* cType)
{
	FILE *hTimeInterval;
	char cLine[MAX_LINE_LEN+1], cCaption[100], cValue[21];
	int iInterval, i;
	char* pLine;
	
	 
	hTimeInterval = fopen( CONFIG_FILE_FOR_TIMEINTERVAL, "r" );
	if( hTimeInterval == NULL )
	{
		ProcessError(LOG_ERROR, "GetTimeInterval: this is %s message:Cannot open file: %s,The file may not exist!",END);
		return(DEFAULT_TIMEINTERVAL);  
	}
	
	while( myapi_ReadALine( cLine, hTimeInterval ) )
	{
		if( cLine[0] == '#' ) continue;
		if( cLine[0] == NULL ) continue;
		
		pLine = cLine;
		while( (*pLine == ' ') || (*pLine == '\t') ) pLine++;
		i=0;
		while( (*pLine != ' ') && (*pLine != '\t') && (*pLine != '\0') )
		{
			cCaption[i] = *pLine;
			i++;
			pLine++;
		}
		
		cCaption[i] = '\0';
		if( strcmp( cCaption, cType ) == 0 ) /*Match*/
		{
			while( (*pLine == ' ') || (*pLine == '\t') ) pLine++;
			if( *pLine == '\0' )
			{	fclose( hTimeInterval );
				return(DEFAULT_TIMEINTERVAL);
			}
			i=0;
			while( (*pLine != ' ') && (*pLine != '\t') && (*pLine != '\0') )
			{
				cValue[i] = *pLine;
				i++;
				pLine++;
			}
			cValue[i] = '\0';
			iInterval = atoi(cValue);
			
			if(iInterval <= 0) 		
			{
				fclose( hTimeInterval );
				return(DEFAULT_TIMEINTERVAL);
			}
			else
				fclose( hTimeInterval );
				return(iInterval);
		}
		else
			continue;
	}
	fclose( hTimeInterval );
	return(DEFAULT_TIMEINTERVAL);
}

/*Read a line to a string from a file, \n is excluded.
  return 1 if sucessful, 0 otherwise
  Do not close the file.*/
int myapi_ReadALine( char* cLine, FILE* hTable )
{
	char cChar;
	int i=0;
	cLine[0] = '\0';
	while( (cChar = fgetc( hTable )) != '\n' )
	{
		if( cChar == EOF ) return(0);
		cLine[i++] = cChar;
		
		
		if( i >= MAX_LINE_LEN ) i=0;
		cLine[i] = '\0';
	}
	return(1);
}

void ProcessError( char *LOG, char *sErrorMessage1, char *sErrorMessage2 )
{
	FILE* hErrorFile;
	char cDateTime[100],tempstr[100];
	int i,j,len,n;
	long filesize;
	char bakfile[100];
	
	tempstr[0]='\0';
	len=strlen(sErrorMessage1);
	for(i=0;i<=len;i++)
	{
		if(sErrorMessage1[i]=='%')
		{			
			n=i;
			if(len!=i+1)
			{
				for(j=0;j<200&&sErrorMessage1[i+2]!='\0';j++,i++)
				tempstr[j]=sErrorMessage1[i+2];
				tempstr[j]='\0';
			}	
			break;
		}
		if(sErrorMessage1[i]=='\0')
		{
			n=i;
			tempstr[0] = '\0';
			break;
		}
			
	}
	
	
	sErrorMessage1[n]='\0';
	hErrorFile = fopen( ERROR_LOG_FILE, "a" );
	if( hErrorFile == NULL )
	{
		printf( "Critical! Cannot open ERROR_LOG_FILE for append or cannot create!\n");
		return;
	}
	fseek( hErrorFile, 0 ,SEEK_END );
	filesize = ftell(hErrorFile);
	if (filesize > 5242880)
	{
		fclose(hErrorFile );
		sprintf(bakfile, "mv %s %s.bak", ERROR_LOG_FILE, ERROR_LOG_FILE);
		system(bakfile);
		hErrorFile = fopen( ERROR_LOG_FILE, "a" );
		if( hErrorFile == NULL )
		{
			printf( "Critical! Cannot open ERROR_LOG_FILE for append or cannot create!\n");
			return;
		}
	}
	fseek( hErrorFile, 0 ,SEEK_END );
	fputs( "\n",hErrorFile);
	fputs( LOG ,hErrorFile);
	printf("\n%s",LOG);
	fputs( sErrorMessage1,hErrorFile );
	printf("%s",sErrorMessage1);
	fputs( sErrorMessage2,hErrorFile );
	printf("%s",sErrorMessage2);
	fputs( tempstr,hErrorFile );
	printf("%s\n",tempstr);
	fputs( "\n",hErrorFile);
	fclose( hErrorFile );
	sprintf( cDateTime, "date >> %s\n", ERROR_LOG_FILE );
	system( cDateTime );
	system( "date");
}