网络套接字编程_cout << "bind socket successed " << endl;-CSDN博客

#include<arpa/inet.h>

uint32_t htonl(uint32_t hostlong);//主机字节序转网络字节序——长整型

uint16_t htons(uint16_t hostshort);//主机字节序转网络字节序——短整型

uint32_t ntohl(uint32_t netlong);//网络字节序转主机字节序——长整型

uint16_t ntohs(uint16_t netshort);//网络字节序转主机字节序——短整型

虽然看上去比较难记，但实际上很好记，其中 h 表示 host ，也就是指主机，n 标示 net，也就是指网络，s 指 short，就是指16位的整数，l 是指 long ,就是指32位的整数。

SOCKET编程接口

socket 这个东西想必大家都很陌生。

在上面我们都知道，两个主机上的进程想要通信，就一定需要知道对方主机的 ip 和进程的 port，而 socket 实际上就是指 ip + port ；

而 socket 也是有自身的编程接口

// 创建 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);

这些接口有点只能在TCP协议中用，有的TCP和UDP都能使用，有的只能在服务器上用，有点能在客户端上用，根据场景不同使用。

而在这些函数中，我们都看见一个参数类型是 struct sockaddr* 类型的，这个类型我们也需要了解。

socket API 是一层抽象的网络编程接口，适用于各种底层网络协议。

但是各种网络协议的地址各不相同。

在上图中，我们发现最左边的sockaddr是函数中所需要传参的变量类型，而右边则是两种没有看到过的类型。

实际上这是这套接口的发明者所用的一个小技巧，他将所有接收的变量类型定义为sockaddr，而不同协议则需要使用不同的 sockaddr,例如TCP和UDP协议都是使用的sockaddr_in的类型，而sockaddr_un 则有不同的协议使用。

因此，我们在外部调用这类函数的时候，只需要根据自己使用的协议来使用不同的sockaddr类型，然后在里面填充数据后强转再传参，而具体的操作和判断就交给函数内部进行。

sockaddr结构

sockaddr_in结构

当我们有了以上的预备知识后，我们便先来学习下UDP协议下的通信以及代码实现。

简单的UDP程序

经过上面的预备知识，我们知道，要进行网络通信，那么一定是需要 IP地址和端口号 port 的，而且socket 套接字也是必不可少的，因此，我们想要编写一个UDP程序，这三者缺一不可。

简单的UDP服务器

我们首先以UDP服务器的编写为示范。

在定义好UDPSever的成员变量后，便是需要对这些变量初始化。

这里我们依靠外面传参决定服务器使用几号端口进行通信，而 IP 地址，我们默认设为 0.0.0.0；

至于为什么 IP 是 0.0.0.0，则在后面进行解答。

在初始化完成员变量后，我们便是需要将服务器给初始化完成。

在start函数中，我们首先创建了一个 socket 套接字。

其中，我们传了三个参数：AF_INET,SOCK_DGREAM,0。

先来了解这三个参数分别代表什么吧。

首先第一个 domain 参数，表示我们是想进行网络通信还是本地通信。这里我们的domain 参数是 AF_INET，表示我们是网络通信，且IP地址是 IPv4 地址格式。

而第二个参数 type 表示我们的socket 所提供的能力类型，即是使用流式套接字还是使用用户数据报套接字。

而第三个参数protocol 则是表示我们采用TCP还是UDP，不过实际上我们前两个参数就已经决定我们使用什么协议了，因此我们这里默认给 0；

而在拿到套接字之后，我们需要将 ip 地址和 port 号绑定给该套接字中，而要将 ip 地址和 port 号两个变量绑定给套接字，我们需要使用bind函数。

bind 函数需要三个参数：sockfd， addr, addrlen。

这里需要提一嘴的是，实际上我们在上面所申请的 socket 实际上类似于文件描述符，如果说之前的socket函数的操作都属于文件范畴，那么这里的 bind 函数的操作就属于网络操作的范畴。

它会告诉操作系统，这个套接字是属于哪个端口号的，这样我们才能成功的通过套接字来进行网络通信。

而addr 这个变量在预备知识我们已经了解过，我们并非是使用 sockaddr 这个类型，而是使用sockaddr_in 这个类型。

预备知识中也说过，sockaddr_in这个类型需要我们手动填充，我们首先将协议定为AF_INET

然后将 IP 地址通过 inet_addr 转换后，填入其中。

关于IP地址这里需要简单讲解一下。

IP地址简单讲解

IP地址分为点分十进制风格和整数风格。

其中点分十进制是一个字符串，可读性好，而整数风格的IP地址则用于网络通信。

因此我们的IP地址都是需要通过函数转换一下才能使用。

此外，我们在前面的预备知识都了解过，网络也有自己的字节序，因此我们的port 端口号需要使用的话，也是需要通过相应的函数进行转化才能在网络上使用。

