套接字实现TCP

套接字

套接字的意义就是客户端与服务器进行双向通信的端点，如果有不理解点上面套接字三字更近距离了解套接字。
网络套接字与客户连接的特定网络有关的服务端口号，这个端口号允许linux进入特定的端口号的连接转到正确的服务器进程。

套接字通信的建立过程:

服务器端

1.使用socket创建一个套接字。它是OS分配给服务器进程的类似文件描述符的资源。
2.服务器进程用系统调用bind命名套接字。然后服务器开始等待客户端连接到这个命名套接字。
3.服务器通过系统调用accept来接受客户的连接。accept会创建一个不同于命名套接字的新套接字来与这个特定客户进行通信，而命名套接字则被保留下来继续处理其他客户的连接请求。
4.系统获取客户端基本信息,为客户端提供服务。

客户端

1.调用socket创建一个未命名套接字。
2.通过远端主机信息,向服务器发起连接。

实现一个客户端与主机端连接，将客户文本进行统一大小写转换。

实现服务器端ServerTcp:

第一步创建类名字为ServerTcp，在类里创建私有变量套接字与端口和IP。
private:
//套接字
int listenSock_;
//port接口
uint16_t port_;
//ip
std::string ip_;

 第二步创建构造函数与析构函数。
ServerTcp(uint16_t port,const std::string &ip=""):port_(port),ip_(ip),listenSock_(-1){ }
~ServerTcp(){ }
 第三步 创建套接字socket,并判断是否创建成功
 listenSock_=socket(PF_INET,SOCK_STREAM,0);
        if(listenSock_<0)
        {
            logMessage(FATAL,"socket:%s",strerror(errno));//日志消息打印错误码
            exit(SOCKET_ERR);//套接字错误
        }
        logMessage(DEBUG,"socket:%s,%d",strerror(errno),listenSock_);
第四步 进行绑定
4.1填充服务器信息
struct sockaddr_in local;//用户栈
        memset(&local,0,sizeof local);//初始化全部置为0
        local.sin_family=PF_INET;//绑定域
        local.sin_port=htons(port_);//将主机字节顺序转为网络字节顺序
        ip_.empty()?(local.sin_addr.s_addr=INADDR_ANY):(inet_aton(ip_.c_str(),&local.sin_addr));
4.2将本地socket信息，写入sock_对应的内核区域
 if(bind(listenSock_,(const struct sockaddr *)&local,sizeof local)<0)
        {
            logMessage(FATAL,"bind: %s",strerror(errno));
            exit(BIND_ERR);//绑定错误
        }
        logMessage(DEBUG,"bind: %s,%d",strerror(errno),listenSock_);
第五步 监听socket，tcp是面向连接的
 if(listen(listenSock_,5)<0)//把一个未连接的套接字转换成一个被动套接字
        {          //指示内核应该接受指向该套接字的连接请求
            logMessage(FATAL,"listen: %s",strerror(errno));
            exit(LISTEN_ERR);
        }
        logMessage(DEBUG,"listen:%s,%d",strerror(errno),listenSock_);
第六步 创建loop函数完成对客户的服务
先获取连接,得到客户端基本信息提供你的服务，本次服务为小写转为大写服务。
void loop()
    {
        while (true)
        {
            struct sockaddr_in peer;
            socklen_t len=sizeof(peer);
            //4、获取连接,accept的返回值是一个新的socket fd??
            int serviceSock=accept(listenSock_,(struct sockaddr *)&peer,&len);//accept() 告诉它你有空闲的连接。它将返回一个新的套接字文 件描述符！这样你就有两个套接字了，原来的一个还在侦听你的那个端口， 新的在准备发送 (send())
                                     //和接收 ( recv()) 数据。这就是这个过程！ 
            if(serviceSock<0)
            {
                //获取链接失败
                logMessage(WARINING,"accept: %s[%d]",strerror(errno),serviceSock);
                continue;//继续链接
            }
            //4.1获取客户端基本信息
            uint16_t peerPort=ntohs(peer.sin_port);//网络字节顺序转主机字节顺序
            std::string peerIp=inet_ntoa(peer.sin_addr);//返回10位的IP地址
            logMessage(DEBUG,"accept: %s | %s[%d], sock fd:%d",strerror(errno),peerIp.c_str(),peerPort,serviceSock);

            //5 提供服务---echo 小写转大写

            //5.0多线程版本
            ThreadData *td=new ThreadData(peerPort,peerIp,serviceSock,this);//每个客户连接过来换创建独立的空间，和ip。实现多进程共享服务
            pthread_t tid;
            pthread_create(&tid,nullptr,threadRoutine,(void *)td);
        }        
    }

这里面的create对应的方法。方法里面又存放有小写转大写的代码。

