linux学习之Socket

编写socket-udp

第一步，编写套接字

第二步，绑定端口号

第三步，启动服务器，读取数据

第四步，接收消息并发回信息给对方

编写socket-Tcp

第一步，编写套接字

第二步，绑定端口号

第三步，将套接字设置为监听状态。

第四步，在服务器运行里获取新连接

第五步，进行读写通信

编写socket-udp

如何认识快速的Udp，我们先来编写一个udp服务器。

第一步，编写套接字

int socket

创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器 )

第一个参数domain即创建套接字的域，如下表：

看以看到有ipv4,ipv6,ipx等。

第二个参数为类型当前socket的类型，如下图所示：

例如sock_stream为有序的可靠的字节流，sock_DGRAM为数据报类型等

第三个为参数protecal,指定域套接字一起使用的特定协议，通常在给定协议族中，只存在一个协议来支持特定的套接字类型。

创建成功会返回一个新的套接字，失败则会返回-1.

第二步，绑定端口号

接口bind

第一个参数为sockfd，套接字id，第二个为套接字类型，这里我们是网络接口，所以应该使用struct sockaddr_in类型的接口。但是我们一般也不会去创建，而是直接定义初始化内存直接用。这里用bzero来初始化内存为0：

之后初始化结构体的内容，设置结构体类型，端口号，ip地址。

之后进行由主机序列转到网络序列：

htons接口：

这些函数名很好记 ,h 表示 host,n 表示 network,l 表示 32 位长整数 ,s 表示 16 位短整数

例如 htonl 表示将 32 位的长整数从主机字节序转换为网络字节序 , 例如将 IP 地址转换后准备发送。

如果主机是小端字节序 , 这些函数将参数做相应的大小端转换然后返回 ;

如果主机是大端字节序 , 这些函数不做转换 , 将参数原封不动地返回。

除了端口号，一般在发送数据时，还需要连ip地址一起打包成封装发送出去，因此对于ip地址我们人需要转化成网络字节序列。分两步转化，现将字符串转化为四字节（uint32_t），再转化为网络字节序列。

当然系统也为我们提供了字符串转为网络字节序的接口 inet_addr:

之后开始绑定，注意结构体（套接字）类型一致，绑定成功返回0，失败返回-1.

第三步，启动服务器，读取数据

recvfrom接口从套接字中获取消息：

参数一位网络文件描述符，参数二为获取的消息，参数三为长度，参数四为标志，当前我们就设置为0，参数五为接收方的套接字，参数六位套接字的大小，后面两个参数是输入型参数。成功返回获取信息的大小。

看可以看到收到消息，我们需要知道消息内容，发消息的源址。

第四步，接收消息并发回信息给对方

收到信息后，发回给对方，调用接口sendto：

参数一为网络文件描述符，参数二为字符缓冲区，参数三为长度，参数四为标志，参数五与参数六接口域recvfrom基本一致，不过这里最后两个参数为输入型参数。

之后我们可以用 netstat -nlup 来查看创建的服务器。

需要注意一点，云服务器不能直接绑定公网ip。我们一般推荐任务地址绑定。

对于端口的选择，我们【0，1023】都是系统端口，直接绑定需要root权限，一般需要有固定的应用协议层使用。绑定我们一般选大一点的端口号。

现在我们就编写一个客户端域服务端的demo版本，先来理解UDP通信：

Udpserver.hpp

#pragma once

#include<cstring>
#include<iostream>
#include<string.h>
#include<sys/types.h>
#include<sys/socket.h>
//包含下面两个头文件，此时struct sockeaddr_in 初始化有提示
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
using namespace std;

const int Size=1024;
string defaultip="0.0.0.0";
uint16_t defaultport=8080;
enum{
    SOCKET_ERR=1,
    Bind_ERR
};


