简易聊天室：命名管道实现

最新推荐文章于 2022-10-28 00:03:11 发布
最新推荐文章于 2022-10-28 00:03:11 发布
阅读量297 收藏 3
点赞数 2
分类专栏： Linux coding 文章标签： linux fifo client server
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46143974/article/details/113728008
版权

目的

通过命名管道实现简易聊天室功能，能通过一个服务器程序，可以实现多个客户端程序之间的通信。

思路

在这里插入图片描述

创建两个结构体成员message、list，分别表示消息包和已登录者信息

struct message{
	unsigned int  pid;	//发送者的PID
	char type;			//消息类型
	char send[8];		//发送者用户名
	char receive[8];	//接收者用户名
	char data[30];		//消息内容
};
message.type为‘0’表示服务器消息、‘1’表示用户消息、‘2’表示客户端退出登录

struct list{
	int pid;
	int fd;
	char name[8];
	struct list *next;
};
登录者信息采用链表存储，方便查看接收者是否在聊天室中，也方便频繁的添加和删除用户信息。
服务器端:
  1. 创建并打开公共FIFO
  2. 初始化链表list
  3. 无阻塞读取公共FIFO中的数据
  4. 判断读取到的message结构体，做出相应动作
  5. 无限循环接收消息
客户端：
  1. 创建并打开一个以用户名命名的专用FIFO
  2. 将标准输入设置为无阻塞
  3. 向公共FIFO发送一个登录消息，使得在服务器l的list链表上添加该用户的详细信息
  4. 无限循环处理消息
  5. 无阻塞读取标准输入
  6. 将输入的消息打包成message结构体发送给服务器
  7. 无阻塞读取并处理私有FIFO的数据

源代码

server.c：

#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <sys/mman.h>

#define TRUE  1
#define FALSE 0

typedef char BOOL;

void print_line(void){
	printf("#####################\n");
}

struct message{
	unsigned int  pid;
	char type;
	char send[8];
	char receive[8];
	char data[30];
};

struct list{
	int pid;
	int fd;
	char name[8];
	struct list *next;
};

void del_node(struct list* root,int id){
	struct list *p=malloc(sizeof(struct list));
	struct list *q=p;
	p->pid=id+10;
	p->next=root;
	while(p->next){
		if(p->next->pid==id){
			p=p->next->next;
			break;
		}else{
			p=p->next;
		}
	}
	root=q->next;
}

void add_node(struct list* root,int id,char* string){
	struct list *p=root;
	struct list *q=malloc(sizeof(struct list));
	q->pid=id;
	strcpy(q->name,string);
	q->next=NULL;
	while(p->next)
		p=p->next;
	p->next=q;
}

BOOL check_list(struct list* root,char* string){
	struct list *p=root;
	while(p){
		if(strcmp(p->name,string)==0){
			return TRUE;
		}
		p=p->next;
	}
	return FALSE;
}

