您现在的位置是：首页 >学无止境 >linux实现网络程序网站首页学无止境

1️⃣ 在linux下，通过套接字实现服务器和客户端的通信。
2️⃣ 实现单线程、多线程通信。或者实现线程池来通信。
3️⃣ 优化通信，增加守护进程。

有情提醒，类里面默认的函数是内联。内联函数在调用的地方展开，没有函数地址，无法保持和传递。

一 、

1.1实现TCP服务器
创建socket文件描述符(TCP/UDP,客户端+服务端)
int socket(int domain, int type, int protocol);
绑定端口号(TCP/UDP,服务器）
int bind(int socket, const struct sockaddr *address,socklen_t address_len);
开始监听socket (TCP, 服务器)
int listen(int socket, int backlog);
// 接收请求 (TCP, 服务器)
int accept(int socket, struct sockaddr* address,socklen_t* address_len);
// 建立连接 (TCP, 客户端
int connect(int sockfd, const struct sockaddr*addr,socklen_t addrlen);

 void init()
    {
        // 1.创建套接字
        // 1.1 协议族 1.2 SOCK_STREAM是一个有序、可靠、面向连接 的双向字节流 1.3建立一个流式套接字
        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_);

        // 2.bind绑定
        // 2.1填充服务器信息
        // sockaddr_in是系统封装的一个结构体，
        // 具体包含了成员变量：sin_family、sin_addr、sin_zero
        struct sockaddr_in local; // 用户栈
        memset(&local, 0, sizeof local);
        local.sin_family = PF_INET;
        local.sin_port = htons(port_);
        // 绑定INADDR_ANY，管理一个套接字不管数据是从哪个网卡过来的，只要是绑定的端口号过来的数据，都可以接收到。
        // 将一个网络字节序的IP地址（也就是结构体in_addr类型变量）转化为点分十进制的IP地址（字符串）。
        ip_.empty() ? (local.sin_addr.s_addr = INADDR_ANY) : (inet_aton(ip_.c_str(), &local.sin_addr));
        // 2.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_);

        // 3.监听socket
        if (listen(listenSock_, 5) < 0)
        {
            logMessage(FATAL, "listen :%s", strerror(errno));
            exit(LISTEN_ERR);
        }
        logMessage(DEBUG, "listen :%s,%d", strerror(errno), listenSock_);

        // 4.启动线程池
        tp_ = ThreadPool<Task>::getInstance();
    }
	void loop()
    {
        // 启动线程池
        tp_->start();
        logMessage(DEBUG, "thread pool start success ,thread number : %d", tp_->ThreadNum());

        // signal(SIGCHLD,SIG_IGN);//基类忽略子类信号
        while (true)
        {
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            // 4.获取连接,accept的返回值是一个新的socket

            int serviceSock = accept(listenSock_, (struct sockaddr *)&peer, &len);
            if (serviceSock < 0)
            {
                logMessage(WARINING, "accept :%s[%d]", strerror(errno), serviceSock);
                continue;
            }
            // 4.1获取客户端基本信息
            uint16_t peerPort = ntohs(peer.sin_port); // 将一个16位数由网络字节顺序转换为主机字节顺序
            std::string peerIp = inet_ntoa(peer.sin_addr);

            logMessage(DEBUG, "accept :%s | %s[%d],socket fd: %d", strerror(errno), peerIp.c_str(), peerPort, serviceSock);

            // 5.3 版本 --线程池版本
            // 5.3.1 构建任务
            //  Task t(serviceSock, peerIp, peerPort, std::bind(&ServerTcp::transService, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
            //  tp_->push(t);//将获取的任务给线程池,目前线程池只有5个线程

            // 5.3.2
            // 直接使用回调函数
            Task t(serviceSock, peerIp, peerPort, execCommand);
            // Task::callback_t call = execCommand;
            tp_->push(t);
            // popen传入命令字符串,让它能以文件的方式读到命令接口
        }
    }