class ThreadData
{
public:
    uint16_t clientPort_;
    std::string clientIp_;
    int sock_;
    ServerTcp *this_;
public:
    ThreadData(uint16_t port,std::string ip,int sock,ServerTcp *ts)
    :clientPort_(port),clientIp_(ip),sock_(sock),this_(ts)
    {}
};
static void *threadRoutine(void *args)
    {
        pthread_detach(pthread_self());//线程分离自动释放资源
        ThreadData *td=static_cast<ThreadData *>(args);//强制类型转换
        td->this_->transService(td->sock_,td->clientIp_,td->clientPort_);
        delete td;
        return nullptr;
    }
 //大小写转换服务
    //TCP && UDP :支持全双工
    void transService(int sock,const std::string &clientIp,uint16_t clinentPort)
    {
        assert(sock>=0);
        assert(!clientIp.empty());
        assert(clinentPort>=1024);
        char inbuffer[BUFFER_SIZE];
        while (true)
        {
            ssize_t s=read(sock,inbuffer,sizeof(inbuffer)-1);
            if(s>0)
            {
                inbuffer[s]='\0';
                if(strcasecmp(inbuffer,"quit")==0)
                {
                    logMessage(DEBUG,"client quit -- %s[%d]",clientIp.c_str(),clinentPort);
                    break;
                }
                logMessage(DEBUG,"trans before: %s[%d]>>> %s",clientIp.c_str(),clinentPort,inbuffer);
                //可以进行大小写转化了
                for(int i=0;i<s;i++)
                {
                    if(isalpha(inbuffer[i]) && islower(inbuffer[i]))//判断是否是字母检查字符是否是小写
                        inbuffer[i] =toupper(inbuffer[i]);
                }
                logMessage(DEBUG,"trans after: %s[%d]>>> %s",clientIp.c_str(),clinentPort,inbuffer);
                
                write(sock,inbuffer,strlen(inbuffer));
            }
            else if(s==0)
            {//s==0表示对方关闭，client退出
                logMessage(DEBUG,"client quit -- %s[%d]",clientIp.c_str(),clinentPort);
                break;
            }   
            else
            {
                logMessage(DEBUG,"%s[%d] --read: %s",clientIp.c_str(),clinentPort,strerror(errno));
                break;
            }
        }
             //client退出，服务到此结束
            close(sock);
            logMessage(DEBUG,"server close %d done",sock);
    }
static void Usage(std::string proc)
{
    std::cerr<<"Usage:\n\t"<<proc<<" Port ip"<<std::endl;
    std::cerr<<"Example:\n\t"<<proc<<" 127.0.0.1 8080\n"<<std::endl;
}

//实现的时候创建ServerTcp调用init和loop服务器端书写完毕。
在这里插入图片描述

实现客户端clientTcp

volatile bool quit=false;

//客户端口
//当输入prog para_1，有一个参数，则由操作系统传来的参数为：
//    argc=2，表示除了程序名外还有一个参数。 
//    argv[0]指向输入的程序路径及名称。
//    argv[1]指向参数para_1字符串。

//    当输入prog para_1 para_2 有2个参数，则由操作系统传来的参数为：
//    argc=3，表示除了程序名外还有2个参数。
//    argv[0]指向输入的程序路径及名称。
//    argv[1]指向参数para_1字符串。
//    argv[2]指向参数para_2字符串。

static void Usage(std::string proc)
{
    std::cerr<<"Usage:\n\t"<<proc<<" serverIp serverPort"<<std::endl;
    std::cerr<<"Example:\n\t"<<proc<<" 127.0.0.1 8080\n"<<std::endl;
}

int main(int argc,char *argv[])
{
    if(argc!=3)
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }
    std::string serverIp=argv[1];
    uint16_t serverPort=atoi(argv[2]);
//1、创建套接字
    int sock=socket(AF_INET,SOCK_STREAM,0);
    if(sock<0)
    {
        std::cerr<<"socket: "<<strerror(errno)<<std::endl;
        exit(SOCKET_ERR);//如果出错退出数据
    }
//2、向服务器发起链接
//2.1发起前的准备工作就是连接远端主机的基本信息
    struct sockaddr_in server;//在客户机中，我们首先创建了一个SCTP套接字，
    //然后创建了一个sockaddr结构，其中包含了将要连接的端点。
    memset(&server,0,sizeof(server));//空间初始化为0
    server.sin_family=AF_INET;//域(定义哪种地址族)说白了就是IP协议
    server.sin_port=htons(serverPort);//端口号(主机字节顺序转换成网络字节顺序)
    //就是返回IP对应的网络字节序表示的无符号整数.
    //网络字节序n转化为点分十进制的IP,例如服务器IP地址
    inet_aton(serverIp.c_str(),&server.sin_addr);//将主机地址转化为二进制数存储在INP结构中
//2.2发起请求，connect会自动帮我们进行bind
    //建立网络连接必须使用connect
    if(connect(sock,(const struct sockaddr *)&server,sizeof(server))!=0)
    {
        std::cerr<<"connect: "<<strerror(errno)<<std::endl;
        exit(CONN_ERR);//通讯失败(连接服务器失败)
    }
    std::cout<<"info : connect success: "<<sock<<std::endl;

    std::string message;
    while (!quit)
    {
        message.clear();//清理
        std::cout<<"请输入你的消息>>>";
        std::getline(std::cin,message);
        if(strcasecmp(message.c_str(),"quit")==0)//将字符全部转换成小写
        {
            quit=true;
        }

        ssize_t s=write(sock,message.c_str(),message.size());//写入sock
        if(s>0)
        {
            message.resize(1024);
            ssize_t s=read(sock,(char *)(message.c_str()),1024);
            if(s>0)
            {
                message[s]=0;
            }
            std::cout<<"Server Echo>>> "<<message<<std::endl;
        }
        else if(s <= 0)
        {
                break;
        }
    }
    close(sock);

    return 0;
}