class UdpServer
{
    public:
        UdpServer(uint16_t &port=defaultport, const string &ip=defaultip):_sockfd(0),_port(port),_ip(ip),is_running(false)
        {

        }
        //搭建udp网络服务器
        void Init()
        {
            //1.创建套接字  协议为ipv4，类型为数据报 
            _sockfd=socket(AF_INET,SOCK_DGRAM,0);  //这里除了AF_INIT  也可以写作PF_INIT
            if(_sockfd<0)
            {
                cout<<"创建套接字失败,socket:"<<socket<<endl;
                exit(SOCKET_ERR);
            }else{
                cout<<"创建套接字成功,socket:"<<socket<<endl;
            }
            //2.告诉服务器端口号，绑定端口号
            struct sockaddr_in local;
            //内容置空
            bzero(&local,sizeof(local));
            //初始化其中内容   
            local.sin_family=AF_INET;//ipv4的类型 该结构体前两个字节表示其类型
            local.sin_port=htons(_port);    //指明端口号，且由于端口好是发送到网络当中去，所以是网络字节序列 
            //由主机序列转到网络序列提供有接口，我们直接调用转化

            local.sin_addr.s_addr=inet_addr(_ip.c_str());      //32位的地址,一般用户喜欢用点分十进制的字符串表示，
            //其次对于ip地址，我们需要将字符串转化为uint32_t 

            //初始化对象完成，开始绑定套接字,设置到内核
            if(bind(_sockfd,(const struct sockaddr*)&local,sizeof(local))<0)
            {
                
                printf("绑定失败,errno:%d,错误信息:%s",errno,strerror(errno));
                exit(Bind_ERR);
            }

            cout<<"绑定成功！！！"<<endl;


        }

        void Run()
        {
            //服务器搭建成功
            char buffer[Size];
            is_running=true;   //改变状态
            while (is_running)
            {
                //读取数据
                struct sockaddr_in client;
                socklen_t len=sizeof(client);
                ssize_t n=recvfrom(_sockfd,buffer,sizeof(buffer)-1,0,( struct sockaddr*)&client,&len);
                if(n<0)
                {
                    printf("接收失败,errno%d:,错误信息%s\n",errno,strerror(errno));
                    continue;
                }
                  
                buffer[n]=0; 
                cout<<"接受消息:"<<buffer<<endl;
                string info=buffer;
                string string_echo="server echo#"+info;
             
                //发回信息给对方
                sendto(_sockfd,string_echo.c_str(),string_echo.size(),0,(const struct sockaddr*)&client,len);
            }

        }

       ~UdpServer()
       {
        if(_sockfd>0) close(_sockfd);
       }



    private:
    int _sockfd;   //网络文件描述符
    uint16_t _port;//端口号
    string _ip; //ip地址 一般绑定任意地址0.0.0.0  可以不需要给出ip。
    bool is_running;//判断服务器是否再运行
};

对应的.cc

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

void Usage(string p)
{
    cout<<"\n\rUsage: "<<p<<" prot[1024] bigger "<<endl;
}

int main(int argc,char *argv[])
{
    if(argc!=2)
    {
        Usage(argv[0]);
        exit(0);
    }

    
    //构建udp服务器
    uint16_t port= stoi(argv[1]);
    const string ip="0.0.0.0";
    std::unique_ptr <UdpServer> svr(new UdpServer(port,ip));
    svr->Init();
    svr->Run();

    return 0;
}

Udpclient.cc

#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
using namespace std;
void Usage(string p)
{
    cout<<"\n Usage:"<<p<<" ip_address   port[1024+]"<<endl;

}

