网络7—tcp_socket

最新推荐文章于 2024-09-09 15:42:52 发布
最新推荐文章于 2024-09-09 15:42:52 发布
阅读量682 收藏 3
点赞数 17
分类专栏： 网络 文章标签： 网络 tcp/ip 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73964834/article/details/140891091
版权

目录

1.server 服务端：

1.1 完整代码展示：

1.2 代码解析

1.2.1.创建套接字绑定和监听

1.2.2 进行链接

1.2.3 功能拓展

1.2.3.1 多进程版本

1.2.3.2 多线程版本

1.3 创建task类，实现功能

1.server 服务端：

1.1 完整代码展示：

class TcpServer
{
public:
    TcpServer(const uint16_t &port, const std::string &ip = defaultip) : listensock_(defaultfd), port_(port), ip_(ip)
    {
    }
    void InitServer()
    {
        listensock_ = socket(AF_INET, SOCK_STREAM, 0);
        if (listensock_ < 0)
        {
            lg(Fatal, "create socket, errno: %d, errstring: %s", errno, strerror(errno));
            exit(SocketError);
        }
        lg(Info, "create socket success, listensock_: %d", listensock_);

        int opt = 1;
        setsockopt(listensock_, SOL_SOCKET, SO_REUSEADDR|SO_REUSEPORT, &opt, sizeof(opt)); // 防止偶发性的服务器无法进行立即重启(tcp协议的时候再说)

        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(port_);
        inet_aton(ip_.c_str(), &(local.sin_addr));
        // local.sin_addr.s_addr = INADDR_ANY;

        if (bind(listensock_, (struct sockaddr *)&local, sizeof(local)) < 0)
        {
            lg(Fatal, "bind error, errno: %d, errstring: %s", errno, strerror(errno));
            exit(BindError);
        }

        lg(Info, "bind socket success, listensock_: %d", listensock_);

        // Tcp是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
        if (listen(listensock_, backlog) < 0)
        {
            lg(Fatal, "listen error, errno: %d, errstring: %s", errno, strerror(errno));
            exit(ListenError);
        }

        lg(Info, "listen socket success, listensock_: %d", listensock_);
    }

    // static void *Routine(void *args)
    // {
    //     pthread_detach(pthread_self());
    //     ThreadData *td = static_cast<ThreadData *>(args);
    //     td->tsvr->Service(td->sockfd, td->clientip, td->clientport);//???
    //     delete td;
    //     return nullptr;
    // }

    void Start()
    {
        Daemon();
        ThreadPool<Task>::GetInstance()->Start();
        // for fork();
        // signal(SIGCHLD, SIG_IGN);
        lg(Info, "tcpServer is running....");
        for (;;)
        {
            // 1. 获取新连接
            struct sockaddr_in client;
            socklen_t len = sizeof(client);
            int sockfd = accept(listensock_, (struct sockaddr *)&client, &len);
            if (sockfd < 0)
            {
                lg(Warning, "accept error, errno: %d, errstring: %s", errno, strerror(errno)); //?
                continue;
            }
            uint16_t clientport = ntohs(client.sin_port);
            char clientip[32];
            inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));

            // 2. 根据新连接来进行通信
            lg(Info, "get a new link..., sockfd: %d, client ip: %s, client port: %d", sockfd, clientip, clientport);
            // std::cout << "hello world" << std::endl;
            // version 1 -- 单进程版
            // Service(sockfd, clientip, clientport);
            // close(sockfd);

            // version 2 -- 多进程版
            // pid_t id = fork();
            // if(id == 0)
            // {
            //     // child
            //     close(listensock_);
            //     if(fork() > 0) exit(0);
            //     Service(sockfd, clientip, clientport); //孙子进程， system 领养
            //     close(sockfd);
            //     exit(0);
            // }
            // close(sockfd);
            // // father
            // pid_t rid = waitpid(id, nullptr, 0);
            // (void)rid;

