4.1本地聊天室fifo简单实现2015/7/27

最新推荐文章于 2021-07-29 11:02:49 发布
最新推荐文章于 2021-07-29 11:02:49 发布
阅读量3k 收藏 12
点赞数 2
分类专栏： linux学习笔记 文章标签： fifo linux编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a312024054/article/details/47112691
版权

这里写图片描述
1、服务器端要有一个公共的共享的管道，用来实现用户到服务器之间的通信，并创建一个链表，用于存储用户登录信息。
2、服务器端要跟每一个用户建立一个管道用于服务器与用户之间的通信，并且进行用户数据转发，当用户退出之后，这条管道自动删除。
3、数据包的格式，首先是协议号，源id，目标id，数据内容

服务端思路
1.先创建一个公共管道，接收客户端的消息
2.根据用户登陆后发出的第一个包来创建以用户名命名的管道文件
3.用一个链表来存储用户的登录列表，随时增添
4.根据用户发送数据包的id号来判定将要执行什么操作，1是登录，2是聊天，4.是退出登录
5.转发数据包，是直接发以目标用户名命名的管道文件，但首先要确认登录列表里面有没有目标用户。
6.随着用户发出退出登录的包，把用户的登陆信息，管道文件删掉

客户端思路
1.登陆的时候输入用户名
2.随着用户登录打开公共信道，向服务器发送登录消息，
3.一边接受服务器发来的消息，一遍等待用户输入信息
4.把用户的信息自动封装成数据包的格式发给服务器

服务器源代码：

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

int main(void)
{
    int fdserver;
    int len;
    char buff[100] = {0};
    struct list *im = creat_list();//用于接收用户的信息
    im->next = NULL;
    struct list *login = creat_list(); //用于存储登录列表
    login->next = NULL;

    if((fdserver = open("server", O_RDONLY|O_NONBLOCK)) < 0)
        sys_err("open fdserver");   //以不阻塞方式打开服务器共享管道

    while(1) {
        if((len = read(fdserver, im, sizeof(struct list))) < 0) {//读取用户发给服务器的数据
            if(errno != EAGAIN)
                sys_err("read fdserver");
        }   
        else 
            resolve(im->id, im, login); //解析这个数据包，根据协议号工作

        sleep(1);
    }

    close(fdserver);

    return 0;
}

客户端源代码：

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

int main(int argc, char *argv[])
{
    int fdserver;
    struct list *im = creat_list();
    im->next = NULL;
    char buff[100] = {0};

    if(argc < 2) {
        printf("./cil username\n");
        exit(1);
    }   
    if(strlen(argv[1]) > 4) {
        printf("username is to long, 4 Bytes\n");
        exit(1);
    }   

    //打开管道文件
    if((fdserver = open("server", O_WRONLY)) < 0)
        sys_err("open fdserver");

    change_list(im, 1, argv[1], "0", "0");//填写第一次发给系统的信息：

    if((write(fdserver, im, sizeof(struct list))) < 0)
        sys_err("write login information");

    //把标准输入改为非阻塞属性
    be_noblock(STDIN_FILENO);
    //把用户自己的管道文件改为非阻塞属性
    //be_noblock(fdclient);

    while(1) {
        //给服务器发信息
        if(comm_client(im, fdserver))
            printf("Invaild input\n");

        sleep(1);

        //接收服务器的信息
        if(im->id == 4) {   //如果是退出包，用户退出，关闭公共管道的文件描述符
            close(fdserver);
            printf("see you\n");
            return 0;
        }
        read_client(argv[1]);
    }

    return 0;
}

函数库

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

struct list {   //节点
    int id; 
    char src[5];
    char dest[5];
    char data[100];
    struct list *next;
};

struct list * creat_list() //创建链表
{
    return calloc(sizeof(struct list), 1); 
}

int  add_list(struct list *ls, int id, char *src, char *data) //添加链表元素
{
    struct list *p = ls; 
    while(p->next) {
        p = p->next;
    }   
    struct list *tmp = creat_list();

    tmp->next = p->next;
    p->next = tmp;
    tmp->id = id; 
    strcpy(tmp->src, src);
    strcpy(tmp->data, data);

    return 0;
}
int  change_list(struct list *ls, int id, char *src, char *dest, char *data) //修改链表元素内容
{
    struct list *tmp = ls;

    tmp->id = id;
    strcpy(tmp->src, src);
    strcpy(tmp->dest, dest);
    strcpy(tmp->data, data);

    return 0;
}
void show_list(struct list *ls) //遍历链表，打印出来
{
    struct list *p = ls;
    while(p) {
        printf("id = %d, src = %s, dest = %s, data = %s\n", p->id, p->src, p->dest, p->data);
        p = p->next;
    }
}

