Linux C 自定义应用层协议多进程TCP通信

自定义消息结构体，包括消息头和消息内容

#ifndef __MSG_H__
#define __MSG_H__

#include <sys/types.h>

typedef struct
{
	// head
	char head[10];
	char checknum;
	// body
	char buff[512];
}Msg;

extern int write_msg(int sockfd, char *buff,
	       	size_t len);

extern int read_msg(int sockfd, char *buff,
		size_t len);

#endif

msg.c 

#include "msg.h"
#include <unistd.h>
#include <string.h>
#include <memory.h>
#include <sys/types.h>

static unsigned char msg_check(Msg *message)
{
	unsigned char s = 0;
	int i;
	for(i=0;i<sizeof(message->head);i++)
	{
		s+=message->head[i];
	}

	for(i=0;i<sizeof(message->buff);i++)
	{
		s+=message->buff[i];
	}

	return s;

}

int write_msg(int sockfd, char *buff,size_t len)
{
	Msg message;
	memset(&message,0,sizeof(message));
	strcpy(message.head, "iotek2012");
	memcpy(message.buff, buff, len);
	message.checknum = msg_check(&message);
	if(write(sockfd, &message, sizeof(message))!=sizeof(message))
	{
		return -1;
	}


}

int read_msg(int sockfd, char *buff,size_t len)
{
	Msg message;
	memset(&message, 0, sizeof(message));
	size_t size;
	if((size = read(sockfd, &message, sizeof(message)))<0)
	{
		return -1;
	}
	else if(size==0)
	{
		return 0;
	}
	unsigned char s = msg_check(&message);
	if((s== (unsigned char)message.checknum)
			&& (!strcmp("iotek2012", message.head)))
	{
		memcpy(buff, message.buff, len);
		return sizeof(message);
	}
	return -1;


}

服务器代码

#include <netdb.h>
#include <stdio.h>
#include <sys/socket.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <memory.h>
#include <signal.h>
#include <time.h>
#include <errno.h>
#include "msg.h"

int sockfd;

void sig_handler(int signo)
{
	if(signo == SIGINT)
	{
		printf("server close\n");
		close(sockfd);
		exit(1);
	}

	if(signo == SIGCHLD)
	{
		printf("child process deader...\n");
		wait(0);
	}
}

void out_addr(struct sockaddr_in *clientaddr)
{
	int port = ntohs(clientaddr->sin_port);
	char ip[16];
	memset(ip,0,sizeof(ip));
	inet_ntop(AF_INET, &clientaddr->sin_addr.s_addr, ip, sizeof(ip));
	printf("client: %s(%d) connected\n", ip, port);
}

void do_service(int fd)
{
	char buff[512];
	while(1)
	{
		memset(buff,0,sizeof(buff));
		printf("start read and write...\n");
		size_t size;
		if((size = read_msg(fd, buff, sizeof(buff)))<0)
		{
			perror("protocal error");
			break;
		}
		else if(size==0)
		{
			break;
		}
		else
		{
			printf("%s\n", buff);
			if(write_msg(fd, buff, sizeof(buff))<0)
			{
				if(errno == EPIPE)
				{
					break;
				}
			}
			perror("protocal error");
		}
	}

}



int main(int argc, char *argv[])
{
	if(argc<2)
	{
		printf("usage: %s #port\n", argv[0]);
		exit(1);
	}

	if(signal(SIGINT, sig_handler) == SIG_ERR)
	{
		perror("signal sigint error");
		exit(1);
	}

	if(signal(SIGCHLD, sig_handler) == SIG_ERR)
	{
		perror("signal sigchld error");
		exit(1);
	}

	// AF_INET: IPV4
	// SOCK_STREAM: tcp
	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(sockfd < 0)
        {
		perror("socket error");
		exit(1);
	}
	struct sockaddr_in  serveraddr;

	memset(&serveraddr, 0, sizeof(serveraddr));

	serveraddr.sin_family = AF_INET;
	serveraddr.sin_port = htons(atoi(argv[1]));
	serveraddr.sin_addr.s_addr = INADDR_ANY;
	if(bind(sockfd,(struct sockaddr*)&serveraddr,
				sizeof(serveraddr))<0)
	{
		perror("bind error");
		exit(1);
	}

	if(listen(sockfd,10) <0)
	{
		perror("listen error");
		exit(1);
	}

	struct sockaddr_in clientaddr;
	socklen_t clientaddr_len = sizeof(clientaddr);
	while(1)
	{
		int fd = accept(sockfd,
				(struct sockaddr*)&clientaddr,
				&clientaddr_len);
		if(fd<0)
		{
			perror("accept error");
			continue;
		}

		pid_t pid = fork();
		if(pid < 0)
		{
			continue;
		}
		else if(pid == 0)
		{
			// child process
			out_addr(&clientaddr);
			do_service(fd);
			close(fd);
			break;
		}
		else
		{

			close(fd);
		}

	}


}

客户端代码

#include <netdb.h>
#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#include <unistd.h>
#include "msg.h"


int main(int argc, char* argv[])
{
	if(argc<3)
	{
		printf("usage : %s ip port\n", argv[0]);
		exit(1);
	}

	// create socket
	// tcp
	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if(sockfd<0)
	{
		perror("socket error");
		exit(1);
	}

	struct sockaddr_in serveraddr;
	memset(&serveraddr,0, sizeof(serveraddr));
	serveraddr.sin_family = AF_INET;
	serveraddr.sin_port = htons(atoi(argv[2]));
	inet_pton(AF_INET, argv[1],
			&serveraddr.sin_addr.s_addr);
	if(connect(sockfd, (struct sockaddr*)&serveraddr,
				sizeof(serveraddr))<0)
	{
		perror("connect error");
		exit(1);
	}

	char buff[512];
	size_t size;
	char *prompt = ">";
	while(1)
	{
		memset(buff,0,sizeof(buff));
		write(STDOUT_FILENO,prompt,1);
		size = read(STDIN_FILENO, buff,sizeof(buff));
		if(size<0)
			continue;
		buff[size-1] = '\0';

		if(write_msg(sockfd, buff, sizeof(buff))<0)
		{
			perror("write msg error");
			continue;
		}
		else
		{
			if(read_msg(sockfd, buff, sizeof(buff))<0)
			{
				perror("read msg error");
				continue;
			}
			else
			{
				printf("%s\n",buff);
			}
		}
	}

	close(sockfd);

	return 0;
}