ipa_ok.c

监控局域网上网

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pcap.h>
#include <net/if.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <netinet/if_ether.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/msg.h>
#include <sys/socket.h>
#include <stdarg.h>

#include <sys/errno.h>
#include <sys/signal.h>

#include <sys/ioctl.h>
#include <sys/wait.h>
#include <sys/signal.h>
#include <sys/time.h>
#include <time.h>
#include <netdb.h>
#include <ctype.h>
#include <stdarg.h>
#include <fcntl.h>
#include <stdio.h>
#include <dirent.h>

#define read_lock(fd,offset,whence,len)     lock_reg(fd,F_SETLK,F_RDLCK,offset,whence,len)
#define readw_lock(fd,offset,whence,len)    lock_reg(fd,F_SETLKW,F_RDLCK,offset,whence,len)
#define write_lock(fd,offset,whence,len)    lock_reg(fd,F_SETLK,F_WRLCK,offset,whence,len)
#define writew_lock(fd,offset,whence,len)   lock_reg(fd,F_SETLKW,F_WRLCK,offset,whence,len)
#define un_lock(fd,offset,whence,len)       lock_reg(fd,F_SETLK,F_UNLCK,offset,whence,len)



#include "ipa_fun.h"

u_short gd_tcpportbase = 0;
chex2char_t gd_chex2char[16];

extern char *gd_SYS_LOG_FILE;

void getNetAddr(char *ip, char *netaddr)
{
	int  i;
	int  j;
	unsigned char c;
	char tmp[16];
	char type = 0;
	
	for (i=0; i<strlen(ip); i++)
	{
		if (ip[i] == '.') break;
	}
	memcpy(tmp, ip, i);
	tmp[i] = 0;
	c = atoi(tmp);
	if (c < 128) 
		type = 0;
	else if ( (c >= 128) && (c < 192) )
		type = 1;
	else
		type = 2;
	j = 0;
	for (i=0; i<strlen(ip); i++)
	{
		if (ip[i] == '.') 
		{
			if (j == type) break;
			j ++;
		}
	}
	memcpy(tmp, ip, i);
	tmp[i] = 0;
	
	strcpy(	netaddr, tmp);
	
}

void init_chex2char()
{
	gd_chex2char[0 ].hexc = '0'; gd_chex2char[0 ].intc = 0;
	gd_chex2char[1 ].hexc = '1'; gd_chex2char[1 ].intc = 1 ;
	gd_chex2char[2 ].hexc = '2'; gd_chex2char[2 ].intc = 2 ;
	gd_chex2char[3 ].hexc = '3'; gd_chex2char[3 ].intc = 3 ;
	gd_chex2char[4 ].hexc = '4'; gd_chex2char[4 ].intc = 4 ;
	gd_chex2char[5 ].hexc = '5'; gd_chex2char[5 ].intc = 5 ;
	gd_chex2char[6 ].hexc = '6'; gd_chex2char[6 ].intc = 6 ;
	gd_chex2char[7 ].hexc = '7'; gd_chex2char[7 ].intc = 7 ;
	gd_chex2char[8 ].hexc = '8'; gd_chex2char[8 ].intc = 8 ;
	gd_chex2char[9 ].hexc = '9'; gd_chex2char[9 ].intc = 9 ;
	gd_chex2char[10].hexc = 'A'; gd_chex2char[10].intc = 10;
	gd_chex2char[11].hexc = 'B'; gd_chex2char[11].intc = 11;
	gd_chex2char[12].hexc = 'C'; gd_chex2char[12].intc = 12;
	gd_chex2char[13].hexc = 'D'; gd_chex2char[13].intc = 13;
	gd_chex2char[14].hexc = 'E'; gd_chex2char[14].intc = 14;
	gd_chex2char[15].hexc = 'F'; gd_chex2char[15].intc = 15;
}

void to_upper(char *str)
{
	int i;
	
	for (i=0; i<strlen(str); i++)
	{
		if  ( (str[i] >= 'a') && (str[i] <= 'z') )
		{
			str[i] -= 32;	
		}
	}	
}

// Calculates the TCP Checksum based on the helper header
u_short csum (unsigned short *buf, int nwords) 
{
	unsigned long sum=0;
	
	for( sum=0; nwords > 0; nwords-- )
		sum += *buf++;
	sum = (sum >> 16) + (sum & 0xffff);
	sum += (sum >> 16);        
	return (u_short)~sum;
}

// Takes in an ip_address structure and returns the equivalent 4byte UINT value
u_int iptoUINT( ip_address_t *ip ) 
{
	u_int ipaddr;
	ipaddr = ip->byte4  | (ip->byte3 << 8);
	ipaddr = ipaddr | (ip->byte2 << 16);
	ipaddr = ipaddr | (ip->byte1 << 24);
	return htonl(ipaddr);
}


