网络编程套接字----UDP协议

最新推荐文章于 2023-01-11 01:02:41 发布
最新推荐文章于 2023-01-11 01:02:41 发布
阅读量1.2k 收藏 3
点赞数 2
文章标签： 网络 udp tcp/ip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61560468/article/details/128491252
版权

文章目录

前言

  1. 认识IP地址,端口号,网络字节序等网络编程中的基本概念;
  2. 学习socket api的基本用法;
  3. 能够实现一个简单的UDP客户端/服务器;
  4. 能够实现一个简单的TCP客户端/服务器(单连接版本,多进程版本,多线程版本);
  5. 理解TCP服务器建立连接,发送数据,断开连接的流程.

正文开始!

一、理解源IP地址和目的IP地址

  • 源IP地址:对应的就是标定通信主机的本机主机.
  • 目的IP地址:对应的就是标定通信主机的目的主机.

二、认识端口号

在这里插入图片描述

端口号(port)是传输层协议的内容:

  • 端口号是一个2字节16位的整数;
  • 端口号用来表示一个进程,告诉操作系统,当前的这个数据要交给哪一个进程来处理;
  • IP地址+端口号能够标识网络上的某一台主机的某一个进程;
  • 一个端口号只能被一个进程占用;

理解"端口号"和"进程ID"

之前在进程的学习中可以知道pid表示唯一一个进程;此处端口号也是表示一个进程,那么这两者有什么关系呢?

一个进程可以绑定多个端口号;但是一个端口号不能被多个进程绑定.

理解源端口号和目的端口号

传输层协议(TCP和UDP)的数据段中有两个端口号,分别叫做源端口号和目的端口号.就是在描述"数据是谁发的,要发给谁";
在这里插入图片描述

三、认识TCP协议

在这里我们先对TCP(Transmission Control Protocol 传输控制协议)做一个简单的认识;

  • 传输层协议
  • 有连接
  • 可靠传输
  • 面向字节流

四、认识UDP协议

在这我们也是对UDP(User Dategram Protocol 用户数据报协议)做一个简单的认识;

  • 传输层协议
  • 无连接
  • 不可靠传输
  • 面向数据报

五、网络字节序

我们已经知道,内存中的多字节数据相对于内存地址有大端和小端之分,磁盘文件中的多字节数据相对于文件中的偏移地址也有大端和小端之分,网络数据流同样有大端和小端之分,那么如何定义数据网络数据流的地址呢?

  • 发送主机通常将发送缓冲区中的数据按内存地址从低到高的顺序发出;
  • 接收主机把从网络上接到的字节一次保存在接收缓冲区中,也是按内存地址从低到高的顺序保存;
  • 因此,网络数据流的地址应这样规定:先发出的数据是低地址,后发出的数据是高地址.
  • TCP/IP协议规定:W昂罗数据流应采用大端字节序,即低地址高字节.
  • 不管这台主机是大端机还是小端机,都会按照这个TCP/IP规定的网络字节序来发送/接收数据.
  • 如果当前发送主机是小端,就需要先将数据转成大端;否则就忽略,直接发送即可.

在这里插入图片描述

为了使网络程序具有可移植性,使用同样的C代码在大端和小端计算机上编译后都能正常运行,可以调用以下的库函数做网络字节序和主机字节序的转换.

在这里插入图片描述

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

六、socket编程接口

socket常见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结构

socket API是一层抽象的网络编程接口,适用于各种底层网络协议,如IPv4,IPv6.
然后各种不同网络协议的地址格式并不相同.
在这里插入图片描述

  • IPv和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以及各种类型的sockaddr结构体指针作为参数;

sockaddr结构

在这里插入图片描述

sockaddr_in 结构

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

in_addr结构

在这里插入图片描述
in_addr用来表示一个IPv4的IP地址.其实就是一个32位整数.

七、地址转换函数

基于IPv4的socket网络编程,sockaddr_in中的成员struct in_addr,sin_addr表示32位的IP地址.但是我们通常使用点分十进制的字符串表示IP地址,以下的函数可以在字符串表示和in_addr表示之间转换:

在这里插入图片描述

关于inet_ntoa

inet_ntoa这个函数返回了一个char*,很显然是这个函数自己在内部为我们申请了一块内存来保存ip的结果,那么是否需要调用者手动释放呢?
在这里我们查看man手册
在这里插入图片描述

