当前位置： 首页 > article >正文

【C-实践】一对一的远程通信（tcp+epoll）

article 2024/11/19 14:00:03

技术


使用tcp+epoll实现的远程通信



功能


  • 服务器只能与单一的客户端进行信息交互
  • 如果服务器连接了多个客户端，由于是单一进程无法同时对多个客户端回复，但可以群发信息


启动


启动服务器

1、在bin目录下生成可执行文件

w@Ubuntu20:bin $ gcc ../src/*.c -o server

2、启动服务器

w@Ubuntu20:bin $ ./server ../conf/server.conf

启动客户端

1、在客户端的目录下生成可执行文件

w@Ubuntu20:Chat3_client $ gcc client.c -o client

2、启动客户端

w@Ubuntu20:Chat3_client $ ./client 192.168.160.129 2000


服务器


目录设计

w@Ubuntu20:Chat3_server $ tree
.
├── bin
│   └── server
├── conf
│   └── server.conf
├── include
│   └── tcp.h
└── src
    ├── interact.c
    ├── server.c
    └── tcp_init.c

4 directories, 6 files


配置文件 server.conf

存放ip地址和port端口，自行更改

192.168.160.129
2000


头文件

#ifndef __TPC_H__
#define __TPC_H__

//检查命令行参数个数
#define ARGS_CHECK(argc, num) { if (argc != num) {\
    fprintf(stderr, "Args error!\n"); return -1; }}

//检查系统调用返回值是否合法，非法报错退出
#define ERROR_CHECK(ret, num, msg) { if (ret == num) {\
    perror("msg");  return -1;  } }

//输入：配置文件（服务器的ip地址，端口号）
//输出：绑定了服务器ip和端口的，正在监听的套接字
int tcp_init(char *conf);

//服务端与客户端的交互
int interact_cli(int sfd);


#endif


源文件

主程序 server.c

#include "../include/tcp.h"
#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
    //命令行参数：配置文件
    ARGS_CHECK(argc, 2);

    //得到一个已绑定服务器ip和port的，正在监听的，tcp类型套接字
    int sfd = tcp_init(argv[1]);
    if (-1 == sfd) {
        return -1;
    }
    printf("The server is listening...\n");

    //与客户端交互，用epoll管理所有文件描述符
    interact_cli(sfd);

    //关闭服务器套接字
    close(sfd);
    printf("The server is closed!\n");
    return 0;
}


初始化服务器套接字 tcp_init.c

#include "../include/tcp.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <arpa/inet.h>

//输入：配置文件(服务器的ip地址，端口号)
//输出：绑定了服务器ip和端口的，正在监听的套接字
int tcp_init(char *conf)
{
    //从配置文件中读取服务器的ip和端口
    FILE* fp = fopen(conf, "r"); 
    char ip[128] = {0};
    char port[128] = {0};
    fscanf(fp, "%s%s", ip, port);
    printf("ip = %s, port = %s\n", ip, port);
    fclose(fp);
    
    //生成一个tcp类型的套接字
    int sfd = socket(AF_INET, SOCK_STREAM, 0);
    ERROR_CHECK(sfd, -1, "ser_socket");

    //将套接口设置为可重用, 不用再等待重启时的TIME_WAIT时间
    int reuse = 1;
    setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));

    //给套接字绑定服务端ip和port
    struct sockaddr_in serverAddr;
    memset(&serverAddr, 0, sizeof(struct sockaddr_in));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = inet_addr(ip);
    serverAddr.sin_port = htons(atoi(port));

    int ret = bind(sfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
    ERROR_CHECK(ret, -1, "ser_bind");

    //将套接字设为监听模式，并指定最大监听数（全连接队列的大小）
    ret = listen(sfd, 10); 
    ERROR_CHECK(ret, -1, "ser_listen");

    return sfd;
}


与客户端的交互文件 interact.c

#include "../include/tcp.h"
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include <sys/socket.h>
#include <sys/epoll.h>

//接受所有客户端的信息，并显示在终端
//将信息发送给所有客户端
int interact_cli(int sfd)
{
    /* //得到一个客户端套接字，用于通信 */
    /* int cfd = accept(sfd, NULL, NULL); */
    /* ERROR_CHECK(cfd, -1, "accept"); */

    int ret = -1;

    //使用epoll管理所有文件描述符
    int epfd = epoll_create(1);

    //将读事件注册进epfd
    struct epoll_event event;
    memset(&event, 0, sizeof(event));
    event.events = EPOLLIN;

    //将标准输入添加进epfd
    event.data.fd = STDIN_FILENO;
    ret = epoll_ctl(epfd, EPOLL_CTL_ADD, STDIN_FILENO, &event);
    ERROR_CHECK(ret, -1, "epoll_add_stdin");

    //将sfd添加进epfd
    event.data.fd = sfd;
    ret = epoll_ctl(epfd, EPOLL_CTL_ADD, sfd, &event);
    ERROR_CHECK(ret, -1, "epoll_add_sfd");

    char buf[128] = {0};//读写缓冲区
    int readyFdNum = 0;//就绪的文件描述符数量
    struct epoll_event evs[2]; //epoll_wait等待数组的大小
    int newfd = 0;//客户端的套接字

    //epoll等待就绪的文件描述符
    while (1) {
        readyFdNum = epoll_wait(epfd, evs, 2, -1);
        ERROR_CHECK(readyFdNum, -1, "epoll_wait");

        for (int i = 0; i < readyFdNum; ++i) {
            //标准输入就绪，发消息给客户端
            if (evs[i].data.fd == STDIN_FILENO) {
                memset(buf, 0, sizeof(buf));
                ret = read(STDIN_FILENO, buf, sizeof(buf) - 1);
                ERROR_CHECK(ret, -1, "read");

                /* //给最后一个连接的客户端发消息 */
                /* send(newfd, buf, strlen(buf) - 1, 0); */

                //群发消息给客户端
                //最小的客户端套接字是4
                //0-标准输入，1-标准输出，2-标准错误输出，3-sfd
                for (int i = 4; i <= newfd; ++i) {
                    send(i, buf, strlen(buf) - 1, 0);
                }
            }

            //服务端套接字就绪，有新的客户端申请连接
            //将其加入进epfd
            else if (evs[i].data.fd == sfd) {
                //newfd指向最后一个客户端套接字
                //每次accept都会更新newfd
                newfd = accept(sfd, NULL, NULL);
                event.data.fd = newfd;
                ret = epoll_ctl(epfd, EPOLL_CTL_ADD, newfd, &event);
                ERROR_CHECK(ret, -1, "epoll_add_newfd");
            }

            //客户端套接字就绪，读取并打印在终端
            else  {
                memset(buf, 0, sizeof(buf));
                //接受信息，如果收不到信息，表示客户端断开
                ret = recv(evs[i].data.fd, buf, sizeof(buf) - 1, 0);
                ERROR_CHECK(ret, -1, "recv");
                if (0 == ret) {
                    //对端已断开, 退出监听
                    printf("client exit!\n");
                    close(evs[i].data.fd);
                    return 0;
                }
                //将信息输出在终端
                printf("cli: %s\n", buf);
            }
        }
    }
    return 0;
}




