Linux下的网络编程——C/S模型 UDP（三）

前言：

UDP（User Datagram Protocol，用户数据报协议）是一种在计算机网络中常用的传输层协议。与TCP（传输控制协议）相比，UDP是一种无连接的协议，不具备可靠性和流量控制等特性，但由于其简单、高效的特点，被广泛应用于实时性要求较高、对数据完整性要求较低的应用场景。下面让我们一起对UDP进行一个简单的学习吧

一、TCP和UDP的区别：

TCP：

UDP：

二、TCP时稳定的连接方式：

三、UDP实现的 C/S 模型：

1. server：

2. client：

3.实现效果

四、socket IPC（本地套接字domain）

1.本地套接字domain

（1）.socket()

（2）.地址结构：

（3）.bind()

（4）.客户端

2.server

3.connect

4.运行效果：

五、对比本地套和网络套。

1.server：

2. client：

六、UDP用户数据报的首部格式：

七、使用 UDP 的这个服务器程序是什么？

一、TCP和UDP的区别：

TCP：

一种面向连接的、可靠的、基于字节流传输。对于不稳定的网络层，采取完全弥补的通信方式,丢包重传。

优点：
稳定。
数据流量稳定、速度稳定、顺序

缺点：
传输速度慢。相率低。开销大。

使用场景：

数据的完整型要求较高，不追求效率。

大数据传输、文件传输

UDP：

一种无连接的，不可靠信息传送服务。对于不稳定的网络层，采取完全不弥补的通信方式。默认还原网络状况。

优点：

传输速度块。相率高。开销小。

缺点：
不稳定。
数据流量。速度。顺序。

使用场景：

对时效性要求较高场合。稳定性其次。

游戏、视频会议、视频电话。

腾讯、华为、阿里 --- 应用层数据校验协议，弥补udp的不足。

并且两者在Linux网络编程中也会有很大的区别

二、TCP时稳定的连接方式：

TCP是面向连接的，TCP的三次握手很大程度上保证了数据的可靠性，而UDP不是面向连接的，UDP传送数据前并不与对方建立连接，对接收到的数据也不发送确认信号，发送端不知道数据是否会正确接收，也不会重发，所以说UDP是无连接的、不可靠的一种数据传输协议。

三、UDP实现的 C/S 模型：

recv()/send() 只能用于 TCP 通信。替代 read、write

accpet();（阻塞监听客户端连接） ---- Connect(); ---被舍弃

1. server：

lfd = socket(AF_INET, STREAM, 0); （创建socke） SOCK_DGRAM --- 报式协议。

bind(); （绑定服务器地址结构）

listen(); （设置监听上限）--- 可有可无

while（1）{

read(cfd, buf, sizeof) --- 被替换 --- recvfrom（） --- 涵盖accept传出地址结构。
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,struct sockaddr *src_addr, socklen_t *addrlen);

/***********recvfrom（）***********/
sockfd： 套接字

buf：缓冲区地址

len：缓冲区大小

flags： 0

src_addr：（struct sockaddr *）&addr 传出。 对端地址结构

addrlen：传入传出。

返回值： 成功接收数据字节数。失败：-1 errn。 0： 对端关闭。

小-- 大

write();--- 被替换 --- sendto（）---- connect

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,const struct sockaddr *dest_addr, socklen_t addrlen);

/***********recvfrom（）***********/
sockfd：套接字

buf：存储数据的缓冲区

len：数据长度

flags： 0

src_addr：（struct sockaddr *）&addr 传入。 目标地址结构

addrlen：地址结构长度。

返回值：成功写出数据字节数。失败 -1， errno

}

close();

#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <ctype.h>

#define SERV_PORT 8000    //端口号

int main(void)
{
    struct sockaddr_in serv_addr, clie_addr;
    socklen_t clie_addr_len;
    int sockfd;
    char buf[BUFSIZ];
    char str[INET_ADDRSTRLEN];
    int i, n;

    sockfd = socket(AF_INET, SOCK_DGRAM, 0);

    bzero(&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(SERV_PORT);

    bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));

    printf("Accepting connections ...\n");
    while (1) {
        clie_addr_len = sizeof(clie_addr);
        n = recvfrom(sockfd, buf, BUFSIZ,0, (struct sockaddr *)&clie_addr, &clie_addr_len);
        if (n == -1)
            perror("recvfrom error");

        //inet_ntop将点分文本IP转换为二进制网络字节序IP    
        //ntohs函数是一个网络字节序转换函数,用于将16位无符号整数从网络字节序(大端)转换为主机字节序

        printf("received from %s at PORT %d\n",
                inet_ntop(AF_INET, &clie_addr.sin_addr, str, sizeof(str)),
                ntohs(clie_addr.sin_port));

        for (i = 0; i < n; i++)
            buf[i] = toupper(buf[i]);

        n = sendto(sockfd, buf, n, 0, (struct sockaddr *)&clie_addr, sizeof(clie_addr));
        if (n == -1)
            perror("sendto error");
    }

    close(sockfd);

    return 0;
}

2. client：

connfd = socket(AF_INET, SOCK_DGRAM, 0);

sendto（‘服务器的地址结构’，地址结构大小）

recvfrom（）

写到屏幕

close();

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <ctype.h>

#define SERV_PORT 8000    //端口号