man手册上面说,inet_ntoa函数是把这个结果放到了静态存储区.这个时候不需要我们手动释放.

那么问题来了,如果我们多次调用这个函数,会有什么样的效果呢?

参考如下代码

#include<stdio.h>
#include<netinet/in.h>
#include<arpa/inet.h>

int main()
{
    struct sockaddr_in addr1;
    struct sockaddr_in addr2;
    addr1.sin_addr.s_addr=0;
    addr2.sin_addr.s_addr=0xffffffff;
    char* ptr1 = inet_ntoa(addr1.sin_addr);
    char* ptr2 = inet_ntoa(addr2.sin_addr);
    printf("ptr1: %s,ptr2: %s\n",ptr1,ptr2);
    return 0;
}

在这里插入图片描述
因为inet_ntoa把结果放到自己内部的一个静态存储区,这样第二次调用时的结果会覆盖掉上一次的结果.

思考:如果有多个线程调用 inet_ntoa,是否会出现异常情况呢?—>一定会的!
在APUE这本书中,明确提出 inet_ntoa 不是线程安全的函数;
在多线程的环境下,推荐使用 inet_ntop,这个函数由调用者提供一个缓冲区保存结果,可以规避线程安全问题;

八、简单的UDP网络程序

实现一个大小写转化的功能
在这里插入图片描述

封装UDPSocket

makefile

.PHONY:all
all:udpClient udpServer
udpClient:udpClient.cc
	g++ -o $@ $^ -std=c++11 -lpthread
udpServer:udpServer.cc
	g++ -o $@ $^ -std=c++11
.PHONY:clean
clean:
	rm -rf udpClient udpServer

Log.hpp

#pragma once
#include<cstdio>
#include<ctime>
#include<cstdarg>
#include<cassert>
#include<cstdlib>
#include<cstring>
#include<cerrno>
#define DEBUG     0
#define NOTICE    1
#define WARINING  2
#define FATAL     3

const char* log_level[]={"DEBUG","NOTICE","WARINING","FATAL"};

//logMessage(DEBUG,"%d",10);
void logMessage(int level,const char* format,...)
{
    assert(level>=DEBUG);
    assert(level<=FATAL);
    char logInfo[1024];
    char* name=getenv("USER");
    va_list ap; //ap--->char*
    va_start(ap,format);

    vsnprintf(logInfo,sizeof(logInfo)-1,format,ap);

    va_end(ap); //ap=NULL

    FILE* out=(level==FATAL)?stderr:stdout;
    fprintf(out,"%s | %u | %s | %s\n",\
    log_level[level],(unsigned int)time(nullptr),\
    name==nullptr?"unknow":name,logInfo);
}

// char* s=format;
// while(s)
// {
//     case: '%'
//     if(*(s+1)=='d')int x=va_arg(ap,int);
//     break;
// }

udpClient.cc

#include <iostream>
#include <string>
#include <cstdlib>
#include <strings.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <pthread.h>
using namespace std;

struct sockaddr_in server;

