support.c

linux下c 编写的 某项目代理服务端部分的代码。其中包括网络通信

#include "../include/shmmsg.h"
#include "../include/SendStru.h"


void IgnoreAllSignal()
{
struct sigaction act;

	act.sa_handler=SIG_IGN;
	sigemptyset(&act.sa_mask);
	act.sa_flags=0;
	sigaction(SIGHUP,&act,NULL);
	sigaction(SIGCHLD,&act,NULL);
	sigaction(SIGQUIT,&act,NULL);
	return;
}
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <netdb.h>
#include <stdlib.h>
#include <arpa/inet.h>

int passivesock(int rcvport)
{
	int sockid;
	struct sockaddr_in sin;

	memset(&sin,0,sizeof(sin));
	sin.sin_family=AF_INET;
	sin.sin_addr.s_addr=htonl(INADDR_ANY);
	sin.sin_port=htons((u_short)rcvport);

	sockid=socket(AF_INET,SOCK_STREAM,0);
	
	  if (sockid<0){
	      syslog("socket error",__FILE__,__LINE__);
	      return -2;
	   }
	if (bind(sockid,(struct sockaddr *)&sin,sizeof(sin))<0){
		syslog("bind error",__FILE__,__LINE__);
		perror("bind err");
		return -3;
	   }
	if (listen(sockid,10)<0){
		syslog("listen error",__FILE__,__LINE__);
		return -4;
	   }
	return sockid;
}

	
#define LINE	80
#define WORKDIR	"WORKDIR"
#define ETCDIR	"/etc"
#define spir	"/"
char *getetcf(const char *filename)
{
	char	*path;
	char	*envp;
	path=(char *)malloc(sizeof(char) * LINE);
	envp=getenv(WORKDIR);
	if (envp==NULL){
		return NULL;
		}
	memset(path,0,LINE);
	strcpy(path,envp);
	strcat(path,ETCDIR);
	strcat(path,spir);
	strcat(path,filename);
	return path;
}
	 
struct comshm *
GetShm()
{
	int shmid;
	key_t key;
	struct comshm *shmp;


	key=ftok(getetcf(SHMDIR1),SHMKEY1);
	if (key<0){
		syslog("get shm key err",__FILE__,__LINE__);
		return NULL;
		}			
	shmid=shmget(key,sizeof(struct comshm),0);
	if (shmid==-1){
		printf("%d",key);
		syslog("getshm err",__FILE__,__LINE__);
		return NULL;
	      }
	shmp=((struct comshm*)shmat(shmid, (char *)0,0));
	if (shmp==((struct comshm*)-1)){
		syslog("shmat err",__FILE__,__LINE__);
		return NULL;
	      }
	return shmp;
}
struct comshm *
Createshm()
{
	key_t	key;
	int	shmid;
	struct 	comshm	*comshm;
		
	key=ftok(getetcf(SHMDIR1),SHMKEY1);
	if (key<0){
		syslog("get share memery key err",__FILE__,__LINE__);
		return NULL;
		}
	shmid=shmget(key,sizeof(struct comshm),0660|IPC_CREAT);
	if (shmid<0){
		printf("%d",key);
		syslog("create shm err",__FILE__,__LINE__);
		return NULL;
		}
	comshm=((struct comshm*)shmat(shmid,(char*)0,0));
	if (comshm==((struct comshm*)-1)){
		syslog("shmat shm err",__FILE__,__LINE__);
		return NULL;
		}
	return comshm;
}
#include <time.h>
#include <stdio.h>
#include <varargs.h>
#define         SYSLOG  "sys.log"
#define         NOWEEK  4
#define         NOYEAR  15
#define         DEBUG
#define         TRUE     1
#define         FALSE    0


syslog( const char *errmsg, const char *file, const int line)
{
	FILE  	*fp;
	int  	flag;
	char 	*envpar;
	char 	*logfile, *GetLogf();
	time_t 	tv;
	char 	tmp[100];
	logfile = GetLogf( SYSLOG );
	memset(tmp,0,sizeof(tmp));
	tv = time((time_t *) 0);
	strcpy(tmp,ctime(&tv)+NOWEEK);
	tmp[NOYEAR]=0;
	if (( fp=fopen(logfile,"a")) == NULL)  
		return FALSE;
	if (( file == NULL ) && ( line == 0 ))
		fprintf( fp,"%s   %s\n",tmp,errmsg);
	else
		fprintf( fp,"%s   file %s  line %d:%s\n",tmp,file,line,errmsg);
	fclose(fp);
	return TRUE;
}
void v_debug(va_alist)
va_dcl
{
	va_list args;
	char 	*fmt;
	FILE	*fp;
	char filename[30],*ttyname(),*tname;
	tname=ttyname(TRUE);
	sprintf(filename,"%s/err",getenv("TEMPDIR"));
	fp=fopen(filename,"a");
	va_start(args);
	fmt=va_arg(args,char *);
	vfprintf(fp,fmt,args);
	va_end(args);
	fclose(fp);
}

#define         LOGDIR  "/log"
#define		SPRI	"/"
#define		LINE	80

char *
GetLogf(const char *file)
{
        char *path;
        char *envp;
        path = (char *) malloc( sizeof(char) * LINE);
        envp = getenv(WORKDIR);
        if ( envp == NULL )
                return NULL;
        memset(path,0,LINE);
        strcpy(path,envp);
        strcat(path,LOGDIR);
        strcat(path,SPRI);
        strcat(path,file);
        return path;
}


#include <stdio.h>
#include <stdlib.h>

#define         WORKDIR         "WORKDIR"
#define NOFILE 	1024