int main(int argc,char *argv[])
{

   
    if(argc!=3)
    {
        Usage(argv[0]);
        exit(0);
    }
    uint16_t port=stoi(argv[2]);
    const string ip=argv[1];
    //构建服务端的套接字
     struct sockaddr_in server;
     bzero(&server,sizeof(server));
    server.sin_addr.s_addr=inet_addr(ip.c_str());
    server.sin_family=AF_INET;
    server.sin_port=htons(port);
    socklen_t len=sizeof(server);
     int sockfd=socket(AF_INET,SOCK_DGRAM,0);
    if(sockfd<0)
    {
        cout<<"create socket error"<<endl;
        return 1;
    }
    //需要绑定ip地址，端口号,不过不需要我们绑定，操作系统随机选择
    //一个端口号只能被一个进程绑定，对于客服端也是如此
    //客户端的端口号不重要，只要保持唯一性即可，因为服务端已经知道客户端是哪里的，在首次发送数据的时候就会绑定
    string message;
    char buffer[1024];
    while(true)
    {
        cout<<"请输入你要发的消息@";
        getline(cin,message);
        //发数据报
        sendto(sockfd,message.c_str(),message.size(),0,(const struct sockaddr*)&server,len);
        cout<<".............."<<endl;
        //该客户端可能还会读取其他服务器发消息
        struct sockaddr_in temp;
        socklen_t len=sizeof(temp);
        ssize_t n=recvfrom(sockfd,buffer,1023,0,( struct sockaddr*)&temp,&len);
        if(n>0)
        {
             buffer[n]=0;
            cout<<"收到消息："<<buffer<<endl;;
        }
        // if(n<0)
        // {
        //     printf("收到消息失败,errno %s,错误信息%s\n",errno,strerror(errno));
        // }else
        // {
        //     buffer[n]=0;
        //     printf("收到消息，消息：%s\n",buffer);
        // }
       

    }
    
    close(sockfd);
    return 0;
}

既然有了服务端那么我们就可以在收到信息时，让他拿到ip地址，端口号和数据报文，同时创建同时在线的用户名单，一个发，所有可以看到。其次客户端显示信息也不太好，我们可以用多线程一个用来收，一个用来发。

改良版：

Udpserver.hpp

class UdpServer
{
    public:
        UdpServer(uint16_t &port=defaultport, const string &ip=defaultip):_sockfd(0),_port(port),_ip(ip),is_running(false)
        {

        }

        //搭建udp网络服务器
        //udp的套接字是全双工的
        void Init()
        {
            //1.创建套接字  协议为ipv4，类型为数据报 
            _sockfd=socket(AF_INET,SOCK_DGRAM,0);  //这里除了AF_INIT  也可以写作PF_INIT
            if(_sockfd<0)
            {
                cout<<"创建套接字失败,socket:"<<socket<<endl;
                exit(SOCKET_ERR);
            }else{
                cout<<"创建套接字成功,socket:"<<socket<<endl;
            }
            //2.告诉服务器端口号，绑定端口号
            struct sockaddr_in local;
            //内容置空
            bzero(&local,sizeof(local));
            //初始化其中内容   
            local.sin_family=AF_INET;//ipv4的类型 该结构体前两个字节表示其类型
            local.sin_port=htons(_port);    //指明端口号，且由于端口好是发送到网络当中去，所以是网络字节序列 
            //由主机序列转到网络序列提供有接口，我们直接调用转化

            local.sin_addr.s_addr=inet_addr(_ip.c_str());      //32位的地址,一般用户喜欢用点分十进制的字符串表示，
            //其次对于ip地址，我们需要将字符串转化为uint32_t 

            //初始化对象完成，开始绑定套接字,设置到内核
            if(bind(_sockfd,(const struct sockaddr*)&local,sizeof(local))<0)
            {
                
                printf("绑定失败,errno:%d,错误信息:%s",errno,strerror(errno));
                exit(Bind_ERR);
            }

            cout<<"绑定成功！！！"<<endl;


        }
        string Handler(const string info,const string clientip,const uint16_t clientport)
        {
            cout<<"["<<clientip<<": "<<to_string(clientport)<<"] @"<<info<<endl;

            string res="server get a message :";
            res+=("["+clientip+":"+to_string(clientport)+"] @");
            res+=info;
            return res;
        }

        void Broadcast(const string info,const string clientip,const uint16_t clientport)  //收到消息发送给所有用户
        {
            for( auto &it :_users)
            {
                string messages=" get a message :";
                messages+=("["+clientip+":"+to_string(clientport)+"] @");
                messages+=info;

                socklen_t len=sizeof(it.second);
                sendto(_sockfd,messages.c_str(),messages.size(),0,(const struct sockaddr*)&(it.second),len);
            }
        }
        bool Checkuser(const struct sockaddr_in user,const string clientip,const uint16_t clientport)//检查用户是否存在，不存在添加用户
        {
                auto it=_users.find(clientip);
                if(it==_users.end())
                {
                    //添加用户
                    _users.insert(make_pair(clientip,user));
                    cout<<"["<<clientip<<": "<<to_string(clientport)<<"] has added to online_users"<<endl;
                }
        }  