客户端

client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>

//检查命令行参数个数                                          
#define ARGS_CHECK(argc, num) { if (argc != num) {\
    fprintf(stderr, "Args error!\n"); return -1; }}

//检查函数返回值是否合法，非法报错退出
#define ERROR_CHECK(ret, num, msg) { if (ret == num) {\
    perror("msg");  return -1;  } }


//输入：服务端的ip，和port
//输出：连接到服务端的套接字
int tcp_connect(char *ip, char *port)
{
    //创建一个tcp类型的套接字
    int sfd = socket(AF_INET, SOCK_STREAM, 0);
    ERROR_CHECK(sfd, -1, "cli_socket");

    struct sockaddr_in serverAddr;
    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = inet_addr(ip);
    serverAddr.sin_port = htons(atoi(port));

    //用套接字连接服务器
    int ret = connect(sfd, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
    ERROR_CHECK(ret, -1, "connect");

    return sfd;
}

//与服务端交互
int interact_sfd(int sfd)
{
    //定义一个读操作集合
    fd_set rdset;
    FD_ZERO(&rdset);

    char buf[128] = {0};//读写缓冲区
    int ret = -1;
    while (1) {
        //每次select前，重置读集合，因为select会修改读集合（将未就绪的文件描述符置为0）
        FD_SET(STDIN_FILENO, &rdset);
        FD_SET(sfd, &rdset);

        //select阻塞在此，等待集合中任意一个文件描述符就绪后，解除阻塞
        //select接触阻塞后，找就绪的文件描述符，需要遍历集合（位图）去找
        ret = select(sfd + 1, &rdset, NULL, NULL, NULL);
        ERROR_CHECK(ret, -1, "select");

        //服务端套接字就绪，表示服务端有数据到来，接收并打印在终端
        if (FD_ISSET(sfd, &rdset)) {
            memset(buf, 0, sizeof(buf));
            ret = recv(sfd, buf, sizeof(buf) - 1, 0);
            if (0 == ret) {
                //服务端已关闭
                printf("server exit\n");            
                return -1;
            }
            printf("ser: %s\n", buf);
        }

        //标准输入就绪，接收并发送给服务端
        if (FD_ISSET(STDIN_FILENO, &rdset)) {
            memset(buf, 0, sizeof(buf));
            read(STDIN_FILENO, buf, sizeof(buf) - 1);
            send(sfd, buf, strlen(buf) - 1, 0);
        }
    }
}

int main(int argc, char *argv[])
{
    //参数：服务器的ip和端口
    ARGS_CHECK(argc, 3);

    //得到一个可以与服务端通信的套接字
    int sfd = tcp_connect(argv[1], argv[2]);
    printf("Already connect the server(ip: %s, port: %s)\n", argv[1], argv[2]);

	//与服务器交互
    interact_sfd(sfd);

    //关闭套接字，断开与服务器的连接
    close(sfd);
    /* printf("Connection closed!\n"); */
    return 0;
}

http://www.kler.cn/a/291649.html

相关文章：

  • 重构Action-cli前端脚手架
  • docker 安装之 windows安装
  • uniapp 实现tabbar分类导航及滚动联动效果
  • 树莓派镜像 DIY 制作
  • 哈希表学习分享
  • 腾讯云内容合规基于springboot架构设计
  • 浅谈维度建模、数据分析模型，何为数据仓库，与数据库的区别
  • Shell脚本字符串处理(Linux篇)
  • 机器人笛卡尔空间轨迹规划原理与MATLAB实现
  • Java【操作符】
  • 如何在本地服务器部署SeaFile自托管文件共享服务结合内网穿透打造私有云盘？
  • python办公自动化：使用`Python-PPTX`创建和操作表格
  • 行测笔记_片段阅读1（中心理解）
  • Flink优化之--旁路缓存和异步IO
  • 图像数据处理23
  • git 常用命令合集
  • 为什么要有RPC
  • OpenIPC开源IPC之重要源码包
  • Redis八种数据结构简介
  • pytorch 自定义Dataset类
  • CAS单点登录说明文档
  • EdgeGallery：聚焦 5 大行业场景，MEC 开源平台将 5G 能力拓展到边缘_边缘mec平台
  • Redis 讲解运行模式：单机、主从、哨兵、集群使用场景和区别
  • OpenCV 100道面试题及参考答案（7万字长文）
  • 第4章 汇编语言和汇编软件
  • 【C++】static作用总结