int
GenDaemon()
{
int childpid,fd;

	if (getppid()==1) {
		chdir ("/");
		umask(0);
		IgnoreAllSignal();
		return 0;
	}
	
	IgnoreAllSignal();
	if ((childpid = fork())<0 ) {
		syslog("can't fork first child",__FILE__,__LINE__);
		exit(-1);
	}
	else
		if (childpid > 0)
			exit(0);
	if ((setpgrp()) == -1) {
		syslog("set process group err",__FILE__,__LINE__);
		exit(-2);
	}
	IgnoreAllSignal();
	if ((childpid = fork()) < 0) {
		syslog("can't fork fist child",__FILE__,__LINE__);
		exit(-3);
	}
	else 
		if (childpid > 0)
			exit(0);
	for (fd=3; fd<=NOFILE;fd++)
		close (fd);
	
	chdir("/");
	umask(0);
	IgnoreAllSignal();
	return 0;
}
static struct sembuf op_open={
                        1,-1,0  };

static struct sembuf op_close={
                        1,1,0  };
static struct sembuf op_endcreat={
			1,-1,SEM_UNDO};

int opensem(key_t semkey)
{
        int semid;
        int semval;
        semid=semget(semkey,2,0);
        if(semid<0){
                syslog("semaphoreid get error!",__FILE__,__LINE__);
                return -1;
        }
	 return semid;
}


int sem_open(int semid)
{
        int semval;
	int errno;
	while(( semop(semid,&op_open,1) ) < 0 ){
        	if( errno==EINTR ) continue;
		syslog("sem op_open error!",__FILE__,__LINE__);
                return -1;
        }
        if((semval=semctl(semid,1,GETVAL,0))<0)
            syslog("sem_open GETVAL error!",__FILE__,__LINE__);
        else
            v_debug("sem_open current semval=[%d]\n",semval);

        return 0;
}


int sem_close(int semid)
{
        int semval;	
	int errno;
        while(( semop(semid,&op_close,1) ) < 0 ){
        	if( errno==EINTR ) continue;
		syslog("sem op_close error!",__FILE__,__LINE__);
                return -1;
        }
        if((semval=semctl(semid,1,GETVAL,0))<0)
            syslog("sem_close GETVAL error!",__FILE__,__LINE__);
        else
            v_debug("sem_close current semval=[%d]\n",semval);

        return 0;
}
int 
DtcShm(struct comshm *shmp)
{
	if (shmdt ((char *) shmp) < 0 ) {
		syslog(" detach share memory err ! ",__FILE__,__LINE__);
		return FALSE;
	}
	return TRUE;
}


/*int  getrcvport(BINDNO *bindno)
{
	struct comshm *shmp;
	int	count,i,j=0;

	shmp=GetShm();
	if (shmp=((struct comshm*)-2)){
		syslog("getshm err",__FILE__,__LINE__);
		return(-1);
	      }
	count=shmp->addno;
	for(i=0;i<count;i++){
	    while ((shmp->addstrlist[i].flag)!=0){	
		bindno->bind[j].jgbm[0]='0';
		bindno->bind[j].rcvport=shmp->addstrlist[i].rcvport;
	      }
	   j++;
	   }
	shmdt(shmp);
	return(0);
}*/


int creatsem(key_t semkey,const int bigcount)
{
 int semid,semval;
 union semun {
      int val;
      struct semid_ds *buf;
      unsigned short *array;
      } semctl_arg;


        semid=semget(semkey,2,IPC_CREAT|0660);
        if(semid<0){
                syslog("semaphoreid get error!",__FILE__,__LINE__);
                return -1;
        }

        if((semval=semctl(semid,1,GETVAL,0))<0)
                syslog("GETVAL error!",__FILE__,__LINE__);
        else
                if(semval==0){
                        semctl_arg.val=1;
                        if(semctl(semid,0,SETVAL,semctl_arg)<0)
 				syslog("SETVAL error!",__FILE__,__LINE__);

                	semctl_arg.val=bigcount;
                	if(( semctl(semid,1,SETVAL,semctl_arg)) < 0 )
                        	syslog("setval1 error!",__FILE__,__LINE__);
  	      }

        if(( semop(semid,&op_endcreat,1 )) < 0 ){
                syslog("can't end creat",__FILE__,__LINE__);
                return -1;
        }

 	return semid;
}
int
conrcvdeal(const int sockid)
{
	/*char buf[256];*/
	char buf[PKTLEN];
	int readlen;
	int rdlen;
	
	readlen=msgfromnet(sockid,buf);
	v_debug("conrcvdeal sockid=[%d]\n",sockid);
	if (readlen<0){
	syslog("receive data err",__FILE__,__LINE__);
	close(sockid);
	return -4;
	}
	close(sockid);
}
#define	BUFLEN	256
#define SOCKLEN	15
#define TIMEVAL	15
int msgfromnet(const int sockid,char *buf)
{
        char execfile[10];
        char getexecfile[80];
        char *GetExecf();
        char csock[SOCKLEN];
        char   execcode[CODESIZE];
        struct pktstru *pkt;
        struct packetstru  pktbuf;
        struct Packet Ppacket;
        char   buff[PKTLEN];


	pkt=(struct pktstru*)malloc(sizeof(struct pktstru));
        memset(&Ppacket,0,sizeof(struct Packet));
        memset(csock,0,SOCKLEN);
/*
        if((recv(sockid,buf,BUFLEN,MSG_PEEK))<0){
             syslog("rcv data error",__FILE__,__LINE__);
             return -4;
                }
*/
        if((recv(sockid,Ppacket.data,PKTSTRULEN,MSG_PEEK))<0){
             syslog("rcv data error",__FILE__,__LINE__);
             return -4;
                }