            // version 3 -- 多线程版本
            // ThreadData *td = new ThreadData(sockfd, clientip, clientport, this);
            // pthread_t tid;
            // pthread_create(&tid, nullptr, Routine, td);

            // version 4 --- 线程池版本
            Task t(sockfd, clientip, clientport);
            ThreadPool<Task>::GetInstance()->Push(t);
        }
    }
    // void Service(int sockfd, const std::string &clientip, const uint16_t &clientport)
    // {
    //     // 测试代码
    //     char buffer[4096];
    //     while (true)
    //     {
    //         ssize_t n = read(sockfd, buffer, sizeof(buffer));
    //         if (n > 0)
    //         {
    //             buffer[n] = 0;
    //             std::cout << "client say# " << buffer << std::endl;
    //             std::string echo_string = "tcpserver echo# ";
    //             echo_string += buffer;

    //             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, client ip: %s, client port: %d", sockfd, clientip.c_str(), clientport);
    //             break;
    //         }
    //     }
    // }
    ~TcpServer() {}
}

1.2 代码解析

1.2.1.创建套接字绑定和监听

void InitServer()
    {
        listensock_ = socket(AF_INET, SOCK_STREAM, 0);
        if (listensock_ < 0)
        {
            lg(Fatal, "create socket, errno: %d, errstring: %s", errno, strerror(errno));
            exit(SocketError);
        }
        lg(Info, "create socket success, listensock_: %d", listensock_);

        int opt = 1;
        setsockopt(listensock_, SOL_SOCKET, SO_REUSEADDR|SO_REUSEPORT, &opt, sizeof(opt)); // 防止偶发性的服务器无法进行立即重启(tcp协议的时候再说)

        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(port_);
        inet_aton(ip_.c_str(), &(local.sin_addr));
        // local.sin_addr.s_addr = INADDR_ANY;

        if (bind(listensock_, (struct sockaddr *)&local, sizeof(local)) < 0)
        {
            lg(Fatal, "bind error, errno: %d, errstring: %s", errno, strerror(errno));
            exit(BindError);
        }

        lg(Info, "bind socket success, listensock_: %d", listensock_);

        // Tcp是面向连接的，服务器一般是比较“被动的”，服务器一直处于一种，一直在等待连接到来的状态
        if (listen(listensock_, backlog) < 0)
        {
            lg(Fatal, "listen error, errno: %d, errstring: %s", errno, strerror(errno));
            exit(ListenError);
        }

        lg(Info, "listen socket success, listensock_: %d", listensock_);
    }

tcp是面向字节流传输的，也是需要绑定的套接字的，

和udp不同的是它需要 处于监听才可以进行链接

参考如下：

listen状态（监听）-CSDN博客

1.2.2 进行链接



    void Start()
    {
        Daemon();
        ThreadPool<Task>::GetInstance()->Start();
        // for fork();
        // signal(SIGCHLD, SIG_IGN);
        lg(Info, "tcpServer is running....");
        for (;;)
        {
            // 1. 获取新连接
            struct sockaddr_in client;
            socklen_t len = sizeof(client);
            int sockfd = accept(listensock_, (struct sockaddr *)&client, &len);
            if (sockfd < 0)
            {
                lg(Warning, "accept error, errno: %d, errstring: %s", errno, strerror(errno)); //?
                continue;
            }
            uint16_t clientport = ntohs(client.sin_port);
            char clientip[32];
            inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));

            // 2. 根据新连接来进行通信
            lg(Info, "get a new link..., sockfd: %d, client ip: %s, client port: %d", sockfd, clientip, clientport);
             std::cout << "hello world" << std::endl;
           // version 1 -- 单进程版
             Service(sockfd, clientip, clientport);
             close(sockfd);

        }
    }
  void Service(int sockfd, const std::string &clientip, const uint16_t &clientport)
    {
         // 测试代码
         char buffer[4096];
         while (true)
         {
             ssize_t n = read(sockfd, buffer, sizeof(buffer));
             if (n > 0)
             {
                 buffer[n] = 0;
                 std::cout << "client say# " << buffer << std::endl;
                 std::string echo_string = "tcpserver echo# ";
                 echo_string += buffer;

                 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, client ip: %s, client port: %d", sockfd, clientip.c_str(), clientport);
                 break;
             }
         }
     }