        void Run()
        {
            //服务器搭建成功
            char buffer[Size];
            is_running=true;   //改变状态
            while (is_running)
            {
                //读取数据
                struct sockaddr_in client;
                socklen_t len=sizeof(client);
                ssize_t n=recvfrom(_sockfd,buffer,sizeof(buffer)-1,0,( struct sockaddr*)&client,&len);
                if(n<0)
                {
                    printf("接收失败,errno%d:,错误信息%s\n",errno,strerror(errno));
                    continue;
                }
                
                
                //获取用户的ip地址与端口号
                 uint16_t clientport=ntohs(client.sin_port);
                 std::string clientip=inet_ntoa(client.sin_addr);
                //先检测用户是否存在过
                 Checkuser(client,clientip,clientport);
                 //广播给所有用户
                 std::string info = buffer;
                 
                 Broadcast(info,clientip,clientport);
                ;
                //发回信息给对方 
                string string_echo="echo#"+info;
                sendto(_sockfd,string_echo.c_str(),string_echo.size(),0,(const struct sockaddr*)&client,len);
            }

        }

       ~UdpServer()
       {
        if(_sockfd>0) close(_sockfd);
       }



    private:
    int _sockfd;   //网络文件描述符
    uint16_t _port;//端口号
    string _ip; //ip地址 一般绑定任意地址0.0.0.0  可以不需要给出ip。
    bool is_running;//判断服务器是否再运行

    //保存客户端用户信息
    std::unordered_map<string,struct sockaddr_in> _users;
};

ucpclient.cc

#include<iostream>
#include<sys/types.h>
#include<sys/socket.h>
#include<unistd.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
#include<pthread.h>
using namespace std;

struct ThreadDate
{
    int sockfd;
    struct sockaddr_in server;

};
void Usage(string p)
{
    cout<<"\n Usage:"<<p<<" ip_address   port[1024+]"<<endl;

}

void *send_message(void *args)
{
        ThreadDate *td=static_cast<ThreadDate*>(args);
        std::string message;
        socklen_t len=sizeof(td->server);
        while(true)
        {
            cout<<"请输入你要发的消息@";
            getline(cin,message);
            //发数据报
            sendto(td->sockfd,message.c_str(),message.size(),0,(const struct sockaddr*)&(td->server),len);
            cout<<".............."<<endl;
        }

 }
