代码编织梦想

六、TCP网络编程

6.1IP地址字符串和整数之间的转换接口

//字符串转整数接口
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int inet_aton(const char *cp, struct in_addr *inp);
int inet_pton(int af, const char *strptr, void *addrptr);//注意dst指的是in_addr *的地址
in_addr_t inet_addr(const char *cp);//将字符串转32位并且是网络序列的;
//整数转字符串
char *inet_ntoa(struct in_addr in);//将整数转为字符串并且将网络字节序转为主机字节序
const char *inet_ntop(int af, const void *addrptr,
                      char *strptr, socklen_t size);

​ 需要注意的是inet_ntoa函数这个函数返回的是一个静态变量地址,使用时有覆盖问题和线程安全问题;最好是使用inet_ntop;

6.2补充知识

1.将网络套接字进行封装

​ 构造函数之中最好少做一些有风险的事情,这样可以保证最起码对象是没有问题的;其他如打开文件之类的操作就交给其他函数去完成;

2.获取新连接会产生多个文件描述符

​ 服务器本地的文件描述符用来进行监听连接,获取新连接,真正进行IO通信的文件描述符是后生成的;这样既提高了服务器的并发度;

3.telnet的使用

​ 默认使用的就是TCP;

​ 使用ctrl+]进入,回车后进行输入(会自动在输入的文本后面加\r\n)会回显数据,q退出;

4.TCP连接中的异常问题

​ 当客户端直接退出时,服务端就会读到0,此时需要关闭为客户端打开的文件描述符;

5.网络抖动断开连接,客户端自动发起连接请求设计

6.tcp服务器重连

​ 服务器断开后不能直接连接,一般要等待120s左右;

6.3使用接口

6.3.1创建套接字

​ 和udp使用是一样的;

6.3.2绑定套接字

​ 和udp使用是一样的;

6.3.3设置监听

​ 由于TCP是面向连接的,所以在通信前要建立连接,将套接字设置为监听状态;

#include <sys/types.h>         
#include <sys/socket.h>
int listen(int sockfd, int backlog);
//第二个参数表示的是全连接的队列的长度,一般不能设置的太大;
6.3.4获取新连接

​ 此处包括以上接口都是阻塞的;

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
//返回值,成功返回一个文件描述符,失败返回-1,错误码被设置;

​ 获取新连接成功后要根据客户端的套接字信息提供服务;

6.3.5客户端发起连接请求

​ 客户端需要绑定但是不需要显式进行绑定,系统会在客户端发起连接请求的时候自动绑定

int connect(int sockfd, const struct sockaddr *addr,
            socklen_t addrlen);

6.4查看网络状态

netstat -nltp
#n显示成数字,l表示listen,表示tcp

6.5单进程版echo服务器

​ 缺陷是同时最多只能有一个客户端进行访问;UDP所有的客户端用的是一个sockfd,一个文件,可以同时读写,而TCP每个客户端对应一个sockfd,一个文件;单进程下对一个文件读写时,服务器因为处理消息是循环处理,必须读完退出循环服务,才能继续获取新连接,此时另一个客户端已经想打开的sockfd文件写入很多数据,当服务端接收连接请求时,会将发送过来的一大批数据处理后返回,这样就无法实现正常的服务器;

char buff[4096];
while (true)
{
    // 数据读取
    ssize_t n = read(sockfd, buff, sizeof(buff) - 1);
    if (n > 0)
    {
        buff[n] = '\0';
        std::cout << "client say@ " << buff << std::endl;

        // 数据回显
        std::string echo_string;
        echo_string += "tcpserver say#";
        echo_string += buff;
        write(sockfd, echo_string.c_str(), echo_string.size());
    }
    else if (n == 0)
    {
        lg(Info, "%s:%d quit..., server close sockfd: %d", clientip.c_str(), clientport, sockfd);
        break;
    }
    else
    {
        lg(Warning, "read error, sockfd: %d, clientip: %s, clientport: %d", sockfd, clientip.c_str(), clientport);
        break;
    }
}

6.6多进程版echo服务器

​ 1.子进程可以看见listenfd_,所以要关闭无关的文件描述符;2.父进程不关心sockfd,要去接收新的连接,如果不关闭就会导致之后的很多文件描述符没有关闭,不断从新的下标打开文件描述符,而不是重新分配;

