rs232.c

一个通过无线设备传输文件程序主要涉及内容是网络通信和RS232设置

#include <stdio.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <errno.h>
#include <time.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/wait.h>
#include <string.h>
#include <stdarg.h>
#include <netdb.h>
#include <netinet/ip_icmp.h>
#include <math.h>
#include <netinet/in.h>
//#include <sockets.h>



#include "common.h"
#include "hc.h"

#define RS_NAME		"/dev/ttyS1"
#define BUFLEN         	512 
#define PORT            9001 
#define TIMEL		3
//#define SEVR_ADDR	"192.168.0.87"
//#define SEVR_ADDR	"192.168.0.87"
#define SEVR_ADDR	"172.29.1.10"
#define MAXC		300	
#define LOG_THREETIME 	3600*3
#define RS232_LOG	"/tmp/rec.log"
#define PING_LOG	"/tmp/ping.log"

int connect_to_serv(void);
int     sock_key;
struct sockaddr_un      addr_wtdog;
struct sockaddr_un      addr_ping;
void hc_key_sock_init(void);
char reboot_buf[]="!@#$A09Z%&";
int  reboot_flags=0; 
int  time_count=0;


struct queue {
        char qbuf[MAXC][BUFLEN];
        char len_buf[MAXC][5];
        int phead;
        int pout;
};

void queue_init(struct queue *p)
{
        int index;
        for(index = 0; index < MAXC;index++)
                memset(p->qbuf[index],0,BUFLEN);
       	for(index = 0; index < MAXC;index++)
                memset(p->len_buf[index],0,5); 
	p->phead = 0;
        p->pout = 0;
}

void  queue_add(struct queue *q,char *str,int n)
{
        if((q->phead+1 == q->pout) || (q->phead+1 == MAXC && !q->pout)) {
                err_dump(PRINT_ERROR,"que is full \n");
		queue_init(q);
                return;
        }
        sprintf(q->len_buf[(q->phead)],"%d", n);
	memcpy(q->qbuf[(q->phead)],str,n);
        q->phead++;
        if (q->phead == MAXC)
                q->phead = 0;
}

void queue_writetors232(struct queue *q, int fd)
{
	int ret=-1;
	int n=-1;

        if (q->pout == MAXC)
                q->pout = 0;
        if (q->pout == q->phead)
                return ;
        n = atoi(q->len_buf[q->pout]);
	if(n > 0) {
		ret = write(fd,q->qbuf[q->pout],n);
        	if (ret < 0) {
			err_dump(PRINT_ERROR,"write rs232 error \n");
			return;
		} else {
			err_dump(PRINT_ERROR,"write rs232 bytes =%d\n",ret);
                	sprintf(q->len_buf[q->pout],"%d", 0);
			q->pout++;
		}
	}
	err_dump(PRINT_ERROR,"**********phead:%d***********pout%d\n",q->phead,q->pout);
}

int is_8bits(void)
{
        int fd ;
        int ret;
        TS_RET  ts_ret;
        fd = open(DEV_NAME_KEYBOARD, O_RDONLY);
        if (fd < 0) {
		err_dump(PRINT_ERROR,"fd < 0 \n");
                return -1;
        }
        ret = read(fd, &ts_ret, sizeof(ts_ret));
        if( ret!=sizeof(ts_ret) ){
	       err_dump(PRINT_ERROR,"ret = read error\n");	
               return -1;
        }
	err_dump(PRINT_ERROR,"ts_ret.y = %d", ts_ret.y);
        return ts_ret.y/500;
}


