【TCP】socket套接字——快速上手

🕗 发布于 2024-04-19 18:21 tcp/ip 网络网络协议

前言

socket套接字的有些知识在上一篇【UDP】socket套接字带你快速上手中已经讲过了，这里就不在过多的叙述了。

初识TCP

TCP的主要特点

TCP是面向连接的传输层协议
TCP提供可靠交付的服务
TCP提供全双工通信
TCP是面向字节流的

TCP socket API

socket()

此函数是用来创建socket文件描述符的。创建成功则返回socket文件描述符，失败则返回-1并且设置对应的错误码
第一个参数是用来指定通信域的，也就是选择用于通信的协议族的，这里用的是IPv4协议，参数指定就是AF_INET
第二个参数是用来指定通信类型的。这里所用到的是TCP，所以参数指定为SOCK_STREAM，表示面向流的传输协议
第三个参数暂时用不到，设置为0即可

bind()

此函数是用来将用户设置的IP地址和port端口号在内核中和当前进程强关联。成功返回0，失败返回-1并且设置对应的错误码
第一个参数是你创建好的socket文件描述符
第二个参数是一个struct sockaddr的结构体指针
第三个参数是这个sockaddr的大小

listen()

此函数用来声明sockfd处于监听状态，并且最多允许有backlog个客户端处于连接等待状态，如果接收到更多的连接请求就忽略
listen成功返回0，失败返回-1并且设置对应的错误码

accept()

三次握手完成后，服务器调用accept()接受连接，如果服务器调用accept()时还没有客户端的连接请求，就阻塞等待直到客户端连接上来
第一个参数是创建好的socket文件描述符

第二个参数是一个struct sockaddr的结构体指针

第三个参数是此结构体的大小

返回值为socket文件描述符

理解accept的返回值

accept中传入了一个socket文件描述符，但是它返回的依然是一个文件描述符，那么如何理解这两个文件描述符呢？

举个例子，假如你家有个饭店，刚好这时到了饭点了，你就派出了张三到饭店门口去拉客，此时来了一名顾客正好被张三拉进到店里去了，你又派出了李四服务员去服务这位顾客，并且让张三又返回到店门口继续拉客。

在上述例子中，张三就是我们传入accept中的socket文件描述符，是获取到的新连接的，而李四就是accept返回的socket文件描述符，是真正提供服务的。

connect()

在客户端中调用，用来连接服务器
参数形式和bind的一致，区别在于bind传入的是自己的地址，为connect传入的是对方的地址
listen成功返回0，失败返回-1并且设置对应的错误码

tcp_client.cc

#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>

void Usage(std::string proc)
{
    std::cout << "\nUsage: " << proc << " serverIp serverPort\n"
              << std::endl;
}

int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }
    std::string serverip = argv[1];
    uint16_t serverport = atoi(argv[2]);

    bool alive = false;
    int sock = 0;
    std::string line;
    while (true)
    {
        if (!alive)
        {
            sock = socket(AF_INET, SOCK_STREAM, 0);
            if (sock < 0)
            {
                std::cerr << "socket error" << std::endl;
                exit(2);
            }
            struct sockaddr_in server;
            memset(&server, 0, sizeof(server));
            server.sin_family = AF_INET;
            server.sin_port = htons(serverport);
            server.sin_addr.s_addr = inet_addr(serverip.c_str());

            if (connect(sock, (struct sockaddr *)&server, sizeof(server)) < 0)
            {
                std::cerr << "connect error" << std::endl;
                exit(3);
            }
            alive = true;
            std::cout << "connect success" << std::endl;
        }
        std::cout << "请输入你的内容# ";
        std::getline(std::cin, line);
        if (line == "quit")
            break;

        ssize_t s = send(sock, line.c_str(), line.size(), 0);
        if (s > 0)
        {
            char buffer[1024];
            ssize_t s = recv(sock, buffer, sizeof(buffer) - 1, 0);
            if (s > 0)
            {
                buffer[s] = 0;
                std::cout << "server 回应# " << buffer << std::endl;
            }
            else if (s == 0)
            {
                close(sock);
            }
        }
        else
        {
            close(sock);
        }
        alive = false;
    }

    return 0;
}

