计算机网络:TCP套接字通信

最新推荐文章于 2024-03-03 19:43:09 发布
最新推荐文章于 2024-03-03 19:43:09 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： Linux系统编程 计算机网络 Linux系统编程 文章标签： 计算机 socket 网络 tcp 通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gebushuaidanhenhuai/article/details/75174552
版权

预备知识

套接字

套接字(socket）这个词可以表示很多概念：在TCP/IP协议中，”IP+地址+TCP/UDP端口号”唯一标示网络通讯中的一个进程，IP地址+端口号”就称为socket。

网络字节序

网络中要实现通信，少不了数据的传输。所以这里就引入了网络字节序的概念。
在前边的学习中，我们接触到大端和小端的概念。小端：数据的地位在低地址，高位在高地址；大端：数据的低位在高地址，高位在低地址。网络数据流同样也有大端和小端之分。网络数据流先发出的是低地址，后发出的是高地址。TCP/IP规定，网络数据流采用大端字节序，即就是低位在高地址。我们之所以会说到大端和小端？是因为，网络通信的时候必须知道端口号，如果发送端是大端字节序，接收端是小端字节序，那么最后看到的端口号就是不正确的端口号，所以，我们必须将端口号在发送端和接收端之间转换成统一的字节序形式。
为使网络程序具有可移植性,使同样的C代码在大端和小端计算机上编译后都能正常运行,可以调用以下库函数做网络字节序和主机字节序的转换。

#include <arpa/inet.h>
uint32_t htonl(uint32_t hostlong); //主机字节序转为网络字节序，long类型
uint16_t htons(uint16_t hostshort); //主机字节序为网络字节序，short类型
uint32_t ntohl(uint32_t netlong); //网络节序转为主机字节序，long类型
uint16_t ntohs(uint16_t netshort); //主机节序转为网络字节序，short类型

socket编程的操作函数

1.套接字创建函数sockt:
这里写图片描述
函数功能：创建套接字。
参数：
(1)domain：表示建立的socket的类型，可选择的类型如下：
这里写图片描述
对于IPv4，参数指定为AF_NET
(2)type：表示的是传输的数据是 数据报传输还是字节流传输，可选的类型如下：

这里写图片描述
对于TCP协议，type参数指定为SOCK_STREAM，表示面向流的传输协议。
如果是UDP协议，type参数指定为SOCK_DGRAM表示面向数据报的协议。
(3)protocol：表示创建的方式，我们在这里把他置为0。
返回值：
成功返回一个文件描述符，失败返回-1。

2.服务器绑定函数bind
这里写图片描述
函数功能：服务器程序所监听的网络地址和端口号通常是固定不变的，客户端程序得知服务器程序的地址和端口号后就可以向服务器发起连接，因此服务器需要调用bind绑定一个固定的网络地址和端口号。
参数：
(1)sockfd:服务器的套接字，也就是socket函数的返回结果。
(2)addr:是socket服务器的地址内容，结构体内的变量则去填写ip地址和端口号。而sockaddr_in这个结构体成员如下：
这里写图片描述
这里有设计到了字符串与in_addr的转换：
这里写图片描述
(3)addrlen：指定结构体的长度。
返回值：成功返回0，失败返回-1。

3.设置监听状态函数listen
这里写图片描述
函数功能：用来设置sockfd套接字为监听状态的，用来监听客户端的连接。
参数：
backlog:表示的是服务器连接达到最大的数量之后，还可以放到等待队列的连接个数，所以一般不要设太大。
返回值：成功返回0，失败返回-1。

4.请求连接函数connect
这里写图片描述
函数功能：用于客户端，用来请求对服务器的连接。
参数：
sockfd表示的表示的是要链接到服务器的客户端套接字。
参数addr表示的是服务器的地址与端口号；
参数addrlen表示的是addr的大小一般使用sizeof得到。

5.接受连接函数accept
这里写图片描述
函数功能：三次握手完成后，服务器调用accept()接受连接，如果是服务器调用accept()时还没有客户端的连接请求，就阻塞等待直到有客户端连接上来。
参数：
sockfd：已经创建好的文件描述符，也是监听套接字。
addr：输出型参数，获取客户端的信息(IP地址，端口号等)。
addrlen：是一个传入传出参数，传入的是调用这提供的缓冲区addr的长度以避免缓冲区溢出问题，传出的是客户端地址结构体的实际长度(有可能没有占满调用者提供的缓冲区)。
返回值：成功返回一个文件描述符，是真正的用于通信的桃姐子。失败返回-1。

单进程的套接字TCP通信

server.c:

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


void Usage(const char* name)
{
    printf("Usage:%s [IpAddress] [port]\n",name);
}

int StartUp(int port, const char* ip)
{
    int ListenSock = socket(AF_INET,SOCK_STREAM,0); 
    if(ListenSock < 0)
    {
        perror("socket");
        return 1;
    }

    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);

    if(bind(ListenSock,(struct sockaddr*)&local,sizeof(local)) < 0)
    {
        perror("bind");
        return 2;
    }

    if(listen(ListenSock,5) < 0)
    {
        perror("listen");
        return 3;
    }
    return ListenSock;
}

