UDP一对一数据收发

一、UDP协议

1.udp是无连接的，也就是不需要像TCP那样调用 connect(...)函数。正是因为UDP是不需要connect(...)，所以UDP是不可靠的。是无应答消息的，即：发出去了就发出去了，也不知道有没有收到。UDP协议也是数据包无序号标识，即：可能先发的数据包，最后收到，也有可能后发的数据包，最先收到，是比较随机的。

2.UDP是面向数据包的，即：UDP每次发送都是以一个一个数据包来进行发送的。正是因为如此，对应的应用层数据既不会合并也不会拆分(保留数据包的边界)。每次发送的数据都是一个独立的UDP数据包，即：第一次发送的UDP数据包和第二次发送的UDP数据包，不会有任何的联系，2次发送的数据，就需要2次接收。因此，不会产生TCP中，那种粘包的行为。

3.UDP没有拥塞控制，UDP只知道不停的往外发送数据，网络出现的拥塞不会使源主机的发送速率降低。从某种意义上来看，UDP的效率更高。因为，UDP没有繁琐的握手机制、同步机制。

4.UDP支持一对一、一对多、多对一和多对多的交互通信。因为UDP只需要知道目标主机ip地址，以及端口号就可以进行通信。

5.UDP消息头开销小，只有8个字节。TCP消息头工有20个字节。

6.所以，我们知道 UDP更加高效，UDP的高效是通过可靠性来换取的。如果想要高效，那么就选UDP，如果想要可靠性，那么就选TCP。UDP he TCP 是互补的。

二、UDP 和 IP 的区别

1.udp是建立于IP之上的数据传输协议

1.1 IP负责将UDP数据包从源主机传输到目标主机

1.2udp 则将应用层数据投递到目标socket（端口号）

2.udp几乎完整继承了IP的传输特性

2.1 通信两端无交互、无流控，无超时重发，不具备可靠性。

疑问：为什么IP 和 UDP 这么像，还要搞出来一个 UDP 协议呢？不直接用 IP 协议呢？

因为网络通信协议栈规定，数据通信是一层一层进行的，下层为上层提供服务。应用层 -> 传输层 -> IP层。应用层不能够直接到 IP 层，中间需要经历一个传输层，而传输层的TCP协议并不适合所有的场景，这个时候就需要UDP协议了。可以这样理解，TCP 就是 IP 的深度定制协议；UDP 就是 IP 的轻度定制协议。

三、api 分析

#include <sys/socket.h>

/* Send N bytes of BUF on socket FD to peer at address ADDR (which is
ADDR_LEN bytes long). Returns the number sent, or -1 for errors.

This function is a cancellation point and therefore not marked with
__THROW. */
extern ssize_t sendto (int __fd, const void *__buf, size_t __n,
int __flags, __CONST_SOCKADDR_ARG __addr,
socklen_t __addr_len);

int __fd //socket 文件描述符

const void *__buf //需要发送的数据

size_t __n // 需要发送的数据量

int __flags // 发送选项，默认是0，为阻塞模式

__CONST_SOCKADDR_ARG __addr // 接收地址信息

socklen_t __addr_len // 接收地址 __addr 的长度信息

从sendto(...) 这个api 分析，可以看出：udp 发送数据是不需要提前进行 connect(...)的。相对于TCP的发送api ,就多了 __CONST_SOCKADDR_ARG __addr ，socklen_t __addr_len 这2个参数。

/* Read N bytes into BUF through socket FD.
If ADDR is not NULL, fill in *ADDR_LEN bytes of it with tha address of
the sender, and store the actual size of the address in *ADDR_LEN.
Returns the number of bytes read or -1 for errors.

This function is a cancellation point and therefore not marked with
__THROW. */
extern ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n,
int __flags, __SOCKADDR_ARG __addr,
socklen_t *__restrict __addr_len);

int __fd //socket 文件描述符

void *__restrict __buf //保存接收数据的内存

size_t __n //可接收的最大数据量

int __flags //发送选项，默认是0，为阻塞模式

__SOCKADDR_ARG __addr // 接收地址信息

socklen_t *__restrict __addr_len // 指向保存 __addr 参数长度的变量地址

{

__SOCKADDR_ARG __addr,
socklen_t *__restrict __addr_len

} 这两个参数标记了接收数据的地址结构体。

server.c

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>


int main()
{
    int server=0;
    struct sockaddr_in saddr={0};
    int client=0;
    struct sockaddr_in remote={0};
    socklen_t asize=0;
    socklen_t len=0;
    char buf[32]={0};
    int r=0;

    server=socket(PF_INET,SOCK_DGRAM,0);

    if(server==-1){
        printf("udp server socket error\n");
        return -1;
    }
    
    saddr.sin_family=AF_INET;
    saddr.sin_addr.s_addr=htonl(INADDR_ANY);
    saddr.sin_port=htons(8888);

    if(bind(server,(struct sockaddr*)&saddr,sizeof(saddr))==-1){
        printf("udp server bind error!\n");
        return -1;
    }

    printf("udp server start success\n");

    while(1){
        len = sizeof(remote);
        
        r=recvfrom(server,buf,sizeof(buf),0,(struct sockaddr*)&remote,&len);

        buf[r]='\0';

        printf("received data length: %d\n",r);
        printf("received data: %s\n",buf);
        printf("remote ip: %s\n",inet_ntoa(remote.sin_addr));
        printf("remote port: %d\n",ntohs(remote.sin_port));

        sendto(server,buf,r,0,(struct sockaddr*)&remote,len); //把从客户端接受到数据，全部发送给客户端
    }

    close(server);

    return 0;
}

client.c

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>


int main()
{
    int sock=0;
    struct sockaddr_in addr;
    struct sockaddr_in remote;
    int len=0;
    char buf[128]={0};
    char input[32]={0};
    int r=0;
    

    sock=socket(PF_INET,SOCK_DGRAM,0);

    if(sock==-1){
        printf("udp socket error!\n");
        return -1;
    }

    addr.sin_family=AF_INET;
    addr.sin_addr.s_addr=htonl(INADDR_ANY);
    addr.sin_port=htons(9999);

    if(bind(sock,(struct sockaddr*)&addr,sizeof(addr)) == -1)
    {
            printf("udp bind error\n");
            return -1;
    }

    printf("udp bind success\n");

    remote.sin_family=AF_INET;
    remote.sin_addr.s_addr=inet_addr("127.0.0.1");
    remote.sin_port=htons(8888);

    while(1){

        printf("Input: ");

        scanf("%s",input);

        len=sizeof(remote);

        sendto(sock,input,strlen(input),0,(struct sockaddr*)&remote,len);

        r = recvfrom(sock,buf,sizeof(buf),0,(struct sockaddr*)&remote,&len);

        if(r>0){
            buf[r]='\0';

            printf("Receive:%s\n",buf);
        }
        else
        {
            break; 
        }

    }

    close(sock);


    return 0;
}