void *recive_mesage(void *args)
{
        ThreadDate *td=static_cast<ThreadDate*>(args);
        char buffer[1024];
        while(true)
        {
            struct sockaddr_in temp;
            socklen_t len=sizeof(temp);
            ssize_t n=recvfrom(td->sockfd,buffer,1023,0,( struct sockaddr*)&temp,&len);
            if(n>0)
            {
                buffer[n]=0;
                cout<<"收到消息："<<buffer<<endl;;
            }
        }
}
int main(int argc,char *argv[])
{
    if(argc!=3)
    {
        Usage(argv[0]);
        exit(0);
    }

    uint16_t port=stoi(argv[2]);
    const string ip=argv[1];
    struct ThreadDate td;
    //初始化服务端的套接字
     bzero(&td.server,sizeof(td.server));
    td.server.sin_addr.s_addr=inet_addr(ip.c_str());
    td.server.sin_family=AF_INET;
    td.server.sin_port=htons(port);
    socklen_t len=sizeof(td.server);
    td.sockfd=socket(AF_INET,SOCK_DGRAM,0);
    if(td.sockfd<0)
    {
        cout<<"create socket error"<<endl;
        return 1;
    }
    //需要绑定ip地址，端口号,不过不需要我们绑定，操作系统随机选择
    //一个端口号只能被一个进程绑定，对于客服端也是如此
    //客户端的端口号不重要，只要保持唯一性即可，因为服务端已经知道客户端是哪里的，在首次发送数据的时候就会绑定

    //创建两个线程  一个用来接受，一个用来发送
    pthread_t reciver,sender;
    pthread_create(&reciver,nullptr,recive_mesage,&td);
    pthread_create(&sender,nullptr,send_message,&td);    

    pthread_join(reciver,nullptr);
    pthread_join(sender,nullptr);

这里在编写的时候注意地址转化函数，,sockaddr_in中的成员struct in_addr sin_addr表示32位的IP 地址但是我们通常用点分十进制的字符串表示IP 地址,以下函数可以在字符串表示和in_addr表示之间转换;

其中inet_pton和inet_ntop不仅可以转换IPv4的in_addr,还可以转换IPv6的in6_addr,因此函数接口是void*addrptr。

关于inet_ntoa：inet_ntoa这个函数返回了一个char*, 很显然是这个函数自己在内部为我们申请了一块内存来保存ip的结果. 那么是否需要调用者手动释放呢?

实际上内部放在了静态区中，但是多线程在竞争调用时，还是会出现线程安全，现在在centos7上好像做了改善，里面加了锁，但是应用的时候，如果我们不放心还是尽量使用inet_mtop这样的接口。

编写socket-Tcp

学了Udp套接字的编写，Tcp相对来说会好一点，因为Tcp与Udp本来就是有交集的。

首先刚开始的套路一样：

第一步，编写套接字

与udp一样，创建sockfd文件描述符。不过这里的参数二即类型我们设置为 SOCK_STREAM（数据流）类型。

第二步，绑定端口号

在绑定端口号前，需要创建sock_addrin结构体并初始化，在将字符串Ip地址转化为网络字节序，我们这里使用的接口为inet_aton().

参数一为char*类型ip，参数二为sin_addr.

第三步不一样。

第三步，将套接字设置为监听状态。

listen 将套接字设置为监听状态

成功返回0，错误返回-1.第二个参数代表列表长度。

第四步，在服务器运行里获取新连接

accept获取新连接

参数一文件描述符，后两个参数为输出型参数，为addrin及其长度，可以获知哪一个客户端的信息。返回值成功返回文件描述符，否则返回-1。

与Udp不同，udp的套接字从始至终都只有一个，而Tcp有两个，实际上最开始的套接字，并不是我们要去通信的套接字，Tcp通信的套接字，是要在accept之后的套接字。因此之前的套接字，我们也可以叫做监听套接字。

之后我们就可以测试了，即使我们没写客户端，但在系统下会有一个工具telnet,可以指定登录远程服务器。

这里注意一点，无论是Tcp还是Udp我们都无法绑定公网ip。

第五步，进行读写通信

与Udp不同，我们这里不使用recvfrom与sendto接收发送消息，而是用文件描述符进行通信。

用read与write。

之后就可以编写客户端进行通信了。

对于客户端通过connect发起连接。

后两个参数为输出型参数，用来保存信息。成功返回0，否则-1.

Tcpserver.hpp

#pragma once
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <strings.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <memory>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
using namespace std;
// 错误码
enum
{
    SOCKERROR = 2,
    BINDERROR,
    LISTENERROR,
    ACCEPTEEROR
};
const uint16_t defaultfd = -1;
const std::string defaultip = "127.0.0.1";
const uint16_t defaultport = 8080;
class TcpServer;
struct PthreadData
{
    PthreadData( int sockfd,std::string clientip,uint16_t port,TcpServer*tcp):_newsockfd(sockfd),_clientip(clientip),_clientport(port),_server(tcp)
    {

    }
    int _newsockfd;
    std::string _clientip;
    uint16_t _clientport;
    TcpServer *_server;
};
class TcpServer
{
public:
    TcpServer(const uint16_t port = defaultport, const int socket = defaultfd, const string ip = defaultip) : _port(port), _listensockfd(socket), _ip(ip)
    {
    }

    void Init()
    {
        // 创建套接字
        _listensockfd = socket(AF_INET, SOCK_STREAM, 0); // TCP我们使用流类型
        if (_listensockfd == -1)
        {
            cout << "错误码：" << errno << ",错误信息: " << strerror(errno) << endl;
            exit(SOCKERROR);
        }

        cout << "创建成功......" << endl;
        // 创建sockaddr 并且绑定端口号
        struct sockaddr_in local;
        bzero(&local, sizeof(local));
        local.sin_family = AF_INET;
        // local.sin_addr.s_addr=inet_addr(c_str(_ip));
        local.sin_port = htons(_port);
        inet_aton(_ip.c_str(), &(local.sin_addr));
        socklen_t len = sizeof(local);
        // 绑定套接字
        int n = bind(_listensockfd, (const struct sockaddr *)&local, len);
        if (n < 0)
        {
            cout << "绑定失败,错误码:" << errno << "，错误信息:" << strerror(errno) << endl;
            exit(BINDERROR);
        }
        cout << "绑定成功........." << endl;
        // 将套接字设置为监听状态
        // 因为Tcp是面向字节流的，且是被动的，服务器需要一直打开来接受客户端的请求
        if (listen(_listensockfd, 5) == -1)
        {
            cout << "设置监听失败"
                 << "错误码，" << errno << "错误信息" << strerror(errno) << endl;
            exit(LISTENERROR);
        }
        cout << "listen has finished......" << endl;
    }
     void Service(int &sockfd, uint16_t &port, char *ip)
    {
        // 测试收到消息显示出来,
        char buffer[1024];
        // 读取消息
        while (true)
        {

            ssize_t n = read(sockfd, buffer, sizeof(buffer));
            fflush(stdin);
            if (n > 0)
            {
                buffer[n] = 0;
                cout << "收到来自 ip:" << ip << "端口号：" << port << "的消息:" << buffer << endl;
                // 写回消息，发送消息
                string inputbuffer = "server recive message";
                inputbuffer += buffer;
                write(sockfd, inputbuffer.c_str(), inputbuffer.size());
            }
            else
            {
                cerr << "信息读取错误，错误码" << errno << "，错误信息" << strerror(errno) << endl;
                break;
            }
        }
    }
    static void *Running(void *args)
    {
        PthreadData*data=static_cast<PthreadData*> (args);
        pthread_detach(pthread_self());
        data->_server->Service(data->_newsockfd, data->_clientport, (char*)(data->_clientip).c_str());
       //这里不能关闭描述符
        delete data;
        return nullptr;
    }
    void Start()
    {
        while (true)
        {
            cout << "server is running....." << endl;
            sleep(1);
            // 由于参数为输出型参数，需要给一个sockaddrin来保存客户端的信息
            struct sockaddr_in client;
            socklen_t len = sizeof(client);
            // 获取新连接
            int newsockfd = accept(_listensockfd, (struct sockaddr *)&client, &len); // 阻塞式等待
            // 对于这两个套接字  ，—listensockfd，可以理解为拉拢客户端 newsockfd，理解为处理客户端
            // 之前的监听套接字不是我们真正要去处理客户端的套接字 ，只有在accept之后获取的新套接字才是
            if (newsockfd < 0) // 客户端会有很多，accept失败继续去accept
            {
                cout << "accept error" << endl;
                continue;
            }

            uint16_t clientport = htons(client.sin_port);
            char clientip[80];
            // 转为char*
            inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));
            // 根据新连接通信
            cout << "get a new link.....,"
                 << "端口号: " << clientport << "ip :" << clientip << endl;

            // 通过newsockfd进行通信

            // 提供服务
            // Service(newsockfd, clientport, clientip);
            // close(newsockfd);
            // 修改为多进程版

            // pid_t id = fork();
            // if (id == 0)
            // {
            //     close(_listensockfd);
            //     // 子进程
            //     if(fork()>0)
            //     {
            //         //当前进程直接退出
            //         exit(0);
            //     }
            //     //孙子进程来执行service
            //     //我直接退出，孙子进程交给系统领养就可以并发访问了。
            //     Service(newsockfd, clientport, clientip);
            //     close(newsockfd);
            //     exit(0);
            // }
            // close(newsockfd);//这里注意需要关闭 子进程已经拿去用了，如果不关，父进程的文件描述符越来越少
            // //这里其实也并不会关闭，里面有引用计数
            // // 父进程
            // pid_t rid = waitpid(id, nullptr,0);//子进程是阻塞等待，但父进程我们要求继续运行，这里等待设置为
            // (void)rid;
            //但是创建进程消耗太大，还是不是很好，因此我们用线程来执行
            pthread_t tid;
            PthreadData *data=new PthreadData(newsockfd,clientip,clientport,this);
            pthread_create(&tid, nullptr,Running,data);
            //我们不想让它直接等待，而是自己去玩自己的，设置detach
        }
    }