int main(int argc,const char* argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        return 1;
    }

    int listenSock = StartUp(atoi(argv[2]),argv[1]);
    struct sockaddr_in client;
    socket_t len = sizeof(client);
    while(1)
    {
        int sock = accept(listenSock,(struct sockaddr*)&client,&len);//获取客户机的信息
        if(sock < 0)
        {
            perror("accept");
            continue;
        }
        printf("Get a client,IP is %s,port is %d\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));
        char buf[1024];
        while(1)
        {
            ssize_t s = read(sock,buf,sizeof(buf)-1);//从服务器读数据
             if(s == 0)
            {
                //数据已经读完了，客户端不发送数据了
                printf("client is quit!\n");
                return 2;
            }
             else if(s <0)
            {
                perror("read");
                return 3;
            }
             else
            {
                buf[s] = 0;
                printf("client# %s\n",buf);
            //  write(sock, buf, strlen(buf));

                printf("say: ");
                fflush(stdout);
                ssize_t _s = read(0,buf,sizeof(buf)-1);
                if(_s <= 0)
                {
                    perror("read");
                    return 1;
                }
                buf[_s-1]=0;
                write(sock,buf,sizeof(buf)-1);
            }
        }
    close(sock);
    }

    return 0;
}

client.c:

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


void Usage(const char* name)
{
    printf("Usage:%s [IpAddress] [port]\n",name);
}


int main(int argc,const char* argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        return 1;
    }

    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock < 0)
    {
        perror("socke");
        return 2;
    }

    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);

    if(connect(sock,(struct sockaddr*)&server,sizeof(server)) < 0)
    {
        perror("connect");
        return 3;
    }

    //printf("connect success!\n");
    char buf[1024];
    while(1)
    {
        printf("send# ");
        fflush(stdout);
        ssize_t s = read(0,buf,sizeof(buf)-1);
        if(s <= 0)
        {
            perror("read");
            return 4;
        }
        buf[s-1] = 0;
        write(sock,buf,strlen(buf));

        ssize_t _s = read(sock, buf, sizeof(buf)-1);
        if(_s == 0)
        {
            printf("server quit\n");
            break;
        }
        else if(_s < 0)
        {
            perror("read");
            return 5;
        }
        else
        {
            buf[s]=0;
            printf("server #: %s\n", buf);
        }
    }
    close(sock);
    return 0;
}

多进程套接字TCP通信

上边的代码，只可以一个客户端进行发送数据，而在实际的应用中，，都是会出现多个客户端给服务器发送数据，所以，上边的实现并不实用。所以，我们可以实现一个多进程的socket通信，以实现多个客户端给服务器发数据。
实现方法：服务器端可以创建多个子进程去处理客户端发来的信息。当每次收到一个新的客户端的连接请求的时候，我们就会fork()出一个子进程，父进程用于等待子进程，子进程用于执行 读客户端发的数据 的操作。细心的你可能会发现，我们在子进程读取信息之前还进行了一次fork()，这是为什么呢？其实，我们用子进程fork()出一个孙子进程，终止掉儿子进程，儿子进程被它的父进程回收，此时的孙子进程就是一个孤儿进程，被1号进程领养。这样做的目的就是，不要让儿子进程等待孙子进程太久而消耗太多的系统资源。
代码实现：
server.c:

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

void Usage(const char* name)
{
    printf("Usage:%s [IP] [port]\n",name);
}

int StartUp(int port, const char* ip)
{
    int ListenSock = socket(AF_INET,SOCK_STREAM,0);
    if(ListenSock < 0)
    {
        perror("socket");
        return 1;
    }
    int opt = 1;
    setsockopt(ListenSock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);

    if(bind(ListenSock,(struct sockaddr*)&local,sizeof(local))<0)
    {
        perror("bind");
        return 2;
    }
    if(listen(ListenSock,5) < 0)
    {
        perror("listen");
        return 3;
    }
    return ListenSock;
}