当我们填充完该变量后，就只需要直接将该变量和socket直接绑定即可。

至此，我们的服务器就初始化完成了。

接着我们就需要让服务器开始运行。

在 start 函数中，我们使用buffer作为缓冲区，用recvfrom函数从套接字中接收数据，把数据放入buffer 中，并且用peer变量来接收客户端的 ip 地址和 port 号。

虽然服务器并不主动开始通信，但是服务器有时需要返回数据，到时候就需要使用客户端的 ip 地址和 port 号。

接着我们用 cip 和 cport 分别将peer 中的字段转换后接收，并且输出客户端发送的信息。

一个简易版的UDP服务器就完成了。

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

using namespace std;



namespace UDP
{
   static const string defaultip = "0.0.0.0";
    class Sever
    {
    
    public:
        Sever(uint16_t port, string ip = defaultip)
            : _port(port), _ip(ip)
        {
        }

        void start()
        {
            //初始化套接字
            _socket = socket(AF_INET,SOCK_DGRAM,0);
            if(_socket == -1)
            {
                cerr<<"socket err!"<<endl;
                exit(-1);
            }
            cout<<"socket successed!"<<endl;
            //绑定IP 和 port
            struct sockaddr_in local;
            bzero(&local,sizeof(local));
            local.sin_family = AF_INET;
            local.sin_addr.s_addr = inet_addr(_ip.c_str());
            local.sin_port = htons(_port);
            int n = bind(_socket,(struct sockaddr*)&local,sizeof(local));               
            if(n == -1)
            {
                cerr<<"bind failed!"<<endl;
                exit(-1);
            }
            cout<<"bind successed!"<<endl;


        }

        void run()
        {
            while(true)
            {
                char buffer[1024];
                struct sockaddr_in peer;
                socklen_t len = sizeof(peer);
                bzero(&peer,sizeof(peer));

                size_t n = recvfrom(_socket,buffer,sizeof(buffer),0,(sockaddr*)&peer,&len);
                if(n == -1)
                {
                    cout<<"recvfrom failed!"<<endl;
                    exit(-1);
                }
                cout<<"recvfrom successed!"<<endl;
                string cip = inet_ntoa(peer.sin_addr);
                uint16_t cport = ntohs(peer.sin_port);

                buffer[strlen(buffer) - 1] = 0;

                cout<<"Client["<<cip<<"]["<<cport<<"] # "<<buffer<<endl;
            }
        }
        ~Sever()
        {
        }

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

接着我们就需要写一个外部调用代码。

我们在UDPSever.cc中写下如下代码，就能够成功运行了。

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


using namespace UDP;

int main(int args,char* argv[])
{
    if(args != 2)
    {
        cout<<"./UDPSever port"<<endl;
        exit(-1);
    }
    uint16_t port = atoi(argv[1]);

    unique_ptr<UDP::Sever> usp(new Sever(port));
    usp->start();
    usp->run();
    return 0;
}

写完服务器，接着就是客户端了。

简单的UDP客户端

一个客户端和服务器都是需要相同的成员变量，但是不同的是客户端的IP地址不能为0.0.0.0;

而必须是服务器的IP地址，这样才能使得客户端成功连接到服务器。

而之后的操作，客户端和服务器基本一致。

客户端的初始化相比服务器而言，少了绑定操作，因为客户端一般是主动向其他主机发送连接请求，只需要通过函数发送数据即可。

然后就是客户端的运行了。

我们也是和服务器一样的操作，不过不同的是，客户端是将数据送出去，而非拿进来。

#include <iostream>
#include <string>
#include <stdlib.h>
#include <strings.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>

using namespace std;

namespace UDP
{
    class Client
    {
    public:
        Client(string ip, uint16_t port)
            : _ip(ip), _port(port)
        {
        }
        void start()
        {
            _socket = socket(AF_INET, SOCK_DGRAM, 0);
            if (_socket == -1)
            {
                cout << "socket failed!" << endl;
                exit(-1);
            }
            cout << "socket successed!" << endl;
        }

