psc.h

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

/**    2001.04.15 在初始化函数增加了等待服务器创建管道文件的语句  邱虎    **/

/*********************************************************************************/
/*         模块名             进程监控--通讯函数库                               */
/*                                                                               */
/*         作者                袁航                                              */
/*                                                                               */
/*         时间                一九九九年   十一月                               */
/*********************************************************************************/
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <netdb.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/uio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/un.h>
#include <strings.h>
#include <semaphore.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/ipc.h>

#define DEBUG_START
#define pscLISTENQ 1024
#define pscMAXLINE 255
#define pscRVC_LOWAT 60
#define pscMAXSOCKADDR 128 
#define pscBUFFSIZE 8192
#define pscCLIENT_PORT 11001
#define pscPC_PORT 11002
#define pscMAX_CLI_CONN 100
#define pscMAX_CLI_LINE 100
#define pscMAX_PC_CONN 100
#define pscCLIENT_LOCK 0
#define pscDB 1
#define pscWC 2
#define pscMUTEX 3
#define pscRC 4
#define pscTOTAL_SEM 5
#define pscCHILD_MAX 100
#define pscMESSAGE_SEG_MAX 91
#define pscSWXH_LENGTH 3
#define pscSWBM_LENGTH 10

#define pscEND_CHARACTER '\n'
#define pscFILL_CHARACTER '#'
#define pscALARM_TIME 5
#define pscSECS_INTERVAL 2
#define pscSECS_INTERVAL_FOR_ERROR 5


#define pscUNIXSTR_PATH "/hubei/hbyd/program/yuanh/unix.str"



#define psc_min(a,b) ((a)<(b)?(a):(b))
#define psc_max(a,b) ((a)>(b)?(a):(b))

#define pscUP_PIPE "myuppipe"
#define pscDOWN_PIPE "mydownpipe"

union semun
{
	int val;
	struct semid_ds *buf;
	ushort *array;
};
/****************************************************************************/

typedef struct psc_client_status
{
	int is_used;

	int error_flag;
	char swxh[pscSWXH_LENGTH+1];
	
	char message_buffer[pscMAX_CLI_LINE+1][pscMAXLINE];
	int update_flag[pscMAX_CLI_LINE+1];
	int line_max;
} pscCLIENT_STATUS;
/***************************************************************************************************/
pscCLIENT_STATUS *psc_client;
int *psc_client_max;
/**********************************************************************************************/
#define pscPERMS S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH
#define pscSEM_KEY (key_t)48

#define pscSHM_KEY (key_t)9887


int psc_semid[pscTOTAL_SEM];

struct sembuf psc_sem_wait[pscTOTAL_SEM];
struct sembuf psc_sem_signal[pscTOTAL_SEM];
struct sembuf psc_sem_zero[pscTOTAL_SEM];
typedef struct rwdes
{
	int rfd;
	int wfd;
} RWFD;
/**************************************************************/
typedef struct buf_struct
{
	int read_cnt;
	char *read_ptr;
	char read_buf[pscMAXLINE];

	int begin;
	char message[pscMAXLINE];
} pscBUF_STRUCT;

/**************************************/
typedef struct child_com_table
{
/*	int is_used;
	pid_t pid;*/
    int sockfd;
	pscBUF_STRUCT buf;
} pscCHILD_COM;
pscCHILD_COM psc_child_com[2];
/*int psc_child_com_max;*/
/***************************************/

typedef struct father_pc_com
{
	int is_used;
    int sockfd;

	pid_t childpid;
	pscBUF_STRUCT buf;
} pscFATHER_PC_COM;
pscFATHER_PC_COM psc_pc_com[pscMAX_PC_CONN];
int psc_pc_com_max;
/****************************************/
typedef struct father_cli_com
{
	int is_used;

	int up_sockfd;
	int down_sockfd;
     	
	pid_t childpid;
	pscBUF_STRUCT buf;

	char swxh[pscSWXH_LENGTH+1];
	char swbm[pscSWBM_LENGTH+1];
	int suffix;
} pscFATHER_CLI_COM;
pscFATHER_CLI_COM psc_cli_com[pscMAX_CLI_CONN];
int psc_cli_com_max;
/*****************************************/
struct sigaction newact;
struct sigaction act;