int main(int argc,const char* argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        return 1;
    }

    int listenSock = StartUp(atoi(argv[2]),argv[1]);
    struct sockaddr_in client;
    socklen_t len = sizeof(client);
    while(1)
    {
        int sock = accept(listenSock,(struct sockaddr*)&client,&len);
        if(sock < 0)
        {
            perror("accept");
            continue;
        }

        printf("get a client is %s,port is %d\n",inet_ntoa(client.sin_addr),\
                ntohs(client.sin_port));
        int id = fork();
        if(id > 0)
        {
            close(sock);
            while(waitpid(-1,NULL,WNOHANG) > 0);
            continue;
        }
        else
        {
            close(listenSock);
            if(fork() > 0)
            {
                exit(0);
            }
            char buf[1024];
            while(1)
            {
                ssize_t s = read(sock,buf,sizeof(buf)-1);  //服务器进行读数据
                if(s > 0)
                {
                    buf[s] = 0;
                    printf("client# %s\n",buf);
                }
                else
                {
                    //数据已经读完了，客户端不发送数据了
                    printf("client is quit!\n");
                    break;
                }
            }
            close(sock);
            break;
        }
    }
    return 0;
}

client.c

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>

void Usage(const char* name)
{
    printf("Usage:%s [IP] [port]",name);
}
int main(int argc,const char* argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        return 1;
    }

    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock < 0)
    {
        perror("socket");
        return 2;
    }

    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);

    if(connect(sock,(struct sockaddr*)&server,sizeof(server)) < 0)
    {
        perror("connec");
        return 3;
    }
    char buf[1024];
    while(1)
    {
        printf("send# ");
        fflush(stdout);
        ssize_t s = read(0,buf,sizeof(buf)-1);
        if(s < 0)
        {
            perror("read");
            break;
        }
        buf[s-1] = 0;
        write(sock,buf,s);
    }
    close(sock);
    return 0;
}

多线程的套接字通信

实现方法：
主线程中创建出一个新线程，新线程的执行函数是读取信息。类似于上边的多进程间的通信，我们可以将新的线程进行分离，分离之后的线程就不需要主线程去等待，而是由操作系统区回收。（这里我们不可以join新线程，如果这样做的话，主线程还是需要花费很长的时间去等待，所以，新的线程还是由系统去回收） 。
代码实现：
server.c

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

void Usage(const char* name)
{
    printf("Usage is %s [IP] [port]\n",name);
}

int StartUp(int port,const char* ip)
{
    int ListenSock = socket(AF_INET,SOCK_STREAM,0);
    if(ListenSock < 0)
    {
        perror("socket");
        return 1;
    }

    int opt = 1;
    setsockopt(ListenSock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_port = htons(port);
    local.sin_addr.s_addr = inet_addr(ip);
    if(bind(ListenSock,(struct sockaddr*)&local,sizeof(local)) < 0)
    {
        perror("bind");
        return 2;
    }
    if(listen(ListenSock,5) < 0)
    {
        perror(("listen"));
        return 3;
    }
    return ListenSock;
}

void* thread_hander(void* arg)
{
    int sock = *((int*)arg);
    char buf[1024];
    while(1)
    {
        ssize_t _s  = read(sock,buf,sizeof(buf)-1);
        if(_s > 0)
        {
            buf[_s-1]=0;
            printf("client say# %s\n",buf);
            if(write(sock,buf,sizeof(buf)-1) < 0)
            {
                break;
            }
        }
        else if(_s == 0)
        {
            printf("client is quit!\n");
            break;
        }
        else
        {
            perror("read");
            break;
        }
    }
    close(sock);
}

int main(int argc,const char* argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        return 1;
    }
    int listenSock = StartUp(atoi(argv[2]),argv[1]);
    struct sockaddr_in client;
    int len = 0;
    while(1)
    {
        int sock = accept(listenSock,(struct sockaddr*)&client,&len);
        if(sock < 0)
        {
            perror("accept");
            continue;
        }
        printf("Get a client! IP is %d\n,port is %d\n",inet_ntoa(client.sin_addr),\
                ntohs(client.sin_port));
        pthread_t tid;
        int ret = pthread_create(&tid,NULL,thread_hander,&sock);
        if(ret < 0)
        {
            perror("pthread_create");
            return 3;
        }
        pthread_detach(tid);
    }
    return 0;
}

server.c:

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

void Usage(const char* name)
{
    printf("Usage is %s [IP] [port]\n",name);
}

