精华内容
下载资源
问答
  • netty搭建TCP、UDP服务

    2020-09-23 17:05:21
    Java异步NIO框架Netty实现高性能高并发,通过netty搭建TCP、UDP服务,支持物联网设备上行,下行
  • 易语言UDP服务源码
  • C# 委托方式(类似事件响应,添加了MessageHandler的都可以接收到数据)实现的UDP服务器,可在多个Form接收UDP客户端发送过来的数据,在需要多个地方用到客接收数据的时候非常方便。完整的C#代码,VS2008工程。 TCP...
  • 使用python代码编写的服务器系统,采用的是UDP协议和socket技术,调试可用。
  • UDP服务器程序

    2016-05-03 16:37:24
    本程序是的功能是接收UDP客户端的消息,并且可以向UDP客户端发送数据
  • TCP/UDP服务管理v2.0.1

    2018-04-16 17:24:34
    提供了TCP Server、UDP Server、TCP/UDP Client、数据包抓取等功能。
  • TCP-UDP服务管理V3.20

    2017-11-29 17:19:25
    模拟TCP、UDP的server或者client,含有抓包分析等功能
  • 1.请检查端口服务类型(服务端端口是TCP/UDP)。 2.检查网络环境。 3.默认回车换行断包。所以注意发送内容后面一定要添加回车换行。 注:由于时间问题,加了心跳机制,但是没加客户端回应,也没加服务端接收到心跳...
  • 在QT下的UDP服务器和客户端的简单DEMO,实现相互发送数据。
  • TCP-UDP服务管理

    2018-07-09 17:15:48
    TCP-UDP服务管理,可以方便的测试服务器和客户端之间的通信
  • 通过该工具可以简单地对一个TCP或UDP服务进行大量连接并发测试;工具提供一些简单的参数设置主要包括:服务类型,测试的连接数,数据格式和数据发送的模式。用户只需要简单地设置相关参数就可以对现有的服务进行相应...
  • TCP-UDP服务管理 V3.01

    2014-03-19 13:24:11
    用于开发调试TCP/IP类软件、代码,还可以保存数据日志记录。
  • 创建UDP服务器

    千次阅读 2018-12-27 10:00:11
    先定义一个实现 handle() 特殊方法的类,为客户端连接服务。 这个类的 request 属性是一个包含了数据报和底层socket对象的元组。client_address 包含了客户端地址。 from socketserver import BaseRequestHandl...

    实现一个基于UDP协议的服务器来与客户端通信。
    UDP服务器也可以通过使用 socketserver 库很容易的被创建。

    先定义一个实现 handle() 特殊方法的类,为客户端连接服务。 这个类的 request 属性是一个包含了数据报和底层socket对象的元组。client_address 包含了客户端地址。

    from socketserver import BaseRequestHandler, UDPServer
    import time
    
    
    class TimeHandler(BaseRequestHandler):
        def handle(self):
            print('Got connection from', self.client_address)
            message, sock = self.request
            resp = time.ctime()
            sock.sendto(resp.encode('ascii'), self.client_address)
    
    
    if __name__ == '__main__':
        serv = UDPServer(('', 16888), TimeHandler)
        serv.serve_forever()
    -----------------------------
    from socket import socket, AF_INET, SOCK_DGRAM
    s = socket(AF_INET, SOCK_DGRAM)
    s.sendto(b'', ('localhost', 16888))
    print(s.recvfrom(8192))
    

    UDPServer 类是单线程的,一次只能为一个客户端连接服务。 如果想要并发操作,可以实例化一个 ForkingUDPServer 或 ThreadingUDPServer 对象

    from socketserver import ThreadingUDPServer
    
       if __name__ == '__main__':
        serv = ThreadingUDPServer(('',20000), TimeHandler)
        serv.serve_forever()
    
    • 可以直接使用socket
    from socket import socket, AF_INET, SOCK_DGRAM
    import time
    
    def time_server(address):
        sock = socket(AF_INET, SOCK_DGRAM)
        sock.bind(address)
        while True:
            msg, addr = sock.recvfrom(8192)
            print('Got message from', addr)
            resp = time.ctime()
            sock.sendto(resp.encode('ascii'), addr)
    
    if __name__ == '__main__':
        time_server(('', 16888))
    
    展开全文
  • UDP服务器客户端.rar

    2020-04-05 15:31:40
    UDP服务器客户端.rar UDP服务器客户端.rar UDP服务器客户端.rar UDP服务器客户端.rar UDP服务器客户端.rar UDP服务器客户端.rar
  • UDP服务器并发压力测试工具

    热门讨论 2012-07-26 19:43:52
    该工具采用QT+ACE实现,应用平台为windows,采用ACE practor模式封装的windows下的完成端口机制,保证并发测试的效果,每秒中我的电脑(4核,4G内存 3.2G主频,100M网卡)可以发送2800个左右的UDP数据包,每个数据包...
  • 1. 设计一个基于UDP的服务器的分析、设计和功能的实现. 2. UDP的服务器的功能包括:客服端发送信息,服务器端能够给予信息的回馈。 ,
  • C#各种类型TCP&UDP服务器代码

    千次下载 热门讨论 2015-03-18 11:09:02
    使用Socket实现的异步TCP服务器、同步TCP服务器、异步UDP服务器、同步UDP服务器 and 使用TcpListener和UdpClient实现的异步TCP服务器
  • 如果您需要发现仅提供UDP服务且经过良好防火墙保护的主机,则可能会很有帮助-例如,如果您要查找IP地址范围内的所有DNS服务器。 或者,在LAN上,您可能想要一种快速的方法来查找所有TFTP服务器。 并非所有的UDP...
  • UDP Hunter是基于python的开源网络评估工具,专注于UDP服务扫描。 通过UDP Hunter,我们专注于为IPv6和IPv4主机提供对广泛已知的UDP协议的审核。 到目前为止,UDP Hunter支持19种不同的服务探针。 该工具允许您对...
  • ESP8266开发之旅 网络篇⑩ UDP服务

    万次阅读 2019-06-20 08:56:15
    1. 前言     前面的博文中,博主讲述的内容基本上都是Tcp以及Http通信的内容,那么我们...TCP提供可靠的服务。也就是说,通过TCP连接传送的数据,无差错,不丢失,不重复,且按序到达;UDP尽最大努力做到可靠...

    授人以鱼不如授人以渔,目的不是为了教会你具体项目开发,而是学会学习的能力。希望大家分享给你周边需要的朋友或者同学,说不定大神成长之路有博哥的奠基石。。。

    共同学习成长QQ群 622368884,不喜勿加,里面有一大群志同道合的探路人

    快速导航
    单片机菜鸟的博客快速索引(快速找到你要的)

    如果觉得有用,麻烦点赞收藏,您的支持是博主创作的动力。

    展开全文
  • 深入理解UDP 服务器与客户端

    千次阅读 2019-08-25 09:45:00
    本文介绍了 UDP 协议的基础知识,并与 TCP 协议进行对比,再用 Python 3 实现并演示了 UDP 服务器与客户端的通信过程,最后将脚本中涉及到的 Python API 做成了的参考索引,有助于读者理解实现过程。 推荐阅读 ...


    640?wx_fmt=png"Python学习开发",一个值得加星标640?wx_fmt=png的公众号。



    640?wx_fmt=jpeg


    正文共:5778 字 5 图

    预计阅读时间:15 分钟

    原始链接: https://ciphersaw.me/2018/06/15/Python%20绝技%20——%20UDP%20服务器与客户端/


    0x00 前言

    在上一篇文章「深入理解TCP 服务器与客户端」中,介绍了传输层的核心协议 TCP ,并运用 Python 脚本的 socket 模块演示了 TCP 服务器与客户端的通信过程。

    本篇将按照同样的套路,先介绍传输层的另一个核心协议 UDP,再比较 TCP 与 UDP 的特点,最后借助 Python 脚本演示 UDP 服务器与客户端的通信过程。

    0x01 UDP 协议

    UDP(User Datagram Protocol,用户数据报协议)是一种无连接、不可靠、基于数据报的传输层通信协议。

    • UDP 的通信过程与 TCP 相比较为简单,不需要复杂的三次握手与四次挥手,体现了无连接

    • UDP 传输速度比 TCP 快,但容易丢包、数据到达顺序无保证、缺乏拥塞控制、秉承尽最大努力交付的原则,体现了不可靠

    • UDP 的无连接与不可靠特性注定无法采用字节流的通信模式,由协议名中的「Datagram」与 socket 类型中的「SOCK_DGRAM」即可体现它基于数据报的通信模式。

     

    为了更直观地比较 TCP 与 UDP 的异同,笔者将其整理成以下表格:


    TCPUDP
    连接模式面向连接(单点通信)无连接(多点通信)
    传输可靠性可靠不可靠
    通信模式基于字节流基于数据报
    报头结构复杂(至少20字节)简单(8字节)
    传输速度
    资源需求
    到达顺序保证不保证
    流量控制
    拥塞控制
    应用场合大量数据传输少量数据传输
    支持的应用层协议Telnet、FTP、SMTP、HTTPDNS、DHCP、TFTP、SNMP

    0x02 Network Socket

    Network Socket(网络套接字)是计算机网络中进程间通信的数据流端点,广义上也代表操作系统提供的一种进程间通信机制。

    进程间通信(Inter-Process Communication,IPC)的根本前提是能够唯一标示每个进程。在本地主机的进程间通信中,可以用 PID(进程 ID)唯一标示每个进程,但 PID 只在本地唯一,在网络中不同主机的 PID 则可能发生冲突,因此采用「IP 地址 + 传输层协议 + 端口号」的方式唯一标示网络中的一个进程。

    小贴士:网络层的 IP 地址可以唯一标示主机,传输层的 TCP/UDP 协议和端口号可以唯一标示该主机的一个进程。注意,同一主机中 TCP 协议与 UDP 协议的可以使用相同的端口号。

    所有支持网络通信的编程语言都各自提供了一套 socket API,下面以 Python 3 为例,讲解服务器与客户端建立 UDP 通信连接的交互过程:

    640?wx_fmt=png

    可见,UDP 的通信过程比 TCP 简单许多,服务器少了监听与接受连接的过程,而客户端也少了请求连接的过程。客户端只需要知道服务器的地址,直接向其发送数据即可,而服务器也敞开大门,接收任何发往自家地址的数据。

    小贴士:由于 UDP 采用无连接模式,可知 UDP 服务器在接收到客户端发来的数据之前,是不知道客户端的地址的,因此必须是客户端先发送数据,服务器后响应数据。而 TCP 则不同,TCP 服务器接受了客户端的连接后,既可以先向客户端发送数据,也可以等待客户端发送数据后再响应。

    0x03 UDP 服务器

    
          
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    
          
    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    import socket
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.bind(( "127.0.0.1", 6000))
    print( "UDP bound on port 6000...")
    while True:
    data, addr = s.recvfrom( 1024)
    print( "Receive from %s:%s" % addr)
    if data == b"exit":
    s.sendto( b"Good bye!\n", addr)
    continue
    s.sendto( b"Hello %s!\n" % data, addr)
    • Line 5:创建 socket 对象,第一个参数为 socket.AF_INET,代表采用 IPv4 协议用于网络通信,第二个参数为 socket.SOCK_DGRAM,代表采用 UDP 协议用于无连接的网络通信。

    • Line 6:向 socket 对象绑定服务器主机地址 (“127.0.0.1”, 6000),即本地主机的 UDP 6000 端口。

    • Line 9:进入与客户端交互数据的循环阶段。

    • Line 10:接收客户端发来的数据,包括 bytes 对象 data,以及客户端的 IP 地址和端口号 addr,其中 addr 为二元组 (host, port)。

    • Line 11:打印接收信息,表示从地址为 addr 的客户端接收到数据。

    • Line 12:若 bytes 对象为 b"exit",则向地址为 addr 的客户端发送结束响应信息 b"Good bye!\n"。发送完毕后,继续等待其他 UDP 客户端发来数据。

    • Line 15:若 bytes 对象不为 b"exit",则向地址为 addr 的客户端发送问候响应信息 b"Hello %s!\n",其中 %s 是客户端发来的 bytes 对象。发送完毕后,继续等待任意 UDP 客户端发来数据。

    与 TCP 服务器相比,UDP 服务器不必使用多线程,因为它无需为每个通信过程创建独立连接,而是采用「即收即发」的模式,又一次体现了 UDP 的无连接特性。

    0x04 UDP 客户端

    
          
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    
          
    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    import socket
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    addr = ( "127.0.0.1", 6000)
    while True:
    data = input( "Please input your name: ")
    if not data:
    continue
    s.sendto(data.encode(), addr)
    response, addr = s.recvfrom( 1024)
    print(response.decode())
    if data == "exit":
    print( "Session is over from the server %s:%s\n" % addr)
    break
    s.close()
    • Line 5:创建 socket 对象,第一个参数为 socket.AF_INET,代表采用 IPv4 协议用于网络通信,第二个参数为 socket.SOCK_DGRAM,代表采用 UDP 协议用于无连接的网络通信。

    • Line 6:初始化 UDP 服务器的地址 (“127.0.0.1”, 6000),即本地主机的 UDP 6000 端口。

    • Line 8:进入与服务器交互数据的循环阶段。

    • Line 9:要求用户输入名字。

    • Line 10:当用户的输入为空时,则重新开始循环,要求用户重新输入。

    • Line 12:当用户的输入非空时,则将字符串转换为 bytes 对象后,发送至地址为 (“127.0.0.1”, 6000) 的 UDP 服务器。

    • Line 13:接收服务器的响应数据,包括 bytes 对象 response,以及服务器的 IP 地址和端口号 addr,其中 addr 为二元组 (host, port)。

    • Line 14:将响应的 bytes 对象 response 转换为字符串后打印输出。

    • Line 15:当用户的输入为 "exit" 时,则打印会话结束信息,终止与服务器交互数据的循环阶段,即将关闭套接字。

    • Line 19:关闭套接字,不再向服务器发送数据。

    0x05 UDP 进程间通信

    将 UDP 服务器与客户端的脚本分别命名为 udp_server.py 与 udp_client.py,然后存至桌面,笔者将在 Windows 10 系统下用 PowerShell 进行演示。

    小贴士:读者进行复现时,要确保本机已安装 Python 3,注意笔者已将默认的启动路径名 python 改为了 python3

    单服务器 VS 多客户端

    640?wx_fmt=png

    1. 在其中一个 PowerShell 中运行命令 python3 ./udp_server.py,服务器绑定本地主机的 UDP 6000 端口,并打印信息 UDP bound on port 6000...,等待客户端发来数据;

    2. 在另两个 PowerShell 中分别运行命令 python3 ./udp_client.py,并向服务器发送字符串 Client1Client2

    3. 服务器打印接收信息,表示分别从 UDP 63643、63644端口接收到数据,并分别向客户端发送问候响应信息;

    4. 客户端 Client1 发送空字符串,则被要求重新输入;

    5. 客户端 Client2 先发送字符串 Alice,得到服务器的问候响应信息,再发送字符串 exit,得到服务器的结束响应信息,最后打印会话结束信息,终止与服务器的数据交互;

    6. 客户端 Client1 发送字符串 exit,得到服务器的结束响应信息,并打印会话结束信息,终止与服务器的数据交互;

    7. 服务器按照以上客户端的数据发送顺序打印接收信息,并继续等待任意 UDP 客户端发来数据。


    0x06 Python API Reference

    socket 模块

    本节介绍上述代码中用到的内建模块 socket,是 Python 网络编程的核心模块。

    socket() 函数

    socket() 函数用于创建网络通信中的套接字对象。函数原型如下:

    
          
    1
    
          
    socket.socket(family=AF_INET, type=SOCK_STREAM, proto= 0, fileno= None)
    • family 参数代表地址族(Address Family),默认值为 AF_INET,用于 IPv4 网络通信,常用的还有 AF_INET6,用于 IPv6 网络通信。family 参数的可选值取决于本机操作系统。

    • type 参数代表套接字的类型,默认值为 SOCK_STREAM,用于 TCP 协议(面向连接)的网络通信,常用的还有 SOCK_DGRAM,用于 UDP 协议(无连接)的网络通信。

    • proto 参数代表套接字的协议,默认值为 0,一般忽略该参数,除非 family 参数为 AF_CAN,则 proto 参数需设置为 CAN_RAW 或 CAN_BCM

    • fileno 参数代表套接字的文件描述符,默认值为 None,若设置了该参数,则其他三个参数将会被忽略。

    创建完套接字对象后,需使用对象的内置函数完成网络通信过程。注意,以下函数原型中的「socket」是指 socket 对象,而不是上述的 socket 模块。

    bind() 函数

    bind() 函数用于向套接字对象绑定 IP 地址与端口号。注意,套接字对象必须未被绑定,并且端口号未被占用,否则会报错。函数原型如下:

    
          
    1
    
          
    socket.bind(address)
    • address 参数代表套接字要绑定的地址,其格式取决于套接字的 family 参数。若 family 参数为 AF_INET,则 address 参数表示为二元组 (host, port),其中 host 是用字符串表示的主机地址,port 是用整型表示的端口号。

    sendto() 函数

    sendto() 函数用于向远程套接字对象发送数据。注意,该函数用于 UDP 进程间的无连接通信,远程套接字的地址在参数中指定,因此使用前不需要先与远程套接字连接。相对地,TCP 进程间面向连接的通信过程需要用 send() 函数。函数原型如下:

    
          
    1
    
          
    socket.sendto(bytes[, flags], address)
    • bytes 参数代表即将发送的 bytes 对象数据。例如,对于字符串 "hello world!" 而言,需要用 encode() 函数转换为 bytes 对象 b"hello world!" 才能进行网络传输。

    • flags 可选参数用于设置 sendto() 函数的特殊功能,默认值为 0,也可由一个或多个预定义值组成,用位或操作符 | 隔开。详情可参考 Unix 函数手册中的 sendto(2),flags 参数的常见取值有 MSG_OOB、MSG_EOR、MSG_DONTROUTE 等。

    • address 参数代表远程套接字的地址,其格式取决于套接字的 family 参数。若 family 参数为 AF_INET,则 address 参数表示为二元组 (host, port),其中 host 是用字符串表示的主机地址,port 是用整型表示的端口号。

    sendto() 函数的返回值是发送数据的字节数。

    recvfrom() 函数

    recvfrom() 函数用于从远程套接字对象接收数据。注意,与 sendto() 函数不同,recvfrom() 函数既可用于 UDP 进程间通信,也能用于 TCP 进程间通信。函数原型如下:

    
          
    1
    
          
    socket.recvfrom(bufsize[, flags])
    • bufsize 参数代表套接字可接收数据的最大字节数。注意,为了使硬件设备与网络传输更好地匹配,bufsize 参数的值最好设置为 2 的幂次方,例如 4096

    • flags 可选参数用于设置 recv() 函数的特殊功能,默认值为 0,也可由一个或多个预定义值组成,用位或操作符 |隔开。详情可参考 Unix 函数手册中的 recvfrom(2),flags 参数的常见取值有 MSG_OOB、MSG_PEEK、MSG_WAITALL 等。

    recvfrom() 函数的返回值是二元组 (bytes, address),其中 bytes 是接收到的 bytes 对象数据,address 是发送方的 IP 地址与端口号,用二元组 (host, port) 表示。注意,recv() 函数的返回值只有 bytes 对象数据。

    close() 函数

    close() 函数用于关闭本地套接字对象,释放与该套接字连接的所有资源。

    
          
    1
    
          
    socket.close()

    0x07 总结

    本文介绍了 UDP 协议的基础知识,并与 TCP 协议进行对比,再用 Python 3 实现并演示了 UDP 服务器与客户端的通信过程,最后将脚本中涉及到的 Python API 做成了的参考索引,有助于读者理解实现过程。

    推荐阅读


    Python 爬虫面试题 170 道:2019 版

    爬虫入门之查找JS入口篇 --- 油猴插件的使用

    JavaScript逆向的时候遇到无限debugger怎么办

    添加微信[italocxa].回复:加群,加入Python交流群


    展开全文
  • UDP服务器的实现

    千次阅读 2018-05-30 20:37:22
    先介绍一个重要的函数:socket(),socket()是用于创建一个套接字的。... type是套接字的类型,进一步的确定了通信的特性,套接字类型以SOCK_开头,常用的如SOCK_DGRAM就是UDP协议,SOCK_STRE...
    先介绍一个重要的函数:socket(),socket()是用于创建一个套接字的。
    函数原型:

    参数: domain确定了通信的特性也包括地址格式,比如AF_INET就是IPV4协议,AF_INET6就是IPV6协议,AF_UNIX是UNIX域。
                 type是套接字的类型,进一步的确定了通信的特性,套接字类型以SOCK_开头,常用的如SOCK_DGRAM就是UDP协议,SOCK_STREAM就是流式套接字,是TCP协议。
                最后一个参数protocol通常设置为0.
    返回值类型: 是一个文件描述符。
             稍微讲解一下为什么返回的是文件描述符:在Linux下一切皆文件, 我们想要往一个文件里边写数据或者读数据,首先得先将这个文件打开,文件打开函数会返回一个文件描述符给我们,然后,我们就可以通过文件描述符对该文件进行操作了,也就是说一个文件描述符对应一个文件。此外 ,以三个文件默认打开的文件描述符,0-----标准输入,1-----标准输出,2------标准出错。标准输入对应的设备就是键盘,当我们通过键盘输入时,会将输入的内容存入到 文件描述符 0 对应的这个文件,也就是说,这个文件就代表着键盘。同样的,屏幕也是一个文件。键盘和屏幕都是外设,这些外设对于Linux系统来说也都是文件,我们将数据写传入到网络上去其实就是将数据写入网卡这个外设中,从网络上获取数据就是从网卡中读取数据。键盘和屏幕可以看做是一个文件,同样的,也可以将网卡看做是一个文件,创建套接字的过程就好像是为进程打开了网卡这个文件,所以,返回的也就是一个文件描述符了。

    sockaddr结构

            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结构体 指针做为参数。这个struct sockaddr * 的作用类似于void*,那么为什么不使用void* 呢?因为在struct sockaddr* 开始使用的时候根本就还没有void* ,后来才有的void* ,但是再把它改成void* 又太麻烦了,所以,就一直采用这种写法了。
    虽然socket api的接口是sockaddr, 但是我们真正在基于IPv4编程时, 使⽤用的数据结构是sockaddr_in; 这个结构 里主要有三部分信息: 地址类型, 端口号, IP地址。

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

    UDP服务器的具体实现:
    UDP服务器端
    1、创建套接字
    int  socket(int domain,int type, int  protocol);
    2、 绑定端口号 (TCP/UDP, 服务器)
    int bind(int socket,  const struct sockaddr *address,   socklen_t address_len);
    3、 使用sendto和recvfrom来进行数据读写.
       使用sendto函数和recvfrom函数需要包含如下两个头文件
       
     #include <sys/types.h>
     #include <sys/socket.h>
    sendto()函数是用来传输消息到另一个套接字的。
        ssize_t sendto(int sockfd, const void *buf,   size_t len, int flags,  const struct sockaddr *dest_addr,   socklen_t addrlen);
    recvfrom函数是用来接收套接字上的数据
        ssize_t recvfrom(int sockfd,  void *buf, size_t len,  int flags, struct sockaddr *src_addr,  socklen_t *addrlen);

    UDP客户端
    创建一个套接字后,可以不绑定,可以直接向UDP服务器发送和接收消息。为什么服务器端需要绑定而客户端就不需要绑定呢?
          原因在于服务器端需要给很多用户提供服务,为了方便用户能够找到它,给服务器绑定一个socket(IP地址+端口号),客户就可以随时找到服务器并请求服务了,如果不绑定的话,就是有系统自动默认指定socket的参数了。客户端可以不绑定是因为,客户端不需要给其他人提供服务,客户端在请求服务时,会把自己的socket传给服务器,那么服务器就可以通过传入的参数找到客户端并为之提供服务了,所以客户端 就没有担心别人找不到他这种苦恼。

    server服务器部分
    #include <stdio.h>
    #include <unistd.h>
    #include <arpa/inet.h>
    #include <string.h>
    
    int main(int argc ,char* argv[])
    {
    	if(argc < 3)
    	{
    		printf("./server [addr:] [port:]\n");
    		return 4;
    	}
            //创建一个套接字
    	int sock = socket(AF_INET,SOCK_DGRAM,0);//SOCK_DGRAM代表UDP
    	if(sock < 0)
    	{
    		perror("socket");
    		return 1;
    	}
    
    	struct sockaddr_in local;
    	local.sin_family = AF_INET;
    	local.sin_port = htons(atoi(argv[2]));
    	local.sin_addr.s_addr = inet_addr(argv[1]);
    	//绑定
    	if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)
    	{
    		perror("bind");
    		return 2;
    	}
    
    	char buf[1024];
    	struct sockaddr_in client;
    	socklen_t len = sizeof(client);
    	while(1)
    	{
    		ssize_t s = recvfrom(sock,buf,sizeof(buf)-1,0,(struct sockaddr*)&client,&len);
    		if(s<0)
    		{
    			perror("recvfrom");
    			return 3;
    		}
    		else if(s == 0)
    		{
    			printf("client closed\n");
    		}
    		else
    		{
    			buf[s] = 0;
    			printf("[%s : %d]:%s\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port),buf);
    			sendto(sock,buf,strlen(buf),0,(struct sockaddr*)&client,len);
    			
    			if(strcmp(buf,"quit") == 0)
    				break;
    		}
    
    	}
    
    	return 0;
    }

    client客户端部分

    #include <stdio.h>
    #include <unistd.h>
    #include <arpa/inet.h>
    
    int main(int argc ,char* argv[])
    {
    	if(argc < 3)
    	{
    		printf("./client [addr:][port:]\n");
    		return 4;
    	}
    	int sock = socket(AF_INET,SOCK_DGRAM,0);
    	if(sock < 0)
    	{
    		perror("socket");
    		return 1;
    	}
    
    	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]);
    	
    	char buf[1024];
    	struct sockaddr_in peer;
    	socklen_t len = sizeof(peer);
    	while(1)
    	{
    		printf("#please enter#  ");
    		fflush(stdout);
    		ssize_t s = read(0,buf,sizeof(buf)-1);
    		if(s < 0)
    		{
    			perror("read");
    			return 2;
    		}
    		buf[s-1] = 0;
    		sendto(sock,buf,sizeof(buf)-1,0,(struct sockaddr*)&server,sizeof(server));
    		s = recvfrom(sock,buf,sizeof(buf)-1,0,(struct sockaddr*)&peer,&len);
    		if(s<0)
    		{
    			perror("recvfrom");
    			return 3;
    		}
    		else if(s == 0)
    		{
    			printf("server closed\n");
    		}
    		else
    		{
    			buf[s] = 0;
    			printf("#server echo#  %s\n",buf);
    			if(strcmp(buf,"quit") == 0)
    				break;
    		}
    	}
    
    	return 0;
    }

    Makefile文件

    .PHONY:all
    all:client server
    
    client:client.c
    	gcc -o $@ $^
    server:server.c
    	gcc -o $@ $^
    .PHONY:clean
    clean:
    	rm -f client server

    运行结果:


    展开全文
  • SpringBoot 开启 UDP 服务,进行接收 UDP,及发送 UDP,这里依赖的是 SpringBoot 内置 integration 包 代码地址 Github: https://github.com/dolyw/ProjectStudy/tree/master/SpringBoot/AsyncDemo Gitee(码云): ...
  • 固件创建socket并使用8080作为服务器端口号,通过socket函数设置服务类型:SOCK_DGRAM为UDP。 备注: 本程序是基于正点原子哥的STM32H7开发板程序,参考了《嵌入式网络那些事——STM32物联实战》--14.2.2 UDP时间...
  • Python 绝技 —— UDP 服务器与客户端

    千次阅读 2018-06-19 19:14:19
    i春秋作家:wasrehpic0x00 前言在上一篇文章「Python 绝技 ——...本篇将按照同样的套路,先介绍传输层的另一个核心协议 UDP,再比较 TCP 与 UDP 的特点,最后借助 Python 脚本演示 UDP 服务器与客户端的通信过程。...
  • SocketUDP服务+客户端数据视频等传输等,服务端+客户端,数据传输案例
  • TCP-UDP服务管理 V1.03

    2021-11-23 08:55:33
    一款桌面pc TCP-UDP服务
  • 一个基于初学者的入门级参考程序:linux简单UDP服务器的实现。
  • 易语言源码易语言UDP服务源码.rar
  • 从零学Netty(九)Netty实现UDP服务器

    千次阅读 2020-10-15 18:01:52
    UDP 是User Datagram Protocol的简称, 中文名是用户数据报协议 UDP协议与TCP协议一样用于处理数据包,在OSI模型中,两者都位于传输层,处于IP协议的上一层 UDP有不提供数据包分组、组装和不能对数据包进行排序的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 354,827
精华内容 141,930
关键字:

udp服务