tcpip.c

arm+linux下的socket编程程序

#include <signal.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <sys/time.h>
#include <sys/types.h> 
#include <sys/socket.h> 
#include <errno.h> 
#include <unistd.h> 
#include <netinet/in.h> 
#include <limits.h> 
#include <netdb.h> 
#include <arpa/inet.h> 

#define 	MAX_CLIENTS	20
#define TCPSERV_PORT		5000
#define UDPSERV_PORT        	5001
#define TCPCLIE_PORT		5002
#define UDPCLIE_PORT       	5003

#define DEBUG_TCPIP
#ifdef DEBUG_TCPIP
#define prout(str...) printf(""str)
#else
#define prout(str...)	// nothing
#endif

int tcp_sockfd=0,udp_sockfd=0; 
struct sockaddr_in	udpserv_addr;
struct sockaddr_in	tcpserv_addr;

int	udp_server();
int	tcp_server();
int tcp_send(char * buf,int len,struct sockaddr_in tcpclient_addr1);
int udp_send(char * buf,int len,struct sockaddr_in udpclient_addr1);


main()
{
	int tcp_readfd=0,udp_readfd=0;
	int addrlen=sizeof(struct sockaddr_in),i;
	struct sockaddr_in tcpclient_addr,udpclient_addr;
	struct sockaddr_in tcpclient_addr11,udpclient_addr11;
	char buf[128];
	fd_set fds;
	int fdslen;
	int tcprecv_num,udprecv_num;

	for(i=0;i<128;i++)
		buf[i]=0;
	bzero(&tcpclient_addr,sizeof(tcpclient_addr));
	tcpclient_addr.sin_family=AF_INET;
	tcpclient_addr.sin_addr.s_addr=inet_addr("192.168.2.138");
	//tcpclient_addr.sin_addr.s_addr=inet_addr("127.0.0.1");
	tcpclient_addr.sin_port=htons(TCPCLIE_PORT);
	bzero(&(tcpclient_addr.sin_zero),8);
	
	bzero(&udpclient_addr,sizeof(udpclient_addr));
	udpclient_addr.sin_family=AF_INET;
	udpclient_addr.sin_port=htons(UDPCLIE_PORT);
	udpclient_addr.sin_addr.s_addr=inet_addr("192.168.2.138");
	bzero(&(udpclient_addr.sin_zero),8);

	setuid(0);
	setgid(0);
	//tcp_server();
	udp_server();

/*select connect or receve data*/
	
	FD_ZERO(&fds);
	FD_SET(tcp_sockfd,&fds);
	FD_SET(udp_sockfd,&fds);
	FD_SET(0,&fds);
	fdslen=tcp_sockfd+udp_sockfd+1;

while(1)
  {
	if(select(fdslen,&fds,NULL,NULL,NULL))
		{
		if((tcp_sockfd!=0)&&FD_ISSET(tcp_sockfd,&fds))
			{
				if((tcp_readfd=accept(tcp_sockfd,(struct sockaddr*)&tcpclient_addr11,&addrlen))<=0)
					{
						prout("tcp_accept from %s error\n",inet_ntoa(tcpclient_addr11.sin_addr));
					}
				else prout("tcp accept from %s ok\n",inet_ntoa(tcpclient_addr11.sin_addr));
				prout("tcp_readfd=%d,tcp_sockfd=%d\n",tcp_readfd,tcp_sockfd);
				prout("case : 0\n");
				goto	RSELECT;
			}
		if((tcp_readfd!=0)&&FD_ISSET(tcp_readfd,&fds))
			{
				tcprecv_num=recv(tcp_readfd,buf,128,0);
				if(tcprecv_num<=0)
					{
						prout("tcp connect over\n");
						close(tcp_readfd);
						tcp_readfd=0;						
						//FD_CLR(tcp_readfd,&fds);
					}
				else printf("receive from tcp:%s\r\n",buf);
				prout("case : 1\n");
				goto	RSELECT;
			}
		
		if((udp_sockfd!=0)&&FD_ISSET(udp_sockfd,&fds))
			{
				if((recvfrom(udp_sockfd,buf,128,0,(struct sockaddr *)&udpserv_addr,&addrlen))<=0)
				//if((recvfrom(udp_sockfd,buf,128,0,(struct sockaddr *)&udpclient_addr11,&addrlen))<=0)
					{
						prout("udp close\n");
					}
				else prout("receive from udp %s:%s\n",inet_ntoa(udpserv_addr.sin_addr),buf);
				close(udp_sockfd);
				udp_server();
				prout("case : 2\n");
				goto	RSELECT;
			}
		
		if(FD_ISSET(0,&fds))
			{
				scanf("%s",buf);
				prout("receive from console: %s\n",buf);
				udp_send(buf,128,udpclient_addr);
				//tcp_send(buf,128,tcpclient_addr);
				prout("case : 3\n");
				goto	RSELECT;
			}
		}
  RSELECT:
	FD_ZERO(&fds);
	FD_SET(tcp_sockfd,&fds);
	//FD_SET(udp_sockfd,&fds);
	FD_SET(0,&fds);
	if(tcp_readfd!=0)
		{
		 	FD_SET(tcp_readfd,&fds);
		 	fdslen=tcp_sockfd+udp_sockfd+tcp_readfd+1;
		}
  }
}

