psc.h

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

    int i;
	for(i=0;i<pscTOTAL_SEM;i++)
	{
		if((psc_semid[i]=semget(key+(key_t)i,1,pscPERMS))<0)
		{
		    printf("\npsc_get_sem:semget error:%d!\n",errno);
		    exit(1);
		}
	}
	return(1);
}
/*******************************************************************************************************/
void psc_init_sem_element(void)
{
	int i;
	for(i=0;i<pscTOTAL_SEM;i++)
	{
		psc_set_sembuf_struct(psc_sem_wait+i,0,-1,SEM_UNDO);
		psc_set_sembuf_struct(psc_sem_signal+i,0,1,SEM_UNDO);
		psc_set_sembuf_struct(psc_sem_zero+i,0,0,SEM_UNDO);
	}
}
/*****************************************************************************************************/
int psc_set_sem_value(int sem_index,int semvalue)
{
	union semun arg;
	arg.val=semvalue;
	if(semctl(psc_semid[sem_index],0,SETVAL,arg)<0)
	{
		printf("\nset_sem_value:semctl error:%d\n",errno);
		exit(1);
	}
	return(0);
}
/********************************************************************************************************/
int psc_get_sem_value(int sem_index)
{
	int retval;
	if((retval=semctl(psc_semid[sem_index],0,GETVAL))<0)
	{
		printf("\npsc_get_sem_value:semctl error:%d\n",errno);
		exit(1);
	}
	return(retval);
}
/*******************************************************************************************************/
void psc_p(int sem_index)
{
	int semop_ret;
	while(((semop_ret=semop(psc_semid[sem_index],psc_sem_wait+sem_index,1))==-1)&&(errno==EINTR));
	if(semop_ret==-1)
	{
		printf("\nlock1:semop error:%d\n",errno);
		exit(1);
	}
}
/**********************************************************************************************************/
/*int psc_try(int sem_index)
{
	int semop_ret;
	while(((semop_ret=semop(psc_semid[sem_index],psc_sem_try+sem_index,1))==-1)&&(errno==EINTR));
	if(semop_ret==-1)
	{
		if(errno==EAGAIN)
			return(1);
		printf("\nlock1:semop error:%d\n",errno);
		exit(1);
	}
	return(0);
}*/
/*******************************************************************************************************/
void psc_v(int sem_index)
{
	int semop_ret;
	while(((semop_ret=semop(psc_semid[sem_index],psc_sem_signal+sem_index,1))==-1)&&(errno==EINTR));
	if(semop_ret==-1)
	{
		printf("\nlock1:semop error:%d\n",errno);
		exit(1);
	}
}
/******************************************************************************************************/
void psc_z(int sem_index)
{
	int semop_ret;
#ifdef DEBUG_LOCK
	printf("\nsw_process:psc_z begin:%d!\n",sem_index);
#endif
	while(((semop_ret=semop(psc_semid[sem_index],psc_sem_zero+sem_index,1))==-1)&&(errno==EINTR));
#ifdef DEBUG_LOCK
	printf("\nsw_process:psc_z end:%d!\n",sem_index);
#endif
	if(semop_ret==-1)
	{
		printf("\nlock1:semop error:%d\n",errno);
		exit(1);
	}
}
/*****************************************************************************************************/
void psc_create_init_sem(void)
{
	int sem_order;
	int semop_ret;
	psc_create_sem(pscSEM_KEY);
	psc_init_sem_element();
	for(sem_order=0;sem_order<pscTOTAL_SEM;sem_order++)
		psc_set_sem_value(sem_order,1);
	
/*	for(sem_order=0;sem_order<pscTOTAL_SEM;sem_order++)
		psc_semop_restart(psc_semid[sem_order],psc_sem_signal+sem_order,1);*/
}
/******************************************************************************************************/


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

/*888888888888888888888888888888888888888888888888888888888888888*/
void psc_get_init_sem(void)
{
	int sem_order;
	int semop_ret;
	psc_get_sem(pscSEM_KEY);
	psc_init_sem_element();
/*	for(sem_order=0;sem_order<pscTOTAL_SEM;sem_order++)
		psc_semop_restart(psc_semid[sem_order],psc_sem_signal+sem_order,1);*/
}
/*888888888888888888888888888888888888888888888888888888888888888888*/
	







