【C-实践】一对一的网络通信

轩轶子

已于 2024-08-30 20:47:50 修改

阅读量491

点赞数 17

文章标签： c语言开发语言

于 2024-08-30 20:47:29 首次发布

本文链接：https://blog.csdn.net/m0_56655520/article/details/141726933

版权

技术

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

功能

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

启动

启动服务器（在配置文件中更换自己的ip地址和port端口号）

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

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

2、启动服务器

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

启动客户端

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

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

2、启动客户端（更换自己的ip地址和port端口号）

w@Ubuntu20:Chat1_client $ ./client 192.168.160.129 2000

服务器

目录设计

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

4 directories, 7 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);

    //生成一个服务器套接字, 并监听客户端的连接
    int sfd = tcp_init(argv[1]);
    if (-1 == sfd) {
        return -1;
    }
    printf("The server is listening...\n");


    //与客户端进行信息交互
    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 <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

//接受所有客户端的信息，并显示在终端
//将信息发送给所有客户端
int interact_cli(int sfd)
{
    //用select监听sfd, 标准输入，和客户端
    fd_set monitor_set;//位图，存放所有被监听的文件描述符
    FD_ZERO(&monitor_set);
    FD_SET(STDIN_FILENO, &monitor_set);
    FD_SET(sfd, &monitor_set);

    int readyFdNum = 0;//就绪的文件描述符数量
    char buf[128] = {0};//读写缓冲区
    int ret = -1;
    int client_fd = 0;

    fd_set rdset;//本轮读操作位图
    while (1) {
        //当前的client_fd是最大的客户端套接字
        memcpy(&rdset, &monitor_set, sizeof(fd_set));

        //读操作位图中，没有就绪的文件描述符会被select修改为0
        readyFdNum = select(10, &rdset, NULL, NULL, NULL);
        ERROR_CHECK(readyFdNum, -1, "select");

        //如果sfd就绪，表示有新的客户端请求连接, 将其加入监听集合
        if (FD_ISSET(sfd, &rdset)) {
            //得到一个客户端套接字，用于通信
            client_fd = accept(sfd, NULL, NULL);
            ERROR_CHECK(client_fd, -1, "accept");
            FD_SET(client_fd, &monitor_set);
        }

        //标准输入就绪，读取并发送给客户端
        if (FD_ISSET(STDIN_FILENO, &rdset)) {
            memset(buf, 0, sizeof(buf));
            ret = read(STDIN_FILENO, buf, sizeof(buf) - 1);
            ERROR_CHECK(ret, -1, "read");

            //将信息发给所有客户端
            for (int i = 4; i <= client_fd; ++i) {
                send(i, buf, strlen(buf) - 1, 0);
            }
        }

        //遍历所有客户端，哪个客户端就绪，读取并显示在终端
        for (int cli_fd = 4; cli_fd < 10; ++cli_fd) {
            if (FD_ISSET(cli_fd, &rdset)) {
                memset(buf, 0, sizeof(buf));
                //接受信息，如果收不到信息，表示客户端断开
                ret = recv(cli_fd, buf, sizeof(buf) - 1, 0);
                ERROR_CHECK(ret, -1, "recv");
                if (0 == ret) {
                    //对端已断开, 退出监听
                    printf("client exit!\n");
                    close(cli_fd);
                    FD_CLR(cli_fd, &monitor_set);
                    continue;
                }
                //将信息输出在终端
                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) {
        FD_SET(STDIN_FILENO, &rdset);
        FD_SET(sfd, &rdset);

        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;
}