- 前言
- 一、前期工作
- 二、项目框架
- 三、伪代码流程
- 四、源代码
- 五、结果显示
- 附录
前言
本文承接上一篇《Linux多人聊天室之前篇》的内容，记录的是多人聊天室室如何实现的。
一、前期工作
前期工作包含有：①学会用内核链表。②知道多线程的原理。
内核链表：
学习存储客户端的已连接套接字的数据结构 – 内核链表。
1、为什么项目中不使用数组，而是使用链表？
因为数组必须要在定义时，确定出数组的空间大小，那么这样就会限制了客户端连接的人数。
例如：int connfd[10]; --> 最多只能有10个客户端连接
2、链表是什么东西来的？
链表是linux下的一种存储结构。
3、如何实现内核链表的初始化头节点、尾插、遍历、删除节点？
1）内核链表所有的操作函数都已经帮你实现好了，你只需要调用即可。
这些操作函数都是放在kernel_list.h，所以待会编译代码，这个头文件必须存放才会编译通过。
2）如何表示一个节点？
经过分析，一个节点既有数据域，又有指针域，最好使用一个结构体来表示？
struct list_node{
//数据域
int connfd; --> 代表每一个节点都是存放一个已连接套接字
//指针域 struct list_head list;
};
指针域在内核链表已经写好了，指针域是一个结构体的：
struct list_head {
struct list_head *next, *prev; //分别是指向下一个节点与上一个节点
};
3）如何申请空间？
使用malloc()函数
头文件：#include
malloc() 参数： 你想申请的空间大小的字节数
malloc() 返回值： 这片新申请的空间的地址
4）如何初始化头节点？
INIT_LIST_HEAD(节点结构体指针域的地址)
5）如何尾插？
list_add_tail(新节点结构体指针域的地址,头节点结构体指针域的地址)
6）如何遍历？
list_for_each_entry(指向节点结构体的指针p变量,头节点结构体指针域的地址,在节点结构体中，指针域变量叫什么名字)
7）如何删除？
list_for_each_entry_safe(指向节点结构体的指针p变量,指向节点结构体的指针q变量,头节点结构体指针域的地址,在节点结构体中，指针域变量叫什么名字)
8)如何把这个节点从链表中脱离？
list_del(那个需要脱离的节点的指针域的地址)
9）如何释放节点空间？
使用free()函数
详细的代码： list_test.c
list_test.c代码：
#include#include "kernel_list.h" //包含当前目录下的kernel_list.h #include //设计节点 struct list_node{ int connfd; struct list_head list; //这个结构体不需要我们自己写， //因为这个结构体已经在kernel_list.h中已经定义好了。 }; struct list_node *init_list_head() { //1. 为头节点申请空间 struct list_node *head = malloc(sizeof(struct list_node)); //2. 为头节点赋值 INIT_LIST_HEAD(&(head->list)); //3. 将头节点返回给main函数，以便后续的尾插、遍历，删除使用。 return head; } void insert_list_node(struct list_node *head,int num) { //1. 为新节点申请空间 struct list_node *New_Node = malloc(sizeof(struct list_node)); //2. 为数据域赋值 New_Node->connfd = num; //3. 为指针域赋值 list_add_tail(&(New_Node->list),&(head->list)); return; } void show_list_node(struct list_node *head) { struct list_node *p = NULL; list_for_each_entry(p, &(head->list), list) { printf("p->connfd:%dn",p->connfd); } return; } void delete_list_node(struct list_node *head,int num) { struct list_node *p = NULL; struct list_node *q = NULL; list_for_each_entry_safe(p,q,&(head->list),list) { //每遍历到一个节点，我都判断一下是不是我想删除的节点 if(p->connfd == num) //找到了我想删除的节点 { list_del(&(p->list)); //让该节点从链表中脱离 free(p); //释放p节点指向的空间 return; } } } int main(int argc,char *argv[]) { //1. 初始化头节点 struct list_node *head = NULL; head = init_list_head(); //2. 尾插(当有客户端连接到服务器，就要使用到尾插的函数) insert_list_node(head,4); insert_list_node(head,5); insert_list_node(head,6); insert_list_node(head,7); insert_list_node(head,8); //3. 遍历(如果需要群发或者私聊，就要使用到遍历) show_list_node(head); //45678 //4. 删除节点 delete_list_node(head,6); //(当客户端发送额quit要退出时，就要删除该客户端节点) //5. 再次遍历链表 printf("------------------------n"); show_list_node(head); //4578 return 0; }
多线程：由于本人博客已经有记录过多线程的内容，本文不再重复
二、项目框架 三、伪代码流程 四、源代码服务端代码如下（示例）：
#include#include #include #include #include #include #include #include #include #include "kernel_list.h" //包含当前目录下的kernel_list.h //设计节点 typedef struct list_node{ int connfd; struct list_head list; //这个结构体不需要我们自己写， //因为这个结构体已经在kernel_list.h中已经定义好了。 }NODE, *PNODE; struct list_node *init_list_head(); //链表初始化 void insert_list_node(struct list_node *head,int num); void show_list_node(struct list_node *head); void delete_list_node(struct list_node *head,int num); void* func(void* arg); //初始化存储已连接套接字的链表 add by LZH PNODE head = NULL; int main(int argc, char const *argv[]) { //1、准备一个未连接的套接字 int sockfd = socket(AF_INET, SOCK_STREAM, 0); head = init_list_head(); //2、绑定一个IP地址到套接字上 struct sockaddr_in seraddr; socklen_t len = sizeof(seraddr); bzero(&seraddr, len); //赋值前先清空seraddr内存上数据 seraddr.sin_family = AF_INET; //设置服务器协议 seraddr.sin_port = htons(atoi(argv[1])); //设置服务器的端口号(把字符串转成短整型) seraddr.sin_addr.s_addr = htonl(INADDR_ANY); //设置服务器的IP地址 bind(sockfd, (struct sockaddr *)(&seraddr), len); //3、将未连接套接字转换成监听套接字 listen(sockfd, 5); //4、不断等待监听套接字上的数据 struct sockaddr_in cliaddr; bzero(&cliaddr, len); int connfd; while(1) { connfd = accept(sockfd, (struct sockaddr *)&cliaddr, &len); //谁连接到服务器上，谁的信息就会保存到这个变量中。 //insert_list_node(head,4); if(connfd > 0) { insert_list_node(head, connfd); //尾插，把connfd添加链表当中 printf("new connection:%dn", connfd); //OK //show_list_node(head); //遍历链表，查看是否添加成功 pthread_t pid; pthread_create(&pid, NULL, func, (void*)&connfd); } else { printf("accept function error!n"); } } //6. 挂断 //close(connfd); close(sockfd); return 0; } //线程回调函数 void* func(void* arg) { //5. 畅聊 不断接受客户端发送过来的数据 char buf[100]; int connfd = *(int*)arg; while(1) { //5.1 清空缓冲区 bzero(buf, sizeof(buf)); //5.2 把已连接套接字上的数据读取到缓冲区 recv(connfd, buf, sizeof(buf), 0); //5.3 将缓冲区的数据打印出来 //printf("from connfd:%d client: %s", connfd, buf); //5.4 如果客户端给我发了quit，那么我就退出 if( strncmp(buf, "quit", 4) == 0 ) { close(connfd); delete_list_node(head, connfd); //(当客户端发送额quit要退出时，就要删除该客户端节点) //free(&connfd); } //判断buf中有没有 冒号: char* tmp = strstr(buf, ":"); if(tmp == NULL) { //群发 struct list_node *p = NULL; list_for_each_entry(p, &(head->list), list) { if(p->connfd != connfd) { send(p->connfd, buf, strlen(buf), 0); //群发信息给每个客户端 } //printf("p->connfd:%dn", p->connfd); } } else { //如果buf的第二个信息不是“冒号：”，那么将它认为是群发信息 if(buf[1] != ':') { //群发 struct list_node *p = NULL; list_for_each_entry(p, &(head->list), list) { if(p->connfd != connfd) { send(p->connfd, buf, strlen(buf), 0); //群发信息给每个客户端 } //printf("p->connfd:%dn", p->connfd); } } else { //私聊 char* str = tmp + 1; //私聊内容 int num = atoi(buf); //找到对方的ID号 （5：hello），找到这个5 send(num, str, strlen(str), 0); //群发信息给每个客户端 } } } } //链表初始化 struct list_node *init_list_head() { //1. 为头节点申请空间 struct list_node *head = malloc(sizeof(struct list_node)); //2. 为头节点赋值 INIT_LIST_HEAD(&(head->list)); //3. 将头节点返回给main函数，以便后续的尾插、遍历，删除使用。 return head; } //尾插法 void insert_list_node(struct list_node *head,int num) { //1. 为新节点申请空间 struct list_node *New_Node = malloc(sizeof(struct list_node)); //2. 为数据域赋值 New_Node->connfd = num; //3. 为指针域赋值 list_add_tail(&(New_Node->list),&(head->list)); return; } //遍历链表 void show_list_node(struct list_node *head) { struct list_node *p = NULL; list_for_each_entry(p,&(head->list),list) { printf("p->connfd:%dn",p->connfd); } return; } //删除结点 void delete_list_node(struct list_node *head,int num) { struct list_node *p = NULL; struct list_node *q = NULL; list_for_each_entry_safe(p,q,&(head->list),list) { //每遍历到一个节点，我都判断一下是不是我想删除的节点 if(p->connfd == num) //找到了我想删除的节点 { list_del(&(p->list)); //让该节点从链表中脱离 free(p); //释放p节点指向的空间 return; } } }
客户端代码如下（示例）：
#include五、结果显示#include #include #include #include #include #include #include #include void* func(void* arg); int main(int argc, char const *argv[]) { //1、准备一个未连接的套接字 int sockfd = socket(AF_INET, SOCK_STREAM, 0); //2. 准备服务器的地址 struct sockaddr_in seraddr; socklen_t len = sizeof(seraddr); bzero(&seraddr, len); //赋值前先清空seraddr内存上数据 seraddr.sin_family = AF_INET; //设置服务器协议 seraddr.sin_port = htons(atoi(argv[2])); //设置服务器的端口号(把字符串转成短整型) inet_pton(AF_INET, argv[1], &seraddr.sin_addr); //设置服务器IP地址 //3. 直接发起连接 int ret = connect(sockfd, (struct sockaddr *)(&seraddr), len); if(ret == 0) { printf("connect success!n"); } else { printf("connect fail!n"); } pthread_t pid; pthread_create(&pid, NULL, func, (void*)&sockfd ); //4. 不断发送数据给服务器。 char buf[100]; while(1) { //4.1 先清空缓冲区 bzero(buf, sizeof(buf)); //4.2 从键盘中获取字符串，然后把字符串存储到这个数组中。 fgets(buf, sizeof(buf), stdin); //stdin就是键盘设备对应的文件指针 //4.3 发送该字符串给服务器 send(sockfd, buf, strlen(buf), 0); //strlen(buf)可以计算出字符串实际的字符个数 //4.4 判断发送的字符串是不是quit if( strncmp(buf, "quit", 4) == 0 ) { break; //如果收到了quit，则跳出循环，程序结束 } } //5. 挂断电话 close(sockfd); return 0; } void* func(void* arg) { int sockfd = *(int*)arg; char buf[100]; while(1) { bzero(buf, sizeof(buf)); recv(sockfd, buf, sizeof(buf), 0); printf("receive from other：%sn", buf); } }
附录
此项目还需要一个内核链表的头文件
kernel_list.h
代码如下：
#ifndef __DLIST_H
#define __DLIST_H
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
#define container_of(ptr, type, member) ({
const typeof( ((type *)0)->member ) *__mptr = (ptr);
(type *)( (char *)__mptr - offsetof(type,member) );})
#define LIST_POISON1 ((void *) 0x00100100)
#define LIST_POISON2 ((void *) 0x00200)
struct list_head {
struct list_head *next, *prev;
};
#define LIST_HEAD_INIT(name) { &(name), &(name) }
#define LIST_HEAD(name)
struct list_head name = LIST_HEAD_INIT(name)
#define INIT_LIST_HEAD(ptr) do {
(ptr)->next = (ptr); (ptr)->prev = (ptr);
} while (0)
static inline void __list_add(struct list_head *new,
struct list_head *prev,
struct list_head *next)
{
next->prev = new;
new->next = next;
new->prev = prev;
prev->next = new;
}
static inline void list_add(struct list_head *new, struct list_head *head)
{
__list_add(new, head, head->next);
}
static inline void list_add_tail(struct list_head *new, struct list_head *head)
{
__list_add(new, head->prev, head);
}
static inline void __list_del(struct list_head *prev, struct list_head *next)
{
next->prev = prev;
prev->next = next;
}
static inline void list_del(struct list_head *entry)
{
__list_del(entry->prev, entry->next);
entry->next = (void *) 0;
entry->prev = (void *) 0;
}
static inline void list_del_init(struct list_head *entry)
{
__list_del(entry->prev, entry->next);
INIT_LIST_HEAD(entry);
}
static inline void list_move(struct list_head *list,
struct list_head *head)
{
__list_del(list->prev, list->next);
list_add(list, head);
}
static inline void list_move_tail(struct list_head *list,
struct list_head *head)
{
__list_del(list->prev, list->next);
list_add_tail(list, head);
}
static inline int list_empty(struct list_head *head)
{
return head->next == head;
}
static inline void __list_splice(struct list_head *list,
struct list_head *head)
{
struct list_head *first = list->next;
struct list_head *last = list->prev;
struct list_head *at = head->next;
first->prev = head;
head->next = first;
last->next = at;
at->prev = last;
}
static inline void list_splice(struct list_head *list, struct list_head *head)
{
if (!list_empty(list))
__list_splice(list, head);
}
static inline void list_splice_init(struct list_head *list,
struct list_head *head)
{
if (!list_empty(list)) {
__list_splice(list, head);
INIT_LIST_HEAD(list);
}
}
#define list_entry(ptr, type, member)
((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
#define list_for_each(pos, head)
for (pos = (head)->next; pos != (head);
pos = pos->next)
#define list_for_each_prev(pos, head)
for (pos = (head)->prev; pos != (head);
pos = pos->prev)
#define list_for_each_safe(pos, n, head)
for (pos = (head)->next, n = pos->next; pos != (head);
pos = n, n = pos->next)
#define list_for_each_entry(pos, head, member)
for (pos = list_entry((head)->next, typeof(*pos), member);
&pos->member != (head);
pos = list_entry(pos->member.next, typeof(*pos), member))
#define list_for_each_entry_safe(pos, n, head, member)
for (pos = list_entry((head)->next, typeof(*pos), member),
n = list_entry(pos->member.next, typeof(*pos), member);
&pos->member != (head);
pos = n, n = list_entry(n->member.next, typeof(*n), member))
#endif