static void Usage(string proc)
{
    printf("Usage\n\t%s server_ip server_port\n", proc.c_str());
}
void *recverAndPrint(void *args)
{
    while (true)
    {
        int sockfd = *(int *)args;
        char buffers[1024];
        memset(buffers,0,sizeof buffers);
        struct sockaddr_in temp;
        socklen_t len = sizeof(temp);
        ssize_t s = recvfrom(sockfd, buffers, sizeof(buffers) - 1, 0, (struct sockaddr *)&temp, &len);
        if (s > 0)
        {
            buffers[s] = 0;
            cout << "server echo# " << buffers << 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
    string server_ip = argv[1];
    uint16_t server_port = stoi(argv[2]);

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

    // 2.2 client 需不需要bind???--->需要bind，但是不需要用户自己bind，而是OS自动给你bind
    //  所谓的"不需要"，指的是：：不需要用户自己bind端口信息！因为OS会自动给你绑定，你也最好这么做！
    //如果我非要自己bind呢?  可以！  严重不推荐！
    //  所有的客户端软件 <->服务器 通信的时候，必须得有 client[ip,port] <->server[ip,port]
    //  为什么呢？ client很多，不能给客户端bind指定的port，port可能被别的client使用了，你的client就无法使用了
    //  那么server凭什么要bind呢？server提供的服务，必须要被所有人知道！server不能随便改变！
    // 2.2填写服务器对应的信息
    bzero(&server, sizeof server);
    socklen_t len = sizeof(server);
    server.sin_family = AF_INET;
    server.sin_port = htons(server_port);
    server.sin_addr.s_addr = inet_addr(server_ip.c_str());

    pthread_t t;
    pthread_create(&t, nullptr, recverAndPrint, (void *)&sockfd);

    // 3.通讯过程
    string buffer;
    while (true)
    {
        cerr << "Please Enter# ";
        getline(cin, buffer);
        //发送消息给server
        sendto(sockfd, buffer.c_str(),
               buffer.size(), 0, (const struct sockaddr *)&server, len);
        //首次调用sendto函数的时候，我们client会自动bind自己的ip和port
    }
    close(sockfd);
    return 0;
}

udpServer.cc

#include <iostream>
#include<unordered_map>
#include <sys/types.h>
#include <strings.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "log.hpp"

using namespace std;

//我们想写一个简单的udpServer
//云服务器有一些特殊情况
// 1.禁止你bind云服务器上的任何确定IP,只能使用INADDR_ANY,如果是虚拟机的话就可以！
class UdpServer
{
public:
    UdpServer(uint16_t port, string ip = "")
        : _sockfd(-1), _port(port), _ip(ip)
    {
    }
    ~UdpServer()
    {
    }
    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+port
        // 2.1先填充基本信息到 struct sockaddr_in
        struct sockaddr_in local;    // local在用户栈上开辟的空间--->临时变量--->写入内核中
        bzero(&local, sizeof local); // memset
        local.sin_family = AF_INET;  // 填充协议家族，域
        //填充服务器对应得端口号信息，一定是会发给对方的，_port一定回到网络中的
        local.sin_port = htons(_port);
        //服务器都必须具有IP地址，"81.70.251.220",字符串风格的点分十进制-->四字节IP-->uint32_t ip
        // INADDR_ANY(0):程序员不关心会bind到哪一个ip，任意地址bind,强烈推荐的做法，所有服务器一般的做法
        // inet_addr:指定填充确定的IP，特殊用途，或者测试时使用，除了做转化，还会自动给我们进行h->n
        local.sin_addr.s_addr = _ip.empty() ? htonl(INADDR_ANY) : inet_addr(_ip.c_str());
        // 2.2
        if (bind(_sockfd, (const struct sockaddr *)&local, sizeof local) < 0)
        {
            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); //输入输出型参数
            // UDP是无连接的
            //对方给你发了消息，你想不想给对方回消息？要的！后面两个参数是输出型参数
            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]
            string peerIp=inet_ntoa(peer.sin_addr);//拿到了对方的ip
            uint32_t peerPort=ntohs(peer.sin_port);//拿到了对方的port
            
            checkOnlineUser(peerIp,peerPort,peer);//如果存在，什么都不做，如果不存在就添加
            
            
            //打印出客户端给服务器发送的消息
            logMessage(NOTICE, "[%s|%d]# %s",peerIp.c_str(),peerPort,inbuffer);
            for(int i=0;i<strlen(inbuffer);i++)
            {
                if(isalpha(inbuffer[i])&&islower(inbuffer[i]))
                    outbuffer[i]=toupper(inbuffer[i]);
                else
                    outbuffer[i]=inbuffer[i];
            }
            messageRoutine(peerIp,peerPort,inbuffer);//消息路由
            
            //线程池！


            //sendto(_sockfd,outbuffer,strlen(outbuffer),0,(const struct sockaddr*)&peer,sizeof(peer));
            
            // logMessage(NOTICE,"server provide service succsee...");
            // sleep(1);
        }
    }
    void checkOnlineUser(string& ip,uint32_t port,struct sockaddr_in& peer)
    {
        string key=ip;
        key+=":";
        key+=to_string(port);
        auto iter =_users.find(key);
        if(iter==_users.end())
        {
            _users.insert({key,peer});
        }
        else
        {
            //do nothing
        }
    }
    void messageRoutine(string ip,uint32_t port,string info)
    {
        string message="[";
        message+=ip;
        message+=":";
        message+=to_string(port);
        message+="]";
        message+=info;
        for(auto& e:_users)
        {
            sendto(_sockfd,message.c_str(),message.size(),0,(const struct sockaddr*)&(e.second),sizeof(e.second));
        }
    }