这是一个单进程版本，

因为tcp面向字节流的，所以可以用write()，read()这些面向字节流的操作

参考如下：

tcp中accept()的理解-CSDN博客

1.2.3 功能拓展

1.2.3.1 多进程版本
version 2 -- 多进程版
            pid_t id = fork();
            if(id == 0)
            {
                // child
                close(listensock_);
                if(fork() > 0) exit(0);
                Service(sockfd, clientip, clientport); //孙子进程， system 领养
                close(sockfd);
                exit(0);
            }
            close(sockfd);
            // father
            pid_t rid = waitpid(id, nullptr, 0);
            (void)rid;

原理解析：

父进程fork（），在子进程中再 fork(),   < 0 是孙子进程 ，将子进程退出。父进程直接等待，继续链接， 孙子进程怎是提供服务。

父进程和孙子进程就可以并发访问了，原理是让子进程退出，父进程直接等待完毕。

孙子进程不用管，他会被系统领养，会被回收。

1.2.3.2 多线程版本
version 3 -- 多线程版本
            ThreadData *td = new ThreadData(sockfd, clientip, clientport, this);
            pthread_t tid;
            pthread_create(&tid, nullptr, Routine, td);


static void *Routine(void *args)
    {
        pthread_detach(pthread_self());
        ThreadData *td = static_cast<ThreadData *>(args);
        td->tsvr->Service(td->sockfd, td->clientip, td->clientport);//???
        delete td;
        return nullptr;
    }

创建routine()函数实现多线程模式

1.2.3.3 线程池模式

 // version 4 --- 线程池版本
            Task t(sockfd, clientip, clientport);
            ThreadPool<Task>::GetInstance()->Push(t);

1.3 创建task类，实现功能

#pragma once
#include <iostream>
#include <string>
#include "Log.hpp"
#include "Init.hpp"

extern Log lg;
Init init;

class Task
{
public:
    Task(int sockfd, const std::string &clientip, const uint16_t &clientport)
        : sockfd_(sockfd), clientip_(clientip), clientport_(clientport)
    {
    }
    Task()
    {
    }
    void run()
    {
        std::cout << "in task" << std::endl; 
        // 测试代码
        char buffer[4096];
        // Tcp是面向字节流的，你怎么保证，你读取上来的数据，是"一个" "完整" 的报文呢？
        ssize_t n = read(sockfd_, buffer, sizeof(buffer)); // BUG?
        if (n > 0)
        {
            buffer[n] = 0;
            std::cout << "client key# " << buffer << std::endl;
            std::string echo_string = init.translation(buffer);

            // sleep(5);
            // // close(sockfd_);
            // lg(Warning, "close sockfd %d done", sockfd_);

            // sleep(2);
            n = write(sockfd_, echo_string.c_str(), echo_string.size()); // 100 fd 不存在
            if(n < 0)
            {
                lg(Warning, "write error, errno : %d, errstring: %s", errno, strerror(errno));
            }
        }
        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, client ip: %s, client port: %d", sockfd_, clientip_.c_str(), clientport_);
        }
        close(sockfd_);
    }
    void operator()()
    {
        run();
    }
    ~Task()
    {
    }

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