int	udp_server()
{
	int	reuse_addr=1;

	memset((char *)&udpserv_addr,0,sizeof(udpserv_addr));
	bzero(&udpserv_addr,sizeof(udpserv_addr));
	udpserv_addr.sin_family=AF_INET;
	udpserv_addr.sin_port=htons(UDPSERV_PORT);
	udpserv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
	bzero(&(udpserv_addr.sin_zero),8);
	
	udp_sockfd=socket(AF_INET,SOCK_DGRAM,0);
	if(udp_sockfd<0)
	{
		prout("socket failed!");
		return -1;
	}
	prout("ude sockfd = %d\n",udp_sockfd);
	setsockopt(udp_sockfd,SOL_SOCKET,SO_REUSEADDR,(void *)&reuse_addr,sizeof(reuse_addr));
	if(bind(udp_sockfd,(struct sockaddr *)&udpserv_addr,sizeof(udpserv_addr))<0)
	{
		prout("bind failed!");
		close(udp_sockfd);
		return -1;
	}
	prout("udp server init ok!\n");
	return 0;
}

int	tcp_server()
{
	int	reuse_addr=1;

	memset((char *)&tcpserv_addr,0,sizeof(tcpserv_addr));
	bzero (&tcpserv_addr, sizeof (tcpserv_addr));	
	tcpserv_addr.sin_family=AF_INET;
	tcpserv_addr.sin_port=htons(TCPSERV_PORT);
	tcpserv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
	bzero (&(tcpserv_addr.sin_zero), 8);
	
	tcp_sockfd=socket(AF_INET,SOCK_STREAM,0);
	if(tcp_sockfd<0)
	{
		prout("socket failed!");
		return -1;
	}
	setsockopt(tcp_sockfd,SOL_SOCKET,SO_REUSEADDR,(void *)&reuse_addr,sizeof(reuse_addr));
	if(bind(tcp_sockfd,(struct sockaddr *)&tcpserv_addr,sizeof(tcpserv_addr))<0)
	{
		prout("bind failed!");
		close(tcp_sockfd);
		return -1;
	}
	if(listen(tcp_sockfd,MAX_CLIENTS)<0)
	{
		prout("listen failed!");
		return -1;
	}
	prout("tcp server init ok!\n");
	return 0;
}

int tcp_send(char * buf,int len,struct sockaddr_in tcpclient_addr1)
{
	int sockfd,sendnum;
  
	sockfd=socket(AF_INET,SOCK_STREAM,0);
	if(sockfd<0)
		{
			prout("tcp_socket err\n");
			return -1;
			//exit(-1);
		}
	prout("sock=%d\n",sockfd);
	if(connect(sockfd,(struct sockaddr *)&tcpclient_addr1,sizeof(tcpclient_addr1))<0)
		{
			prout("tcp_connect err\n");
			close(sockfd);
			return -1;
			//exit(-1);
		}
	prout("connect to %s\n",inet_ntoa(tcpclient_addr1.sin_addr));
	sendnum=send(sockfd,buf,len,0);
	if(sendnum<0)
		{
			prout("tcp_send err\n");
			close(sockfd);
			return -1;
			//exit(-1);
		}
	close(sockfd);
	prout("tcp send ok!\n");
	return (sendnum);
}

int udp_send(char * buf,int len,struct sockaddr_in udpclient_addr1)
{
	int sockfd,sendnum;

	//bzero(&udpclient_addr1,sizeof(udpclient_addr1));
	//udpclient_addr1.sin_family=AF_INET;
	//udpclient_addr1.sin_port=htons(UDPCLIE_PORT);
	//udpclient_addr1.sin_addr.s_addr=inet_addr("192.168.2.138");
	//bzero(&(udpclient_addr1.sin_zero),8);

	sockfd=socket(AF_INET,SOCK_DGRAM,0);
	if(sockfd<0)
		{
			prout("udp_socket err\n");
			//exit(-1);
		}
	sendnum=sendto(sockfd,buf,len,0,(struct sockaddr *)&udpclient_addr1,sizeof(udpclient_addr1));
	if(sendnum<=0)
		{
			prout("udp_sendto err\n");
			//exit(-1);
		}
	prout("udp send to %s\n",inet_ntoa(udpclient_addr1.sin_addr));
	close(sockfd);
	prout("udp send ok!\n");
	return (sendnum);
}