#include <sys/types.h>
#include <sys/socket.h>
int accept(int sockfd,struct sockaddr *addr,socklen_t *addrlen);
sockfd,利用系统调用socket()建立的套接字描述符，通过bind()绑定到一个本地地址(一般为服务器的套接字)，并且通过listen()一直在监听连接；
addr,指向struct sockaddr的指针，该结构用通讯层服务器对等套接字的地址(一般为客户端地址)填写，返回地址addr的确切格式由套接字的地址类别(比如TCP或UDP)决定；若addr为NULL，没有有效地址填写，这种情况下，addrlen也不使用，应该置为NULL；
addrlen,一个值结果参数，调用函数必须初始化为包含addr所指向结构大小的数值，函数返回时包含对等地址(一般为服务器地址)的实际数值；

上边绑定的时候需要将16位主机字节序转16位网络字节序。还有设置=cockaddr_in的结构体里面有域、协议家族该结构体是系统封装的。就是处理网络字节和主机字节的相互转换。获取连接的时候需要重新将网络字节序转化为主机字节序。accept返回的是一个新的socket

1.2实现UDP客户端
创建socket套接字
connect向服务器发起链接请求

int main(int argc,char *argv[])
{
    if(argc!=3)
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }
    //  ./clientTcp serverIp serverPort
    //默认argc为1，argv[0]为程序名称。如果输入一个参数，则argc为2
    std::string serverIp=argv[1];
    uint16_t serverPort=atoi(argv[2]);
    //1.创建soket
    int sock=socket(AF_INET,SOCK_STREAM,0);
    if(sock<0)
    {
        std::cerr<<"socket:"<<strerror(errno)<<std::endl;
        exit(SOCKET_ERR);
    }
    //2.CONNECT向服务器发起链接请求
    //2.1先填充需要连接的远端主机的基本信息
    struct sockaddr_in server;
    memset(&server,0,sizeof(server));
    server.sin_family=AF_INET;
    server.sin_port=htons(serverPort);//将一个16位主机字节顺序转换成网络字节顺序
    inet_aton(serverIp.c_str(),&server.sin_addr);//将一个网络字节序的IP地址（也就是结构体in_addr类型变量）转化为点分十进制的IP地址（字符串）。
    //2.2发起请求connect自动绑定bind
    if(connect(sock,(const struct sockaddr *)&server,sizeof(server))!=0)
    {
        std::cerr<<"connect:"<<strerror(errno)<<std::endl;
        exit(CONN_ERR);
    }
    std::cout<<"inof : 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;
        }
       size_t s=write(sock,message.c_str(),message.size());
        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;
}

以上代码主要是创建套接字，获取远端信息，端口和ip将主机字节顺序转换为网络字节顺序。使用connect请求连接。

#include <sys/types.h> 					
#include <sys/socket.h>
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

参数：
第一个参数：int sockdf：
		    socket文件描述符
第二个参数： const struct sockaddr *addr：
			传入参数，指定服务器端地址信息，含IP地址和端口号
第三个参数：socklen_t addrlen：
			传入参数,传入sizeof(addr)大小
返回值：
	成功： 0
	失败：-1，设置errno

connect（）函数返回后并不进行数据交换。而是要等服务器端 accept 之后才能进行数据交换（read、write）。客户端端需要调用connect()连接服务器，connect和bind的参数形式一致，区别在于bind的参数是自己的地址，而connect的参数是对方的地址。

二、

我们这边要注意既然是实现服务器与客户端互通。我们提供服务就需要考虑让多人连接单人连接等问题。
以下我们实现单线程和多线程版本。
提供服务：

void transService(int sock,const std::string &clientIp,uint16_t clientPort)
{
assert(sock>=0);
assert(!clientIp.empty());
assert(clientPort>=1024);

    char inbuffer[BUFFER_SIZE];
    while (true)
    {
        size_t s=read(sock,inbuffer,sizeof(inbuffer)-1);
        if(s>0)
        {
            inbuffer[s]='';
            if(strcasecmp(inbuffer,"quit")==0)
            {
                logMessage(DEBUG,"client quit -- %s[%d]",clientIp.c_str(),clientPort);
                break;
            }
            logMessage(DEBUG,"trans before: %s[%d]>>>%s",clientIp.c_str(),clientPort,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(),clientPort,inbuffer);
            write(sock,inbuffer,strlen(inbuffer));
        }
        else if(s==0)
        {
                logMessage(DEBUG,"client quit -- %s[%d]",clientIp.c_str(),clientPort);
                break;
        }
        else
        {
                logMessage(DEBUG,"%s[%d] - read:%s",clientIp.c_str(),clientPort,strerror(errno));
                break;
        }

    }
    close(sock);
    logMessage(DEBUG,"server close %d done",sock);

}