private:
    int _listensockfd;
    uint16_t _port;
    string _ip;
};

main.cc

#include<iostream>
#include<memory>
#include <unistd.h>
#include"Tcpserver.hpp"


void Helper(char *str)
{
    cout<<"please enter command in correct :"<<str<<" port[1024+]."<<endl;
}
int main(int argc,char*argv[])
{
    if(argc!=2)
    {
        Helper(argv[0]);
        exit(1);
    }
    uint16_t port=atoi(argv[1]);
    std::unique_ptr <TcpServer> svr(new TcpServer(port));
    svr->Init();
    svr->Start();
}

Tcpclient.cc

#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <strings.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
using namespace std;

void Helper(char *s)
{
    cout<<"please enter in coorrct command"<<s<<" port[1024+],"<<" ip(0.0.0.0)"<<endl;
}
int main(int argc,char *argv[])
{

    if(argc!=3)
    {
        Helper(argv[0]);
        exit(1);
    }

    uint16_t serverport=stoi(argv[1]);
    string serverip=string(argv[2]);

    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0)
    {
        cerr<<"Error,创建套接字错误"<<endl;
        return 1;
    }
    //不需要显示绑定，系统给绑定了,会在我们connect发起连接后，自动随机绑定

    //发起连接
    //通过命令行参数获取ip地址与端口号
    struct sockaddr_in server;
    bzero(&server, sizeof(server));
    server.sin_family=AF_INET;
    inet_pton(AF_INET,serverip.c_str(),&server.sin_addr);
    server.sin_port=htons(serverport);
    socklen_t len=sizeof(server);
    int n=connect(sockfd,(const struct sockaddr*)&server,len);
    if(n<0)
    {
        cerr<<"Error,连接失败,错误码"<<errno<<"错误信息"<<strerror(errno)<<endl;
        return 2;
    }
    cout<<"连接成功......"<<endl;

    //发消息
    while(true)
    {
        string message;
        cout<<"please enter#"<<endl;
        getline(cin,message);
        //将消息写入文件中
        write(sockfd,message.c_str(),message.size());
        //写完消息，再接受来自服务端的消息

        char buf[1024];
        int n=read(sockfd,buf,sizeof(buf));
        if(n<0)
        {
            cerr<<"接收消息失败,错误码"<<errno<<"错误信息"<<strerror(errno)<<endl;
        }else{
            buf[n]=0;
            cout<<"port :"<<serverport<<" ip:"<<serverip<<"recive:"<<buf<<endl;
        }
        

    }

    close(sockfd);

    return 0;


}