int del_list(struct list *login, char *src) //删除链表的元素
{
    struct list *ls = login;
    while(strcmp(ls->next->src, src))
        ls = ls->next;
    struct list *tmp = ls->next;

    if(ls->next->next == NULL)
        ls->next = NULL;
    else {
        ls->next = ls->next->next;
    }
    free(tmp);

    return 0;
}

int find_list(struct list *ls, char *name)  //查找链表中是否有寻呼的用户
{
    show_list(ls);
    struct list *login = ls;
    while(login) {
        if((strcmp(login->src, name)) == 0)
            return 0;   //存在，返回0
        login=login->next;
    }
    return -1;  //不存在返回-1
}

void sys_err(const char *str)
{
    perror(str);
    exit(1);
}

int resolve(int id, struct list *im, struct list * login)   //解析服务器接收到的数据
{
    int fdclient;

    switch (id) //根据数据包的id处理
    {
    case 1: //登录信息
        add_list(login,im->id, im->src, im->data);  //在链表中添加一个元素
        if((mkfifo(im->src, 0644)) < 0)  //创建服务器与用户之间通信的管道
            sys_err("mkfifo");
        break;

    case 2: //聊天包    
        if(find_list(login, im->dest) <0) {     //聊天包首先是查找用户是否在线
            printf("The user is not login\n");
        if((fdclient = open(im->src, O_WRONLY)) < 0) //如果存在，就打开对方的管道文件
            sys_err("open userfifo");
        write(fdclient, "Don't have this user\n", 21);
        close(fdclient);
            return -1;  //如果不在线就返回-1
        }
        char buff[105] = {0};
        if((fdclient = open(im->dest, O_WRONLY)) < 0) //如果存在，就打开对方的管道文件
            sys_err("open userfifo");
        sprintf(buff, "%s:%s\n", im->src, im->data);    //把要发给对方的数据写入buff内
        if((write(fdclient, buff, strlen(buff))) < 0)    //把buff写入对方的管道文件中，等待对方读取
            sys_err("write userfifo");
        close(fdclient);
        break;
    case 4: //退出
        unlink(im->src);    //退出，把用户的管道文件删除
        del_list(login, im->src);   //删除链表元素
        im->id = 0; //修改协议号，保证下次在没有用户输入的情况下也不会重复删除，导致段错误
        break;
    }
    return 0;
}

int  comm_client(struct list *im, int fdserver)   //用户输入数据并把它封装到结构体中去
{
    char buff[100] = {0};
    char dest_tmp[100];
    char *dest_name;
    int flags;
    int len;

    if((len = read(STDIN_FILENO, buff, sizeof(buff))) < 0) { //读用户输入的数据
        if(errno != EAGAIN)
            sys_err("read user input");
    }
    else  {   //如果len不小于0，说明有数据，如果有数据就把数据封装到结构体中去
        if((strcmp(buff, "quit\n")) == 0||(strcmp(buff,"exit\n") == 0)) { //如果用户输入quit或exit就向服务器发送一个id为4的包，是退出登录信息
            im->id = 4; //把id改为4
            write(fdserver, im, sizeof(struct list)); //给服务器发送信息
            return 0;
        }
        len = strlen(buff);
        if((len < 4) && (len > 0))
            return -1;

        if(strlen((dest_name = strtok(buff, ":"))) > 4) //判断用户的用户名不超过四个字节
            return -1;
        //当用户输入的内容不是上述这几种，那就按照正常的用户数据包发出
        im->id = 2; //然后把id置为2，说明是正常的数据
        strcpy(im->dest, dest_name);    //把对方的用户名放到dest这个结构体元素中去
        dest_name = strtok(NULL, ":");  //冒号后面是内容，放到data这个元素里面去
        strcpy(im->data, dest_name);
        printf("im->src = %s, im->dest = %s, im->data = %s\n", im->src, im->dest, im->data);
        write(fdserver, im, sizeof(struct list)); //给服务器发送信息

    }
    return 0;
}

void read_client(char *client_fifo)   //读取自己管道文件中服务器发给自己的文件
{
    int len;
    char buff[100] = {0};
    struct list *tmp = creat_list();
    int fdclient;

    if((fdclient = open(client_fifo,O_RDONLY|O_NONBLOCK)) < 0)   //打开以自己名字命名的管道文件
        sys_err("open userfifo");
    if((len = read(fdclient, buff, sizeof(buff))) < 0) {    //读管道中的
        if(errno != EAGAIN)
            sys_err("read data");
    }
    else
        write(STDIN_FILENO, buff, strlen(buff));    //打印到屏幕上
    return;
}

