计算机网络（1） --- 网络介绍_哈里沃克的博客-CSDN博客https://blog.csdn.net/m0_63488627/article/details/131967378?spm=1001.2014.3001.5501

目录

1.端口号

2.TCP与UDP协议

1.TCP协议介绍

1.TCP协议

2.UDP协议

3.理解

2.网络字节序

发送逻辑

3.socket

1.介绍

2.sockaddr结构

4.UDP协议编程

1.接口介绍

1.创建套接字

2.绑定IP和PORT接口

3.IP介绍

4.网络情况

5.执行接口

5.UPD的服务器和客户端接口实现

1.服务端

1.成员函数

2.接口

3.main函数

4.回调函数

2.客户端

1.成员函数

2.接口

3.main函数

---

1.端口号

1.IP用于广域网，而MAC地址用于局域网。但是当前解决的问题只是把数据传输到指定的操作系统下，但是这并不意味着成功运行我们想要实现的目的了。我们还想要让程序执行我们想要的。

2.为了解决表示当前操作系统下进程的唯一性，端口号port的引入就是为了保证客户端的唯一性

3.IP+port保证全网的唯一的进程

4.网络通信的本质：进程间通信。公共资源就是网络，通信就是进程的在IO操作

5.pid也可以表示进程的唯一性，但是之所以使用port是为了协议与系统解耦，使得port可以单独设计。

6.操作系统通过映射关系由port找到对应的进程

7.一个端口号只能绑定一个进程，一个进程可以绑定多个端口号

2.TCP与UDP协议

1.TCP协议介绍

1.TCP协议

Transmission Control Protocol 传输控制协议

1.传输层协议
2.有连接：连接两个进程，再传输
3.可靠传输
4.面向字节流

2.UDP协议

User Datagram Protocol 用户数据报协议

1.传输层协议
2.无连接：直接传数据
3.不可靠传输
4.面向数据报

3.理解

特别的：不可靠和可靠其实是一种中性词，它用于不同的场景。可靠是有成本的，写出的协议一定是比较复杂的，并且维护的成本高；不可靠没有成本，比较简单就可以设计和使用了。

2.网络字节序

1.数据在内存中存储，但是不同的主机大小端不同，所以会出现不同主机的大小端不同。那么如果不做任何改变，网络传输时，数据给到另一台大小端不同时，会出现数据的问题。

2.现在的问题是，不知道接收到的数据是大端还是小端，发送也不知道对方认识大端还是小端

3.因此，规定在网络中传输的数据一定是大端。

发送逻辑

1.发送主机通常将发送缓冲区中的数据按内存地址从低到高的顺序发出；
2.接收主机把从网络上接到的字节依次保存在接收缓冲区中,也是按内存地址从低到高的顺序保存；

3.因此,网络数据流的地址应这样规定:先发出的数据是低地址,后发出的数据是高地址；

4.TCP/IP协议规定,网络数据流应采用大端字节序,即低地址高字节

5.不管这台主机是大端还是小端, 都会按照这个TCP/IP规定的网络字节序来发送/接收数据；
6.如果当前发送主机是小端, 就需要先将数据转成大端; 否则就忽略, 直接发送即可

7.系统有专门的接口对数据进行大小端转换：

主机转网络htonl，htons；

网络转主机ntohl，ntohs；

3.socket

1.介绍

1.socket为“套接字”，它是计算机之间进行通信的一种约定或一种方式。通过 socket 这种约，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据。

2.套接字的种类有很多：网络套接字（本地通信使用和主机间使用），原始套接字（绕开上层，直接与物理层等下层协议直接访问），域间套接字（本地通信使用的）

3.设计套接字的一套接口，通过不同参数得到不同的套接字模式解决不同的场景问题

2.sockaddr结构

1.struct sockaddr为最初的结构，它是调用接口的模板结构

2.struct sockaddr_in和struct sockaddr_un为不同格式的套接字

3.struct sockaddr_in和struct sockaddr_un的前位反映了他们对应的结构。那么当我们使用struct sockaddr，只需要读取前16位就知道我们使用的结构体是哪一个了

4.UDP协议编程

1.接口介绍