tcp_server.cc

#include "tcp_server.hpp"
#include <memory>

static void Usage(std::string proc)
{
    std::cout << "\nUsage" << proc << " port\n" << std::endl;
}

int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        Usage(argv[0]);
        exit(1);
    }
    uint16_t port = atoi(argv[1]);
    std::unique_ptr<Tcp_Server> svr(new Tcp_Server(port));
    svr->InitServer();
    svr->Start();
    return 0;
}

tcp_server.hpp

#pragma once

#include <iostream>
#include <string>
#include <cstring>
#include <strings.h>
#include <assert.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <pthread.h>
#include <sys/wait.h>
#include "log.hpp"

static void service(int sock, const std::string &clientip, const uint16_t &clientport)
{
    char buffer[1024];
    while (true)
    {
        ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
        if (s > 0)
        {
            buffer[s] = 0;
            std::cout << clientip << ":" << clientport << "# " << buffer << std::endl;
        }
        else if (s == 0) // 对端关闭连接
        {
            logMessage(NORMAL, "%s:%d shutdown, me too", clientip.c_str(), clientport);
            break;
        }
        else
        {
            logMessage(ERROR, "read socket error, %d:%s", errno, strerror(errno));
            break;
        }
        
        write(sock, buffer, strlen(buffer));
    }
    close(sock);
}

class ThreadDate
{
public:
    int _sock;
    std::string _ip;
    uint16_t _port;
};

class Tcp_Server
{
private:
    const static int gbacklog = 20;
    static void *threadRoutine(void *args)//必须得是static，因为不是static的话会多出一个this指针
    {
        pthread_detach(pthread_self());//线程分离
        ThreadDate *td = static_cast<ThreadDate*> (args);
        service(td->_sock, td->_ip, td->_port);
        delete td;
        
        return nullptr;
    }

public:
    Tcp_Server(uint16_t port, std::string ip = "")
        : _port(port), _ip(ip), listensock(-1)
    {
    }
    ~Tcp_Server()
    {
    }

    void InitServer()
    {
        // 1.创建socket
        listensock = socket(AF_INET, SOCK_STREAM, 0);
        if (listensock < 0)
        {
            //创建socket失败
            logMessage(FATAL, "create socket error, %d:%S", errno, strerror(errno));
            exit(2);
        }
        logMessage(NORMAL, "create socket success, listensock:%d", listensock);

        // 2.bind
        struct sockaddr_in local;
        memset(&local, 0, sizeof local);
        local.sin_family = AF_INET;
        local.sin_port = htons(_port);
        local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str()); //INADDR_ANY：任意IP
        if (bind(listensock, (struct sockaddr *)&local, sizeof(local)) < 0)
        {
            //bind失败
            logMessage(FATAL, "bind error, %d:%s", errno, strerror(errno));
            exit(3);
        }

        // 3.建立连接
        if (listen(listensock, gbacklog) < 0)
        {
            //建立连接失败
            logMessage(FATAL, "listen error, %d:%s", errno, strerror(errno));
            exit(4);
        }