​ 2.子进程中继续fork(),然后子进程退出,被父进程阻塞等待回收,父进程继续获取新的连接,孙子进程被操作系统领养,执行服务部分;也可以使用信号异步等待的方式实现;

​ 3.也可以在循环执行获取连接和执行任务之前创建子进程,但是会存在数据不一致问题需要用信号量;

​ 4.多进程创建的成本过高,所以应该选择多线程;

//方式1
pid_t id = fork();
if (id < 0)
{
    std::cerr << "fork error" << std::endl;
}
else if (id == 0)
{
    close(listensockfd_);
    if (fork() > 0)
    {
        exit(0);
    }
    // 此处执行代码的是孙子进程,会被做系统领养
    service(sockfd, clientip, clientport);
    close(sockfd);
    exit(0);
}
close(sockfd);
pid_t rid = waitpid(id, nullptr, 0);
(void)rid;
//方式2
signal(SIGCHLD, SIG_IGN);
pid_t id = fork();
if (id == 0)
{
    close(listensockfd_);
    service(sockfd, clientip, clientport);
    close(sockfd);
    exit(0);
}
close(sockfd);

6.7多线程版本的echo服务器

​ 1.因为线程中大部分资源都是共享的所以不可以关闭文件描述符,否则会出错;

​ 2.线程没有退出时会有峰值的,服务器此时压力很大,所以长服务是不合理的;

​ 3.创建线程也是有成本的,即系统调用的成本,所以应该用线程池;

struct threaddata
{
    threaddata(const int sockfd, const std::string &clientip, const uint16_t &clientport, tcpserver *t) : sockfd_(sockfd), clientport_(clientport),
    clientip_(clientip), t_(t)
    {
    }
    int sockfd_;
    uint16_t clientport_;
    std::string clientip_;
    tcpserver *t_;
};

pthread_t tid;
threaddata *td = new threaddata(sockfd, clientip, clientport, this);
pthread_create(&tid, nullptr, routine, (void *)td);

static void *routine(void *args)
{
    threaddata *td = static_cast<threaddata *>(args);
    pthread_detach(pthread_self());
    td->t_->service(td->sockfd_, td->clientip_, td->clientport_);
    delete td;
    return nullptr;
}

6.8线程池版本的echo服务器

​ 1.线程池里不可以执行长时间的服务;2.服务器关闭了客户端套接字,客户端继续写入,会触发服务器异常,返回一个RST消息,然后客户端操作系统发送SIGPIPE信号杀死客户端进程;

class Task
{
    public:
    Task(const int &sockfd, const std::string &clientip, const uint16_t &clientport)
        : sockfd_(sockfd), clientport_(clientport), clientip_(clientip) {}

    void run()
    {
        char buff[4096];
        // 数据读取
        ssize_t n = read(sockfd_, buff, sizeof(buff) - 1);
        if (n > 0)
        {
            buff[n] = '\0';
            std::cout << "client say@ " << buff << std::endl;

            // 数据回显
            std::string echo_string;
            echo_string += "tcpserver say#";
            echo_string += buff;
            write(sockfd_, echo_string.c_str(), echo_string.size());
        }
        else if (n == 0)
        {
            lg(Info, "%s:%d quit..., server close sockfd: %d", clientip_.c_str(), clientport_, sockfd_);
        }
        else
        {
            lg(Warning, "read error, sockfd: %d, clientip: %s, clientport: %d", sockfd_, clientip_.c_str(), clientport_);
        }
        close(sockfd_);
    }
    void operator()()
    {
        run();
    }

    ~Task()
    {
    }

    private:
    int sockfd_;
    uint16_t clientport_;
    std::string clientip_;
};

Task t(sockfd, clientip, clientport);
ThreadPool<Task>::GetInstance()->Push(t);

#include <iostream>
#include <vector>
#include <string>
#include <queue>
#include <pthread.h>
#include "Task.hpp"
#include <unistd.h>

struct ThreadInfo
{
    pthread_t tid;
    std::string name;
};

static const int defaultnum = 5;