int main(void)
{
        int rs232_fd;
	struct hc_event_msg_str msg;
        char recv_buf[BUFLEN]={0};
	char read_buf[BUFLEN]= {0};
	char tmpbuf[BUFLEN]={0}; 
        int nread=-1;
	int sockfd=-1;
        struct sockaddr_in my_addr;
	struct timeval  timetmp;
        int bindflag;
        fd_set rset,wset;
        int ret;
        int maxfd;
        int apt_fd=-1;
        int namelen;
        int servfd = -1;
	int on = 1;	
	int nr=-1;
	int nw;
	int first=1;
	struct queue que;
	time_t runtime;

	err_dump_init(RS232_LOG);
	hc_key_sock_init();
        queue_init(&que);	

	rs232_fd = opendev(RS_NAME,O_RDWR | O_NOCTTY | O_NDELAY);
	if (rs232_fd < 0) {
		err_dump(PRINT_ERROR,"open ttys1 error");
		return -1;
	}		

	set_speed(rs232_fd,9600);

	if (is_8bits() > 0) {
		err_dump(PRINT_ERROR,"is 7 2 E\n");
		if (set_parity(rs232_fd,7,2,'E') == -1){
                        err_dump(PRINT_ERROR,"set 7 Parity Error");
                        return -1;
                }
	} else {
		err_dump(PRINT_ERROR,"is 8 1 N\n");
		if (set_parity(rs232_fd,8,1,'N') == -1){
			err_dump(PRINT_ERROR,"set 8 Parity Error");
			return -1;
		}
	}	

	read(rs232_fd,tmpbuf,BUFLEN);	
	read(rs232_fd,tmpbuf,BUFLEN);
	
	if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        	err_dump(PRINT_ERROR, "socket error\n");
                return -1;
        }
        setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,(char *)&on, sizeof(on));

        my_addr.sin_family = AF_INET;
        my_addr.sin_port = htons(PORT);
        my_addr.sin_addr.s_addr = INADDR_ANY;
        bzero((&my_addr.sin_zero), 8);
        bindflag = bind(sockfd, (struct sockaddr*)&my_addr, sizeof(struct sockaddr));
        if (bindflag != 0) {
                err_dump(PRINT_ERROR,"bindflag =%d\n",bindflag);
                exit(-1);
        }
        if (listen(sockfd, 4) == -1) {
                shutdown(sockfd, 2);
        }
	memset(read_buf,0,BUFLEN);
	memset(recv_buf,0,BUFLEN);
	
	time(&runtime);

	while(1) {

                FD_ZERO(&rset);
		FD_ZERO(&wset);
                FD_SET(sockfd, &rset);
		FD_SET(sock_key, &rset);
		FD_SET(rs232_fd, &rset);
		FD_SET(rs232_fd,&wset);
		
		timetmp.tv_sec = 0;
                timetmp.tv_usec = 1;

		if(time(NULL) - runtime >= LOG_THREETIME) {
			time(&runtime);
                        err_dump_init(RS232_LOG);
                        err_dump_init(PING_LOG);
		}		

		if(time_count == 7){
err_dump(PRINT_ERROR, "********1sec delay memset SQL\n");
			memset(read_buf,0,BUFLEN);
                     	memset(recv_buf,0,BUFLEN);
			time_count = 0;
		}	
		
                if(servfd < 0){
                        servfd =  connect_to_serv();
	        } else {
                        FD_SET(servfd,&wset);
			FD_SET(servfd,&rset);
                }
                maxfd = servfd > sockfd ? servfd : sockfd;
		maxfd = maxfd > sock_key ? maxfd : sock_key;
		maxfd = maxfd >rs232_fd ? maxfd : rs232_fd;
                if(apt_fd > 0){ 
			FD_SET(apt_fd,&rset);
                	maxfd = maxfd > apt_fd ? maxfd : apt_fd;
                	ret = select(maxfd+1, &rset, &wset, NULL, &timetmp);
                	if( ret <= 0 )
				continue;
		} else {			
			ret = select(maxfd+1, &rset, &wset, NULL, &timetmp);
			if( ret<=0 )
				continue;
		}

		if(FD_ISSET(sock_key,&rset)) {
			recvfrom( sock_key, (char *)&msg, sizeof(msg),0, NULL, NULL );
	        	if( msg.type==HC_EVENT_TYPE_DOG ){
err_dump(PRINT_ERROR,"HC_EVENT_TYPE_DOG###############\n");
        			if( msg.event_dog == HC_EVENT_DOG_MAGIC ){
                			sendto( sock_key, (void *)&msg, sizeof(msg), 0,
                        	    	(struct sockaddr *)&addr_wtdog, sizeof(addr_wtdog) );
                		}else if( msg.event_dog==HC_EVENT_DOG_REBOOT ){
                    			exit(-1);
                		}
            		}
			if( msg.type == HC_EVENT_TYPE_KEY){
err_dump(PRINT_ERROR,"msg.event_key = %d\n",msg.event_key);
				if(msg.event_key==-1) {
					close(servfd);
                                	close(apt_fd);
					servfd=-1;
                        		apt_fd=-1;
					time_count++; 
				}else{
					time_count=0;
				}
			}
		}

		if(apt_fd < 0) {	
			if( FD_ISSET(sockfd, &rset)){
                		namelen = sizeof (my_addr);
                         	apt_fd = accept(sockfd, (struct sockaddr *)&my_addr, &namelen);
                        	if (apt_fd < 0)
                              		continue;
                         	err_dump(PRINT_ERROR,"accept succecc\n");			
                	}
		}

		if (servfd > 0) {
			if(reboot_flags == 0) {
				ret = writen(servfd,reboot_buf,10);
				if(ret>0){
					err_dump(PRINT_ERROR,"send reboot message\n");
					reboot_flags = 1;
				}
			} else {
				first = 0;
			}
			if (FD_ISSET(rs232_fd,&rset)) {
				nr = read(rs232_fd,read_buf,BUFLEN);
				if (nr > 0) {
					err_dump(PRINT_ERROR,"read rs232 bytes = %d\n",nr);
					nw = writen(servfd,read_buf,nr);
                                        if (nw < 0){
                                        	err_dump(1,"nr>0,nw<0\n");
                                                close(servfd);
                                                servfd = -1;
						continue;
                                        } else {
                                                err_dump(PRINT_ERROR, "sendto net bytes:%d\n" ,nw);
                                                memset(read_buf,0,BUFLEN);
                                                nr = -1;
                                        }

				}
			}

			if(FD_ISSET(servfd,&rset)) {
				int nnread=-1;
                                nnread = readn(servfd,tmpbuf,BUFLEN);
                                if (nnread <= 0) {
                                        close(servfd);
                                        servfd = -1;
                                        continue;
                                }
                        }

		}

                if(apt_fd > 0){
                        if( FD_ISSET(apt_fd,&rset)){
                                nread = read(apt_fd,recv_buf,BUFLEN);
				if (nread <= 0) {
				err_dump(PRINT_ERROR,"read apt error \n");
                                        close(apt_fd);
                                        apt_fd = -1;
/*					if(servfd > 0){
						close(servfd);
						servfd = -1;
					}
*/
                                }else if(nread==10 && strcmp(recv_buf,reboot_buf)==0){
					if(first != 1) {
						err_dump(PRINT_ERROR,"there is reboot********* \n");
						memset(read_buf,0,BUFLEN);
						memset(recv_buf,0,BUFLEN);
						continue;
					}
				} else {
					queue_add(&que,recv_buf,nread);
					memset(recv_buf,0,BUFLEN);
				}
			}	
		}

               queue_writetors232(&que,rs232_fd);	
        }
	close(servfd);
	close(apt_fd);
	close(sockfd);
	close(rs232_fd);
	return 0;
}