1.创建套接字

 domain：选择本地通信还是网络通信(AF_INET)

type：选择什么类型的服务提供给网络通信

protocol：未来选择什么协议

调用成功，传出一个fd文件描述符，指向打开的文件

2.绑定IP和PORT接口

addr：填充协议的数据结构，是具体的协议，加入IP和PORT

addrlen：结构体长度

1.server服务器的struct sockaddr_in的sin_addr.s_addr定义为INADDR_ANY：绑定任意IP

2.client客户端不需要绑定，操作系统自动帮忙绑定。当要进行通信时，操作系统检查到套接字没有绑定，随机形成端口号进行绑定

3.之所以server服务器需要手动绑定是因为port需要指定，不能随意的改变；而client客户端不需要考虑port是多少，只需要port唯一即可。

4.在云服务器中，0~1024的端口号不允许使用。

3.IP介绍

1.127.0.0.1：本地环回，用于本地测试的IP；其作用原理是，数据往下传到网络层就回到应用层，不进入物理层。

2.云服务器的IP是虚拟化的服务器，不能作为公网的IP地址

3.ifconfig可以查询内网IP地址，表示的是局域网的IP

4.实际上，一款网络服务器不建议只绑定一个IP，因为真实情况会通过不同的IP来进行访问；使用绑定任意IP，只要端口对应，无论哪个IP传过来都可以执行服务器

4.网络情况

netstat：查看当前网络情况（sudo查询更详细的情况）

-u：udp， -a：all，-p：进程，-n：描述

5.执行接口

buf：特定的缓冲区

flags：读取的模式

scr_addr：谁发送的消息

发送消息

buf：特定的缓冲区

flags：读取的模式

scr_addr：谁发送的消息

5.UPD的服务器和客户端接口实现

1.服务端

namespace Server
{
    enum
    {
        USAGE_ERR = 1,
        SOCKET_ERR,
        BIND_ERR,
        OPEN_ERR
    };

    static const std::string defaultIp = "0.0.0.0";
    static const int gnum = 1024;

    typedef std::function<void(int,std::string, uint16_t, std::string)> func_t;

    class udpServer
    {
    public:
        udpServer(const func_t &cb, const uint16_t port, const std::string ip = defaultIp)
            : _callback(cb), _port(port), _ip(ip), _sockfd(-1)
        {
        }

        void initServer()
        {
            // 1.创建套接字
            _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
            if (_sockfd == -1)
            {
                std::cerr << "socket error: " << errno << " : " << strerror(errno) << std::endl;
                exit(SOCKET_ERR);
            }
            // 告诉操作系统，当前的IP和PORT是多少，上面的代码只是把数据存在堆栈上
            // 2.绑定IP接口
            struct sockaddr_in local;
            bzero(&local, sizeof local); // 清空结构体
            local.sin_family = AF_INET;
            local.sin_port = htons(_port);
            // local.sin_addr.s_addr = INADDR_ANY;

            int n = bind(_sockfd, (struct sockaddr *)&local, sizeof local);
            if (n == -1)
            {
                std::cerr << "bind error: " << errno << " : " << strerror(errno) << std::endl;
                exit(BIND_ERR);
            }
        }

        void start()
        {
            // 服务器的本质其实就是死循环
            char buffer[gnum];
            for (;;)
            {
                struct sockaddr_in peer;
                socklen_t len = sizeof peer;
                ssize_t s = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, (socklen_t *)&len);
                // 1.数据是什么2.谁发的
                if (s > 0)
                {
                    std::string clientip = inet_ntoa(peer.sin_addr);
                    uint16_t clientport = ntohs(peer.sin_port);
                    std::string massage = buffer;

                    std::cout << clientip << "[" << clientport << "]# " << massage << std::endl;
                    _callback(_sockfd, clientip, clientport, massage);
                }
            }
        }

        ~udpServer()
        {
        }

    private:
        uint16_t _port;
        std::string _ip; // 实际上，一款网络服务器不建议只绑定一个IP
        int _sockfd;
        func_t _callback;
    };
}

1.成员函数

