Linux--Socket编程TCP

前文：Socket套接字编程

TCP的特点

面向连接：TCP 在发送数据之前，必须先建立连接。
可靠性：TCP 提供了数据传输的可靠性。
面向字节流：TCP 是一个面向字节流的协议，这意味着 TCP 将应用程序交下来的数据看成是一连串的无结构的字节流。

TcpServer.hpp

创建一个Tcp服务端
在这里插入图片描述

代码

#pragma once

#include<iostream>
#include<string>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<cstring>
#include<arpa/inet.h>
#include<unistd.h>
#include <sys/wait.h>
#include<functional>
#include<pthread.h>
#include"InetAddr.hpp"
#include"Log.hpp"
#include"Threadpool.hpp"

enum
{
    SOCKET_ERROR = 1,
    BIND_ERROR,
    LISTEN_ERROR,
    USAGE_ERROR
};

const static int defaultsockfd = -1;//默认文件描述符
const static int gbacklog = 16;//默认最大连接数

using task_t=std::function<void*()>; //任务函数的类型（V3）
class TcpServer;
//线程类型数据
class ThreadData
{
public:
    ThreadData(int fd,InetAddr addr,TcpServer* s)
    :sockfd(fd),
    clientaddr(addr),
    self(s)
    {}
public:
    int sockfd;//文件描述符
    InetAddr clientaddr;//客户端地址
    TcpServer* self;//服务端
};
class TcpServer
{
public:
    TcpServer(int port)
    :_port(port),
    _listensock(defaultsockfd),
    _isrunning(false)
    {}
    void InitServer()
    {
        //1.创建字节流套接字
        _listensock=socket(AF_INET,SOCK_STREAM,0);
        if(_listensock<0)
        {
            LOG(FATAL, "socket error");
            exit(SOCKET_ERROR);
        }
        LOG(DEBUG, "socket create success, sockfd is : %d\n", _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=INADDR_ANY;

        int n= ::bind(_listensock,(struct sockaddr*)&local,sizeof(local));
        if(n<0)
        {
            LOG(FATAL, "bind error\n");
            exit(BIND_ERROR);
        }
        LOG(DEBUG, "bind success, sockfd is : %d\n", _listensock);

        //3.监听客户端，等待被连接
        n=listen(_listensock,gbacklog);
        if(n<0)
        {
            LOG(FATAL, "listen error");
            exit(LISTEN_ERROR);
        }
        LOG(DEBUG, "listen success, sockfd is : %d\n", _listensock);
    }
    //将接收到的数据进行处理，完成对应服务
    void Service(int sockfd,InetAddr client)
    {
        LOG(DEBUG, "get a new link, info %s %d ,fd: %d \n ",client.Ip().c_str(),client.Port(),sockfd);

        std::string clientaddr = "[" + client.Ip() + ":" + std::to_string(client.Port()) + "]# ";

        while(true)
        {
            char inbuffer[1024];
            ssize_t n = read(sockfd,inbuffer,sizeof(inbuffer)-1);//读取数据
            if(n>0)
            {
                inbuffer[n]=0;
                std::cout<<clientaddr<<inbuffer<<std::endl;//打印对应的数据

                std::string echo_string = "[server echo]# ";
                echo_string+=inbuffer;
                
                write(sockfd,echo_string.c_str(),echo_string.size());//返回给客户端
            }
            else if(n==0) //client退出并且关闭连接了
            {
                LOG(INFO, "%s quit\n", clientaddr.c_str());
                break;
            }
            else
            {
                LOG(ERROR, "read error\n");
                break;
            }
        }
	close(sockfd);        
    }
    //线程的处理函数
    static void* HandlerSock(void* args)
    {
        pthread_detach(pthread_self());//线程分离
        ThreadData* td=static_cast<ThreadData*>(args);//创建对应线程数据类型
        td->self->Service(td->sockfd,td->clientaddr);
        delete td;
        return nullptr;
    }
    //服务器循环运行着
    void Loop()
    {
        _isrunning=true;
        while(_isrunning)
        {
            struct sockaddr_in peer;//sock地址peer
            socklen_t len=sizeof(peer);
            //要先通过连接才能够进行通信
            int sockfd=::accept(_listensock,(struct sockaddr *)&peer,&len);//这里的监听sock和sockfd是不同的
            if(sockfd<0)
            {
                 LOG(WARNING, "accept error\n");
                continue;
            }

            //Version0 这种版本只能接收一次需求，无法多客户端连接
           // Service(sockfd,InetAddr(peer));

            //Version1 多进程
            // pid_t id=fork();
            // if(id>0)
            // {
            //     //子进程负责连接，父进程负责监听，
            //     close(_listensock);
            //     if(fork()>0) exit(0);
            //     //孙进程负责服务，由于子进程连接之后，子进程会进行回收，因此孙进程称为孤儿进程，之后不受子进程的影响
            //     //类似线程分离，是独立的，之后受系统进行回收
            //     Service(sockfd,InetAddr(peer));
            //     exit(0);
            // }
            // //父进程只负责监听，不需要进行连接
            // close(sockfd);
            // waitpid(id,nullptr,0);

            //Version2:采用多线程
            pthread_t t;
            ThreadData* td=new ThreadData(sockfd,peer,this);
            pthread_create(&t,nullptr,HandlerSock,td);//将线程分离

            //Version3:线程池
            //task_t t = std::bind(&TcpServer::Service,this,sockfd,InetAddr(peer));
            //ThreadPool<task_t>::GetInstance()->Enqueue(t);
        }
        _isrunning=false;
    }
    ~TcpServer()
    {
        if(_listensock>defaultsockfd)
        {
            close(_listensock);
        }
    }
    
private:
    uint16_t _port;//端口号
    int _listensock;//监听的文件描述符
    bool _isrunning;//启动
};

解释

在这里插入图片描述
初始化服务端，主要完成套接字的创建绑定，已经完成对应的监听客户端，因为Tcp是有连接的，所以需要监听客户端是否有请求连接的需求；
SOCK_STREAM表示字节流

gbacklog：这个参数定义了内核应该为相应套接字排队的最大连接数。这个值至少为0；其实际值由系统限制，可以通过sysctl命令的net.core.somaxconn参数查看和设置。需要注意的是，这个值并不是指系统能处理的并发连接数，而是内核中等待accept(处理的连接队列的最大长度。

在这里插入图片描述
启动服务器之后，通过循环让服务端不断运行着，在循环里面，服务端可能接收到多个客户端请求的连接，所以accpet要在循环中不断接收看是否有对应的连接；

连接完之后通过Service服务函数完成双方的通信
在这里插入图片描述
在Loop中，循环表示接收多个客户端，而Service中，循环表示每个服务端与客户端的通信保持；
由于tcp是面向字节流的，所以可以利用文件描述符的性质，运用read函数，读取对应的发送端数据.
当n大于0时，表示对方有数据发送，处理完信息后反馈给对方；
当n==0，表示sockfd被关闭了，也就是连接被断开了；
当n小于0时，表示出现错误；
如果一直没有发送数据，那么会在read函数这里发生阻塞；

在这里插入图片描述
而对于服务的处理，这里有多种方法，如果直接使用Service函数的话，是不可行的，因为这样无法多客户端连接：

通过多进程的方法，让父进程只负责监听，子进程负责连接，孙进程负责服务，由于孙进程是孤儿进程，相当于线程分离，这样处理服务时就不会受到父子进程的影响了；也就能完成多客户端的通信了；

在这里插入图片描述
直接通过多线程的方法，将创建的线程进行分离，完成对应的服务任务

main.cc

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

void Usage(std::string proc)
{
    std::cout << "Usage:\n\t" << proc << " local_port\n" << std::endl;
}
// ./main.cc 8080
int main(int argc,char* argv[])
{
    if(argc!=2)
    {
        Usage(argv[0]);
        return 1;
    }
    EnableScreen();//打印到屏幕
    uint16_t port=std::stoi(argv[1]);//获取端口号
    std::unique_ptr<TcpServer> tsvr=std::make_unique<TcpServer>(port);//服务端的指针
    tsvr->InitServer();//初始化
    tsvr->Loop();//循环运行
    return 0;

}

TcpClient.cc

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

void Usage(std::string proc)
{
    std::cout << "Usage:\n\t" << proc << " serverip serverport\n"
              << std::endl;
}
// ./TcpClient.cc 127.0.0.1 8080
int main(int argc,char* argv[])
{
    if(argc!=3)
    {
        Usage(argv[0]);
        exit(1);
    }

    std::string serverip=argv[1];//服务端ip
    uint16_t serverport=std::stoi(argv[2]);//服务端端口号

    int sockfd = socket(AF_INET, SOCK_STREAM, 0);//创建套接字
    if (sockfd < 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());
    //连接服务端
    int n=connect(sockfd,(struct sockaddr*)&server,sizeof(server));
    if(n<0)
    {
        std::cerr << "connect error" << std::endl;
        exit(3);
    }

    while(true)
    {
        std::cout<<"Please Enter# ";
        std::string outstring;
        getline(std::cin,outstring);
        //发送对应数据
        ssize_t s=send(sockfd,outstring.c_str(),outstring.size(),0);
        if(s>0)
        {
            char inbuffer[1024];
            ssize_t m=recv(sockfd,inbuffer,sizeof(inbuffer)-1,0);//接收对应数据
            if(m>0)
            {
                inbuffer[m]=0;
                std::cout<<inbuffer<<std::endl;
            }
            else
            {
                break;
            }
        }
        else
        {
            break;
        }

       
    }
    close(sockfd);
    return 0;
}