/*************************************************************************************************/
/************************************************************************************************/
char *psc_shm_client(key_t p_key,int shm_len)
{
	int shmid;
 /*   void *shmat();*/
    char *shm;
    int i;

    if ((shmid=shmget(p_key,shm_len,0666))<0)
    {
		printf("\npsc_shm_client:shmget error:%d!\n",errno);
		exit(1);
    }
    printf("\nshmid=%d\n",shmid);
    if ((shm=shmat(shmid,NULL,0))==(char *)-1)
    {
		printf("\npsc_shm_client:shmat error:%d!\n",errno);
		exit(1);
		
    }
    return (shm);
}
/*************************************************************************************************/
int psc_shm_kill(key_t p_key,int shm_len)
{
   struct shmid_ds shm_ds;
   int shmid;


/*   shm_ds=(struct shmid_ds *) malloc(sizeof(struct shmid_ds));*/

   if ((shmid=shmget(p_key,shm_len,0666))<0)
   {
	   printf("\npsc_shm_kill:shmget error:%d!\n",errno);
	   exit(1);
	          
   }
   if(shmctl(shmid,0,&shm_ds)<0)
   {
      printf("\npsc_shm_kill:shmctl error:%d!\n",errno);
	  exit(1);
   }
   return (0);
}
/***************************************************************************************************/
/**************************************************************************************************/
void psc_get_init_shm(void)
{
	char *shmptr;
	int shmsize;
	
    shmsize=sizeof(pscCLIENT_STATUS)*(pscMAX_CLI_CONN+1)+sizeof(int);

	printf("\nThe shmsize is:%d\n",shmsize);
	
	shmptr=(char *)psc_shm_client(pscSHM_KEY,shmsize);
	psc_client=(pscCLIENT_STATUS *)shmptr;
	shmptr+=sizeof(pscCLIENT_STATUS)*(pscMAX_CLI_CONN+1);
	psc_client_max=(int *)shmptr;


	*psc_client_max=0;

}

/*************************************************************************************************/
void psc_buf_extract(char *outstr,char *in_str,int start_location,int byte_len)
{
 int i;
 char *p;
 if (byte_len==0)
   {
    *outstr='\0';
    return;
   }
 p=in_str+start_location;
 for (i=0;i<byte_len; i++)
  {
     *outstr=*p;
     p++;
     outstr++;
  }
 *outstr='\0';
}		
/*************************************************************************************************/
int psc_yh_exec(char *commandline)
{
	char path[100];
	char command_seg[5][100];
	int i,j,k,n;
	int segnum;

	i=0;j=0;
	while((commandline[i]!='\0')&&(commandline[i]!=' '))
		path[j++]=commandline[i++];
    path[j]='\0';
	k=i-1;
	while((k>=0)&&(commandline[k]!='/'))
		k--;
	psc_buf_extract(command_seg[0],commandline,k+1,i-k-1);
	n=0;
	for(segnum=1;segnum<=5;segnum++)
	{
		while((commandline[i]!='\0')&&(commandline[i]==' '))
			i++;
	    if(commandline[i]=='\0')
			break;
		n++;
		if(n>5)
		{
			printf("\nToo many parameters!\n");
			exit(1);
		}
		j=0;
		while((commandline[i]!='\0')&&(commandline[i]!=' '))
			command_seg[segnum][j++]=commandline[i++];
		command_seg[segnum][j]='\0';
		

	}
	switch(n)
	{
	case 0:return(execl(path,command_seg[0],NULL));
	case 1:return(execl(path,command_seg[0],command_seg[1],NULL));
	case 2:return(execl(path,command_seg[0],command_seg[1],command_seg[2],NULL));
	case 3:return(execl(path,command_seg[0],command_seg[1],command_seg[2],command_seg[3],NULL));
	case 4:return(execl(path,command_seg[0],command_seg[1],command_seg[2],command_seg[3],command_seg[4],NULL));
	case 5:return(execl(path,command_seg[0],command_seg[1],command_seg[2],command_seg[3],command_seg[4],command_seg[5],NULL));
	}
}
/**************************************************************************************************/