template <class T>
    class ThreadPool
    {
        private:
        void Lock()
        {
            pthread_mutex_lock(&_mutex);
        }

        void UnLock()
        {
            pthread_mutex_unlock(&_mutex);
        }

        void Wakeup()
        {
            pthread_cond_signal(&_cond);
        }

        void ThreadSleep()
        {
            pthread_cond_wait(&_cond, &_mutex);
        }

        bool IsQueueEmpty()
        {
            return _tasks.empty();
        }

        std::string GetThreadName(pthread_t tid)
        {
            for (const auto e : _threads)
            {
                if (e.tid == tid)
                {
                    return e.name;
                }
            }
            return "None";
        }

        public:
        T Pop()
        {
            T t = _tasks.front();
            _tasks.pop();
            return t;
        }

        void Push(const T &t)
        {
            Lock();
            _tasks.push(t);
            Wakeup();
            UnLock();
        }

        static void *HandlerTask(void *args) // 类内函数默认都有一个this指针,静态成员函数无法直接看到成员属性
        {
            ThreadPool<T> *tp = static_cast<ThreadPool<T> *>(args);
            std::string name = tp->GetThreadName(pthread_self());
            while (true)
            {
                tp->Lock();
                while (tp->IsQueueEmpty())
                {
                    tp->ThreadSleep();
                }
                Task t = tp->Pop();
                tp->UnLock();
                t();
            }
        }

        void Start() // 创建线程
        {
            int num = _threads.size();
            for (int i = 0; i < num; i++)
            {
                _threads[i].name = "thread-" + std::to_string(i + 1);
                pthread_create(&(_threads[i].tid), nullptr, HandlerTask, this);
            }
        }

        static ThreadPool<T> *GetInstance()
        {
            pthread_mutex_lock(&_smutex);
            if (_tp == nullptr)
            {
                std::cout << "log : singleton create done first!" << std::endl;
                _tp = new ThreadPool<T>();
            }
            pthread_mutex_unlock(&_smutex);
            return _tp;
        }

        private:
        ThreadPool(int num = defaultnum) : _threads(num)
        {
            pthread_mutex_init(&_mutex, nullptr);
            pthread_cond_init(&_cond, nullptr);
        }

        ThreadPool(const ThreadPool<T> &tp) = delete;
        const ThreadPool<T> &operator=(const ThreadPool<T> tp) = delete;
        ~ThreadPool()
        {
            pthread_mutex_destroy(&_mutex);
            pthread_cond_destroy(&_cond);
        }

        std::vector<ThreadInfo> _threads;
        std::queue<T> _tasks;
        pthread_mutex_t _mutex;
        pthread_cond_t _cond;
        static ThreadPool<T> *_tp;
        static pthread_mutex_t _smutex;
    };
template <class T>
    ThreadPool<T> *ThreadPool<T>::_tp = nullptr;
template <class T>
    pthread_mutex_t ThreadPool<T>::_smutex = PTHREAD_MUTEX_INITIALIZER;

6.9线程池版翻译服务器

​ 打开KV式的字符串文件,来比较进行翻译;

#include <iostream>
#include <string>
#include <unordered_map>
#include <fstream>
#include <cstring>
#include "log.hpp"

extern Log lg;

const std::string filename = "./dict.txt";

// 打开字典并且自动将初始化dict
class init
{
    public:
    bool split(const std::string &line, std::string &part1, std::string &part2)
    {
        auto pos = line.find(sep);
        if (pos == std::string::npos)
        {
            return false;
        }
        part1 = line.substr(0, pos);
        part2 = line.substr(pos + sep.size());
        return true;
    }
    init()
    {
        // 1.打开文件
        std::ifstream in(filename); // 默认打开文件
        if (!in.is_open())
        {
            lg(Fatal, "open %s file error, errno: %d, strerror: %s", filename.c_str(), errno, strerror(errno));
            exit(4);
        }
        std::string line;
        // 2.对文件进行按行读取
        while (std::getline(in, line))
        {
            std::string part1, part2;
            split(line, part1, part2);
            dict_[part1] = part2;
        }
        // 3.关闭文件
        in.close();
    }
    std::string translation(const std::string &key)
    {
        auto it = dict_.find(key);
        if (it != dict_.end())
        {
            return dict_[key];
        }
        else
        {
            return "unknown";
        }
    }

    private:
    std::unordered_map<std::string, std::string> dict_;
    static const std::string sep;
};
const std::string init::sep = ": ";
// 处理任务
buff[n] = '\0'; // 当作字符串使用
std::string echo_string;
echo_string += it.translation(buff);
write(sockfd_, echo_string.c_str(), echo_string.size());

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/qq_33093885/article/details/137158808