1.uint16_t _port：服务器指定的端口号
2.std::string _ip：客户端发送给服务器的IP，一般建议设置为0，表示任意IP路径过来的都可以访问
3.int _sockfd：需要生成的服务器端网络套接字
4.func_t _callback：回调函数，用于服务器业务处理的

2.接口

1.initServer()创建套接字，先初始化套接字，生成对应的套接字，随后将当前的IP和port绑定(bind)起来

2.start()死循环的执行服务器的任务，把需要发送给客户端发送的语句接收到，随后把客户端的IP和port记录，最后执行回调函数

3.main函数

// ./udpServer port
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }
    uint16_t port = atoi(argv[1]);

    signal(2, reload);

    std::unique_ptr<udpServer> usvt(new udpServer(Message, port));

    usvt->initServer();
    usvt->start();
    return 0;
}

main函数先选定需要执行的回调函数，随后创建套接字，运行服务器即可

popen=pipe+fork+exec --- 先打开管道pipe，做重定向与文件指针关联，文件内部fork进程，执行exec

4.回调函数

// demo1
const std::string dictTxt = "./dict.txt";
unordered_map<string, string> dict;

static bool cutString(const string &target, string *s1, string *s2, const string &sep)
{
    auto pos = target.find(sep);
    if (pos == string::npos)
        return false;
    *s1 = target.substr(0, pos);           //[)
    *s2 = target.substr(pos + sep.size()); //[)
    return true;
}

static void debugPrint()
{
    for (auto &e : dict)
    {
        cout << e.first << " " << e.second << endl;
    }
}

void reload()
{
    (void)signo;
    initDict();
}

static void initDict()
{
    ifstream in(dictTxt, std::ios::binary);
    if (!in.is_open())
    {
        cerr << "open file " << dictTxt << " error" << endl;
        exit(OPEN_ERR);
    }

    string line;
    string key, value;
    while (getline(in, line))
    {
        // cout << line << endl;
        if (cutString(line, &key, &value, ":"))
        {
            dict.insert({key, value});
        }
    }

    in.close();
    cout << "load dict success!" << endl;
}

void handlerMessage(int sockfd, std::string clientip, uint16_t clientport, std::string message)
{
    // 处理业务
    string response_message;
    auto iter = dict.find(message);
    if (iter == dict.end())
        response_message = "unkonw";
    else
        response_message = iter->second;

    struct sockaddr_in client;
    bzero(&client, sizeof client);

    client.sin_family = AF_INET;
    client.sin_port = htons(clientport);
    client.sin_addr.s_addr = inet_addr(clientip.c_str());
    sendto(sockfd, response_message.c_str(), response_message.size(), 0, (struct sockaddr *)&client, sizeof client);
}

// demo2
void execMessage(int sockfd, std::string clientip, uint16_t clientport, std::string cmd)
{
    string response;
    FILE *fp = popen(cmd.c_str(), "r");
    if (fp == NULL)
    {
        response = cmd + " exec failed";
    }
    char line[1024];
    while (fget(line, sizeof line, fp))
    {
        response += line;
    }
    pclose(fp);

    struct sockaddr_in client;
    bzero(&client, sizeof client);

    client.sin_family = AF_INET;
    client.sin_port = htons(clientport);
    client.sin_addr.s_addr = inet_addr(clientip.c_str());
    sendto(sockfd, response_message.c_str(), response_message.size(), 0, (struct sockaddr *)&client, sizeof client);
}

// demo3
class User
{
public:
    User(const string &ip, const uint16_t &port) : _ip(ip), _port(port)
    {
    }
    ~User()
    {
    }
    string ip(){ return _ip; }
    uint16_t port(){ return _port; }
private:
    string _ip;
    uint16_t _port;
};