fd_set psc_rset,psc_allset;
int psc_maxfd;
mode_t fifo_perms=S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH;
int psc_alarm_flag=0;
/****************************************************/
int psc_read_open(char *path)
{
	char buf[2];
	int n;
	int fd;
    sleep(0); /*等待服务进程创建好管道文件*/	
    sleep(0);
a1:
   if((fd=open(path,O_RDONLY|O_NONBLOCK))<0) /*第一次尝试*/
      {   
       printf("\nTry again open fifo files:%s\n",path);	
       sleep(1);
       if((fd=open(path,O_RDONLY|O_NONBLOCK))<0)  /*第二次尝试*/
	 {
          printf("\nswopen error:%d!\n",errno);
          exit(1);
         }
      }
b1:
    sleep(0);
    if((n=read(fd,buf,1))<0)
	{
		if((errno!=EWOULDBLOCK)&&(errno!=EAGAIN)&&(errno!=EINTR))
		{
            printf("\nswread error:%d!\n",errno);
            exit(1);
		}
#ifdef DEBUG_START
		printf("swstart:I am going to goto b1...\n");
#endif
        goto b1;
	}
    else if(n==0)
	{
        close(fd);
#ifdef DEBUG_START
		printf("swstart:I am going to goto a1...\n");
#endif

        sleep(0);
        goto a1;
	}
	return(fd);
}
/************************************************************/


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

void psc_child_init(void)
{
	int i;
	for(i=0;i<2;i++)
	{
/*		psc_child_com[i].is_used=0;*/
		psc_child_com[i].buf.read_cnt=0;
		psc_child_com[i].buf.read_ptr=psc_child_com[i].buf.read_buf;
		psc_child_com[i].buf.begin=0;
	}
/*	psc_child_com_max=0;*/
}
/***********************************************************/




/*****************************************/
void psc_father_init(void)
{
	int i;
	for(i=0;i<pscMAX_PC_CONN;i++)
	{
		psc_pc_com[i].is_used=0;
		psc_pc_com[i].buf.read_cnt=0;
		psc_pc_com[i].buf.read_ptr=psc_child_com[i].buf.read_buf;
		psc_pc_com[i].buf.begin=0;
	}

	psc_pc_com_max=0;
	for(i=0;i<pscMAX_CLI_CONN;i++)
	{
		psc_cli_com[i].is_used=0;
		psc_cli_com[i].buf.read_cnt=0;
		psc_cli_com[i].buf.read_ptr=psc_child_com[i].buf.read_buf;
		psc_cli_com[i].buf.begin=0;
	}
	psc_cli_com_max=0;
}
/**********************************************/