        void run()
        {
            struct sockaddr_in peer;
            peer.sin_family = AF_INET;
            peer.sin_addr.s_addr = inet_addr(_ip.c_str());
            peer.sin_port = htons(_port);


            while (true)
            {
                    char buffer[1024];
                    cout<<"Enter # "<<endl;
                    fgets(buffer,sizeof(buffer),stdin);
                    sendto(_socket,buffer,sizeof(buffer),0,(sockaddr*)&peer,sizeof(peer));
            }
        }
        ~Client()
        {
        }

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

此外就是客户端的外部调用了。

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

using namespace UDP;

int main(int args,char* argv[])
{
    if(args != 3)
    {
        cout<<"./UDPClient ip port"<<endl;
        exit(-1);
    }
    string ip = argv[1];
    uint16_t port =  atoi(argv[2]);
    unique_ptr<Client> upc(new Client(ip,port));
    upc->start();
    upc->run();

}

这样我们的简单的UDP客户端就完成了。

我们来看看成果吧！

由于笔者是在一台电脑上进行通信，因此这里客户端输入的 IP 地址为 127.0.0.1，即本地回流，表明接收的IP地址是本机。

此外，客户端上输入的端口号应该和服务器的端口号相同，因为客户端输入的IP地址和端口号都是服务器的IP地址和端口号。

那么这里就有一个问题，既然我们客户端所有初始化的 IP 地址和端口号都是服务器的，那么服务器又是怎么知道客户端的 IP 地址和端口号的呢？

实际上，客户端在发送数据之前，操作系统会自动选择一个可用的本地IP地址和端口号来和目标主机建立连接，因此不用我们手动建立连接。

简单的TCP程序

TCP服务器

在做完一个简单的UDP协议服务器和客户端后，自然就要试试写一个TCP服务器了。

实际上TC服务器和UDP服务器的代码十分相似，只有个别不同，我们直接看代码。

在代码中我们能够看到，TCP服务器的初始化和UDP服务器的初始化是十分相似的，只有两点不同。

1：socket函数创建套接字的时候，第二个参数是SOCK_STREM。

2：初始化时有listen函数，来设置套接字的状态。

关于为何socket函数第二个参数是SOCK_STREM，这是因为TCP协议是面向字节流的，因而使用SOCK_STREM。

而listen函数也是因为TCP协议是面向连接的，listen函数使套接字处于监听状态。

listen函数一共两个参数，第一个就是需要改变状态的socket，第二个参数表明最多允许backlog个客户端处于连接等待状态，连接到更多请求就会忽略。

将服务器初始化后，我们就需要写运行代码。

在运行代码中，我们发现，有一个accept函数，我们先来看一下这个函数是干嘛的。、

对于accept函数，它的三个参数我们都不陌生，第一个就是进入监听状态的listensocket，后面两个参数我们在UDP协议中使用recvfrom的时候就已经见识到了。

重点在于accept函数的返回值。

根据手册的描述，accept函数返回值也是一个socket套接字！

那么这个返回的socket和我们设为监听的listensocket又有什么区别呢？

实际上，listensocket的作用并不是用来通信的，是用来监听是否有新的连接到来。

而真正进行通信的实际上是accept函数返回的socket。

紧接着，我们就能够使用seviceIO函数，在函数内部进行真正的通信。

我们的函数内部使用read函数从socket里面接收信息，从而成功通信。

然而，我们这里有一串代码需要详细的讲一下：

这串代码从字面意思上来看，就是父进程创建一个子进程，然后在子进程里面创建一个孙子进程，然后将子进程关闭，由孙子进程进行通信，然后父进程回收子进程，这是为什么呢？

首先我们都知道，子进程在退出的时候，若是父进程不等待，就会导致子进程变成僵尸进程，从而导致资源泄露等问题。

但是，如果我们的父进程等待子进程，就会造成串行的问题，因为等待是阻塞的，这样我们的服务器就不能对多个客户端请求进行处理。

因此，我们这里创建了一个孙子进程，然后将子进程退出，这样孙子进程就会被1号进程领养，当孙子进程退出时，会自动回收资源，而父进程在子进程退出时就已经回收它的资源了。

这样就不会出现串行的问题，也不会出现资源泄露的问题。

当然，这里有多种写法，我们可以使用多线程的写法，就不用关心这么多了。

TCP客户端

对于客户端，实际上也和UDP协议相差不多。

首先是客户端初始化的时候，创建套接字。

其次便是运行。

我们发现TCP的客户端比UDP的客户端多一个connect的步骤，实际上也是因为TCP是面向连接的，因此需要用connect与服务器建立连接。

我们先来看看connect的描述。

实际上connect的具体用法相信不用说都能够明白了，重点是这一串描述。

这句话说：如果连接或者绑定成功了，返回0，错误返回1.

也就是说，TCP客户端的隐式绑定是在connet的时候发生的，这和UDP客户端不同，UDP绑定是在客户端初次sendto的时候绑定的。

不过需要注意的是，客户端所保存的ip和port都是服务器的。

接着我们就能顺利运行起来了。

守护进程

目前，我们已经将TCP和UDP的服务器和客户端分别写了一遍，但是，真正的服务器并不是像我们这样，将程序一关就结束了，这个时候就需要讲一讲守护进程了。

在了解守护进程前需要一些预备知识。

会话，前台任务和后台任务

当我们打开xshell连接到服务器时，服务器内部会创建一个会话，然后再在会话里面创建一个bash，也就是命令行解释器，其中，bash就是一个前台任务。

在会话中，只能有一个前台任务，但是可以有多个后台任务。

而我们的后台任务可以创建多个。

我们创建两串进程组，分别是sleep 10000| sleep 20000| sleep 30000 和 sleep 40000| sleep 50000| sleep 60000，然后通过 & 将它们放到后台去。并且通过jobs指令查看到他们都在后台中。

而这两串进程组就是后台任务。

然后我们通过 ps 命令查看这些后台任务的时候，发现一件事。

这些后台任务有一个PGID，并且这两个进程组的PGID各不相同。

实际上PGID指的是该进程组的组长的PID，我们可以看到都有对应的进程ID。

此外，我们发现PGID旁边还有一个SID，而且这两个进程组的SID都一样，SID又是什么呢？

SIG：指该会话（session）的ID

此时，若是我们将后台进程变为前台任务就会发现我们的命令行解释器bash失效了。

通过fg + 后台任务号，我们将2号后台任务提到前台中，发现bash命令都不能用了，然后ctrl+z将2号任务暂停，才能够使用bash，然后使用bg + 后台任务号让2号任务继续运行起来。

而我们发现，前台任务和后台任务都是受用户的退出和注销的影响的，而想避免这种影响，就必须自成会话，自成进程组，和终端设备无关，这就是守护进程。

如何创建守护进程

创建守护进程需要我们自己写一个函数。

创建守护进程一共三步：

1.忽略异常信号

2.不可选择组长

3.关闭或者重定向进程默认打开的文件

忽略异常信号

有时候当一个客户端在写，而服务器未接收时，服务器会收到信号从而导致服务器崩溃，因此需要忽略异常信号。

不可选择组长

创建守护进程最重要的就是setsid函数，他会将调用该函数的进程设置为守护进程，但是前提是该进程不能是组长。

该函数的描述中就确定不能是组长，否则会报错。

关闭或者重定向默认打开的文件

在这里我先隆重讲解一下传说中的文件黑洞——/dev/null

想要创建一个守护进程，就必须将该进程的三个文件描述符全部重定向到该文件。

/dev/null是一个文件黑洞，任何放入其中的文件都会被丢弃。

说完三个需要注意的点，我们直接看代码。

#pragma once

#include <unistd.h>
#include <signal.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

using namespace std;
#define DEV "/dev/null"

void daemonSelf()
{
    // 1.忽略异常信号
    signal(SIGPIPE, SIG_IGN);
    // 2.让自己不成为组长
    if (fork() != 0)
        exit(0);
    pid_t n = setsid();
    assert(n != -1);
    // 3.关闭或者重定向进程默认打开的文件
    int fd = open(DEV,O_RDWR);
    if(fd >= 0)
    {
        dup2(fd,0);
        dup2(fd,1);
        dup2(fd,2);

        close(fd);
    }
    else 
    {
        close(0);
        close(1);
        close(2);
    }
}

首先第一步，我们直接忽略掉异常信号SIGPIPE；

其次，我们fork一下，让子进程调用setsid，这样就不是组长进程了；

最后，我们打开文件黑洞，然后将文件都重定向到里面，否则就关闭它们。

这样就完成了，然后在服务器的调用中使用该函数即可。

然后我们看看表现。

我们发现确实这个进程不是前台任务了，而且它的PID，PGID和SID都是它自己，说明它确实已经成为了守护进程了！

TCP通讯流程

TCP的客户端和服务器的通信流程用一句话就是三次握手和四次挥手。

三次握手

服务器初始化

1.通过socket函数创建文件描述符。

2.调用bind函数，将该文件描述符和ip与port绑定，若port号被占用，绑定失败。

3.通过listen函数，声明该文件描述符作为服务器的文件描述符，为accept做准备。

4.阻塞等待accept返回，等待客户端连接。

建立连接

1.当客户端初始化后，通过connect向服务器发起连接请求。

2.connect发送SYN段并且阻塞等待服务器应答（第一次）。

3.服务器收到SYN段会返回SYN-ACK表示同意建立连接（第二次）。

4.客户端收到SYN-ACK段从connect函数返回，并且应答一个ACK段（第三次）。

当客户端和服务器通过三次握手建立连接后，两边可以重复通过write和read函数进行通信。直到调用close函数关闭文件描述符。

四次挥手

断开连接

1.当客户端调用close关闭连接时，客户端向服务器发送FIN段（第一次）。

2.服务器收到FIN段后，会回应ACK段，同时read返回0（第二次）。

3.read返回后，服务器就知道客户端断开连接，会调用close断开连接，同时发送FIN（第三次）。

4.客户端收到FIN，再返回一个ACK给服务器（第四次）。

通过四次挥手，客户端和服务器就断开了连接。