psc.h

采用非对称密钥加密方式的应用系统认证系统

void psc_exit_handler(signo)
{
	char message_buffer[pscMAXLINE];
	int length;
	strcpy(message_buffer,"14");
	psc_get_sys_t(message_buffer+2);
	strcpy(message_buffer+16,"进程被杀死");
	length=strlen(message_buffer);
	message_buffer[length]=pscEND_CHARACTER;
	message_buffer[length+1]='\0';
	psc_writen(psc_up_sockfd,message_buffer,length+1);
	exit(1);
}
/*************************************************************************************************/
void psc_init_myself(void)
{
#ifdef PSC
	int i,j;
	int temp_num;
	char su[3];
	fd_set rset,allset;
	int maxfd;
	int nready;
	int n;

	act.sa_handler=psc_exit_handler;
	act.sa_flags=0;
    sigfillset(&act.sa_mask);
	if(sigaction(SIGUSR1,&act,NULL)<0)
	{
		printf("\nsigaction error:%d!\n",errno);
		exit(1);
	}
	psc_get_init_shm();
	psc_get_init_sem();


	psc_buf.read_cnt=0;
	psc_buf.read_ptr=psc_buf.read_buf;
	psc_buf.begin=0;

	psc_pid=getpid();
	sprintf(psc_up_pipename,"%s%d",pscUP_PIPE,psc_pid);
	sprintf(psc_down_pipename,"%s%d",pscDOWN_PIPE,psc_pid);

    psc_down_sockfd=psc_read_open(psc_down_pipename);

psc_again1:	
	if((psc_up_sockfd=open(psc_up_pipename,O_WRONLY))<0)
	{
		if(errno==EINTR)
			goto psc_again1;
		printf("\nopen error:%d!\n",errno);
		exit(1);
	}
	psc_writen(psc_up_sockfd,"A",1);
	FD_ZERO(&allset);
	FD_SET(psc_down_sockfd,&allset);
	maxfd=psc_down_sockfd;
	memcpy(&rset,&allset,sizeof(rset));
psc_again2:
    if((nready=select(maxfd+1,&rset,NULL,NULL,NULL))<0)
    {
		if(errno==EINTR)
			goto psc_again2;
        printf("\nselect error:%d!\n",errno);
        exit(1);
    }
	if((n=psc_readn(psc_down_sockfd,su,2))!=2)
	{
		printf("\nThe main server close the sockfd inmaturely!\n");
		exit(1);
	}
	psc_suffix=atoi(su);

    for(j=0;j<=pscMAX_CLI_LINE;j++)
	{
		psc_status_secs[j]=0;
		psc_status[j][0]=0;
		psc_error_secs[j]=0;
		psc_error[j][0]=0;
	}
	status_max=-1;
	error_max=-1;
	
#endif
}
/******************************************************************************/

/****************************************************************************/
void psc_send_status_message(char *message,int n)
{
	int row;
	char code[3];
	time_t secs;
	char message_buffer[pscMAXLINE];
    unsigned long length;
	int len;
	row=1;
	strcpy(code,"RZZ");
	length=strlen(message);
	if(length>pscMAXLINE-50)
		message[pscMAXLINE-50]='\0';
#ifdef PSC
	time(&secs);
	if(secs-psc_status_secs[row]<pscSECS_INTERVAL)
		return;
	psc_status_secs[row]=secs;
	strcpy(psc_status[row],message);
	psc_get_time_from_secs(message_buffer,&secs);
	sprintf(message_buffer+14,"%02d%3s%s",row,code,message);
	psc_p(pscCLIENT_LOCK);
	if(row>(psc_client+psc_suffix)->line_max)
		(psc_client+psc_suffix)->line_max=row;
	(psc_client+psc_suffix)->update_flag[row]=1;
	strcpy((psc_client+psc_suffix)->message_buffer[row],message_buffer);
	psc_v(pscCLIENT_LOCK);
#else
	printf("\n%s",message);
#endif
}
/*****************************************************************************/
void psc_send_error_message(char *message,int n)
{
	time_t secs;

	char message_buffer[pscMAXLINE];
	unsigned long length;
	int len;
	int row;
	char code[3];
	row=1;
	strcpy(code,"PZZ");
	length=strlen(message);
	if(length>pscMAXLINE-50)
	    message[pscMAXLINE-50]='\0';
#ifdef PSC
	time(&secs);
	if(secs-psc_error_secs[row]<pscSECS_INTERVAL_FOR_ERROR)
		return;
	psc_error_secs[row]=secs;
	strcpy(psc_error[row],message);
	strcpy(message_buffer,"15");
	psc_get_time_from_secs(message_buffer+2,&secs);	  
	sprintf(message_buffer+16,"%02d%3s%s",row,code,message);
	len=strlen(message_buffer);
	message_buffer[len]=pscEND_CHARACTER;
    message_buffer[len+1]=0;
	psc_writen(psc_up_sockfd,message_buffer,len+1);

#else
	printf("%s\n",message);
#endif
}
/****************************************************************************/