void be_noblock(int fd) //把文件设置为非阻塞
{
    int flags;
    if((flags = fcntl(fd, F_GETFL)) < 0)
        sys_err("fcntl");
    flags |= O_NONBLOCK;
    if((fcntl(fd, F_SETFL, flags)) < 0)
        sys_err("fcntl");
}

头文件

#ifndef __LIST_H_
#define __LIST_H_
struct list { //链表节点
    int id; 
    char src[5];
    char dest[5];
    char data[100];
    struct list *next;
};

struct list * creat_list(); //创建节点

//添加节点
int  add_list(struct list *ls, int id, char *src, char *data);

//修改节点
int  change_list(struct list *ls, int id, char *src, char *dest, char *data);

//遍历链表，打印出来
void show_list(struct list *ls);

//分析id号来辨别用户的操作
int resolve(int id, struct list *ls, struct list *login);

//接收用户输入，判别用户输入，然后把用户输入转换到im结构体里面      
int  comm_client(struct list *im, int fdserver);

//查找登录的用户中是否有这个用户存在
int find_list(struct list *ls, char *name);

//从用户自己的fifo文件中读取服务器发过来的数据
void read_client(char *); 

void be_noblock(int fd); //把文件设置为非阻塞
#endif

编译过程中遇到的问题
在修改文件阻塞属性的时候，该文件为空时也会返回EAGAIN这个数并且这个数小于0，所以要进行比较，如果返回值是EAGAIN这个数，那就不算出错，继续向下执行，如果不是EAGAIN，而且小于0执行出错行为。

if((len = read(STDIN_FILENO, buff, sizeof(buff))) < 0) { //读用户输入的数据
        if(errno != EAGAIN)
            sys_err("read user input");
    }

每个执行出错会设置errno出错码的函数一定会在下面加上perror，会有效的知道出错的地方，方便排错