        logMessage(NORMAL, "init server success");
    }

    void Start()
    {
        // signal(SIGCHLD, SIG_IGN);//多进程版
        while (true)
        {
            // 4.获取连接
            struct sockaddr_in src;
            socklen_t len = sizeof(src);
            int servicesock = accept(listensock, (struct sockaddr *)&src, &len);
            // 获取连接失败
            if (servicesock < 0)
            {
                logMessage(ERROR, "accept error, %d:%s", errno, strerror(errno));
                continue;
            }
            // 获取连接成功
            uint16_t client_port = ntohs(src.sin_port);
            std::string client_ip = inet_ntoa(src.sin_addr);
            logMessage(NORMAL, "link success, servicesock: %d | %s : %d |\n", servicesock, client_ip.c_str(), client_port);

            // 5.开始通信
            // 版本1——单进程循环版
            // 缺点：一次只能处理一个客户端，处理完后才能处理下一个
            // service(servicesock, client_ip, client_port);
            // close(servicesock);

            //版本2.0——多进程（创建子进程）
            // pid_t id = fork();
            // assert(id != -1);
            // if(id == 0)
            // {
                //子进程
                // close(listensock);
                // service(servicesock, client_ip, client_port);
                // exit(0);
            // }
            //父进程
            // close(servicesock);

            //版本2.1——多进程版本（孤儿进程）
            // pid_t id = fork();
            // assert(id != -1);
            // if(id == 0)
            // {
                //子进程
                // close(listensock);
                // if(fork() > 0) exit(0);//子进程退出，由操作系统领养
                //孙子进程
                // service(servicesock, client_ip, client_port);
                // exit(0);
            // }
            //父进程
            // waitpid(id, nullptr, 0);
            // close(servicesock);

            //版本3——多线程版
            ThreadDate *td = new ThreadDate();
            td->_sock = servicesock;
            td->_ip = client_ip;
            td->_port = client_port;
            pthread_t tid;
            pthread_create(&tid, nullptr, threadRoutine, td);
        }
    }

private:
    uint16_t _port;
    std::string _ip;
    int listensock;
};

完整代码链接

TCP socket：TCP Socket

原文地址：https://blog.csdn.net/m0_62537611/article/details/137748968

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：华为云服务镜像手动更换
下一篇：Linux debian gdb dump

FPGA 第7讲简单组合逻辑译码器
经过验证对比发现两种方法虽然最后实现的功能是一样的，而所得到的 RTL 视图差别较大，但最后的逻辑资源使用却是相同的（时序逻辑中不一定相同），说明综合器进行了适当的优化。if-else 的这种写法是存
阅读更多2024-11-16
梧桐杯初赛入围（人工智能赛道） 15 / 100
本项目开发了一套先进的医疗问答系统，该系统融合了 Reinforced Attention Generator (RAG) 技术与大模型，旨在通过精确的知识检索和问答生成技术，显著提升心理健康咨询系统
阅读更多2024-11-16
faiss 提供了多种索引类型
faiss 多种索引类型
阅读更多2024-11-16
物联网低功耗广域网LoRa开发(二)：LoRa开发环境搭建及驱动移植
【代码】物联网低功耗广域网LoRa开发(二)：LoRa开发环境搭建及驱动移植。
阅读更多2024-11-16
【隐私计算】隐私计算的应用场景探索(大模型隐私计算、隐私数据存储计算、Web3、隐私物联网等)
隐私计算、隐私保护、大模型安全、大模型隐私推理、数据安全、数据隐私、web3、分布式网络、去中心化网络、隐私数据存储、大厂数据保护、隐私计算应用探索
阅读更多2024-11-16
EHOME视频平台EasyCVR多品牌摄像机视频平台监控视频编码H.265与Smart 265的区别？
Smart 265和Smart 264的区别是一个是在H.264编码基础上，一个是在H.265编码基础上，其作用都是在当前码率参数下进一步节省码流，如果你摄像头图像上运动画面越少，静止画面越多，则码率
阅读更多2024-11-16
软件测试基础二十九（接口测试 mock）
软件测试基础之接口测试 mock
阅读更多2024-11-16
《FreeRTOS任务基础知识以及任务创建相关函数》
FreeRTOS学习日志（4）--FreeRTOS任务基础知识以及任务创建相关函数
阅读更多2024-11-16
dlopen: cannot load any more object with static TLS & sklearn, HPOBench, smac3
成功解决：升级glibc版本到2.23。
阅读更多2024-11-16
2024年11月15日Github流行趋势
项目名称：MinerU项目名称：exo项目名称：nvm项目名称：kotaemon项目名称：VideoLingo项目名称：motion项目名称：primeng项目名称：bbot项目名称：es-toolk
阅读更多2024-11-16