/***************************************************************************/
void psc_have_to_exit(void)
{
#ifdef PSC
	char message_buffer[pscMAXLINE];
	int length;
	strcpy(message_buffer,"13");
	psc_get_sys_t(message_buffer+2);
	strcpy(message_buffer+16,"进程被正常终止");
	length=strlen(message_buffer);
	message_buffer[length]=pscEND_CHARACTER;
	message_buffer[length+1]='\0';
	psc_writen(psc_up_sockfd,message_buffer,length+1);
	exit(1);
#else
	exit(1);
#endif
}
/******************************************************************************/
/*****************************************************************************/
void psc_normal_exit(void)
{
#ifdef PSC
	char message_buffer[pscMAXLINE];
	int length;
	strcpy(message_buffer,"18");
	psc_get_sys_t(message_buffer+2);
	strcpy(message_buffer+16,"进程运行完毕退出");
	length=strlen(message_buffer);
	message_buffer[length]=pscEND_CHARACTER;
	message_buffer[length+1]='\0';
	psc_writen(psc_up_sockfd,message_buffer,length+1);
	exit(0);
#else
	exit(0);
#endif
}
/******************************************************************************/
void psc_exit_for_error(void)
{
#ifdef PSC
	char message_buffer[pscMAXLINE];
	int length;
	strcpy(message_buffer,"19");
	psc_get_sys_t(message_buffer+2);
	strcpy(message_buffer+16,"进程因为错误退出");
	length=strlen(message_buffer);
	message_buffer[length]=pscEND_CHARACTER;
	message_buffer[length+1]='\0';
	psc_writen(psc_up_sockfd,message_buffer,length+1);
	exit(1);
#else
	exit(1);
#endif
}
/********************************************************************************/
/*void psc_send_and_exit(char *message,int n)
{
	psc_send_error_message(message,n);
	psc_exit_for_error();
}*/
/*********************************************************************************/
int psc_is_end(void)
{
#ifdef PSC
	char buf[2];
	int n;
c1:
	n=read(psc_down_sockfd,buf,1);
/*	printf("\nn=%d\n",n);*/
	if(n<0)
	{
		if(errno==EINTR)
			goto c1;
		else if((errno==EWOULDBLOCK)||(errno==EAGAIN))
		{
/*			printf("\nerrno=%d\n",errno);
			return(0);*/
		}
		else 
			printf("\nswread error:%d!",errno);
        return(0);
	}
	else if(n==0)
	{
		if(close(psc_down_sockfd)<0)
		{printf("\npsc_is_end:close end:%d\n",errno);}
		if(close(psc_up_sockfd)<0)
        {printf("\npsc_is_end:close end:%d\n",errno);}
		exit(1);
	}
/*	printf("\n66666666666666%c\n",buf[0]);*/
	return(1);
#else
	return(0);
#endif
}
/********************************************************************************/
void psc_send_message(int row,char *code,char *message)
{
#ifdef PSC
	time_t secs;

	char message_buffer[pscMAXLINE];
	unsigned long length;
	int len;
	length=strlen(message);
	if(length>pscMAXLINE-50)
	    message[pscMAXLINE-50]='\0';
    row=abs(row);
    row=row%100;
	*(code+3)=0;
	
	switch(code[0])
	{
	case 'R':
	/*	if(strcmp(psc_status[row],message)==0)
			return;*/
		time(&secs);
		if(secs-psc_status_secs[row]<pscSECS_INTERVAL)
			return;
		psc_status_secs[row]=secs;
		strcpy(psc_status[row],message);
	
		psc_get_time_from_secs(message_buffer,&secs);
	    sprintf(message_buffer+14,"%02d%3s%s",row,code,message);
		psc_p(pscCLIENT_LOCK);
		if(row>(psc_client+psc_suffix)->line_max)
			(psc_client+psc_suffix)->line_max=row;
		(psc_client+psc_suffix)->update_flag[row]=1;
		strcpy((psc_client+psc_suffix)->message_buffer[row],message_buffer);
		psc_v(pscCLIENT_LOCK);
		break;
	case 'D':;
	case 'F':;
	case 'S':;
	case 'P':;
	case 'E':
      /*  if(strcmp(psc_error[row],message)==0)
			return;*/
		if(time(&secs)<0)
			exit(1);
		if(secs-psc_error_secs[row]<pscSECS_INTERVAL_FOR_ERROR)
			return;
		psc_error_secs[row]=secs;
		strcpy(psc_error[row],message);
		strcpy(message_buffer,"15");
		psc_get_time_from_secs(message_buffer+2,&secs);	  
		sprintf(message_buffer+16,"%02d%3s%s",row,code,message);
		len=strlen(message_buffer);
		message_buffer[len]=pscEND_CHARACTER;
        message_buffer[len+1]=0;
		psc_writen(psc_up_sockfd,message_buffer,len+1);
		break;
	case 'T':
	    time(&secs);
/*  	if(secs-psc_status_secs[row]<pscSECS_INTERVAL)
			return;*/
		psc_status_secs[row]=secs;
		strcpy(psc_status[row],message);
	
		psc_get_time_from_secs(message_buffer,&secs);
	    sprintf(message_buffer+14,"%02d%3s%s",row,code,message);
		psc_p(pscCLIENT_LOCK);
		if(row>(psc_client+psc_suffix)->line_max)
			(psc_client+psc_suffix)->line_max=row;
		(psc_client+psc_suffix)->update_flag[row]=1;
		strcpy((psc_client+psc_suffix)->message_buffer[row],message_buffer);
		psc_v(pscCLIENT_LOCK);

/*      if(secs-psc_error_secs[row]<pscSECS_INTERVAL_FOR_ERROR)
			return;*/
		psc_error_secs[row]=secs;
		strcpy(psc_error[row],message);
		strcpy(message_buffer,"15");
		psc_get_time_from_secs(message_buffer+2,&secs);	  
		sprintf(message_buffer+16,"%02d%3s%s",row,code,message);
		len=strlen(message_buffer);
		message_buffer[len]=pscEND_CHARACTER;
        message_buffer[len+1]=0;
		psc_writen(psc_up_sockfd,message_buffer,len+1);
		break;
	default:
		printf("\n待发送消息不合法!\n");
	}
#else
	printf("%s\n",message);
#endif
}
/*******************************************************************************/
void psc_send_and_exit(char *message,int n)
{
	psc_send_message(1,"PZZ",message);
	psc_exit_for_error();
}
/*******************************************************************************/
void psc_begin_reading(void)
{
	int rc;
	psc_z(pscWC);
    psc_p(pscMUTEX);
	psc_v(pscRC);
	if((rc=psc_get_sem_value(pscRC))==1)
		psc_p(pscDB);
	psc_v(pscMUTEX);
}
/********************************************************************************/

void psc_end_reading(void)
{
	int rc;
	psc_p(pscMUTEX);
	psc_p(pscRC);
	if((rc=psc_get_sem_value(pscRC))==0)
		psc_v(pscDB);
	psc_v(pscMUTEX);
}
/*********************************************************************************/

void psc_begin_writing(void)
{
	psc_v(pscWC);
	psc_p(pscDB);
}
/*********************************************************************************/

void psc_end_writing(void)
{
	psc_v(pscDB);
	psc_p(pscWC);
}
/*********************************************************************************/

/*********************************************************************************/

/*void main(void)
{
    char message[100];
	psc_init_myself();
    int i;
	for(i=0;;i=(i+1)%10000)
	{
		if(psc_is_end())
		{
			printf("\nI will be terminated!\n");
			psc_have_to_exit();
		}
		sprintf(message,"I have just sent an error message:%d!",i);
		psc_send_message(0,"P00",message);

	}
	psc_normal_exit();
}*/