是布吉岛
关注
  • 17
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
TCP_socket实现客户端和服务器端通信
weixin_43268181的博客
05-08 1882
客户端 import socket def main(): # 创建套接字 tcp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 目的信息 server_ip = "127.0.0.1" server_port = 60000 # 链接服务器 tcp_client_socket.con...
基于TCP协议的Socket通信
m0_63089658的博客
08-27 1355
基于TCP协议的Socket通信
套接字socket选项TCP_NODELAY、TCP_CORK与TCP_QUICKACK
未冬生
03-01 7182
一、简介： TCP_NODELAY关闭Nagle算法，控制的是数据的发送。Nagle 算法规定，如果包大于MSS(Max Segment Size)或含有FIN则立即发送，否则放入缓冲区，等已经发送的包被确认后后再发送。即网络上只能有一个未确认的小包。可以降低网络小包数量，减少了ip头部在网络上的比重，提升网络性能。https://www.fanhaobai.com/2017/11/40ms-delay-and-tcp-nodelay.html TCP_CORK：设置后不会发送任何小包（小于mss）除非超时
SELinux is preventing /usr/sbin/httpd from name_bind access on the tcp_socket port
wephper
09-04 2676
SELinux is preventing /usr/sbin/httpd from name_bind access on the tcp_socket port 附加表现症状：服务器起来后本地curl 127.0.0.1:端口可以访问 但是配置nginx代理用80端口转发后无法访问。
Python利用tcp_socket实现文件下载器
陈c
01-25 3899
python利用tcp_socket实现简单文件下载功能
【计算机网络】Socket的TCP_NODELAY选项与Nagle算法
热门推荐
morris
01-19 1万+
TCP_NODELAY是一个套接字选项，用于控制TCP套接字的延迟行为。当TCP_NODELAY选项被启用时，即设置为true，就会禁用Nagle算法，从而实现TCP套接字的无延迟传输。这意味着每次发送数据时都会立即发送，不会等待缓冲区的填充或等待确认。
stream_socket_client的异步使用方式
庵中十三居士的博客
12-29 2921
php异步的stream_socket_client和发送数据。
Python 网络协议 TCP 详解
Nick.Peng's Blogs
04-08 1572
网络tcp协议的概述 TCP协议, 传输控制协议(全称:Transmission Control Protocol)是一种面向连接的, 可靠的, 基于字节流的传输层通信协议, TCP通信需要经过创建连接, 数据传送, 终止连接 三个步骤, 类似于生活中的打电话场景, 需要建立连接, 确认发送结果, 安全传输. TCP 严格区分客户端和服务端, 服务端一般都需要绑定端口, 否则客户端找不到服务器...
【网络篇】socket编程——TCP（史上最全）
Linux驱动开发工程师，熟悉Linux/Android底层驱动、TP、显示、IIC、网络等通用外设调试适配，Linux上层应用开发，主要集中在瑞芯微和全志平台。
03-19 9943
（1）TCP 是面向连接的运输层协议。应用程序在使用 TCP 协议之前，必须先建立 TCP 连接。在传送数据完毕后，必须释放已经建立的 TCP 连接 （2）每一条 TCP 连接只能有两个端点，每一条 TCP 连接只能是点对点的(一对一) （3）TCP 提供可靠交付（确认机制、拥塞控制、流量控制、超时重传）的服务。通过 TCP 连接传送的数据，无差错、不丢失、不重复，并且按序到达 （4）TCP 提供全双工通信。TCP 允许通信双方的应用进程在任何时候都能发送数据。TCP 连接的两端都设有发送缓存和接受缓存
TCP_Server
xiaochuan1984的博客
08-27 1563
通过监听本地端口，实现多线程TCP连接；
tcp_socket VS2010实现_tcp_socketVS2010_vs2010下使用tcp_
09-29
在本文中，我们将深入探讨如何在Visual Studio 2010环境下使用TCP_Socket进行网络通信。TCP（传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议，广泛应用于互联网上的各种服务，如HTTP、FTP等。...
tcp_socket.rar_TCP socket_socket_socket tcp_socket-tcp
09-23
TCP套接字（TCP Socket）是网络编程中的一个重要概念，它是基于传输控制协议（TCP）的应用层接口，用于实现两台计算机之间的可靠、面向连接的数据通信。本教程将围绕TCP套接字，深入讲解相关知识，并以一个简单的TCP...
tcp_client_socket.rar_TCP socket_client_socket_socket tcp_socket
09-23
TCP socket客户端是网络通信的一端，它通过TCP协议与服务器建立连接，发送和接收数据。在TCP协议中，客户端首先发起连接请求，经过三次握手与服务器建立起连接，然后可以进行数据传输，最后通过四次挥手断开连接。这...
TCP_socket.rar_TCP socket客户端_TCP_Socket_socket_socket 客户端
09-21
在IT领域，网络通信是不可或缺的一部分，而TCP（Transmission Control Protocol）套接字则是实现可靠网络通信的基础。本文将深入探讨TCP套接字的概念、工作原理以及如何在C++环境中实现一个简单的TCP客户端。 TCP是...
tcp_server_socket.rar_TCP服务器_socket server_socket tcp_socket 服务器
09-21
本资源“tcp_server_socket.rar”提供了一个TCP服务器的源代码实现，这对于理解和开发基于TCP的网络应用非常有帮助。下面，我们将详细探讨TCP服务器、socket_server、socket_tcp以及socket服务器相关的知识点。 ...
UDP协议
hyldzbg的博客
09-04 892
把当前要计算校验和的数据，每个字节，都进行累加，把结果保存到这两个字节的变量(校验和)中，过程中溢出也没关系，如果中间某个数据，出现传输错误，第二次计算的校验和就会和第一次不同(CRC这个算法其实不是特别靠谱，比如如果前一个字节大小少1，后一个字节大小多1，那么最后得到的校验和任然相同，但是数据可能已经不同了)。描绘这个数据报的报文长度(包含报头)，这里的长度是指该报文有多少个字节，因为只有16位比特位的大小，因为数据传输可能会出错，所以需要一定的方法知道所传输的数据是否正确传输。
网络第五章：多路转接
qincjun的博客
09-05 590
2.HTTP1.1采用了长连接的方式来进行通信：建立连接，服务器响应完之后，不断开连接，活跃的用户对服务器发送请求，服务器都会正常响应；对不活跃的用户，不进行任何操作；events是分配好的epoll_event结构体数组.epoll将会把发生的事件赋值到events数组中 (events不可以是空指针，内核只负责把数据复制到这个events数组中，不会去帮助我们在用户态中分配内存).epoll通过这些值的设定，来监视fd的行为，如果fd做了这些行为，则会通过epoll_wait来反馈给上层，进行处理。
JAVA—网络通信
Hismybestlove的博客
09-05 1488
本文是学习网络通信入门和简单了解UDP协议和TCP协议，学习和了解CS架构和简单了解BS架构和HTTP协议
​数据链路层——流量控制&可靠传输机制 ​
最新发布
qq_25467441的博客
09-09 559
例题:一个信道的数据传输率为4kb/s ,单向传播时延为30ms ,如果使停止-等待协议的信道最大利用率达到80%,要求的数据帧长度至少为。设数据帧的长度为L比特，则发送方发送全部的数据需要时间：L/4。“停止-等待”就是每发送完一个分组就停止发送，等待对方确认，在收到确认后再发送下一个分组。因为是在讨论可靠传输的原理,所以并不考虑数据是在哪一个层次上传送的。发送方在一个发送周期内,有效地发送数据所需要的时间占整个发送周期的比率。数据链路层的流量控制是点对点的，而传输层的流量控制是端到端的。
TCP/IP Socket网络编程指南
"TCP/IP Socket网络编程教程" TCP/IP协议是Internet的基础，它的设计目标是实现不同硬件、操作系统和网络环境下的计算机之间的通信。TCP/IP协议并非单指一个协议，而是一组协议的集合，它包括了网络接口层、网际层...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值