int main(void){
	int fd_public,fd_private,ret;

	//创建服务器管道并打开
	fd_public=mkfifo("server_fifo",0644);
	if(fd_public==-1){
		perror("mkfifo(server_fifo)");
		exit(1);
	}
	fd_public=open("server_fifo",O_RDWR);
	if(fd_public==-1){
		perror("open(server_fifo)");
		exit(1);
	}

	struct message *tip=malloc(sizeof(struct message));
	struct message *buff=malloc(sizeof(struct message));
	struct list *root=malloc(sizeof(struct list));
	//初始化登录信息链表
	root->pid=getpid();
	root->fd=0;
	root->next=NULL;
	strcpy(root->name,"SERVER");
	
	tip->pid=getpid();
	strcpy(tip->send,"SERVER");

	const char tip1[30]={"Login successful\n"};
	const char tip2[30]={"Friends not logged in\n"};
	const char tip3[30]={"You have logged in\n"};


	while(1){
		memset(buff,0,sizeof(struct message));
		print_line();
		if((ret=read(fd_public,buff,sizeof(struct message)))==-1){
			perror("read fifo error:");
			exit(1);
		}
		if(ret<=0){
			continue;
		}
		printf("pid:%d\ntype:%c\nsend:%s\nreceive:%s\ndata:%s\n",buff->pid,buff->type,buff->send,buff->receive,buff->data);
		print_line();

		if(buff->type=='0'){
			tip->type='0';
			strcpy(tip->receive,buff->send);

			strcpy(tip->data,tip1);
			printf("[SERVER]Login successfully\n");
			add_node(root,buff->pid,buff->send);

			//send message
			if((fd_private=open(buff->send,O_RDWR))==-1){
				perror("open(private_fifo)");
				exit(1);
			}
			if((ret=write(fd_private,tip,sizeof(struct message)))==-1){
				perror("write(private_fifo)");
				exit(1);
			}
		}else if(buff->type=='1'){
			//check receive status
			if(check_list(root,buff->receive)){
				printf("sending...\n");
				strcpy(tip->data,buff->data);
				strcpy(tip->send,buff->send);
				tip->type='1';
				//send message
				if((fd_private=open(buff->receive,O_RDWR))==-1){
					perror("open(private_fifo)");
					exit(1);
				}
				if(write(fd_private,tip,sizeof(struct message))==-1){
					perror("write(private_fifo)");
					exit(1);
				}
			}else{
				printf("receive don't login in\n");
				strcpy(tip->data,tip2);
				strcpy(tip->send,"SERVER");
				tip->type='0';
				//send message
				if((fd_private=open(buff->send,O_RDWR))==-1){
					perror("open(private_fifo)");
					exit(1);
				}
				if(write(fd_private,tip,sizeof(struct message))==-1){
					perror("write(private_fifo)");
					exit(1);
				}
			}
		}else if(buff->type=='2'){
			printf("delete node...\n");
			del_node(root,buff->pid);
		}else{
			//nothing
		}
	}
	return 0;
}

client.c：

#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <sys/mman.h>

void print_line(void){
	printf("##################\n");
}

struct message{
	unsigned int pid;
	char type;
	char send[8];
	char receive[8];
	char data[30];
};

int main(int argc,char* argv[]){
	if(argc<2 || strlen(argv[1])>8){
		printf("Input error!\n");
		exit(1);
	}

	int flags,fd_public,fd_private,ret,ret2;
	char info[38];
	struct message *buff=malloc(sizeof(struct message));
	struct message *p=malloc(sizeof(struct message));
	buff->pid=getpid();
	buff->type='0';
	strcpy(buff->send,argv[1]);
	strcpy(buff->receive,"server");
	strcpy(buff->data,"login");
	
	if(mkfifo(buff->send,0644)==-1){
		perror("mkfifo(private_fifo)");
		exit(1);
	}
	fd_public=open("server_fifo",O_RDWR);
	if(fd_public==-1){
		perror("open(server_fifo)");
		exit(1);
	}
	fd_private=open(buff->send,O_RDONLY|O_NONBLOCK);
	if(fd_private==-1){
		perror("open(private_fifo)");
		exit(1);
	}

    if((flags = fcntl(STDIN_FILENO, F_GETFL)) < 0)
        perror("fcntl");
    flags |= O_NONBLOCK;
    if((fcntl(STDIN_FILENO, F_SETFL, flags)) < 0)
        perror("fcntl");

	if(write(fd_public,buff,sizeof(struct message))==-1){
		perror("write login(server_fifo)");
		exit(1);
	}


	while(1){
		memset(info,0,sizeof(info));

		ret=read(STDIN_FILENO,&info,sizeof(info));
		if(ret>0){
			if(strcmp(info,"quit")==0){
				printf("goodbye!\n");
				buff->type='2';
				//send my message
				if(write(fd_public,buff,sizeof(struct message))==-1){
					perror("write(server_fifo)");
					exit(1);
				}
				exit(1);
			}else{
				int i=0;
				while(i<8){
					if(info[i]==':'){
						break;
					}
					i++;
				}
				if(i==8){
					printf("input receive name error!\n");
					memset(info,0,sizeof(info));
					continue;
				}else{
					memset(buff->receive,0,sizeof(buff->receive));
					strncpy(buff->receive,info,i);
					strcpy(buff->data,&info[i+1]);
					//printf("buff->send:%s\nbuff->receive:%s\nbuff->data:%s\n",buff->send,buff->receive,buff->data);
				}
				buff->type='1';
				buff->pid=getpid();
				strcpy(buff->send,argv[1]);
			}

			//send my message
			if(write(fd_public,buff,sizeof(struct message))==-1){
				perror("write(server_fifo)");
				exit(1);
			}
		}

		//read!
		if((ret2=read(fd_private,p,sizeof(struct message)))<0){
			if(errno != EAGAIN)
				perror("read(private_fifo)");
		}else if(ret2>0){
			if(p->type==48){
				printf("[SERVER]:%s",p->data);
			}else if(p->type==49){
				printf("[%s]:%s",p->send,p->data);
			}
		}
		//write(STDOUT_FILENO,p,sizeof(p));
	}
	return 0;
}