单线程版本：

直接传套接字、ip、端口号

```cpp
 transService(serviceSock,peerIp,peerPort);

多线程版本：

  //5.1 多线程版本

		pid_t id=fork();
        if(id==0)
        {   //基类进程
            close(listenSock_);
            //又进行了一次fork，让
            if(fork()>0) exit(0);
            //子类进程 基类退出--子类还在被系统拿到--回收问题就交给系统回收
            transService(serviceSock,peerIp,peerPort);
            exit(0);//子进程退出后会进入僵尸状态
        }
        //基类退出
        close(serviceSock);
        //获取基类退出后的退出码
        pid_t ret=waitpid(id,nullptr,0);
        assert(ret>0);
        (void)ret;

//多线程会共享文件描述符表
ThreadData td=new ThreadData(peerPort,peerIp,serviceSock,this);
pthread_t tid;
pthread_create(&tid,nullptr,threadRoutine,(void)td);

pthread_detach的使用让每个线程结束后自动释放自己所用的资源。
int serviceSock=accept(listenSock_,(struct sockaddr*)&peer,&len);每个用户连接后需要执行5步。

• ThreadData *td=new ThreadData(peerPort,peerIp,serviceSock,this);这步是为了将主线程把链接信息封装好，然后创建子线程，让子线程去处理这份数据，然后等待下一个链接。
• pthread_create就是完成第一行的创建子进程是执行子进程对应的任务。

线程池版本：

pthread_mutex_init的使用是为了解决在多线程访问共享资源时，多个线程同时对共享资源操作产生的冲突而提出的一种解决方法，在执行时，哪个线程持有互斥锁,并对共享资源进行加锁后，才能对共享资源进行操作，此时其它线程不能对共享资源进行操作。
我们先启动线程池

    tp_ = ThreadPool<Task>::getInstance();为每个线程池进行加锁

然后启动线程池
tp_->start();
来了任务就将任务放至任务队列里面，如果没有任务就等待。如果有任务就拿任务并且把任务队列的首部弹出该任务。返回任务。

Task t(serviceSock, peerIp, peerPort, execCommand);
 tp_->push(t);

调用程序执和被调用函数同时在执行。当被调函数执行完毕后，被调函数会反过来调用某个事先指定函数，以通知调用程序：函数调用结束。这个过程称为回调(Callback)。

void execCommand(int sock, const std::string& clientIp, uint16_t clientPort)
{
    assert(sock >= 0);
    assert(!clientIp.empty());
    assert(clientPort >= 1024);

    char command[BUFFER_SIZE];
    while (true)
    {
        size_t s = read(sock, command, sizeof(command) - 1);
        if (s > 0)
        {
            command[s] = '';
            // 这个用户执行command命令
            logMessage(DEBUG, "[%s:%d] exec [%s] ..done", clientIp.c_str(), clientPort, command);

            // 考虑安全
            std::string safe = command;
            if ((std::string::npos != safe.find("rm")) || (std::string::npos != safe.find("unlink")))
            {
                break;
            }

            FILE *fp = popen(command, "r");
            if (fp == nullptr)
            {
                logMessage(WARINING, "exec %s failed,beacuse: %s", command, strerror(errno));
                break;
            }
            // 遍历目录
            char line[1024];
            while (fgets(line, sizeof(line) - 1, fp) != nullptr)
            {
                write(sock, line, strlen(line));
            }
            // //本来要写入dile里但现在写入网络。
            // dup2(sock,fp->_fileno);
            // fflush(fp);
            pclose(fp);
            logMessage(DEBUG, "[%s:%d] exec [%s]...done", clientIp.c_str(), clientPort, command);
        }
        else if (s == 0)
        {
            logMessage(DEBUG, "client quit -- %s[%d]", clientIp.c_str(), clientPort);
            break;
        }
        else
        {
            logMessage(DEBUG, "%s[%d] - read:%s", clientIp.c_str(), clientPort, strerror(errno));
            break;
        }
    }
    close(sock);
    logMessage(DEBUG, "server close %d done", sock);
}

对于线程池我的理解还是不行。希望能多多与大家一块交流。