class OnlineUser
{
public:
    OnlineUser() {}
    ~OnlineUser() {}
    void addUser(const string &ip, const uint16_t &port)
    {
        string id = ip + "-" + to_string(port);
        users.insert(make_pair(id, User(ip, port)));
    }
    void delUser(const string &ip, const uint16_t &port)
    {
        string id = ip + "-" + to_string(port);
        users.erase(id);
    }
    bool isOnline(const string &ip, const uint16_t &port)
    {
        string id = ip + "-" + to_string(port);
        return users.find(id) == users.end() ? false : true;
    }
    void broadcastMessage(int sockfd, const string &ip, const uint16_t &port, const string &message)
    {
        for (auto &user : users)
        {
            struct sockaddr_in client;
            bzero(&client, sizeof(client));

            client.sin_family = AF_INET;
            client.sin_port = htons(user.second.port());
            client.sin_addr.s_addr = inet_addr(user.second.ip().c_str());
            string s = ip + "-" + to_string(port) + "# ";
            s += message;
            sendto(sockfd, s.c_str(), s.size(), 0, (struct sockaddr *)&client, sizeof(client));
        }
    }

private:
    unordered_map<string, User> users;
};

void routeMessage(int sockfd, string clientip, uint16_t clientport, string message)
{
    if (message == "online")
        onlineuser.addUser(clientip, clientport);
    if (message == "offline")
        onlineuser.delUser(clientip, clientport);
    if (onlineuser.isOnline(clientip, clientport))
    {
        // 消息的路由
        onlineuser.broadcastMessage(sockfd, clientip, clientport, message);
    }
    else
    {
        struct sockaddr_in client;
        bzero(&client, sizeof(client));

        client.sin_family = AF_INET;
        client.sin_port = htons(clientport);
        client.sin_addr.s_addr = inet_addr(clientip.c_str());

        string response = "你还没有上线，请先上线，运行: online";

        sendto(sockfd, response.c_str(), response.size(), 0, (struct sockaddr *)&client, sizeof(client));
    }
}

demo的逻辑都是先接收到客户端的信息，通过回调函数执行对应的任务，最后把结果发送给客户端。

此外，将服务端的类和回调函数分离，这样使得耦合度变低，只在main函数修改每一次的指令即可更换命任务。

2.客户端

namespace Client
{
    class udpClient
    {
    public:
        udpClient(const std::string serverip, const uint16_t serverport)
            : _sockfd(-1), _serverport(serverport), _serverip(serverip), _quit(false)
        {
        }

        void initClient()
        {
            // 1.创建套接字
            _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
            if (_sockfd == -1)
            {
                std::cerr << "socket error: " << errno << " : " << strerror(errno) << std::endl;
                exit(2);
            }
            std::cout << "socket success: " << _sockfd << std::endl;
            // 2.绑定IP接口,Client不需要程序员显示的bind,由操作系统进行绑定
        }

        void run()
        {
            struct sockaddr_in server;
            memset(&server, 0, sizeof server);
            server.sin_family = AF_INET;
            server.sin_addr.s_addr = inet_addr(_serverip.c_str());
            server.sin_port = htons(_serverport);

            std::string massage;
            while (!_quit)
            {
                std::cout << "Please Enter# ";
                std::cin >> massage;

                sendto(_sockfd, massage.c_str(), massage.size(), 0, (struct sockaddr *)&server, sizeof server);

                char buffer[1024];
                struct sockaddr_in temp;
                socklen_t temp_len = sizeof temp;
                ssize_t n = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&temp, &temp_len);
                if (n > 0)
                    buffer[n] = 0;
                std::cout << "服务器的翻译结果：" << buffer << std::endl;
            }
        }

        ~udpClient()
        {
        }

    private:
        int _sockfd;
        std::string _serverip;
        uint16_t _serverport;
        bool _quit;
    };
}

1.成员函数

int _sockfd：客户端的套接字

std::string _serverip：服务器的IP地址

uint16_t _serverport：服务器的端口号

bool _quit：执行条件逻辑判断变量

2.接口

1.initClient()初始化客户端的套接字，再绑定套接字

2.run()，客户端先准备好数据，发送给服务端，随着服务端的任务处理，把最终服务端的套接字发送给运行的客户端，得到自己的需求

3.main函数

static void Usage(string proc)
{
    cout << "Usage:\n\t" << proc << " server_ip server_port\n\n";
}

// ./udpClient server_ip server_port
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }
    uint16_t serverport = atoi(argv[2]);
    std::string serverip = argv[1];
    std::unique_ptr<udpClient> ucli(new udpClient(serverip, serverport));
    ucli->initClient();
    ucli->run();
    return 0;
}

main函数初始化套接字，随后运行即可。