int connect_to_serv(void)
{
        int sockfd;
        struct sockaddr_in my_addr;
	int on;
        struct timeval  timetmp;
        int conflag = -1;
        
	if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
                err_dump(PRINT_ERROR, "socket error\n");
                return -1;
        }

	timetmp.tv_sec = 2;
	timetmp.tv_usec = 0;
	setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, &timetmp, sizeof(timetmp));
	setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &timetmp, sizeof(timetmp));
        setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on));

        my_addr.sin_family = AF_INET;
        my_addr.sin_port = htons(PORT);
        my_addr.sin_addr.s_addr = inet_addr(SEVR_ADDR);
        conflag = connect(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr));
        if (conflag ==0 ) {
                err_dump(PRINT_ERROR,"connect success\n");
                return sockfd;
        }else{
		close(sockfd);
                return -1;
	}
}
void hc_key_sock_init()
{
        int     ret, on=1;
        struct sockaddr_un      addr_un;	

        unlink(HC_EVENT_GENERAL_SOCK);
        sock_key = socket(PF_UNIX, SOCK_DGRAM, 0);
        setsockopt(sock_key, SOL_SOCKET, SO_REUSEADDR,(char *)&on, sizeof(on));
        addr_un.sun_family = AF_UNIX;
        strcpy(addr_un.sun_path, HC_EVENT_GENERAL_SOCK);
        ret = bind(sock_key, (struct sockaddr *)&addr_un, sizeof(addr_un));
        if( ret<0 ){
                ERR_DUMP();
                exit(-1);
        }
	addr_ping.sun_family = AF_UNIX;
        strcpy(addr_ping.sun_path, HC_KEY_SOCK);

        addr_wtdog.sun_family = AF_UNIX;
        strcpy(addr_wtdog.sun_path, HC_EVENT_WTDOG_SOCK);
}

int readn(fd,ptr1,nbytes)
        int fd;
        char *ptr1;
        int nbytes;
{
        int     nleft,nread;
        char    *ptr = ptr1;
        nleft=nbytes;
        while(nleft>0) {
                nread=read(fd,ptr,nleft);
                if(nread<0)
                        return(nread);  /*error,return<1*/
                else if(nread==0)
                        break;          /*EOF*/
                nleft-=nread;
                ptr+=nread;
        }
        return(nbytes-nleft);
}

int writen(fd,ptr,nbytes)
        int fd;
        char *ptr;
        int nbytes;
{
        int nleft,nwritten;
        nleft = nbytes;
        while(nleft>0) {
                nwritten = write(fd,ptr,nleft);
                if (nwritten<=0)
                        return (nwritten);      /*error*/
                nleft -= nwritten;
                ptr += nwritten;
        }
        return (nbytes-nleft);
}