int main(int argc,const char* argv[])
{
    if(argc != 3)
    {
        Usage(argv[0]);
        return 1;
    }
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock < 0)
    {
        perror("socket");
        return 2;
    }
    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    server.sin_addr.s_addr = inet_addr(argv[1]);
    int ret = connect(sock,(struct sockaddr*)&server,sizeof(server));
    if(ret < 0)
    {
        perror("connect");
        return 3;
    }
    char buf[1024];
    while(1)
    {
        printf("send# ");
        fflush(stdout);
        ssize_t _s = read(0,buf,sizeof(buf)-1);
        if(_s > 0)
        {
            buf[_s -1 ] = 0;
            if(write(sock,buf,sizeof(buf)-1) < 0)
            {
                break;
            }
            ssize_t s = read(sock,buf,sizeof(buf)-1);
            if(s > 0)
            {
                buf[s] = 0;
                printf("server echo# %s\n",buf);
            }
        }
        else
        {
            perror("read");
            return 4;
        }
    }
    return 0;
}
哈哈哈哈哈哈丶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于tcp的异步套接字客户端服务端通信
11-08
基于tcp的异步套接字客户端服务端通信,需要的就下载吧 1分不多哦
Tcp server是如何一个端口处理多个客户端连接的(一对一还是一对多)
热门推荐
weixin_42139800的博客
07-22 1万+
tcp server一个端口是如何处理多个客户的连接的
Linux网络编程 ——TCP套接字通信
最新发布
weixin_43412762的博客
03-03 1561
TCP 提供了一种 可靠、面向连接、字节流、传输层的服务，采用 三次握手 建立一个连接。采用 四次挥手 来关闭一个连接。
计算机网络-TCP篇
dz45693的专栏
04-05 4282
TCP篇 基本认识 TCP 是⾯向连接的（⼀定是「⼀对⼀」才能连接）、可靠的、基于字节流的传输层通信协议。 RFC 793 是如何定义「连接」的：⽤于保证可靠性和流量控制维护的某些状态信息，这些信息的组合，包括Socket、序列号和窗⼝⼤⼩称为连接。 建⽴⼀个 TCP 连接是需要客户端与服务器端达成上述三个信息的共识。 Socket：由 IP 地址和端⼝号组成 序列号：⽤来解决乱序问题等 窗⼝⼤⼩：⽤来做流量控制 TCP 四元组可以唯⼀的确定⼀个连接，四元组包括如下： 格式 序列
基于tcp协议通信的套接字（链接循环）
weixin_30569001的博客
07-30 116
实现效果：多个客户端只能一个执行，只有等上一个关闭了，下一个才能接着通信 from socket import * client = socket(AF_INET, SOCK_STREAM) client.connect(('127.0.0.1', 8081)) # 通信循环 while True: msg=input('>>: ').st...
TCP & UDP
zien的博客
08-03 1956
对比分析TCP与UDP的优缺点
TCP 套接字编程计算机网络实验
11-22
通过 TCP 套接字编程实验，掌握网络套接字的构成，掌握 TCP 的通信特点， 理解面向连接的通信方式；实现基于 TCP 的服务器/客户端通信过程。 2. 实验设备 能够连接网络的计算机一台；高级程序设计软件如 Microsoft ...
socket UDP.zip_C语言_TCP通信_TP_stream_原始套接字
09-24
套接字（socket）：在网络中用来描述计算机中不同程序与其他计算程序的通信方式。 套接字分为三类; 流式socket（SOCK_STREAM）:提供可靠，面向连接的通信流；它使用TCP协议，从而保证了数据传输的正确性和顺序性。...
计算机网络之tcp通信实验C语言
12-30
该实验演示TCP通信的基本原理，首先创建一个TCP套接字，并将其绑定到指定的IP地址和端口。然后，它监听传入的连接请求，并接受客户端的连接
C++实现的基于Socket套接字的编程
10-29
C++实现的基于Socket套接字的编程。能够能够单线程处理一个请求。能够实现经TCP连接向请求的浏览器发送响应，浏览器可以正确显示网页的内容。
chatkat:使用 Java 套接字的聊天应用程序 - TCP
06-02
使用 Java 套接字的聊天应用程序 - TCP 指示 ： 启动run.bat。 将为您打开三个客户端，您可以测试三个控制台之间的聊天。 如果从客户端连接到服务器时出现问题，您必须使用您自己 LAN 上的 IP 更改 ChatClient....
TCP一对多通信_基于Select模型
04-19
我用MFC VC6编写的一个 TCP 一对多通信的程序（MFC 对话框程序），就是服务器端利用Select模型技术， 能同时接收多个客户端的消息， 其次， 服务器端还能将消息群发给所有已连接的客户端， 实现的基本思路 是使用Select模型的套接字集合管理与每个客户端进行通信的套接字。由于Select模型是阻塞的，因此将Select模型放到一个单独的线程中。
TCP套接字通信
心飞扬
07-26 2518
TCP套接字通信网络中进程之间如何通信？我们知道在本地进程间通信有很多种方式:比如管道、消息队列、共享内存、同步与互斥等，这些方法都要求通信的两个进程位于同一个主机那么网络之间该如何通信呢？在本地可以用进程PID来唯一的标识一个进程，但是在网络中是不行的，通过以前所学TCP/IP等知识，我们清楚网络层的“ip地址”可以唯一标识网络中的主机，而传输层的“端口号”又可以唯一标识主机中的应用程序。这样，我
TCP 通信的实现
yqqの博客
11-04 3784
一.TCP 通信介绍 前边我们提到 TCP 协议是面向连接的协议，在通信时客户端与服务器端必须建立连接。 在网络通信中，第一次主动发起通信的程序被称作客户端(Client)程序，简称客户端，而在 第一次通信中等待连接的程序被称作服务器端(Server)程序，简称服务器。一旦通信建立， 则客户端和服务器端完全一样，没有本质的区别.  “请求-响应”模式：  Socket 类：发送 TCP 消息。  ServerSocket 类：创建服务器。 套接字 Socket 是一种进程间的数据交换机制。这些进程既可
网络编程套接字（ TCP协议通讯流程）
bit_zyx的博客
03-23 719
目录 1、绑定失败问题 2、TCP协议通讯流程 三次握手的过程 数据传输的过程 四次挥手的过程 TCP和UDP对比
TCP四元组
yao00037的博客
12-17 3340
TCP四元组可以唯一确定一个连接，四元组包括如下： 源地址 源端口 目的地址 目的端口 源地址和目的地址字段都是32位，在IP头部，目的是通过IP协议发送报文给对端主机。 源端口和目的端口字段也是32位，在TCP的头部，目的是告诉TCP协议应该把报文发送给哪个进程。 ...
计算机网络—TCP知识点总结（一）
wait2023的博客
05-12 1420
0 引言 文章主要对TCP相关的知识点进行了总结，文中的图片均来自小林Coding《图解网络》 1 什么是传输层？ 传输层位于应用层的下层，为应用程序提供端到端的逻辑通信。传输层有两个非常重要的作用——复用和分用。复用的意思是在应用层的角度来看，我们不同的应用程序都能够被封装成一定格式的传输层报文后进行传输；分用的意思是将我们的传输层报文头部去除后可以将数据传输给不同的应用进程。 2 传输层协议 传输层有两个非常重要的协议，分别是TCP协议（传输控制协议）和UDP协议（用户数据报协议）。二者的区别
套接字编程（四）TCP通信
嘴大且吃雯的博客
02-12 685
介绍TCP与UDP的区别、防火墙操作、TCP通信基本流程、客户端实现流程、服务端多线程实现、服务端多进程实现
初识网络之TCP网络套接字
Masquerena114514的博客
06-04 980
本文介绍了tcp协议中常用的一些系统接口，并实现了一份简单的tcp网络通信程序和一份简单的日志函数，同时也介绍了如何将进程修改为守护进程以实现进程后台化以及简单介绍了tcp三次握手和四次挥手的概念
计算机网络实验UDP套接字编程
10-27
计算机网络实验中，UDP套接字编程是一个非常重要的实验内容。UDP是一种无连接的传输协议，它不保证数据传输的可靠性，但是具有传输速度快、开销小等优点。在UDP套接字编程中，我们可以通过编写程序来实现UDP协议的通信。 下面是一个简单的UDP套接字编程示例： ```python import socket # 创建UDP套接字 udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 绑定本地地址和端口 local_addr = ('', 8888) udp_socket.bind(local_addr) # 接收数据 recv_data, remote_addr = udp_socket.recvfrom(1024) print('Received from %s:%s' % remote_addr) print(recv_data.decode('utf-8')) # 发送数据 send_data = 'Hello, I am UDP client.'.encode('utf-8') udp_socket.sendto(send_data, remote_addr) # 关闭套接字 udp_socket.close() ``` 在这个示例中，我们首先创建了一个UDP套接字，并绑定了本地地址和端口。然后通过`recvfrom()`方法接收数据，并通过`sendto()`方法发送数据。最后关闭套接字。 如果你想深入了解UDP套接字编程，可以学习一些相关的网络编程知识，例如socket编程、网络协议等。同时，也可以参考一些相关的书籍和网络资源，例如《Python网络编程》、《TCP/IP详解》等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值