【网络】udp_socket编程

#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(uint32_t netshort);

这些函数名很好记，h表示host,n表示network，l表示32位长整数，s表示16位短整数
例如 htonl 表示将32位的长整数从主机字节序转换为网络字节序，例如将IP地址转换后准备发送
如果主机是小端字节序，这些函数将参数做相应的大小端转换然后返回
如果主机是大端字节序，这些函数不做转换，将参数原封不动地返回

5.socket编程接口

5.1socket常见API

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

我们发现很多函数都有一个sockaddr结构，那么这是一个什么结构呢？

5.2sockaddr结构

socket API是一层抽象的网络编程接口，适用于各种底层网络协议，如IPv4,IPv6,以及UNIX Domain Socket（域间套接字 -- 不跨网络）,然后各种网络协议的地址格式并不相同。

因此我们只要拿到sockaddr结构我们强转成sockaddr类型，读取前16位，如果是AF_INET则是跨网络通信，如果是AF_UNIX则是域间通信。因此我们这里都是网络通信，因此前16位都是AF_INET.

IPv4和IPv6的地址格式定义在netinet/in.h中，IPv4地址用sockaddr_in结构体表示，包括16位地址类型，16位端口号和32位IP地址
IPv4、IPv6地址类型分别定义为常数AF_INET、AF_INET6.这样,只要取得某种sockaddr结构体的首地址，不需要知道具体是那种类型的sockaddr结构体,就可以根据地址类型字段确定结构体中的内容
socket API可以都用struct sockaddr* 类型表示，在使用的时候需要强转转换成sockaddr_in;这样的好处是程序的通用性，可以接受IPv4,IPv6,以及UNIX Domain Socket各种类型的sockaddr结构体指针作为参数。

sockaddr结构

sockaddr_in 结构

虽然socket api的接口时sockaddr，但是我们真正在基于IPv4编程时，使用的数据结构是sockaddr_in这个结构里主要有三部分信息：地址类型，端口号，IP地址

in_addr结构

in_addr用来表示一个IPv4的IP地址，其实就是一个32位整数

6.简单的UDP网络程序

上面的准备工作结束，我们可以实现一个简单的英译汉的功能

6.1创建套接字

int socket(int domain,int type,int protocol);

返回值：如果成功，返回一个新的文件描述符。失败返回-1。

6.2 绑定网络信息指明IP+prot

6.3 udpServe代码

6.3.1 udpServe通用服务器

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <cerrno>
#include <unistd.h>
#include "Log.hpp"

static void Usage(const std::string proc)
{
    std::cout<<"Usage:\n\t"<<proc<<"port [ip]" <<std::endl;
}


//udp服务器
class UdpServer
{
public:
    UdpServer(int port,std::string ip="")
    :port_((uint16_t)port)
    ,ip_(ip)
    ,sockfd_(-1)
    {}

    ~UdpServer(){}

public:
    void init()
    {
        //1.创建socket套接字
        sockfd_ = socket(AF_INET,SOCK_DGRAM,0);//就是打开了一个文件
        // 无连接的  不可靠的
        if(sockfd_ < 0)
        {
            logMessage(FATAL,"socket:%s:%d",strerror(errno),sockfd_);
            exit(1);
        }
        logMessage(DEBUG,"socket create success : %d",sockfd_);

        // 2.绑定网络信息 指明IP+prot
        // 2.1 先填充基本信息到struct sockaddr_in
        struct sockaddr_in local;
        bzero(&local,sizeof(local));//memset
        local.sin_family = AF_INET;//协议家族 前2个字节 16位 域的概念
        //填充服务器的端口号信息,是会发给对方的port_一定会到网络中
        local.sin_port = htons(port_);
        // 服务器都必须具有IP地址,
        //"aaa.zzz.yy.xx" 字符串风格的点分十进制->4字节IP->uint32_t ip
        // INADDR_ANY(0) 程序员不关心会bind到哪一个ip,任意地址bind,强烈推荐的做法
        // inet_addr：指定填充确定的ip,特殊用途,测试时使用;除了做转换，还会自动给我做序列转换
        local.sin_addr.s_addr = ip_.empty()?htonl(INADDR_ANY):inet_addr(ip_.c_str());
        // 2.2 bind网络信息
        if(bind(sockfd_,(const struct sockaddr*)&local,sizeof(local)) == -1)
        {
            logMessage(FATAL,"bind:%s:%d",strerror(errno),sockfd_);
            exit(2);
        }
        logMessage(DEBUG,"socket bind success : %d",sockfd_);
        // done 
    }

    void start()
    {
        //服务器设计的时候都是死循环
        //将来读取到的数据都放在这里
        char inbuffer[1024];
        //将来发送的数据都放在这里
        char outbuffer[1024];


        while(true)
        {
            // struct sockaddr_in peer;//远端 输出型参数
            // socklen_t len = sizeof(peer);//输入输出型参数
            // //demo 2
            // //后面的两个参数是输出型参数，谁给你发的消息 和客户端多长
            // ssize_t s = recvfrom(sockfd_,inbuffer,sizeof(inbuffer)-1,0,
            //     (struct sockaddr*)&peer,&len);
            
            logMessage(NOTICE,"serve 提供 service中...");
            sleep(1);
        }
    }
private:
    //服务器端口号信息
    uint16_t port_;
    //服务器必须得有ip地址
    std::string ip_;
    int sockfd_;//套接字信息
};
// ./udpSever port [ip]
int main(int argc,char* argv[])
{
    if(argc != 2 && argc != 3)
    {
        Usage(argv[0]);
        exit(3);
    }  
    uint16_t port = atoi(argv[1]);
    std::string ip;
    if(argc == 3)
    {
        ip = argv[2];
    }
    UdpServer svr(port,ip);
    svr.init();
    svr.start();

    return 0;
}