如有错误，请指正！

两点半选手
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
利用可命名管道实现简易本地聊天室
weixin_45217107的博客
04-22 485
说明 ①虽然说是本地聊天室，但是由于个人能力的原因，只是实现了两个客户端的通信。 服务器客户端介绍 ①服务器编写中先定义三个管道，以及进行宏定义。然后定义文件描述符，和读写buf。创建一个公共管道，并对其进行属性设置，并依照次上述步骤，分别完成对私有管道1和私有管道2的设置。接下来循环执行功能，首先进行打开，然后进行判断为哪个客户端。若为客户端1，打开私有管道1，然后接收信息，并输出在屏幕上。 ②...
用命名管道实现进程间的通信-----简单聊天室的建立
maizi_hsx的博客
11-27 2605
本篇博文讲的是用两个命名管道实现简单聊天室的建立，本质上就是进程间的通信 程序共有四部分组成：命名管道myfifo 命名管道yourfifo 服务器端 客户端 功能实现过程：服务器端父进程往myfifo中写数据      客户端子进程从myfifo中读取服务器端父进程发送来的数据    客户端父进程往yourfifo中写数据     服务器端子进程从yourfifo中读取客户端父进
利用命名管道实现简单聊天功能
编程小镇
01-17 502
利用命名管道实现简单聊天功能 进程A： 以只写方式打开FIFO1 以只读方式打开FIFO2 循环读写数据 进程B： 以只读方式打开FIFO1 以只写方式打开FIFO2 循环读写数据 chata.c如下 #include <stdio.h> #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <stdlib.h> #include <fcnt
命名管道实现点对点聊天程序
01-11
利用命名管道实现本机两个进程之间通信。一个服务器，一个客户端。可以通过修改管道的名字实现网络通信（参照管道的命名方法），并且可以通过修改服务器创建管道时的参数，实现服务器与多个客户之间的的通信。 相对于Socket编程，通过命名管道的实现方法更简单，尤其适用于客户端少且数据量大的场合，而且在单机不同进程间通信方面也比用Socket更优。
Linux下利用命名管道实现简单的聊天室
TOmyLord的博客
09-21 1128
1、服务器端 ①先建立一个Sever_FIFO文件 用于接收来自不同客户端的数据，所有客户端的数据都会发送至这个文件，经过处理后再转存到别的文件之后才会发送到另一个客户端上。 ②利用结构体传输过来客户端的pid，并将pid存在pid【】数组中，pid的值是用来区分将信息回传的依据。 ③通过简单的pid区分传来的结构体中的数据应该回传的文件，并将数据写入该文件。不停的重复此步骤。 2
python实现的简易版QQ聊天室系统
06-28
python实现的简易版QQ聊天室系统，界面简洁干净，可实现多人聊天室。方便易用，也适合学习用，非常适合初学者练手小项目，加深python知识以及如何做项目。也可以在此基础上扩展自己的功能，实现更复杂的功能。
javascript实现简易聊天室
10-16
本文将详细介绍如何使用JavaScript实现一个简易的聊天室功能。这个聊天室的基本结构包括HTML、CSS和JavaScript三个部分，适合初学者理解和实践JavaScript在网页交互中的应用。 首先，我们来看HTML部分。聊天室的...
java+swing简易聊天室
最新发布
07-20
## 使用JAVA语言实现简易聊天室（本程序含有GUI图形界面） ### (1)、服务器要求1：能够看到所有在线用户 ### (2)、服务器要求2：能够强制用户下线 ### (3)、客户端要求1：能够看到所有在线用户 ### (4)、客户端要求2...
简易聊天室_聊天室_
09-29
【简易聊天室_聊天室_】是一个实现两台主机间通信的应用程序，它允许用户通过互联网进行实时对话。这个项目的核心在于构建一个简单的聊天环境，让用户能够交换各种类型的数据，包括数字、字符、汉字和英文字母。在IT...
使用命名管道实现单机双人聊天
explore_world的博客
07-19 599
/********************************************************************************** 命名管道 (FIFO) 利用命名管道实现单机双人聊天 提示： 父进程创建子进程，实现多任务。父进程负责发信息(向FIFO里写数据)，子进 程负责接收信息( ...
利用LINUX FIFO命名管道技术实现双向聊天的C语言源代码
08-12
/**************************************************************************/ //本程序是利用LINUX FIFO命名管道技术实现双向聊天的C语言源代码。 //优点：代码简洁明了。 //其中： //chat.c: 聊天源代码。 //makefile: 利用宏定义，把一个源码生成两个不同的可执行程序。 // //使用： //make clean 清除上次编译生成的结果文件。 //make 重新编译生成两个可执行程序。./a_chat和./b_chat的执行顺序没有先后。 //作者：david.q@sz 2012-8-11 2263537@qq.com /**************************************************************************/
用消息队列，实现聊天程序
10-14
用消息队列，实现聊天程序用消息队列，实现聊天程序，每次发言后自动在后面增加当前系统时间。增加结束字符，比如最后输入“88”后结束进程。
一个简单的聊天程序--命名管道FIFO
weixin_33962621的博客
09-27 475
本程序是一个使用FIFO进行进程间通信的典型程序lucy.c创建了FIFO write──fifo用于向程序peter.c发送信息：程序创建了FIFO read-fifo，用于向lucy.c发送消息。编译本程序，先运行peter.c再运行lucy.c就可以了。 源程序如下： //filename:lucy.c #include<sys/types.h> #include...
Linux管道用什么来实现的,linux利用管道来实现本地聊天室
weixin_39964573的博客
05-14 78
//server.c#include "Packet.h"#include #include #include #include #include #include #include #include void sys_err(char *str, int exitno){perror(str);exit(exitno);}int find(char *Name, char LoginList[1...
命名管道（FIFO）聊天程序
xhjcehust的专栏
07-20 1517
{CSDN:CODE:202} {CSDN:CODE:201}
C语言有名管道实现简单聊天
ma_de_hao_mei_le的博客
02-22 630
程序1： #include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <stdlib.h> #include <unistd.h> #include <fcntl.h> #include <string.h> int main() { // 使用两条有名管道，实现简单的聊天功能 // 进程1 // 以只写方式打
linux下使用命名管道实现的聊天室
weixin_44284357的博客
12-09 379
linux下使用IPC实现的聊天室 做这个纯粹是为了联系命名管道的使用，先来看看效果图吧！ 从图里面看，实现聊天室的基本功能，如消息收发，用户离开提醒。
Linux有名管道学习——实现两个进程的简单聊天
qq_51011672的博客
10-28 1281
为了克服匿名管道只能用于亲缘关系的进程间通信缺点，提出了有名管道（FIFO），也叫命名管道、FIFO文件一旦打开了FIFO，就能在它上面使用与操作匿名管道和其他文件的系统调用一样的I/O系统调用了（如read()、write()和close()）。与管道一样，FIFO也有一个写入端和读取端，并且从管道中读取数据的顺序与写入的顺序是一样的。FIFO的名称也由此而来：先入先出。通过命令创建有名管道mkfifo 名字通过函数创建有名管道关于mkfifo函数pathnamemode0-1openreadread。
【Linux程序设计第三版】利用消息队列实现聊天程序
yuyanhaonan的博客
06-02 1315
设计两个程序，要求用消息队列实现聊天程序，每次发言后自动在发言内容后面增加系统时间。程序结束时增加结束字符，比如最后输入“88”后结束进程
java实现简易聊天室
05-01
本文主要介绍了一个使用Java语言实现的简易聊天室。该聊天室通过巩固所学Java语言基本知识，掌握JDK、JCreator等开发工具的运用，拓宽常用类库的应用，实现了图形界面、线程、流与文件等技术的综合应用。 首先，该...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值