计算机网络(三)——tcp套接字编程_tcp套接字编程实验-爱代码爱编程

文章目录 一、TCP常用接口函数2.1 设置监听套接字2.2 accept获取连接2.3 connect发起连接2.4 流读取 二、TCP通信2.1 服务端2.2 客户端2.3 不断优化的服务端2.3.1

tcp/ip网络编程——理解网络编程和套接字编程-爱代码爱编程

完整版文章请参考: TCP/IP网络编程完整版文章 文章目录 一、理解网络编程和套接字编程1.1 socket套接字1.1.1 一个例子来表示TCP的网络连接1.1.2 程序实现 1.2 文件操作1.

网络编程套接字( tcp )_头个,第1关:tcp套接字创建与端口绑定-爱代码爱编程

目录 1、实现一个TCP网络程序(单进程版)         1.1、服务端serverTcp.cc文件                  服务端创建套接字                  服务端绑定                  服务端监听                  服务端获取连接                  服务端提供

wireshark流量分析-爱代码爱编程

wireshark流量分析 着色规则: 显示自定义列 wireshark 默认显示列 No:编号,即pacp开始的帧号 Time:时间,分解为纳秒 Source:源地址,通常为IPv4、IPv6、以太网地址 Dest

网络安全-爱代码爱编程

一、php://input 我们先来看一个简单的代码 <meta charset="utf8"> <?php error_reporting(0); $file = $_GET["file"]; if(stristr($file,"php://filter") || stristr($file,"zip://") || stristr

网络安全(黑客)——2024自学-爱代码爱编程

01 什么是网络安全 网络安全可以基于攻击和防御视角来分类,我们经常听到的 “红队”、“渗透测试” 等就是研究攻击技术,而“蓝队”、“安全运营”、“安全运维”则研究防御技术。 无论网络、Web、移动、桌面、云等哪个领域,都有攻与防两面性,例如 Web 安全技术,既有 Web 渗透,也有 Web 防御技术(WAF)。作为一个合格的网络安全工程师,应该做到

nat 机制的工作流程-爱代码爱编程

1.NAT概念  NAT(Network Address Translation),是指网络地址转换,1994年提出的。NAT是用于在本地网络中使用私有地址,在连接互联网时转而使用全局 IP 地址的技术。NAT实际上是为解决IPv4地址短缺而开发的技术。  NAT旨在通过将一个外部 IP 地址和端口映射到更大的内部 IP 地址集来转换 IP 地

web 前端性能优化之一:性能模型及网页原理-爱代码爱编程

一、RAIL 性能模型 RAIL性能模型指出了用户对不同延迟时间的感知度,以用户为中心的原则,就是要让用户满意网站或应用的性能体验。 RAIL :响应(Response)、动画(Animation)、空闲(Idle)、加

技术导读 | 如何为secops插上ai的翅膀-爱代码爱编程

随着数字经济的蓬勃发展,数据安全和网络安全的重要性日益凸显。在数字经济时代,数据已成为企业的核心资产,而网络安全则是保障数据安全的基石。然而,面对不断变化的攻击模式、扩大的攻击面以及日益复杂的安全事件,许多企业的安全运营(SOC)面临着严峻的挑战。 攻击智能化、自动化、扩大化 当前,随着AI技术在各个领域的普及,黑客攻击手段呈现爆发式增长。比如,其利用

ospf之单区域配置-爱代码爱编程

文章目录 单区域配置项目背景项目分析拓扑图配置思路基础配置命令查看路由器接口IP地址信息OSPF配置 测试PC1与PC2互通查看OSPF邻居表修改OSPF路由器的router-id完美的OSPF配置命令写

day54:web攻防-爱代码爱编程

目录 XSS跨站-攻击利用-凭据盗取 XSS跨站-攻击利用-数据提交 XSS跨站-攻击利用-flash钓鱼 XSS跨站-攻击利用-溯源综合 知识点: 1、XSS跨站-攻击利用-凭据盗取 2、XSS跨站-攻击利用-数据提交 3、XSS跨站-攻击利用-网络钓鱼 4、XSS跨站-攻击利用-溯源综合