这里的多线程也不是最好的，因为可能存在多线程，少资源的情况，这里最后直接把线程池拿过来，我需要几个线程就创造几个线程来用。从而效果达到更优。
有时候为了避免出现和管道一样的错误，比如异常读写，读已经结束了，写还在进行，此时就会发送pipe信号强制结束写，但我们此时是想让客户端一直尝试连接，因此一般我们需要调用接口Signal来忽略pipe信号。客户端与服务端，服务端首先必须要屏蔽，对于客户端，我们实际上更想将错误暴露给用户，因此我们可以不做处理。

守护进程

首先来区分一下前台与后台程序，前台程序只有一个，后台程序有很多，一般拥有键盘文件的就是前台进程，其次每一个用户在登陆时都会形成一个session(会话)，退出时就会释放会话。系统中os就要管理会话，对应的sid就会话id。

而一个会话只有一个前台程序，键盘只能发信号给前台进程，

为什么要守护进程：

如果在我的会话中创建了很多任务，

所谓的守护进程就是可以自称进程组，自称会话的进程。

通过接口setsid,我们可以设置为会话。

setsid 设置会话，只要不是第一个进程，我就不是组长。

一般我们通过创建子进程，在退出，在设置sid，所以守护进程的本质就是孤儿进程。

其次一般我们还需要1.忽略异常信号，2.将自己变成独立的会话，3.更改当前进程的工作目录，4，保准输入标注输出全放在/dev/null这个文件，这是一个垃圾桶，这样服务器的错误信息就不会向显示其中打印。