void charMac2binMac(char *cmac, char bmac[6])
{
	char hex[3];
	int  i;
	
	to_upper(cmac);

	for (i=0; i<5; i++)
	{
		memcpy(hex, cmac+i*3, 2);
		hex[2] = 0;
		charHex2char(hex, bmac+i);
	}
	memcpy(hex, cmac+15, 2);
	hex[2] = 0;
	charHex2char(hex, bmac+5);	
}

void charHex2char(char *hex, char *c)
{
	int  i;
	char c1, c2;

//printf("hex[%s]\n", hex);
	c1 = 0;
	for (i=0; i<16; i++)
	{
		if (hex[0] == gd_chex2char[i].hexc)
		{
			c1 = gd_chex2char[i].intc;
			break;
		}
	}
	c2 = 0;
	for (i=0; i<16; i++)
	{
		if (hex[1] == gd_chex2char[i].hexc)
		{
			c2 = gd_chex2char[i].intc;
			break;
		}
	}
	c1 <<= 4;
	*c = c1 | c2;
//printf("c1[%d] c2[%d] c[%d]\n", c1, c2, *c);	
	return;
}

int passivesock(const char *service, const char *transport, int qlen)
{
	int len, ret, type, sock ;	
	struct servent *pse;
	struct protoent *ppe;
	struct sockaddr_in sin;
	memset(&sin, 0, sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_addr.s_addr = INADDR_ANY;
	
	if(pse = getservbyname(service, transport))
		sin.sin_port = htons(ntohs((u_short)pse->s_port) + gd_tcpportbase);
	else if((sin.sin_port = htons((u_short)atoi(service))) == 0)
	{
		logit(gd_SYS_LOG_FILE, "file[%s] line[%d] in passivesock, errno[%d:%s]\n",__FILE__,__LINE__, errno, strerror(errno));
		return(-1);
	}

	ppe = getprotobyname(transport);
	if(ppe == 0)
	{
		logit(gd_SYS_LOG_FILE, "file[%s] line[%d] in passivesock getprotobyname, errno[%d:%s]\n",__FILE__,__LINE__, errno, strerror(errno));
		return(-2);
	}

	if(strcmp(transport, "udp") == 0)
		type = SOCK_DGRAM;
	else
		type = SOCK_STREAM;

	sock = socket(PF_INET, type, ppe->p_proto);
	if(sock < 0)
	{
		logit(gd_SYS_LOG_FILE, "file[%s] line[%d]in passivesock socket, errno[%d:%s]\n",__FILE__,__LINE__, errno, strerror(errno));
		return(-3);
	}

	if(bind(sock, (struct sockaddr *)&sin, sizeof(sin))<0)
	{
printf("该程序在运行中,或您选定的端口[%s]与其它服务端口冲突,或稍后再试!\n", service);		
		logit(gd_SYS_LOG_FILE, "file[%s] line[%d]in passivesock bind, errno[%d:%s]\n",__FILE__,__LINE__, errno, strerror(errno));
		close(sock);
		return(-4);
	}

	if((type == SOCK_STREAM) && (listen(sock, qlen) < 0))
	{
		logit(gd_SYS_LOG_FILE, "file[%s] line[%d]in passivesock listen, errno[%d:%s]\n",__FILE__,__LINE__, errno, strerror(errno));
		close(sock);
		return(-5);
	}

	return(sock);
}	 

int connectTCP(const char *host, const char *service)
{
	int	ret;
	
	ret = connectsock(host, service, "tcp");
	
	return ret;
}


int connectsock(const char *host, const char *service, const char *transport)
{
	struct hostent *phe, *phe1;	
	struct servent *pse;
	struct protoent *ppe;	
	struct sockaddr_in sin, client_addr; 
	int s, type;		
	u_long baddr;
	int	ret, len, buflen;
	struct sockaddr *pSkAddr;

	memset(&sin, 0, sizeof(sin));
	sin.sin_family = AF_INET;

	if(pse = getservbyname(service, transport))
		sin.sin_port = pse->s_port;
	else if((sin.sin_port = htons((u_short)atoi(service))) == 0)
	{
		logit(gd_SYS_LOG_FILE, "file[%s] line[%d]in connectsock getservbyname, errno[%d:%s]\n",__FILE__,__LINE__, errno, strerror(errno));
		return(-1);
	}

	if(phe = gethostbyname(host))
	{
		memcpy(&sin.sin_addr, phe->h_addr, phe->h_length);
	}
	else
	{		
		baddr = inet_addr(host) ;
		if(baddr == INADDR_NONE)
		{
			logit(gd_SYS_LOG_FILE, "file[%s] line[%d]in connectsock gethostbyname inet_addr, errno[%d:%s]\n",__FILE__,__LINE__, errno, strerror(errno));
			return(-2);
		}
		else
			memcpy(&sin.sin_addr, &baddr, 4); 
	}
	

	if((ppe = getprotobyname(transport)) == 0)
	{
		logit(gd_SYS_LOG_FILE, "file[%s] line[%d]in connectsock getprotobyname, errno[%d:%s]\n",__FILE__,__LINE__, errno, strerror(errno));
		return(-3);
	}

	if(strcmp(transport, "udp") == 0)
		type = SOCK_DGRAM;
	else
		type = SOCK_STREAM;

	s = socket(PF_INET, type, ppe->p_proto);
	if(s < 0)	
	{
		logit(gd_SYS_LOG_FILE, "file[%s] line[%d]in connectsock socket, errno[%d:%s]\n",__FILE__,__LINE__, errno, strerror(errno));
		return(-4);
	}

	pSkAddr = (struct sockaddr *)&sin;
	if(connect(s, pSkAddr, sizeof(sin))<0)
	{
		logit(gd_SYS_LOG_FILE, "file[%s] line[%d]in connectsock connect, errno[%d:%s]\n",__FILE__,__LINE__, errno, strerror(errno));
		close(s);
		return(-5);
	}

	return(s);
}	 


int start_tcp_serv(int msock, int (*fun)(int sock))
{
	int ssock;
	int ret;
	int  alen;
	struct sockaddr_in fsin;
	fd_set	infds;
	int	maxfd;

	//safe_signal(SIGTERM, (void *)SIG_DFL);

	for (;;)
	{				
		FD_ZERO(&infds);
		maxfd = 0;
		FD_SET(msock, &infds);
		ret = select(msock+1, &infds, NULL, NULL, NULL);
		if (ret < 0)
		{
			if (errno == EINTR) continue;
			logit(gd_SYS_LOG_FILE, "in select, msock[%d] errno[%d] pid[%d]\n", msock, errno,  getpid());
			close(msock);
			return 1;
		}
		if (!FD_ISSET(msock, &infds)) continue;
		alen = sizeof(fsin);
		ssock = accept(msock, (struct sockaddr *)&fsin, (socklen_t *)&alen);
		if(ssock < 0)
		{
			close(ssock);
			if (errno == EINTR) continue;
			logit(gd_SYS_LOG_FILE, "in accept, ssock[%d] errno[%d] pid[%d]\n", ssock, errno, getpid());
			close(msock);
			return 2;
		}
		fun(ssock);
		close(ssock);
	}

	return 0;
}


void* safe_signal(int signo, void* func)
{
	struct sigaction act, oact;
	
	act.sa_handler = (void (*)(int))func;
	sigemptyset(&act.sa_mask);
	act.sa_flags = 0;
	if (signo == SIGALRM)
	{
#ifdef SA_INTERRUPT
		act.sa_flags |= SA_INTERRUPT;	/*sun os*/	
#endif
	}
	else
	{
#ifdef SA_RESTART
		act.sa_flags |= SA_RESTART;	/*svr4, 4.3+bsd*/
#endif 
	}
	
	if (sigaction(signo, &act, &oact) < 0)
		return (void *)(SIG_ERR);
	
	return (void *)(oact.sa_handler);
}


int  writesock(int sock, char *hdata, int hsize)
{
	int ret;
	fd_set	outfds;

	ret = write(sock, hdata, hsize);
	if(ret != hsize)
	{
		logit(gd_SYS_LOG_FILE, "file[%s] line[%d]in writesock, errno[%d:%s]\n",__FILE__,__LINE__, errno, strerror(errno));
		return -1;
	}

	return(0);
}


int logit(char *fn, char *args, ...)
{
        va_list ap;
        int argno = 0;
	FILE *fp;
	int  ret;
	struct stat fbuf;
	char ascday[9];
	char asctm[7];
	char stime[16];
	char cmd[256];

	getNow(ascday, asctm);

	memset(&fbuf, 0, sizeof(struct stat));
	ret = stat(fn, &fbuf);
	if (ret == 0)
	{
		if (fbuf.st_size > 1024*10000)
		{
			getDatetime(stime);
			sprintf(cmd, "cp %s %s.%s", fn, fn, stime);
			system(cmd);
			sprintf(cmd, "echo>%s", fn);
			system(cmd);
		}
	}
	fp = fopen(fn, "a");
	if (fp == NULL) return -1;
        va_start(ap, args);
        fprintf(fp, "[%s %s]", ascday, asctm);
        vfprintf(fp, args, ap);

	fclose(fp);
	va_end(ap);
	
	return 0;
}

int getDatetime(char *stime)
{

	time_t 	t;
	struct tm 	* tm1;
	char ascday[9];
	char asctm[7];

	t = time(NULL);
	tm1 = localtime(&t);
	
        sprintf(ascday,"%04d",tm1->tm_year+1900);
        sprintf(ascday+4,"%02d",tm1->tm_mon+1);
        sprintf(ascday+6,"%02d",tm1->tm_mday);