private:
    //服务器socket fd信息
    int _sockfd;
    // 服务器必须得有端口号信息
    uint16_t _port;
    //服务器必须要有ip地址
    string _ip;
    //onlineuser
    std::unordered_map<std::string,struct sockaddr_in> _users;
};
// struct ip
// {
//     uint32_t part1:8;
//     uint32_t part2:8;
//     uint32_t part3:8;
//     uint32_t part4:8;
// };

static void Usage(const string proc)
{
    printf("Usage:\n\t%s port [ip]\n", proc.c_str());
}

// ./udpServer port [ip]
int main(int argc, char *argv[])
{
    if (argc != 2 && argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }
    uint16_t port = stoi(argv[1]);
    string ip;
    if (argc == 3)
    {
        ip = argv[2];
    }

    UdpServer svr(port, ip);
    svr.init();
    svr.start();
    return 0;
}

在这里插入图片描述

Windows下的客户端实现

#pragma warning(disable:4996)
#pragma comment(lib,"Ws2_32.lib")
#include<iostream>
#include<cstdio>
#include<string>
#include<cassert>
#include<cstdlib>
#include<WinSock2.h>
using namespace std;
int main()
{
	WSADATA data;
	WSAStartup(MAKEWORD(2,2),&data);

    string server_ip = "81.70.251.220";
    uint16_t server_port = 8081;

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

    // 2.2 client 需不需要bind???--->需要bind，但是不需要用户自己bind，而是OS自动给你bind
    //  所谓的"不需要"，指的是：：不需要用户自己bind端口信息！因为OS会自动给你绑定，你也最好这么做！
    //如果我非要自己bind呢?  可以！  严重不推荐！
    //  所有的客户端软件 <->服务器 通信的时候，必须得有 client[ip,port] <->server[ip,port]
    //  为什么呢？ client很多，不能给客户端bind指定的port，port可能被别的client使用了，你的client就无法使用了
    //  那么server凭什么要bind呢？server提供的服务，必须要被所有人知道！server不能随便改变！
    // 2.2填写服务器对应的信息
    struct sockaddr_in server;
    memset(&server,'\0',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.通讯过程
    string buffer;

    while (true)
    {
        cerr << "Please Enter# ";
        getline(cin, buffer);
        //发送消息给server
        sendto(sockfd, buffer.c_str(), \
            buffer.size(), 0, (const struct sockaddr*)&server, sizeof(server));
        //首次调用sendto函数的时候，我们client会自动bind自己的ip和port
    } 
    closesocket(sockfd);
    WSACleanup();
	return 0;
}

在这里插入图片描述

中间的乱码问题可能是因为编码问题,但是其他的内容我们就可以直接的进行通讯.

总结

(本章完!)

拾至灬名瑰
关注
Python网络编程之UDP套接字编程
Junds0的博客
10-27 1217
发生丢包时要有反馈信息，并且需要输出，内容为The x package is lost，x为第几次发生数据包报丢失，x初始值为0，表示没有出现任何丢包情况，每出现一次丢失数据包，x值就会增加一，具体参考预期输出。接收的内容为Receive x: from y，你需要将其输出，其中x表示收到第几次的报文，y为来自服务器的消息（并且是解码后的字符串类型的消息），具体参考预期输出。本关任务：完成一个客户端程序，向服务器端发出请求，传输数据，并设置超时丢包，体验 UDP 的基本连接过程。（你不需要将发送内容输出）
【Linux】网络编程之套接字 -- UDP
gangaue的博客
04-05 871
这篇文章给大家带来套接字的学习！！！
网络编程（UDP协议）
sunnnnh的博客
12-17 303
使用UDP协议编写一个网络程序，设置接收端程序的监听端口是8001，发送端发送的数据是“Hello, world”。 （1）代码 import java.net.*; public class UdpReceive { public static void main(String[] args)throws Exception { //创建存放接收数据的数组 byte[] b=n
络编程之UDP协议
小白有个大牛梦
12-30 1323
网络编程之UDP协议
套接字编程——基于UDP协议
weixin_34244102的博客
05-23 74
《UDP用到的大多数函数在上一片TCP中已讲解，这儿就不再重复了，只有接受和发送所用的函数不同》函数（1）接受——recvfrom()（2）发送——sendto()a. 参数sockfd:表示一个已经建立的socket编号（描述符）；buf: 接受数据的缓冲区；len:缓冲区的大小；flags: 调用操作方式，当设为0时，表示用阻塞方式接收；src_addr: 发送方网络...
网络编程之UDP协议和TCP协议
WH1731754188的博客
09-08 370
UDP协议和TCP协议UDP协议(用户数据报协议): 需要一个发送端和接收端; 发送端:只负责发送数据,不管接收端是否接收到数据. 在传输数据的过程中是允许数据报丢失的;特点: 1.需要一个发送端和接收端; 2.发送端只负责发送数据,不管接收端是否接收到数据; 3.在传输数据的过程中是允许数据报丢失的;TCP/IP协议: 特点: 1.需要一个客户端 和
网络编程套接字 - UDP套接字
最新发布
09-07
网络编程中的UDP套接字是基于用户数据报协议（User Datagram Protocol）的一种通信方式，它在互联网协议族中扮演着重要角色。UDP是一种无连接、不可靠的传输协议，相较于TCP，它更注重效率和速度，但不保证数据的...
Python基于UDP协议的套接字通信，网络编程必看
08-15
在IT行业中，网络编程是构建分布式系统和网络应用的基础，而Python作为一种强大的...这份资源分享计划中的"基于UDP协议的套接字"文件，应该包含了更详细的代码实现和注释，可以帮助深入学习和实践Python的网络编程。
网络异步套接字-易语言
06-13
- **创建套接字**：首先，我们需要使用`socket()`函数创建一个套接字，指定协议类型（TCP或UDP）、地址族（如AF_INET代表IPv4）和套接字类型（如SOCK_STREAM代表TCP）。 - **绑定**：然后使用`bind()`函数将套接字...
网络编程——(3)UDP协议
真香号
01-27 162
目录 一、 首先需要明确什么是Socket? 二、UDP 2.1DatagramSocket 2.1.1构造方法 2.1.2常用方法 3.1DatagramPacket 3.1.1构造方法 3.1.2常用方法 一、 首先需要明确什么是Socket? 在java.net包中有一个socket包 java.net.socket包。 实际上Sock...
TCP与UDP客户服务端实现大小写及SOCKET编程实现聊天程序
01-23
TCP与UDP客户服务端实现大小写及SOCKET编程实现聊天程序
java网络编程之udp协议
hai_man_的博客
01-06 1380
java网络编程之udp协议
UDP网络编程
weixin_47783699的博客
11-18 2689
使用UDP网络通讯
网络编程（UDP）
weixin_43665107的博客
01-05 800
数据库
网络编程（十）——基于UDP协议的套接字
hold_on_qlc的博客
01-11 337
TCP和UDP协议传输对比 TCP协议传输数据可靠，TCP传输数据后，如果收到接收方回应消息，则会在本机缓存中删除已发送消息；如果没有收到接收方回应消息，则会利用缓存继续发送消息。 UDP协议传输数据相对来说不可靠，发送方只要发出消息即完成任务。但是UDP传输无需建立三次握手链接，开销较小，也不需要等待对方回应，发送效率很高。
Linux网络编程 2 写一个udp服务器，实现字母的大小写转换（附udp和tcp服务器的区别）
weixin_A13253323604
08-31 861
服务器端：udp_ser.c #include <stdlib.h> #include <stdio.h> #include <string.h> #include <unistd.h> #include <errno.h> #include <ctype.h> #include <sys/socket.h> #include <arpa/inet.h> /* udp：用户数据报协议，是一种无连接的传输层协议，
UDP套接字编程
加啊啊啊啊零的博客
06-06 345
UDP Socket编程UDP：在客户端和服务器之间没有连接UDP：传送的数据可能乱序，也可能丢失进程视角看UDP服务——UDP为客户端和服务器提供不可靠的字节组的传送服务【UDP是无连接的，所以提供的服务也叫数据报，IP也叫数据报（datagram），无连接的PDU通常可以把它叫数据报，所以看到datagram要结合上下文来看他是UDP的协议数据单元还是IP的协议数据单元】Client/server socket 交互：UDP【第一步（服务器端）建立一个serverSocket，返回一个整数】【第二步（服
Linux网络编程：套接字接口与TCP/UDP协议
2. 数据报套接字（SOCK_DGRAM）：基于UDP协议，采用无连接服务，数据报文独立传输，不保证顺序和可靠性。 3. 原始套接字（SOCK_RAW）：适用于协议开发或底层操作，可以直接处理网络层的数据包。 在编程中，涉及套...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

拾至灬名瑰

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值