/******************************************************************************************************/
int psc_my_safe_read(int fd,char *ptr,pscBUF_STRUCT *buf_ptr)
{
	if(buf_ptr->read_cnt<=0)
	{
again:
	    if((buf_ptr->read_cnt=read(fd,buf_ptr->read_buf,pscMAXLINE))<0)
		{
			if(errno==EINTR)
				goto again;
			else if((errno==EWOULDBLOCK)||(errno==EAGAIN))
				return(-1);
			printf("\npsc_my_safe_read:read error:%d!\n",errno);
			exit(1);
		}
		else if(buf_ptr->read_cnt==0)
			return(0);
		buf_ptr->read_ptr=buf_ptr->read_buf;
	}
	buf_ptr->read_cnt=buf_ptr->read_cnt-1;
	*ptr=*(buf_ptr->read_ptr);
	buf_ptr->read_ptr=buf_ptr->read_ptr+1;
	return(1);
}
/***************************************************************************************************/
int psc_safe_readline(int fd,pscBUF_STRUCT *buf_ptr)
{
	int i,rc;
	char c;
	for(i=buf_ptr->begin;i<pscMAXLINE-1;i++)
	{
		rc=psc_my_safe_read(fd,&c,buf_ptr);
		if((rc==1)&&(c!=pscEND_CHARACTER))
			buf_ptr->message[i]=c;
		else if((rc==1)&&(c==pscEND_CHARACTER))
		{
			buf_ptr->message[i]=pscEND_CHARACTER;
			buf_ptr->message[i+1]='\0';
			buf_ptr->begin=0;
			return(i+1);
		}
		else if(rc==0)
		{
			buf_ptr->begin=0;
			buf_ptr->read_cnt=0;
			buf_ptr->read_ptr=buf_ptr->read_buf;
			return(0);
		}
		else if(rc==-1)
		{
			buf_ptr->begin=i;
			return(-1);
		}
		
	}
	printf("\npsc_safe_readline:too long message!\n");
	exit(1);
}
/*********************************************************************************/
ssize_t psc_readn(int fd,char *vptr,size_t n)
{
	ssize_t nleft;
	ssize_t nread;
	char *ptr;
	ptr=vptr;
	nleft=n;
	while(nleft>0)
	{
		if((nread=read(fd,ptr,nleft))<0)
		{
			if(errno==EINTR)
				nread=0;
			else 
			{
				printf("\npsc_readn:read error:%d!\n",errno);
				exit(1);
			}
		}
		else if(nread==0)
			break;
		nleft-=nread;
		ptr+=nread;
	}
	return(n-nleft);
}

/**************************************************************************************************/
ssize_t psc_writen(int fd,const char *vptr,size_t n)
{
	size_t nleft;
	ssize_t nwritten;
	const char *ptr;
	ptr=vptr;
	nleft=n;
	while(nleft>0)
	{
		if((nwritten=write(fd,ptr,nleft))<=0)
		{
			if(errno==EINTR)
				nwritten=0;
			else 
			{
				printf("\npsc_writen:write error:%d!\n",errno);
				return(0);
			}
		}
		nleft-=nwritten;
		ptr+=nwritten;
	}
	return(n);
}

/************************************************************************************************/
void psc_set_nonblock(int fd)
{
	int flags;
	if((flags=fcntl(fd,F_GETFL,0))<0)
	{
		printf("\nF_GETTFL error!\n");
		exit(1);
	}
	flags|=O_NONBLOCK;
    if(fcntl(fd,F_SETFL,flags)<0)
	{
		printf("\nF_SETFL error!\n");
		exit(1);
	}
}
/*******************************************************************************/
void psc_set_block(int fd)
{
	int flags;
	if((flags=fcntl(fd,F_GETFL,0))<0)
	{
		printf("\nF_GETFL error!\n");
		exit(1);
	}
	flags&=~O_NONBLOCK;
	if(fcntl(fd,F_SETFL,flags)<0)
	{
		printf("\nF_SETFL error!\n");
		exit(1);
	}
}

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

int psc_semop_restart(int semid,struct sembuf *sops,int nsops)
{
	int retval;
	while(((retval=semop(semid,sops,nsops))==-1)&&(errno==EINTR));
	return retval;
}
/************************************************************************************************/
void psc_set_sembuf_struct(struct sembuf *s,int num,int op,int flg)
{
	s->sem_num=(short)num;
	s->sem_op=op;
	s->sem_flg=flg;
	return;
}
/***************************************************************************************************/
int psc_create_sem(key_t key)
{
	int i;
	for(i=0;i<pscTOTAL_SEM;i++)
	{
		if((psc_semid[i]=semget(key+(key_t)i,1,IPC_CREAT|pscPERMS))<0)
		{
		    printf("\npsc_create_sem:semget error:%d!\n",errno);
		    exit(1);
		}
	}
	return(1);
}
/*****************************************************************************************************/
int psc_get_sem(key_t key)
{