在真正的服务器运行时，也不会再显示器看云习惯过程，而是将日志写到文件中。

之后我们会选择将该守护进程放在服务器运行前。

具体的demo版：

#pragma once

#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <signal.h>
#include <string>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

const std::string nullfile = "/dev/null";

void Daemon(const std::string &cwd = "")
{
    // 1. 忽略其他异常信号
    signal(SIGCLD, SIG_IGN);
    signal(SIGPIPE, SIG_IGN);
    signal(SIGSTOP, SIG_IGN);

    // 2. 将自己变成独立的会话
    if (fork() > 0)
        exit(0);
    setsid();

    // 3. 更改当前调用进程的工作目录
    if (!cwd.empty())
        chdir(cwd.c_str());

    // 4. 标准输入，标准输出，标准错误重定向至/dev/null
    int fd = open(nullfile.c_str(), O_RDWR);
    if(fd > 0)
    {
        dup2(fd, 0);
        dup2(fd, 1);
        dup2(fd, 2);
        close(fd);
    }
}

在系统下，也有接口为我们守护进程，一般我们自己写：daemon 在后台运行

Tcp的连接与释放

我们已经知道了代码是如何建立TCP连接的，事实上，tcp再连接过程中，是有三次握手的,服务端与客户端断开连接时，有四次挥手的过程，如下图：

在底层，操作系统会发三个报文，系统间会相互进行协商，四次挥手，在底层就是一个系统关闭文件描述符，一个确认关闭，一次关闭，两次挥手。

在两者建立连接的时候，其实就已经在通信了，我们可以这样理解三次握手与四次挥手与：

用一个谈恋爱的例子解读：

三次握手：

男：做我女朋友吧，好吗？

女：好啊，什么时候开始呢？

男：从此刻开始。

确定关系后，之后就可以发消息了

四次挥手：

第一种情况（舔狗，死性不改）：

女：现在腻了，我们必须分手。

男：好的

男：还在向女发消息。（这种就是单向的通信信道关闭）

第二种情况（顺利且完美）：

女：我们分手吧，不合适。

男：好的

男：那从现在我们就分手了

女：没问题

（双方都同意无异议的关闭通信管道）

三次握手连接：

调用 socket, 创建文件描述符 ;

调用 connect, 向服务器发起连接请求 ;

connect 会发出 SYN 段并阻塞等待服务器应答 ; ( 第一次 )

服务器收到客户端的 SYN, 会应答一个 SYN-ACK 段表示 " 同意建立连接 "; ( 第二次 )

客户端收到 SYN-ACK 后会从 connect() 返回 , 同时应答一个 ACK 段 ; ( 第三次 )

四次挥手断开连接：

如果客户端没有更多的请求了 , 就调用 close() 关闭连接 , 客户端会向服务器发送 FIN 段 ( 第一次 );

此时服务器收到 FIN 后 , 会回应一个 ACK, 同时 read 会返回 0 ( 第二次 );

read 返回之后 , 服务器就知道客户端关闭了连接 , 也调用 close 关闭连接 , 这个时候服务器会向客户端发送一个FIN; ( 第三次 )

客户端收到 FIN, 再返回一个 ACK 给服务器 ; ( 第四次 )