int main(int argc, char *argv[])
{
    struct sockaddr_in servaddr;
    int sockfd, n;
    char buf[BUFSIZ];

    sockfd = socket(AF_INET, SOCK_DGRAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
    servaddr.sin_port = htons(SERV_PORT);

   // bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));    //无效,可有可无

    while (fgets(buf, BUFSIZ, stdin) != NULL) {
        n = sendto(sockfd, buf, strlen(buf), 0, (struct sockaddr *)&servaddr, sizeof(servaddr));
        if (n == -1)
            perror("sendto error");

        n = recvfrom(sockfd, buf, BUFSIZ, 0, NULL, 0);         //NULL:不关心对端信息
        if (n == -1)
            perror("recvfrom error");

        write(STDOUT_FILENO, buf, n);
    }

    close(sockfd);

    return 0;
}

3.实现效果

四、socket IPC（本地套接字domain）

IPC： pipe、fifo、mmap、信号、本地套（domain）--- CS模型

1.本地套接字domain

对比网络编程 TCP C/S模型，注意以下几点：

（1）.socket()

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

                 参数 domain：AF_INET --》 AF_UNIX/AF_LOCAL

   type: SOCK_STREAM/SOCK_DGRAM 都可以。

（2）. 地址结构：

sockaddr_in --》 sockaddr_un；

struct sockaddr_in srv_addr; --》struct sockaddr_un srv_adrr;

srv_addr.sin_family = AF_INET; --》 srv_addr.sun_family = AF_UNIX;
·
srv_addr.sin_port = htons(8888); --》 strcpy(srv_addr.sun_path, "srv.socket")

srv_addr.sin_addr.s_addr = htonl(INADDR_ANY);

  len = offsetof(struct sockaddr_un, sun_path) + strlen("srv.socket");

       bind(fd, (struct sockaddr *)&srv_addr, sizeof(srv_addr)); --》 bind(fd, (struct sockaddr *)&srv_addr, len);

（3）.bind()

bind()函数调用成功，会创建一个 socket。因此为保证bind成功，通常我们在 bind之前，可以使用 unlink("srv.socket");

（4）.客户端

客户端不能依赖 “隐式绑定”。并且应该在通信建立过程中，创建且初始化2个地址结构：

1） client_addr --》 bind()

2) server_addr --》connect();

2.server

#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <strings.h>
#include <string.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <sys/un.h>
#include <stddef.h>

#include "wrap.h"

#define SERV_ADDR  "serv.socket"

int main(void)
{
    int lfd, cfd, len, size, i;
    struct sockaddr_un servaddr, cliaddr;
    char buf[4096];

    lfd = Socket(AF_UNIX, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sun_family = AF_UNIX;
    strcpy(servaddr.sun_path, SERV_ADDR);

    len = offsetof(struct sockaddr_un, sun_path) + strlen(servaddr.sun_path);     /* servaddr total len */

    unlink(SERV_ADDR);                              /* 确保bind之前serv.sock文件不存在,bind会创建该文件 */
    Bind(lfd, (struct sockaddr *)&servaddr, len);           /* 参3不能是sizeof(servaddr) */

    Listen(lfd, 20);

    printf("Accept ...\n");
    while (1) {
        len = sizeof(cliaddr);  //AF_UNIX大小+108B

        cfd = Accept(lfd, (struct sockaddr *)&cliaddr, (socklen_t *)&len);

        len -= offsetof(struct sockaddr_un, sun_path);      /* 得到文件名的长度 */
        cliaddr.sun_path[len] = '\0';                       /* 确保打印时,没有乱码出现 */

        printf("client bind filename %s\n", cliaddr.sun_path);

        while ((size = read(cfd, buf, sizeof(buf))) > 0) {
            for (i = 0; i < size; i++)
                buf[i] = toupper(buf[i]);
            write(cfd, buf, size);
        }
        close(cfd);
    }
    close(lfd);

    return 0;
}

3.connect

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>         
#include <sys/socket.h>
#include <strings.h>
#include <string.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <sys/un.h>
#include <stddef.h>

#include "wrap.h"

#define SERV_ADDR "serv.socket"
#define CLIE_ADDR "clie.socket"

int main(void)
{
    int  cfd, len;
    struct sockaddr_un servaddr, cliaddr;
    char buf[4096];

    cfd = Socket(AF_UNIX, SOCK_STREAM, 0);

    bzero(&cliaddr, sizeof(cliaddr));
    cliaddr.sun_family = AF_UNIX;
    strcpy(cliaddr.sun_path,CLIE_ADDR);

    len = offsetof(struct sockaddr_un, sun_path) + strlen(cliaddr.sun_path);     /* 计算客户端地址结构有效长度 */

    unlink(CLIE_ADDR);
    Bind(cfd, (struct sockaddr *)&cliaddr, len);                                 /* 客户端也需要bind, 不能依赖自动绑定*/

 /
   
    bzero(&servaddr, sizeof(servaddr));                                          /* 构造server 地址 */
    servaddr.sun_family = AF_UNIX;
    strcpy(servaddr.sun_path, SERV_ADDR);

    len = offsetof(struct sockaddr_un, sun_path) + strlen(servaddr.sun_path);   /* 计算服务器端地址结构有效长度 */

    Connect(cfd, (struct sockaddr *)&servaddr, len);

    while (fgets(buf, sizeof(buf), stdin) != NULL) {
        write(cfd, buf, strlen(buf));
        len = read(cfd, buf, sizeof(buf));
        write(STDOUT_FILENO, buf, len);
    }

    close(cfd);

    return 0;
}