/**************************************************************************************************/
int pscPassiveTcpDescriptor(int port)
{
	int listenfd;
	struct sockaddr_in servaddr;
	if((listenfd=socket(PF_INET,SOCK_STREAM,0))<0)
	{
		printf("\nsocket error:%d!\n",errno);
		exit(1);
	}
	bzero(&servaddr,sizeof(servaddr));
	servaddr.sin_family=AF_INET;
	servaddr.sin_addr.s_addr=htons(INADDR_ANY);
	servaddr.sin_port=htons(port);
    if(bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr))<0)
	{
		printf("\nbind error:%d!\n",errno);
		exit(1);
	}
	if(listen(listenfd,pscLISTENQ)<0)
	{
		printf("\nlisten error:%d!\n",errno);
		exit(1);
	}
	return(listenfd);
}
/***************************************************************************************************/
int pscPassiveUnixDescriptor(char *unixstr)
{
	int listenfd;
	struct sockaddr_un servaddr;
	unlink(unixstr);
	if((listenfd=socket(PF_UNIX,SOCK_STREAM,0))<0)
	{
		printf("\nsocket error:%d!\n",errno);
		exit(1);
	}
	bzero(&servaddr,sizeof(servaddr));
	servaddr.sun_family=AF_UNIX;
	strcpy(servaddr.sun_path,unixstr);
	if(bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr))<0)
	{
		printf("\nbind error:%d!\n",errno);
		exit(1);
	}
	if(listen(listenfd,pscLISTENQ)<0)
	{
		printf("\nlisten error:%d!\n",errno);
		exit(1);
		
	}
	return(listenfd);
}
/*****************************************************************************************************/
int pscConnectToUnix(char *unixstr)
{
	int sockfd;
	struct sockaddr_un cliaddr,servaddr;
	if((sockfd=socket(PF_UNIX,SOCK_STREAM,0))<0)
	{
		printf("\nsocket error:%d!\n",errno);
		exit(1);
	}
	bzero(&servaddr,sizeof(servaddr));
	servaddr.sun_family=AF_UNIX;
	strcpy(servaddr.sun_path,unixstr);
	if(connect(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr))<0)
	{
		printf("\nconnect error!\n");
		exit(1);
	}
	return(sockfd);
}
/*****************************************************************************************************/


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

/*****************************************************************************************/
void psc_send_start_message(int connfd,char *flags,char *swxh,char *swbm,char *message)
{
	int message_len;
	char message_buffer[pscMAXLINE+2+pscSWXH_LENGTH+pscSWBM_LENGTH];
	strcpy(message_buffer,flags);
	strcat(message_buffer,swxh);
	strcat(message_buffer,swbm);
	strcat(message_buffer,message);
    message_len=strlen(message_buffer);
	message_buffer[message_len]=pscEND_CHARACTER;
	message_buffer[message_len+1]='\0';
	psc_writen(connfd,message_buffer,message_len+1);
	return;
}
/****************************************************************************/

/*********************/
char commandline[91];
int psc_connfd;
/**************************************************************************************************/
	int psc_client_suffix;
	int psc_s_suffix;
	int psc_swxh_suffix;
	int psc_hint_suffix;
			

/*************************************************/
void sig_chld(int signo)
{
	pid_t pid;
	int stat;
	while((pid=waitpid(-1,&stat,WNOHANG))>0)
		printf("child %d terminated\n",pid);
	return;
}
/*********************************/
void alarm_handler(int signo)
{
	psc_alarm_flag=1;
}

/*****************************************/
int psc_up_sockfd;
int psc_down_sockfd;
int psc_suffix;
pscBUF_STRUCT psc_buf;
pid_t psc_pid;
char psc_up_pipename[100];
char psc_down_pipename[100];
struct sigaction act;
/**************************************************************************************************/
char psc_status[pscMAX_CLI_LINE+1][pscMAXLINE];
time_t psc_status_secs[pscMAX_CLI_LINE+1];
int status_max;

char psc_error[pscMAX_CLI_LINE+1][pscMAXLINE];
time_t psc_error_secs[pscMAX_CLI_LINE+1];
int error_max;
/**************************************************************************************************/
void psc_sys_t(int *year,int *mon,int *day,int *hour,int *min,int *sec)
{
	struct tm *tt;
    time_t secs;
    time(&secs);
    tt=localtime(&secs);
    *year=tt->tm_year+1900;
    *mon=tt->tm_mon+1;
    *day=tt->tm_mday;
    *hour=tt->tm_hour;
    *min=tt->tm_min;
    *sec=tt->tm_sec;
}
/*******************************************************************************/
void psc_get_sys_t(char *t)
{
	int year,mon,day,hour,min,sec;
	
	psc_sys_t(&year,&mon,&day,&hour,&min,&sec);
	sprintf(t,"%04d%02d%02d%02d%02d%02d",year,mon,day,hour,min,sec);
}
/*******************************************************************************/
void psc_get_time_from_secs(char *t,time_t *secs)
{
	struct tm *tt;
	tt=localtime(secs);
	sprintf(t,"%04d%02d%02d%02d%02d%02d",tt->tm_year+1900,tt->tm_mon+1,tt->tm_mday,
		tt->tm_hour,tt->tm_min,tt->tm_sec);
}	

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