Linux socket聊天室
目录
一、运行效果
1、分别编译客户端和服务端代码
2、运行
3、使用效果
二、代码
chat.h
服务端代码
客户端代码
一、运行效果
1、分别编译客户端和服务端代码
gcc client.c -o C -lpthread
gcc server.c -o S -lpthread
2、运行
先运行服务器端，8888为端口号
./S 8888
再运行客户端，这里创建两个客户端，端口号要和服务端的一样
./C 127.0.0.1 8888
可以看到，左下的窗口运之后，就会进入注册界面；而服务器也会提示有客户端的ip连接进来，这个时候再用右边的窗口运行客户端
进入两个主页之后，服务器就会有不同的port对应不同的客户端
3、使用效果
注册
上图可以看到，左下进行了一个注册之后就会提示注册成功，服务器上面也会有记录，下面进行登录
上图左下登录之后会提示登录成功，服务器也会有记录，而左下的窗口只要再按下回车就能进入到功能主页。下面再用左下的窗口注册一个用户2
上图可以看到，用户2注册成功登录之后，进入功能主页的左下用户也会有提示说右下用户上线了，服务器也会记录。下面左下用户进行“公聊”，只要是在线的用户都会收到信息
上图坐下用户输入数字3，选择功能之后，就会提示输入，输入之后按回车，右下用户就出现了信息（蓝色字体），如下
上图可以看到右下用户出现了“公聊信息”蓝色字体，下面用右边的用户对左边用户进行“私聊”
输入4选择功能之后，会询问对谁发信息，接着就输入用户的名字，在输入发送的消息，按下回车就可以发送，如下
可以看到坐下的用户已经收到私聊的信息，这样就不会像公聊那样谁都能看到，输入5可以查看有谁在线，下面先把右下的用户退出
上图可以看到只查询到自己用户1的名字在线，下面用第二个用户查询
上图可以看到，用户2上线之后，查到两个用户在线
二、代码
chat.h
#ifndef __CHAT_H
#define __CHAT_H
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define SERVER_PORT 8888
#define SIZE 32
/*最大的用户数量*/
#define MAX_USER_NUM 64
/*在线用户*/
struct ONLINE{
int fd; /*描述符，-1：该用户下线 >0:该用户已经登录，对应的套接字*/
int flage; /*注册标志，-1 该条目没有用户信息 1：该条目有用户注册信息*/
char name[SIZE]; /*姓名*/
char password[SIZE]; /*密码*/
};
/*C/S通信的结构体*/
struct protocol{
int cmd; /*命令*/
int state; /*存储命令返回信息*/
char name[SIZE]; /*用户姓名*/
char data[MAX_USER_NUM]; /*数据*/
};
/*cmd（命令类型）*/
#define BROADCAST 0X00000001 /*广播数据*/
#define PRIVATE 0X00000002 /*私聊*/
#define REGISTE 0X00000004 /*注册*/
#define LOGIN 0X00000008 /*登录*/
#define ONLINEUSER 0X00000010 /*显示在线用户*/
#define LOGOUT 0X00000020 /*退出*/
/*return code（服务器处理结果返回值）*/
#define OP_OK 0X80000000 /*操作成功*/
#define ONLINEUSER_OK 0X80000001 /*显示在线用户，未结束*/
#define ONLINEUSER_OVER 0X88888888 /*显示在线用户，已经发送完毕*/
#define NAME_EXIST 0X80000003 /*注册信息，用户名已经存在*/
#define NAME_PWD_NMATCH 0X80000004 /*登录时，输入的用户名密码不对 */
#define USER_LOGED 0X80000005 /*登录时，提示该用户已经在线*/
#define USER_NOT_REGIST 0X80000006 /*登录时，提示用户没有注册*/
#endif
服务端代码
#include "chat.h"
#include
#include
struct ONLINE online[MAX_USER_NUM];
/*将用户注册信息存储到在线用户列表中*/
int add_user(int socket_fd, struct protocol *msg) {
int i, index = -1;
char buf[128] = {0};
/*历在线用户列表数组，从第一个开始找没有被占用的位置，将用户的注册信息存储到该位置*/
for (i = 0; i < MAX_USER_NUM; i++) { /*判断当前位置是否已经被占用*/
if (online[i].flage == -1) { /* 标记该位置为已占用*/
online[i].flage = 1;
strcpy(online[i].name, msg->name);
strcpy(online[i].password, msg->data);
printf("regist %s to %d \n", msg->name, i);
index = i;
return index; /* 返回存储用户信息的位置*/
}
}
return index;
}
/*从在线列表中删除
*在聊天室程序中将在线用户列表中指定位置的客户端信息删除，
*并向所有在线客户端发送某用户下线通知
*/
void del_user_online(int index) {
int i;
char buf[128] = {0};
/*通过比较传入的 index 变量与 0 的大小，来判断传入参数是否合法
*如果 index 小于 0，代表传入参数无效，直接返回
*/
if (index < 0)
return;
/*删除在线用户列表中相应位置的客户端信息
*将在线用户列表中指定位置的客户端信息的 fd 字段设置为 -1，表示该客户端已下线
*/
online[index].fd = -1;
/*通知所有客户端，某个用户下线了
*遍历在线用户列表中的每个客户端，fd 不为 -1
*的客户端，向其发送某用户下线的通知消息buf
*/
sprintf(buf, "%s offline\n", online[index].name);
for (i = 0; i < MAX_USER_NUM; i++) {
if (online[i].fd == -1) {
continue;
}
write(online[i].fd, buf, strlen(buf));
}
return;
}
/*向所有在线用户广播消息*/
void broadcast(int index, struct protocol *msg) {
int i;
char buf[128] = {0};
sprintf(buf, "\033[0;34m\t%s say:%s\33[0m\n", online[index].name, msg->data);
for (i = 0; i < MAX_USER_NUM; i++) {
if ((online[i].fd == -1) || (i == index)) /*跳过不在线的和自己*/
{
continue;
}
write(online[i].fd, buf, strlen(buf));
}
}
/*用于判断准备登录的用户是否已经登录，并返回其在列表中的索引*/
int find_dest_user_online(int socket_fd, int *index, struct protocol *msg) {
int i;
/*遍历在线用户列表数组*/
for (i = 0; i < MAX_USER_NUM; i++) {
if (online[i].flage == -1) {
continue;
}
/*如果用户名和密码都匹配*/
if ((strcmp(msg->name, online[i].name) == 0) &&
(strcmp(msg->data, online[i].password) == 0))
{/*不在线的先建立服务器连接*/
if (online[i].fd == -1) {
online[i].fd = socket_fd;
*index = i;
return OP_OK;
} else {/*在线的打印已经登陆在线*/
printf("%s had login\n", online[i].name);
return USER_LOGED;/*用户已经登陆*/
}
}
}/*遍历完所有在线用户仍然没有找到匹配的用户*/
return NAME_PWD_NMATCH;
}
/*查找在线用户列表 online 中指定用户名*/
int find_dest_user(char *name) {
int i;
for (i = 0; i < MAX_USER_NUM; i++) {
if (online[i].flage == -1) {
continue;
}
if (strcmp(name, online[i].name) == 0) {
return i;
}
}
return -1;
}
/*私聊功能*/
void private(int index, struct protocol *msg) {
int dest_index;
char buf[128];
/*查找目标用户在在线用户列表 online 中的索引*/
dest_index = find_dest_user(msg->name);
if (dest_index == -1) {
/*向发送私聊请求的用户发送一条提示消息，告诉其该用户不在线*/
sprintf(buf, "there is no user :%s \n", msg->name);
write(online[index].fd, buf, strlen(buf));
return;
} else {
sprintf(buf, "\033[0;34m\t%s say to %s:%s\33[0m\n", online[index].name,
online[dest_index].name,
msg->data);
write(online[dest_index].fd, buf, strlen(buf));
return;
}
}
/*列出在线用户*/
void list_online_user(int index) {
int i;
struct protocol msg;
for (i = 0; i < MAX_USER_NUM; i++) {
/*如果该套接字已经关闭，则继续下一个循环*/
if (online[i].fd == -1) {
continue;
}
memset(&msg, 0, sizeof(msg));
msg.cmd = ONLINEUSER;
msg.state = ONLINEUSER_OK;
strcpy(msg.name, online[i].name);
printf("list online[%d].name =%s \n",i, msg.name);
/*向客户端发送在线用户结构体的数据*/
write(online[index].fd, &msg, sizeof(msg));
sleep(1);
}
/*表示在线用户列表已经全部发送完毕*/
msg.cmd = ONLINEUSER;
msg.state = ONLINEUSER_OVER;
/*用于通知客户端当前任务已完成，并结束本次传输*/
write(online[index].fd, &msg, sizeof(msg));
}
/*注册*/
void registe(int socket_fd, int *index, struct protocol *msg) {
int dest_index;
char buf[128];
struct protocol msg_back;
msg_back.cmd = REGISTE;
/*查找该用户名是否已经被其他用户注册*/
dest_index = find_dest_user(msg->name);
if (dest_index == -1) {
*index = add_user(socket_fd, msg);
online[*index].flage = 1;
msg_back.state = OP_OK;
printf("user %s regist success!\n", msg->name);
write(socket_fd, &msg_back, sizeof(msg_back));
return;
} else {/*用户名已存在*/
msg_back.state = NAME_EXIST;
printf("user %s exist!\n", msg->name);
write(socket_fd, &msg_back, sizeof(msg_back));
return;
}
}
/*登录*/
void login(int socket_fd, int *index, struct protocol *msg) {
int i, ret;
char buf[128];
struct protocol msg_back;
msg_back.cmd = LOGIN;
/*查找该用户名是否已经在线*/
ret = find_dest_user_online(socket_fd, index, msg);
if (ret != OP_OK) {/*不等于表示该用户名不存在或者该用户未登录*/
msg_back.state = ret;
strcpy(buf, " no this user\n");
printf("user %s login fail!\n", msg->name);
write(socket_fd, &msg_back, sizeof(msg_back));
return;
} else {/*登录成功*/
msg_back.state = OP_OK;
strcpy(msg_back.data, "login success\n");
printf("user %s login success!index =%d \n", msg->name, *index);
write(online[*index].fd, &msg_back, sizeof(msg_back));
}
// 通知所有客户端，某个用户上线了
sprintf(buf, "%s online\n", online[*index].name);
for (i = 0; i < MAX_USER_NUM; i++) {
if (online[i].fd != -1) {
write(online[i].fd, buf, strlen(buf));
}
}
}
void *func(void *arg) {
int socket_fd = *((int *)arg);
char buf[64];
int len;
int index = -1;
struct protocol msg;
free(arg);
/*进入聊天*/
while (1) {
/*read()函数和recv()函数都可以用于从套接字中读取数据，都会阻塞
*小于等于0说明未能成功读取任何数据或连接已关闭，因此用户被视为离线
*/
if ((len = read(socket_fd, &msg, sizeof(msg))) <= 0) {
printf("%s offline\n", online[index].name);
del_user_online(index);
close(socket_fd);
return;
}
switch (msg.cmd) {
case REGISTE:
registe(socket_fd, &index, &msg);
break;
case LOGIN:
login(socket_fd, &index, &msg);
break;
case BROADCAST:
broadcast(index, &msg);
break;
case PRIVATE:
private(index, &msg);
break;
case ONLINEUSER:
list_online_user(index);
break;
default:
break;
}
}
}
int main(int argc, char *argv[]) {
int ls_fd, new_fd;
int addr_len, clientaddr_len;
struct sockaddr_in my_addr;
struct sockaddr_in client_addr;
char buf[64] = {0};
pthread_t pid;
int *arg, i, port_number, ret;
/*判断输入命令行参数数量是否正确*/
if (argc != 2) {
fprintf(stderr, "Usage: %s [port_number]>5000\a\n", argv[0]);
exit(-1);
}
/*将第二个参数转换为整数类型并赋值给变量，然后判断输入的端口参数是否小于0*/
if ((port_number = atoi(argv[1])) < 5000) {
fprintf(stderr, "Usage: %s [port_number]>5000\a\n", argv[0]);
exit(-1);
}
/*原型：int socket(int domain, int type, int protocol);
*创建一个网络通信端点（打开一个网络通信），成功则返回一个网络文件描述符;调用失败，则会返回-1
*domain：AF_INET，协议族名字,代表IPv4互联网协议；如果用IPV6在后面加个6即可
*type:SOCK_STREAM,这是用于 TCP 协议
*protocol：0,表示为给定的通信域和套接字类型选择默认协议
*/
if ((ls_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
perror("socket() fail\n");
return;
}
/*将 server_addr 结构体变量所占用的内存区域全部清零。*/
memset(&my_addr, 0, sizeof(struct sockaddr_in));
/*指定套接字服务器的地址信息*/
/*表示使用 IPv4 地址*/
my_addr.sin_family = AF_INET;
/*端口号设置并将主机字节顺序转换为网络字节顺序*/
my_addr.sin_port = htons(port_number);
/*使用了宏 INADDR_ANY
* 来指定监听所有可用的网络接口,从而使得服务器能够接受到所有网络接口上的连接请求*/
my_addr.sin_addr.s_addr = htonl(INADDR_ANY);
addr_len = sizeof(struct sockaddr_in);
/*int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
*将参数 sockfd 指定的套接字与一个地址 addr 进行绑定，成功返回
*0，失败情况下返回-1 sockfd:网络文件描述符 addr:服务器结构体地址
*addrlen:addr参数所指向的结构体对应的字节长度
*/
if (bind(ls_fd, (struct sockaddr *)(&my_addr), addr_len) == -1) {
perror("bind() fail\n");
exit(-1);
}
/*int listen(int sockfd, int backlog);
*让服务器进程进入监听状态,监听sockfd描述符并创建一个等待连接队列，若执行成功则返回0，否则返回-1
*sockfd:要设置为监听状态的套接字描述符
*backlog:5,指定允许的连接数为
*5。如果有更多的客户端连接请求到达，它们将被服务器拒绝或忽略。
*/
if (listen(ls_fd, 5) == -1) {
fprintf(stderr, "listen error:%s\n\a", strerror(errno));
return;
}
clientaddr_len = sizeof(struct sockaddr_in);
/*初始化online结构体*/
for (i = 0; i < 64; i++) {
online[i].fd = -1;
online[i].flage = -1;
}
while (1) {
/*int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
*调用成功返回一个新的
*socket_fd描述符，用于与客户端通信的。如果发生错误或者连接被中断，则函数返回
*-1 函数成功返回时，addr 所指的缓冲区将被填充上客户端的地址信息，而 addrlen
*则会被更新为实际的地址信息长度
*调用时没有客户端请求连接（等待连接队列中也没有等待连接的请求），
*accept()会进入阻塞状态，直到客户程序建立连接
*/
if ((new_fd = accept(ls_fd, (struct sockaddr *)(&client_addr),
&clientaddr_len)) == -1) {
fprintf(stderr, "Accept error:%s\n\a", strerror(errno));
return;
}
/*char *inet_ntoa(struct in_addr in);
*将32位IP地址转换为点分十进制形式的字符串表示
*/
printf("Client-ip: %s\tport: %d\t\n", inet_ntoa(client_addr.sin_addr),
client_addr.sin_port);
/*用堆空间单独存放new_fd，防止高并发状态覆盖原栈空间的new_fd*/
arg = malloc(sizeof(int));
*arg = new_fd;
/*pthread_create(pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine) (void *),
void *arg);
*创建一个新的线程,返回 0
表示成功，否则返回一个非零的错误码，表示创建线程失败 *thread:线程标识符pid
*attr:指定线程的属性，如果传递了 NULL，则表示使用默认属性
*start_routine:是一个函数指针，用于指定线程启动时要执行的函数
*arg:传递给该函数的参数
*/
if ((ret = pthread_create(&pid, NULL, func, (void *)arg)) != 0) {
perror("pthread_create err");
return;
}
}
close(new_fd);
close(ls_fd);
exit(0);
} 客户端代码
#include "chat.h"
#include
#include
#include
#include
#include
#include
int socket_fd, addrlen;
struct sockaddr_in server_addr;
pthread_t pid;
int login_f = -1;
void *func(void *arg) {
int len;
char buf[128] = {0};
struct protocol *msg;
while (1) {
if (login_f != 1) {
continue;
}
memset(buf, 0, sizeof(buf));
if ((len = read(socket_fd, buf, sizeof(buf))) <= 0) {
close(socket_fd);
return;
}
msg = (struct protocol *)buf;
/*显示在线用户*/
if ((msg->state == ONLINEUSER_OK) && (msg->cmd == ONLINEUSER)) {
printf("%s\t", msg->name);
continue;
}
if ((msg->state == ONLINEUSER_OVER) && (msg->cmd == ONLINEUSER)) {
printf("\n");
continue;
}
buf[len] = '\0';
printf("%s\n", buf);
}
}
/*广播信息*/
void broadcast(int fd) {
struct protocol msg;
msg.cmd = BROADCAST;
printf("say:\n#");
scanf("%s", msg.data);
write(fd, &msg, sizeof(msg));
}
/*私聊信息*/
void private(int fd) {
struct protocol msg, msgback;
msg.cmd = PRIVATE;
printf("input name you want to talk:\n\t#");
scanf("%s", msg.name);
printf("\n#say:\n");
scanf("%s", msg.data);
write(fd, &msg, sizeof(msg));
}
/*显示在线人数*/
void list_online_user(int socket_fd) {
struct protocol msg;
msg.cmd = ONLINEUSER;
write(socket_fd, &msg, sizeof(msg));
while (1) {
read(socket_fd, &msg, sizeof(msg));
if (msg.state != ONLINEUSER_OK) {
getchar();
getchar();
break;
} else
printf("%s\r\n", msg.name);
}
}
/*注册*/
int registe(int fd) {
struct protocol msg, msgback;
msg.cmd = REGISTE;
printf("input your name\n");
scanf("%s", msg.name);
printf("input your passwd\n");
scanf("%s", msg.data);
write(socket_fd, &msg, sizeof(msg));
read(socket_fd, &msgback, sizeof(msgback));
if (msgback.state != OP_OK) {
printf("\033[0;31m\tName had exist,try again!\n");
getchar();
getchar();
return -1;
} else {
printf("\033[0;31m\tRegist success!\n");
getchar();
getchar();
return 0;
}
}
/*登陆*/
int login(int fd) {
struct protocol msg, msgback;
msg.cmd = LOGIN;
printf("input your name\n");
scanf("%s", msg.name);
printf("input your passwd\n");
scanf("%s", msg.data);
write(socket_fd, &msg, sizeof(msg));
read(socket_fd, &msgback, sizeof(msgback));
if (msgback.state != OP_OK) {
printf("\033[0;31m\tName had exist,maybe the password is wrong,try "
"again!\33[0m\n");
getchar();
getchar();
login_f = -1;
return NAME_PWD_NMATCH;
} else {
printf("\033[0;31m\tLogin success!\33[0m\n");
getchar();
getchar();
login_f = 1;
return OP_OK;
}
}
/*退出*/
int logout(int fd) {
close(fd);
login_f = -1;
}
int main(int argc, char *argv[]) {
int sel, ret;
int port_number;
int min_sel, max_sel;
struct protocol msg;
/* 检测参数个数*/
if (argc != 3) {
fprintf(stderr, "Usage:%s hostname portnumber\a\n", argv[0]);
exit(-1);
}
/*argv2 存放的是端口号 ，读取该端口，转换成整型变量*/
if ((port_number = atoi(argv[2])) < 5000) {
fprintf(stderr, "Usage:%s hostname [portnumber]>5000\a\n", argv[0]);
exit(-1);
}
/*创建一个 套接字*/
if ((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
fprintf(stderr, "Socket Error:%s\a\n", strerror(errno));
return;
}
/*填充结构体，ip和port必须是服务器的*/
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
/*转换为网络字节序*/
server_addr.sin_port = htons(port_number);
/*点分十进制表示的字符串形式转换成二进制 Ipv4 或 Ipv6 地址*/
server_addr.sin_addr.s_addr = inet_addr(argv[1]);
addrlen = sizeof(struct sockaddr_in);
if (connect(socket_fd, (struct sockaddr *)(&server_addr), addrlen) == -1) {
fprintf(stderr, "Connect Error:%s\a\n", strerror(errno));
return;
}
/*创建线程*/
if ((ret = pthread_create(&pid, NULL, func, NULL)) != 0) {
perror("pthread_create err");
return;
}
while (1) {
system("clear");
if (login_f == -1) {
printf(
"\033[0;33m+---------------------------------------------+\033[0m\n");
printf("\33[0;31m\t 1、 注册 \n\33[0m");
printf("\33[0;31m\t 2、 登录 \33[0m\n");
} else if (login_f == 1) {
printf(
"\033[0;33m+---------------------------------------------+\033[0m\n");
printf("\33[0;31m\t 3、 公聊\33[0m\n");
printf("\33[0;31m\t 4、 私聊\33[0m\n");
printf("\33[0;31m\t 5、 在线用户\33[0m\n");
}
printf("\33[0;31m\t 0、 退出\033[0m\n");
printf(
"\033[0;33m+---------------------------------------------+\033[0m\n");
fflush(stdin);
scanf("%d", &sel);
if (sel == 0) {
break;
}
if (login_f == 1) {
min_sel = 3;
max_sel = 5;
} else if (login_f == -1) {
min_sel = 1;
max_sel = 2;
}
if (sel < min_sel || sel > max_sel) {
printf("输入的数字不在范围内，请重新输入\n");
continue;
}
switch (sel) {
case 1:
registe(socket_fd);
break;
case 2:
login(socket_fd);
break;
case 3:
broadcast(socket_fd);
break;
case 4:
private
(socket_fd);
break;
case 5:
list_online_user(socket_fd);
break;
case 0:
logout(socket_fd);
break;
default:
break;
}
if (sel == 0) {
exit(0);
}
}
} 本项目学习于从0实现基于Linux socket聊天室-多线程服务器模型-1_一口Linux的博客-CSDN博客
从0实现基于Linux socket聊天室-多线程服务器一个很隐晦的错误-2_一口Linux的博客-CSDN博客从0实现基于Linux socket聊天室-多线程服务器一个很隐晦的错误-2_一口Linux的博客-CSDN博客
从0实现基于Linux socket聊天室-实现聊天室的公聊、私聊功能-4_一口Linux的博客-CSDN博客
一口Linux博主实力强悍、经验丰富、知识领域广，笔下文章内容丰富，大家可以点点关注