我们在用指令也可以查看当前的服务信息

netstat -lnup

第一列为服务类型(Proto)：当前为udp
第二列表示有没有收到消息(Recv-Q)：0表示没有
第三列表示有没有发送消息(Send-Q)：0表示没有
第四列表示本地绑定的ip地址：为全0表示任意地址绑定，绑定的端口号是8080
Foreign Address ：表示允许远端的任何主机任何端口给我发消息

注意：云服务器不能显示的写端口号，因为云服务器不允许你绑定云服务器公网IP

因此我们一旦实现绑定云服务器ip会报错。我们直接不写让他任意绑定即可

6.3.2 实现简单通信的服务器

我们完成服务器编写的基本框架后，我们想要实现一个可以将客户端传入的字符进行大小写转换的服务。具体服务如下：

 void start()
    {
        //服务器设计的时候都是死循环
        //将来读取到的数据都放在这里
        char inbuffer[1024];
        //将来发送的数据都放在这里
        char outbuffer[1024];


        while(true)
        {
            struct sockaddr_in peer;//远端 输出型参数
            socklen_t len = sizeof(peer);//输入输出型参数
            //demo 2
            //后面的两个参数是输出型参数，谁给你发的消息 和客户端多长
            ssize_t s = recvfrom(sockfd_,inbuffer,sizeof(inbuffer)-1,0,
                (struct sockaddr*)&peer,&len);
            if(s>0)
            {
                inbuffer[s] = 0;//当做字符串
            }
            else if(s == -1)
            {
                logMessage(WARINING,"recvfrom:%s:%d",strerror(errno),sockfd_);
                continue;//服务器不能退出
            }
            //走到这里一定成功了 除了读取到对方的数据 还要读取对方的网络地址[ip:port]
            std::string peerIp = inet_ntoa(peer.sin_addr);//拿到了对方的ip
            uint32_t peerPort = ntohs(peer.sin_port);//拿到了对方的port
            //打印出来客户端给服务器发送过来的消息
            logMessage(NOTICE,"[%s:%d]]# %s",peerIp.c_str(),peerPort,inbuffer);
            // logMessage(NOTICE,"serve 提供 service中...");
            // sleep(1);
        }
    }

6.4 udpClient代码

我们服务器写完之后，现在来编写客户端的代码

客户端在编写的时候不需要bind,为什么？

所谓的"不需要"指的是：不需要用户自己bind端口信息因为OS会自动给你绑定，如果我们非要自己bind 可以但是不推荐！！！

所有的客户端软件<- ->服务器通信的时候必须得有client[ip:port] <-->serve[ip:port]。为什么？

因为client很多，不能给客户bind指定的port，因为port可能被别的client使用了. 你的client就无法启动了

那么Server凭什么要bind呢？

server提供的服务，必须被所有人都知道！而且server不能随便改变！

#include <iostream>
#include <string>
#include <cstring>
#include <strings.h>
#include <unistd.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <cstdlib>
#include <sys/socket.h>
#include <assert.h>
static void Usage(std::string name)
{
    std::cout << "Usage:\n\t" << name << " server_ip server_port" << std::endl;
}

// udpClient server_ip server_port
//  如果一个客户端要连接server必须知道server对应的ip和port
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }
    // 1.根据命令行 设置要访问的服务器IP
    std::string server_ip = argv[1];
    uint16_t server_port = atoi(argv[2]);

    // 2.创建客户端
    //  2.1 创建socket
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    assert(sockfd > 0);

    // 2.2 client 不需要bind
    // 所谓的"不需要" 指的是：不需要用户自己bind端口信息 因为OS会自动给你绑定
    // 如果我们非要自己bind 可以 但是不推荐
    // 所有的客户端软件<- ->服务器 通信的时候 必须得有client[ip:port] <-->serve[ip:port]
    // 为什么？client很多，不能给客户bind指定的port，因为port可能被别的client使用了
    // 你的client就无法启动了
    // 2.2 填写服务器信息
    struct sockaddr_in server;
    bzero(&server, sizeof server);
    server.sin_family = AF_INET;
    server.sin_port = htons(server_port);
    server.sin_addr.s_addr = inet_addr(server_ip.c_str());

    // 3.通信过程
    std::string buffer;
    while (true)
    {
        std::cout << "Please Enter# ";

        std::getline(std::cin, buffer);
        // 发送消息给sever
        // 首次调用sendto函数的时候 我们的client
        sendto(sockfd, buffer.c_str(), buffer.size(), 0,
               (const struct sockaddr *)&server, sizeof(server));
    }

    return 0;
}

6.5本地测试

其中127.0.0.1 是本地换回的端口号，也就是本主机

当然如果大家有多台主机就可以跨网络传输通信啦！

这是我朋友链接我的主机给我发送的消息（跨主机网络通信）

注意：如果是云服务器的话，大家一定要手动开端口号，否则是不能使用指定端口号的

（本篇完）

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

网络

udp

服务器