小小初行者
关注
  • 2
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
fifo实现本地简单聊天程序
Linux_forker的博客
08-29 2659
最近做了一个小练习，要求如下： 1.设计协议 2.客户端只写公共管道，向服务端发信息 3.客户端只读私有管道，接收信息。 4.服务端维护用户登录列表 详细如图： 1.server#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <s
用FIFO实现A／D与ARM处理器的接口
12-03
下面就介绍如何利用FIFO芯片CY7C4255V实现高速高精度模／数转换器AD767l与LPC2200系列ARM处理器的接口。  1 器件简介  1.1 模／数转换器AD7671   AD767l是采样速率达1Msps的16位逐次逼近型高速高精度模／数...
利用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 /**************************************************************************/
Linux小练习(2)----利用FIFO实现本地聊天室（C/S模式）
孔晨瑞的博客
03-12 1292
程序：利用FIFO实现本地聊天室 程序功能：实现本地进程间的相互通信 程序分析：通过FIFO管道可以实现本地（本机）上无血缘关系（进程不是fork()出来的）的进程间的通讯，而FIFO管道支持“一写多读”，“多写一读”。我们可以利用这一特点建立本地聊天室的模型。 服务器提供一条公共的管道，各个客户端通过这条公共管道发送消息给服务器，服务器接收到消息后，对消息包进行解析后交给相应的函数处理...
Linux下利用FIFO+Thread实现聊天
少言才不会咸's Tech-blog
12-02 560
/*client1_str.c*/ #include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #include <string.h> #include <errno.h> #include <pthread.h> #include <unistd.h>
一个本地聊天的一个项目，很有意思的一个项目
刘子君编程路子与生活一致
11-17 400
1.软件分为服务器端和客户端，客户端又有多个，服务器与多个客户端都可进行通信，并且多个客户端也可互相通信。 2.服务器端和客户端通过管道实现数据的传输，服务器端收到客户端发来的数据包之后对其进行解析，并按照数据包中的请求做出相应的处理。 项目收获：掌握和深入理解了多进程、多线程机制和管道的操作，熟练运用socket，listen，bind，accept等的编程应用。
用FIFO实现超声测厚系统A/D与ARM接口设计
01-20
在高频超声波数据采集系统中，很多高速A／D转换器往往不能直接与处理器相连接，这时就需要使用FIFO在处理器与A／D转换器之间架一座桥梁，FIFO的先入先出特性可以方便缓存大量的数据块。在基于ARM的超声波测厚系统中...
基于SRAM/DRAM的大容量FIFO的设计与实现
12-10
1 引言FIFO(First In First Out)是一种具有先进先出存储功能的部件。在高速数字系统当中通常用作数据缓存。在高速数据采集、传输和实时显示控制领域中．往往需要对大量数据进行快速存储和读取，而这种先进先出的结构...
ram+fifo_ram/fifo_
10-02
本项目结合了这两种存储机制，创建了一个名为"ram+fifo_ram/fifo_"的综合解决方案，旨在实现更高效、灵活的数据管理和处理。 首先，同步FIFO是一种常见的数字逻辑设计组件，用于存储并顺序传输数据流。它通常包括两...
用FIFO实现A/D与ARM处理器的接口
02-03
用FIFO实现A/D与ARM处理器的接口、电子技术,开发板制作交流
本地聊天软件，可以在本地聊天
06-02
可以在本地聊天，这个是用C#写的，可以在本地聊天，这个是用C#写的可以在本地聊天，这个是用C#写的
FIFO编写QQ聊天功能
11-10
开启管道mkfifo fifo1 fifo2 make或者gcc chat.c 得到a.out或者其他文件 ./a.out 1登录账号 在另一终端./a.out 2登录账号2 即可相互聊天
基于Linux消息队列的简易聊天室(C语言)(附源代码)
12-01
采用客户-服务器结构，其中服务器实现各个用户的登录并存储相关信息，客户端通过服务器端获取当前登录用户信息，然后各客户进程通过消息队列实现双向通信。 Linux IPC通信利用消息队列消息机制，多线程通信，字符串处理，链表操作，信号简单处理。消息队列是System V支持一种IPC机制，通过类似链表的操作向一个FIFO里通过msgsnd发送用户自定义数据，进程可以通过msgrcv来接收指定类似mtype的数据，从而实现进程间通信。 在服务器端实现广播功能，以及服务器退出以后通知；所有客户端退出并删除消息队列功能；对所有客户端的统计由链表实现 在客户端实现：上线提醒，下线提醒，服务器断线后子进程都退出。
实现一个简易聊天室(一)
moernagedian的博客
07-29 697
三次握手建立连接时，发送方再次发送确认的必要性？
简单实现本地QQ聊天器(最简单版本)
qq_31238727的博客
08-08 1029
之前老师为了讲"socket"套接字,讲了一遍如何实现一个简单版本的QQ聊天器,今天复习了一遍,觉得有些地方的知识点还是没有掌握的很好,于是来一篇博客压压惊 先简单介绍一下”socket”套接字: 在客户/服务器通信模式中, 客户端需要主动创建与服务器连接的 Socket(套接字), 服务器端收到了客户端的连接请求, 也会创建与客户连接的 Socket. Socket可看做是通信连接两端的收发器,
一对一通信（自制本地QQ聊天器）
春分笑桃花的博客
05-25 454
一对一通信（自制本地QQ聊天器） 客户端代码： import java.awt.BorderLayout; import java.awt.Color; import java.awt.Dimension; import java.awt.Font; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; i...
java 类似QQ的本地聊天室程序实现（上）(客户端程序)
王文强的博客
05-10 1351
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.OutputStreamWriter; import java.io.
IOS网络开发（一）
weixin_30802171的博客
12-15 148
1 简易的聊天工具 1.1 问题 Socket的英文原义是孔或者插座的意思，通常也称作套接字，用于描述IP地址和端口，是一个通信链的句柄，本案例使用第三方Socket编程框架AsyncSocket框架实现一个简易的聊天工具，并且能够进行文件传输，由于没有服务器本案例将服务器端和客户端写在一个程序中，如图-1所示： 图-1 1.2 方案 首先创建一个SingleViewApplic...
linux下gcc参数的使用以及编译过程
a312024054的专栏
07-20 4559
gcc的使用-v / --v / --version 查看gcc版本号-I目录 指定头文件目录，注意-I和目录之间没有空格-c 只编译，生成.o文件，不进行链接-g 包含调试信息-On n=1~3 编译优化，n越大优化的越多-Wall 提示更多告警信息（严格编译)-D<DEF> 编译时定义宏，注意-D和<DEF>之间没有空格-E 生成预处理文件，一般是.i文件,(展开头文件，替换宏
(完整word版)操作系统课程设计-页面置换算法C语言.pdf
07-07
这些算法的设计目的是理解进程运行时内存管理策略，考察不同算法的优缺点，如FIFO简单直观但可能导致长驻留时间的页面被频繁替换，而LRU则倾向于优先淘汰长时间未被访问的页面。 实验目标涵盖了多个关键知识点，如...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值