基于udp创建多人聊天室

udp服务器：udp

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>

#define ERRLOG(msg)  \
	do {\
		fprintf(stderr,"%s %s %d:", __FILE__, __func__, __LINE__); \
		perror(msg);                                       \
	} while(0)

typedef struct _MSG {
	char code; //操作码 ('L' 登录)，('C' 群聊)，('Q' 退出)
	char name[32];
	char txt[128];
} msg_t;
typedef struct _NODE {
	struct sockaddr_in cin; //客户端网络信息结构体
	struct _NODE* next; //指针域
} node_t;

int create_node(node_t **p);
int do_login(struct sockaddr_in cin, node_t* phead, int sockfd, msg_t msg);
int do_chat(struct sockaddr_in cin, node_t* phead, int sockfd, msg_t msg);
int do_quit(struct sockaddr_in cin, node_t* phead, int sockfd, msg_t msg);
int main(int argc, char const* argv[])
{
	//入参合理性检查
	if (3 != argc) {
		printf("Usage : %s <IP> <PORT>\n", argv[0]);
		return -1;
	}

	// 创建套接字
	int sfd = socket(AF_INET, SOCK_DGRAM, 0);
	if(sfd<0)
	{
		ERRLOG("socket error");
	}
	// 填充服务器网络信息结构体
	struct sockaddr_in sin;
	memset(&sin, 0, sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_port = htons(atoi(argv[2]));
	sin.sin_addr.s_addr = inet_addr(argv[1]);
	socklen_t sin_addrlen = sizeof(sin);

	//绑定
	if(bind(sfd, (struct sockaddr*)&sin, sin_addrlen)<0) 
	{
		ERRLOG("bind error");
	}

	//用来保存客户端网络信息结构体
	struct sockaddr_in cin;
	socklen_t cin_addrlen = sizeof(cin);

	msg_t msg;

	pid_t pid = fork();
	if (pid<0) 
	{
		ERRLOG("fork error");
	} else if (0 == pid) 
	{
		//子进程，用来接收数据并处理
		//创建用来保存客户端网络信息结构体的链表
		node_t *phead = NULL;
		create_node(&phead);
		phead->next =NULL;
		printf("聊天室已创建,等待用户加入群聊！！！\n");
		while(1) 
		{
			memset(&msg, 0, sizeof(msg));
			memset(&cin, 0, sizeof(cin));
			if (recvfrom(sfd, &msg, sizeof(msg), 0, (struct sockaddr*)&cin, &cin_addrlen)<0) 
			{
				ERRLOG("recvfrom error");
			}
			printf("[%s]: [%s]\n", msg.name, msg.txt);
			switch (msg.code) {
			case 'L':
				do_login(cin, phead, sfd, msg);
				break;
			case 'C':
				do_chat(cin, phead, sfd, msg);
				break;
			case 'Q':
				do_quit(cin, phead, sfd, msg);
				break;
			}
		}
	} else if (0 < pid) {
		//父进程，用来发送系统消息
		//把父进程当作一个客户端，以群聊的方式发送消息给所有人（系统消息）
		msg.code = 'C';
		strcpy(msg.name, "系统");
		while (1)
		{
			fgets(msg.txt, 128, stdin);
			msg.txt[strlen(msg.txt) - 1] = '\0';
			if (sendto(sfd, &msg, sizeof(msg), 0, (struct sockaddr*)&sin, sin_addrlen)<0)
			{
				ERRLOG("sendto error");
			}
		}
	}
	close(sfd);
	return 0;
}
//创建链表节点的函数
int create_node(node_t** p)
{
	*p = (node_t*)malloc(sizeof(node_t));
	if (NULL == *p || NULL == p) {
		ERRLOG("malloc error");
	}
}
//登录的函数
int do_login(struct sockaddr_in cin, node_t* phead, int sfd, msg_t msg)
{
	//先遍历链表，将xxxx登录的消息 转发给所有人
	node_t* ptemp = phead;
	while (ptemp->next != NULL)
	{
		ptemp = ptemp->next;
		if (sendto(sfd, &msg, sizeof(msg), 0, ((struct sockaddr*)&(ptemp->cin)), sizeof(ptemp->cin))<0) 
		{
			ERRLOG("sendto error");
		}
	}
	//将新登录的用户头插到链表中
	node_t* pnew = NULL;
	create_node(&pnew);
	pnew->cin = cin;
	pnew->next = phead->next;
	phead->next = pnew;
	return 0;
}

//群聊消息的函数
int do_chat(struct sockaddr_in cin, node_t* phead, int sfd, msg_t msg)
{
	//遍历链表，将群聊的数据发送给除自己外的所有人
	node_t* ptemp = phead;
	while (ptemp->next != NULL) {
		ptemp = ptemp->next;
		if (0 != memcmp(&cin, &(ptemp->cin), sizeof(cin)))
		{
			if (sendto(sfd, &msg, sizeof(msg), 0, ((struct sockaddr*)&(ptemp->cin)), sizeof(ptemp->cin))<0)
			{
				ERRLOG("sendto error");
			}
		}
	}
}

int do_quit(struct sockaddr_in cin, node_t* phead, int sfd, msg_t msg)
{
	//将xxxx退出群聊的消息发送给除自己外所有的所有客户端，并且将自己在链表中删除
	node_t* ptemp = phead;
	while (ptemp->next != NULL) 
	{
		if (0 != memcmp(&cin, &(ptemp->cin), sizeof(cin))) {
			//判断是不是自己，不是自己就发送数据
			ptemp = ptemp->next;
			if (sendto(sfd, &msg, sizeof(msg), 0, ((struct sockaddr*)&(ptemp->cin)), sizeof(ptemp->cin))<0)
			{
				ERRLOG("sendto error");
			}
		} else {
			//是自己，就将自己在链表中删除
			node_t* pdel = ptemp->next;
			ptemp->next = pdel->next;
			free(pdel);
			pdel == NULL;
		}
	}
}

udp客户端：

#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#define ERRLOG(msg)                                        \
	do {                                                   \
		fprintf(stderr,"%s %s %d:", __FILE__, __func__, __LINE__); \
		perror(msg);                                       \
	} while (0)

typedef struct _MSG 
{
	char code; //操作码 ('L' 登录)，('C' 群聊)，('Q' 退出)
	char name[32];
	char txt[128];
} msg_t;
int main(int argc, const char* argv[])
{
	//入参合理性检查
	if (3 != argc) {
		printf("Usage : %s <IP> <PORT>\n", argv[0]);
		return -1;
	}

	// 1.创建套接字
	int sfd = socket(AF_INET, SOCK_DGRAM, 0);
	if(sfd<0)
	{
		ERRLOG("socket error");
	}
	// 2.填充服务器网络信息结构体
	struct sockaddr_in sin;
	memset(&sin, 0, sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_port = htons(atoi(argv[2]));
	sin.sin_addr.s_addr = inet_addr(argv[1]);
	socklen_t sin_addrlen = sizeof(sin);

	msg_t msg;
	memset(&msg, 0, sizeof(msg));
	printf("请输入用户名: ");
	fgets(msg.name, 32, stdin);
	msg.name[strlen(msg.name) - 1] = '\0';

	//给服务器发送登录的数据包

	msg.code = 'L';
	strcpy(msg.txt, "加入群聊");
	if (sendto(sfd, &msg, sizeof(msg), 0, (struct sockaddr*)&sin, sin_addrlen)<0)
	{
		ERRLOG("sendto error");
	}

	pid_t pid = fork();
	if(pid<0)
	{
		ERRLOG("fork error");
	} else if (0 == pid)
	{
		//子进程
		//接收由服务器发来的数据并打印
		while (1)
		{
			memset(&msg, 0, sizeof(msg));
			if (recvfrom(sfd, &msg, sizeof(msg), 0, NULL, NULL)<0)
			{
				ERRLOG("recvfrom error");
			}
			printf("[%s]: %s\n", msg.name, msg.txt);
		}
	} else if (0 < pid)
	{
		//父进程
		while (1)
		{

			msg.code = 'C';
			printf("我:");
			fgets(msg.txt, 128, stdin);
			msg.txt[strlen(msg.txt) - 1] = '\0';
			//判断是不是要退出
			if (!strncmp(msg.txt, "quit", 5)) {
				msg.code = 'Q';
				strcpy(msg.txt, "退出群聊");
			}

			if (sendto(sfd, &msg, sizeof(msg), 0, (struct sockaddr*)&sin, sin_addrlen)<0)
			{
				ERRLOG("sendto error");
			}
			if (!strcmp(msg.txt, "退出群聊"))
			{
				break;
			}
		}
		//先让子进程自杀
		kill(pid, SIGKILL);
		wait(NULL);
		close(sfd);
	}

	return 0;
}

测试结果：