精华内容
参与话题
问答
  • 10个TCP/UDP网络调试工具(有3个是带串口调试的TCP/UDP的调试工具),包含组播调试的工具
  • UDP数据录制工具——可接收组播数据,文件分割存储,性能稳定。适用WindowXP及以后版本系统。
  • 测试使用的tcp、udp、及其组播测试工具,可以测试组播收发,tcp程序、udp程序测试,界面简单易用。
  • windows下UDP组播

    千次阅读 2018-08-12 18:19:57
    最近研究下UDP组播,首先上网看看各种组播的含义,以下是总结的:  多播,也称为“组播”,将网络中同一业务类型主机进行了逻辑上的分组,进行数据收发的时候其数据仅仅在同一分组中进行,其他的主机没有加入此...

    最近研究下UDP组播,首先上网看看各种组播的含义,以下是总结的:

        多播,也称为“组播”,将网络中同一业务类型主机进行了逻辑上的分组,进行数据收发的时候其数据仅仅在同一分组中进行,其他的主机没有加入此分组不能收发对应的数据。

        在广域网上广播的时候,其中的交换机和路由器只向需要获取数据的主机复制并转发数据。主机可以向路由器请求加入或退出某个组,网络中的路由器和交换机有选择地复制并传输数据,将数据仅仅传输给组内的主机。多播的这种功能,可以一次将数据发送到多个主机,又能保证不影响其他不需要(未加入组)的主机的其他通 信。

    多播的地址是特定的,D类地址用于多播。D类IP地址就是多播IP地址,即224.0.0.0至239.255.255.255之间的IP地址,并被划分为局部连接多播地址、预留多播地址和管理权限多播地址3类:

      1、局部多播地址:在224.0.0.0~224.0.0.255之间,这是为路由协议和其他用途保留的地址,路由器并不转发属于此范围的IP包。

      2、预留多播地址:在224.0.1.0~238.255.255.255之间,可用于全球范围(如Internet)或网络协议。

      3、管理权限多播地址:在239.0.0.0~239.255.255.255之间,可供组织内部使用,类似于私有IP地址,不能用于Internet,可限制多播范围。

      多播的程序设计使用setsockopt()函数和getsockopt()函数来实现,组播的选项是IP层的,其选项值和含义参见下表。

                             

    getsockopt()/setsockopt()的选项

    含 义

    IP_MULTICAST_TTL

    设置多播组数据的TTL值

    IP_ADD_MEMBERSHIP

    在指定接口上加入组播组

    IP_DROP_MEMBERSHIP

    退出组播组

    IP_MULTICAST_IF

    获取默认接口或设置接口

    IP_MULTICAST_LOOP

    禁止组播数据回送

    下面是写的实例代码:

    client代码

    #include <stdio.h>  
    #include <winsock2.h>  
    #include <ws2tcpip.h>  
    #pragma comment(lib, "ws2_32.lib")
    
    int main()
    {
    	int iRet = 0;
    	WSADATA wsaData;
    	WSAStartup(MAKEWORD(2, 2), &wsaData);
    
    	SOCKET sock = socket(AF_INET,SOCK_DGRAM,0);
    
    	int iFlag = 0;	// 0-同一台主机 1-夸主机
    	iRet = setsockopt(sock, IPPROTO_IP, IP_MULTICAST_TTL, (char*)&iFlag, sizeof(iFlag));
    	if(iRet != 0){
    		printf("setsockopt fail:%d", WSAGetLastError());
    		return -1;
    	}
    
    	sockaddr_in addr;
    	addr.sin_addr.S_un.S_addr = inet_addr("234.2.2.2");
    	addr.sin_family = AF_INET;
    	addr.sin_port = htons(9411);
    	
    	char strSend[1024] = {0};
    	static int iIdx = 0;
    	while(1)  
    	{     
    		sprintf_s(strSend, "udp send group data:%d", iIdx++);
    		iRet = sendto(sock, strSend, strlen(strSend) + 1, 0, (sockaddr*)&addr, sizeof(sockaddr));
    		if(iRet <= 0){
    			printf("send fail:%d", WSAGetLastError());
    		}else{
    			printf("send data:%s\n", strSend);
    		}
    		Sleep(500); 
    	}  
    
    	closesocket(sock);
    	WSACleanup();
    
    	return 0;
    }

    server代码:

    #include <stdio.h>  
    #include <winsock2.h>  
    #include <ws2tcpip.h>  
    #pragma comment(lib, "ws2_32.lib")
    
    int main()
    {
    	int iRet = 0;
    	WSADATA wsaData;
    	WSAStartup(MAKEWORD(2, 2), &wsaData);
    
    	SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);
    
    	sockaddr_in addr;
    	addr.sin_family = AF_INET;
    	//addr.sin_addr.S_un.S_addr = INADDR_ANY;
    	addr.sin_addr.S_un.S_addr = inet_addr("192.168.0.104");
    	addr.sin_port = htons(9411);
    
     	bool bOptval = true;
     	iRet = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)&bOptval, sizeof(bOptval));
     	if(iRet != 0){
     		printf("setsockopt fail:%d", WSAGetLastError());
     		return -1;
     	}
    
    	iRet = bind(sock, (sockaddr*)&addr, sizeof(addr));
    	if(iRet != 0){
    		printf("bind fail:%d", WSAGetLastError());
    		return -1;
    	}
    	printf("socket:%d bind success\n", sock);
    
    	// 加入组播  
    	ip_mreq multiCast;
    	//multiCast.imr_interface.S_un.S_addr = INADDR_ANY;
    	multiCast.imr_interface.S_un.S_addr = inet_addr("192.168.0.104");
    	multiCast.imr_multiaddr.S_un.S_addr = inet_addr("234.2.2.2");
    	iRet = setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&multiCast, sizeof(multiCast));
    	if(iRet != 0){
    		printf("setsockopt fail:%d", WSAGetLastError());
    		return -1;
    	}
    
    	printf("udp group start\n");
    
    	int len = sizeof(sockaddr);
    	char strRecv[1024] = {0};
    	while(true)  
    	{     
    		memset(strRecv, 0, sizeof(strRecv));
    		iRet = recvfrom(sock, strRecv, sizeof(strRecv) - 1, 0, (sockaddr*)&addr, &len);
    		if(iRet <= 0){
    			printf("recvfrom fail:%d", WSAGetLastError());
    			return -1;
    		}
    		printf("recv data:%s\n", strRecv);
    	}  
    
    	closesocket(sock);
    	WSACleanup();
    
    	return 0;
    }
    

     

     

    展开全文
  • UDP组播调试(使用TCP&UDP调试工具

    万次阅读 2018-12-09 22:29:32
    如何使用调试工具进行UDP组播调试 一、下载UDP&amp;TCP调试工具 二、双击打开调试工具并建立端口 2.1 创建组播客户端1  类型:UDP(组播模式);目标IP:225.0.0.20;端口:60000;本机端口制定:60002  ...

    如何使用调试工具进行UDP组播调试

    一、下载UDP&TCP调试工具

    二、双击打开调试工具并建立端口

    2.1 创建组播客户端1

         类型:UDP(组播模式);目标IP:225.0.0.20;端口:60000;本机端口制定:60002

         点击“创建”按钮;如图所示:

         2.2 创建组播客户端2

        如上图再操作一遍,端口:60002;本机端口制定:60000.如下图所示:

    三、测试通信情况

        端1发送“78 90 65 33 44 66”,端2发送“11 22 33 44”,效果如下图所示(测试成功):

    //---------------------------------------------------------------------------------------------------------

    UDP相关知识(以下转自:https://blog.csdn.net/u011555996/article/details/72967619

    一、什么是UDP?

           UDP 是UserDatagram Protocol的简称, 中文名是用户数据报协议,是OSI(Open System Interconnection,开放式系统互联) 参考模型中一种无连接的传输层协议,提供面向事务的简单不可靠信息传送服务,IETF RFC 768是UDP的正式规范。UDP在IP报文的协议号是17。
    UDP和TCP的区别:http://blog.csdn.net/ljheee/article/details/50823050
    UDP详解:http://blog.csdn.NET/ljheee/article/details/51720594

    二、UDP信息传递的方式
    ①  单播Unicast:是客户端与服务器之间的点到点连接。
    ②  广播BroadCast:主机之间“一对所有”的通讯模式,广播者可以向网络中所有主机发送信息。广播禁止在Internet宽带网上传输(广播风暴)。 
    ③  多播MultiCast:主机之间“一对一组”的通讯模式,也就是加入了同一个组的主机可以接受到此组内的所有数据。
    这里需要注意的是:只有UDP才有广播、组播的传递方式;而TCP是一对一连接通信。多播的重点是高效的把同一个包尽可能多的发送到不同的,甚至可能是未知的设备。但是TCP连接是一对一明确的,只能单播。

    三、UDP组播
             组播报文的目的地址使用D类IP地址, D类地址不能出现在IP报文的源IP地址字段。单播数据传输过程中,一个数据包传输的路径是从源地址路由到目的地址,利用“逐跳”的原理[路由选择]在IP网络中传输。
            然而在ip组播环中,数据包的目的地址不是一个,而是一组,形成组地址。所有的信息接收者都加入到一个组内,并且一旦加入之后,流向组地址的数据立即开始向接收者传输,组中的所有成员都能接收到数据包。组播组中的成员是动态的,主机可以在任何时刻加入和离开组播组。
            用同一个IP多播地址接收多播数据包的所有主机构成了一个主机组,也称为多播组。一个多播组的成员是随时变动的,一台主机可以随时加入或离开多播组,多播组成员的数目和所在的地理位置也不受限制,一台主机也可以属于几个多播组。此外,不属于某一个多播组的主机也可以向该多播组发送数据包。  
    四、组播地址
    组播组可以是永久的也可以是临时的。组播组地址中,有一部分由官方分配的,称为永久组播组。永久组播组保持不变的是它的ip地址,组中的成员构成可以发生变化。永久组播组中成员的数量都可以是任意的,甚至可以为零。那些没有保留下来供永久组播组使用的ip组播地址,可以被临时组播组利用。
    224.0.0.0~224.0.0.255为预留的组播地址(永久组地址),地址224.0.0.0保留不做分配,其它地址供路由协议使用;
    224.0.1.0~224.0.1.255是公用组播地址,可以用于Internet;
    224.0.2.0~238.255.255.255为用户可用的组播地址(临时组地址),全网范围内有效;
    239.0.0.0~239.255.255.255为本地管理组播地址,仅在特定的本地范围内有效。
            组播是一对多的传输方式,其中有个组播组的 概念,发送端将数据向一个组内发送,网络中的路由器通过底层的IGMP协议自动将数据发送到所有监听这个组的终端。至于广播则和组播有一些相似,区别是路由器向子网内的每一个终端都投递一份数据包,不论这些终端是否乐于接收该数据包。UDP广播只能在内网(同一网段)有效,而组播可以较好实现跨网段群发数据。
           UDP组播是采用的无连接,数据报的连接方式,所以是不可靠的。也就是数据能不能到达接受端和数据到达的顺序都是不能保证的。但是由于UDP不用保证数据 的可靠性,所有数据的传送效率是很快的。

    五、IGMP协议
          IGMP是IP组播的基础。在IP协议出现以后为了加入对组播的支持,IGMP产生了。IGMP所做的实际上就是告诉路由器,在这个路由器所在的子网内有人对发送到某一个组播组的数据感兴趣,这样当这个组播组的数据到达后面,路由器就不会抛弃它,而是把他转送给所有感兴趣的客户。假如不同子网内的A和B要 进行组播通信,那么位于AB之间的所有路由器必须都要支持IGMP协议,否则AB之间不能进行通信。

    六、组播的原理:
          组播首先由一个用户申请一个组播组,这个组播组被维护在路由器中,其他用户申请加入组播组,这样当一个用户向组内发送消息时,路由器将消息转发给组内的所有成员。如果申请加入的组不在本级路由中,如果路由器和交换机允许组播协议通过,路由器将申请加入的操作向上级路由提交。广域网通信要经过多级路由器和交换机,几乎所有的网络设备都默认阻止组播协议通过(只允许本网段内,不向上级提交),这使得广域网上实现组播有一定局限。 

    七、UDP组播的基本步骤
    建立socket 
    socket和端口绑定 
    加入一个组播组 
    通过sendto / recvfrom进行数据的收发 
    关闭socket
    服务器和客户端必须都要加入相同的组播地址才可以。
    多播数据报套接字类用于发送和接收 IP 多播包。MulticastSocket 是一种 (UDP) DatagramSocket,它具有加入 Internet 上其他多播主机的“组”的附加功能。
    多播组通过 D 类 IP 地址和标准 UDP 端口号指定。可以通过首先使用所需端口创建 MulticastSocket,然后调用 joinGroup(InetAddress groupAddr) 方法来加入多播组。
            在Java中,多播一样十分好实现,要实现多播,就要用到MulticastSocket类,其实该类就是DatagramSocket的子类,在使用时除了多播自己的一些特性外,把它当做DatagramSocket类使用就可以了。
            默认我们知道IP(UDP和TCP一样)可以把数据包在一个网络中发到另一个设备。更准确点就是IP把数据包从一个IP地址发到另一个IP地址。多播的决窍就是在同一时间把一个数据包发送到多个设备,可以把一个特定的IP地址指定为多播地址,并同时发送到多个设备。
            IP多播首先要知道的是只有UDP有多播,没有TCP多播这样的东西,为什么呢?多播的重点是高效的把同一个包尽可能多的发送到不同的,甚至可能是未知的设备。但是TCP连接可能要求丢包重发或者延时或重组顺序,这些操作可能非常消耗资源,不适于许多使用多播的应用场景。(同时多播不知道发出的包是不是已经到达,这个也导致不能使用TCP)。

    展开全文
  • udp&组播测试工具

    2010-04-18 13:31:43
    udp&组播测试工具,含sourcecode
  • udp组播测试

    2019-03-23 11:35:17
    这周主要做了udp组播测试 服务器端代码: //服务器发送端 #include <cstdio> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h&...

     这周主要做了udp组播的测试

    服务器端代码:

    //服务器发送端
    #include <cstdio>
    #include <sys/types.h>  
    #include <sys/socket.h>  
    #include <netinet/in.h>  
    #include <arpa/inet.h>
    #include <net/if.h>
    #include <linux/sockios.h>
    #include <sys/ioctl.h>
    #include <time.h>  
    #include <string.h>  
    #include <stdio.h>  
    #include <unistd.h>  
    #include <stdlib.h>  
    #include <signal.h>
    
    std::string HELLO_GROUP = "224.0.31.128";
    int HELLO_PORT = 12345;
    bool bRunning = true;
    
    void handler(int signo)
    {
    	if (signo == SIGINT ||
    		signo == SIGQUIT)
    	{
    		bRunning = false;
    	}
    }
    
    int main(int argc, char *argv[])
    {
    	
    	// 如果传参,就优先从参数中读取
    	if (argc > 1)
    	{
    		HELLO_GROUP = argv[1];
    	}
    	else
    	{
    		HELLO_GROUP = udp_ip;
    	}
    
    	if (argc > 2)
    	{
    		HELLO_PORT = atoi(argv[2]);
    	}
    
    	signal(SIGPIPE, handler);
    	signal(SIGINT, handler);
    	signal(SIGHUP, handler);
    	signal(SIGTERM, handler);
    	signal(SIGCHLD, handler);
    	signal(SIGTSTP, handler);
    	signal(SIGQUIT, handler);
    
    	struct sockaddr_in addr;
    	int fd, cnt;
    	struct ip_mreq mreq;
    	char *message = "Hello, World!";
    	/* create what looks like an ordinary UDP socket */
    	if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
    	{
    		perror("socket");
    		exit(1);
    	}
        //设置指定网卡名
    	if (interface_name.size() > 0)
    	{
    		struct ifreq interface;
    		strncpy(interface.ifr_ifrn.ifrn_name, interface_name.c_str(), interface_name.size());
    		if (setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, (char *)&interface, sizeof(interface)) < 0) {
    			perror("SO_BINDTODEVICE failed");
    			exit(1);
    		}
    	}
    	/* set up destination address */
    	memset(&addr, 0, sizeof(addr));
    	addr.sin_family = AF_INET;
    
    	if (HELLO_GROUP.length() > 0)
    	{
    		addr.sin_addr.s_addr = inet_addr(HELLO_GROUP.c_str());
    	}
    	else
    	{
    		addr.sin_addr.s_addr = htonl(INADDR_ANY); /* N.B.: differs from sender */
    	}
    	addr.sin_port = htons(HELLO_PORT);
    
    	printf("send udp group data start, ip = %s, port = %d\n", HELLO_GROUP.c_str(), HELLO_PORT);
    
    	/* now just sendto() our destination! */
    	std::uint64_t count = 0;
    	while (bRunning)
    	{
    		if (sendto(fd, message, strlen(message), 0, (struct sockaddr *) &addr, sizeof(addr)) < 0)
    		{
    			perror("sendto");
    			exit(1);
    		}
    		printf("send %d byte to group count: %ld\n", strlen(message), ++count);
    		sleep(1);
    	}
    	close(fd);
    	printf("send udp group data end, ip = %s, port = %d\n", HELLO_GROUP.c_str(), HELLO_PORT);
    	return 0;
    }

    客户端代码:

    //客户端代码
    #include <cstdio>
    #include <sys/time.h>
    #include <sys/types.h>  
    #include <sys/socket.h>  
    #include <netinet/in.h>  
    #include <arpa/inet.h>
    #include <net/if.h>
    #include <linux/sockios.h>
    #include <sys/ioctl.h>
    #include <chrono>
    #include <time.h>  
    #include <string.h>  
    #include <stdio.h>  
    #include <unistd.h>
    #include <time.h>
    #include <stdlib.h>  
    #include <fcntl.h>
    #include <signal.h>
    #include <string>
    
    std::string HELLO_GROUP = "224.0.31.172";
    int HELLO_PORT = 14382;
    
    #define MSGBUFSIZE 8000  
    
    const long MIN_KB = 1024;
    const long MIN_MB = 1024 * MIN_KB;
    const long MIN_GB = 1024 * MIN_MB;
    const long MIN_TB = 1024 * MIN_GB;
    
    int g_filed = -1;        // fd 就是file descriptor,文件描述符
    bool bRunning = true;
    
    void GetSize(long datasize, char* sret)
    {
    	char sRet[100] = {0};
    	if (datasize < MIN_KB)
    		sprintf(sRet, "%ld B", datasize);
    	else if (datasize < MIN_MB)
    		sprintf(sRet, "%.4lf KB", (double)(datasize * 1000 / MIN_KB) / 1000);
    	else if (datasize < MIN_GB)
    		sprintf(sRet, "%.4lf MB", (double)(datasize * 1000 / MIN_MB) / 1000);
    	else if (datasize < MIN_TB)
    		sprintf(sRet, "%.4lf GB", (double)(datasize * 1000 / MIN_GB) / 1000);
    	else if (datasize >= MIN_TB)
    		sprintf(sRet, "%.4lf TB", (double)(datasize * 1000 / MIN_TB) / 1000);
    
    	strcpy(sret, sRet);
    }
    
    void GetDateTime(char* sret)
    {
    	struct timeval tvnow;
    	gettimeofday(&tvnow, NULL);
    	auto mTime = std::chrono::milliseconds(tvnow.tv_sec * 1000);
    	auto tp = std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds>(mTime);
    	auto tt = std::chrono::system_clock::to_time_t(tp);
    	std::tm* now = std::localtime(&tt);
    	sprintf(sret, "%04d%02d%02d-%02d:%02d:%02d.%06ld",
    		now->tm_year + 1900, now->tm_mon + 1, now->tm_mday,
    		now->tm_hour, now->tm_min, now->tm_sec, tvnow.tv_usec);
    }
    
    void handler(int signo)
    {
    	if (signo == SIGINT || 
    		signo == SIGQUIT) 
    	{
    		bRunning = false;
    	}
    }
    
    #define  RECV_LOOP_COUNT 5
    int recv_within_time(int fd, char *buf, size_t buf_n, struct sockaddr* addr, socklen_t *len, unsigned int sec, unsigned usec)
    {
    	struct timeval tv;
    	fd_set readfds;
    	int i = 0;
    	unsigned int n = 0;
    	for (i = 0; i < RECV_LOOP_COUNT; i++)
    	{
    		FD_ZERO(&readfds);
    		FD_SET(fd, &readfds);
    		tv.tv_sec = sec;
    		tv.tv_usec = usec;
    		select(fd + 1, &readfds, NULL, NULL, &tv);
    		if (FD_ISSET(fd, &readfds))
    		{
    			if ((n = recvfrom(fd, buf, buf_n, 0, addr, len)) >= 0)
    			{
    				return n;
    			}
    		}
    	}
    	return -1;
    }
    
    int main(int argc, char *argv[])
    {
    	signal(SIGPIPE, handler);
    	signal(SIGINT, handler);
    	signal(SIGHUP, handler);
    	signal(SIGTERM, handler);
    	signal(SIGCHLD, handler);
    	signal(SIGTSTP, handler);
    	signal(SIGQUIT, handler);
    
    	struct sockaddr_in addr;
    	int fd, nbytes, addrlen;
    	struct ip_mreq mreq;
    	char msgbuf[MSGBUFSIZE] = {0};
    	u_int yes = 1; /*** MODIFICATION TO ORIGINAL */
    				   /* create what looks like an ordinary UDP socket */
    	if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
    	{
    		perror("socket failed");
    		exit(1);
    	}
    	/**** MODIFICATION TO ORIGINAL */
    	/* allow multiple sockets to use the same PORT number */
    	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0)
    	{
    		perror("Reusing ADDR failed");
    		exit(1);
    	}
    
    	
    	/*** END OF MODIFICATION TO ORIGINAL */
    	/* set up destination address */
    	memset(&addr, 0, sizeof(addr));
    	addr.sin_family = AF_INET;
    	addr.sin_addr.s_addr = htonl(INADDR_ANY); /* N.B.: differs from sender */
    	addr.sin_port = htons(HELLO_PORT);
    	/* bind to receive address */
    	if (bind(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0)
    	{
    		perror("bind failed");
    		exit(1);
    	}
    	std::string interface_addr = "";
    	/* use setsockopt() to request that the kernel join a multicast group */
    	mreq.imr_multiaddr.s_addr = inet_addr(HELLO_GROUP.c_str());
    	if (interface_addr.size() > 0)
    	{
    		mreq.imr_interface.s_addr = inet_addr(interface_addr.c_str());
    	}
    	else
    	{
    		mreq.imr_interface.s_addr = htonl(INADDR_ANY);
    	}
    	if (setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0)
    	{
    		perror("setsockopt failed");
    		exit(1);
    	}
    
    	/* now just enter a read-print loop */
    	printf("receive udp group data start, ip = %s, port = %d\n", HELLO_GROUP.c_str(), HELLO_PORT);
    
    	// open data file
    	char stime[30] = { 0 };
    	GetDateTime(stime);
    	char sdatasize[100] = {0};
    
    	long datasize = 0;
    	int ret = 0;
    	std::uint64_t count = 0;
    	while (bRunning)
    	{
    		//ssize_t recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen);  
    		addrlen = sizeof(addr);
    		memset(msgbuf, 0, sizeof(msgbuf));
    		if ((nbytes = recv_within_time(fd, msgbuf, sizeof(msgbuf),(struct sockaddr*)&addr, (socklen_t *)&addrlen, 0, 0)) < 0)
    		{
    			printf("out of time...\n");
    			sleep(1);
    			continue;
    		}
    		datasize += nbytes;
    
    		GetDateTime(stime);
    
    		GetSize(datasize, sdatasize);
    		printf("%s receive data size: %d, total size: %s, count: %ld\n", stime, nbytes, sdatasize, ++count);
    
    		
    	}
    
    	close(fd);
    	printf("receive udp group data end, ip = %s, port = %d\n", HELLO_GROUP.c_str(), HELLO_PORT);
    	return 0;
    }

    udp组播需要三层交换机的支持,没有三层交换机没办法做组播测试

    udp组播会发生概率丢包,要减少丢包率,见https://blog.csdn.net/u011001084/article/details/79093393

    展开全文
  • UDP组播)调试工具

    2018-03-02 16:55:08
    UDP通信,UDP组播调试助手源码。VS2010开发,C#语言编写。支持UDP通信接收与发送,UDP组播接收与发送功能,能够发送字符串和16进制数据
  • 周立功网络调试软件,网络故障分析必备,也可用于网络编程模拟器。亲测可用
  • 组播测试收发工具

    2019-03-24 10:23:48
    MultiCast 应用开发调试助手 是一个网络辅助开发工具,本工具简单、易操作、无需安装、安全绿色软件。可以帮助网络应用设计、开发、测试人员检查所开发的网络应用软硬件的数据收发状况,提高开发的速度,降低检查...
  • UDP组播通信,发送数据正常,但是只能接受到本机发出的数据,收不到其他机器发出的数据。这是代码:`enter code here`Send_ACT_time_interval_set(); int nlen=sizeof(sact); memcpy(sendbuf,(char*)&sact,...
  • UDP组播配置

    2020-01-04 17:44:27
    在win环境下配置UDP组播发送和接收,解决无法接收和发送组播信息的问题。

    1.配置组播协议

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    点击添加,安装列表的协议,随后可以看到如下所示
    在这里插入图片描述

    2.配置注册列表

    1. 按下win+R打开,输入regedit;
    2. 依次展开HKEY_LOCAL_MACHINE——SYSTEM——CurrentControlSet——Service——Tcpip;
    3. 选择Parameters;
    4. 找到IGMPLevel和IGMPVersion两个变量;如果没有,则新建这两个变量,类型为字符串值,值分别为2和3;
    5. 重启电脑。

    3.测试组播功能

    发送代码:

    #include "pch.h"
    #include <stdio.h>  
    #include <winsock2.h>  
    #include <ws2tcpip.h>  
    #pragma comment(lib, "ws2_32.lib")
    
    int main()
    {
    	int iRet = 0;
    	WSADATA wsaData;
    	WSAStartup(MAKEWORD(2, 2), &wsaData);
    
    	SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);
    
    	int iFlag = 1;	// 0-同一台主机 1-夸主机
    	iRet = setsockopt(sock, IPPROTO_IP, IP_MULTICAST_TTL, (char*)&iFlag, sizeof(iFlag));
    	if (iRet != 0) {
    		printf("setsockopt fail:%d", WSAGetLastError());
    		return -1;
    	}
    
    	sockaddr_in addr;
    	addr.sin_addr.S_un.S_addr = inet_addr("224.16.132.22");//修改组播IP
    	addr.sin_family = AF_INET;
    	addr.sin_port = htons(8119);//修改组播端口
    
    	char strSend[1024] = { 0 };
    	static int iIdx = 0;
    	while (1)
    	{
    		sprintf_s(strSend, "udp send group data:%d", iIdx++);
    		iRet = sendto(sock, strSend, strlen(strSend) + 1, 0, (sockaddr*)&addr, sizeof(sockaddr));
    		if (iRet <= 0) {
    			printf("send fail:%d", WSAGetLastError());
    		}
    		else {
    			printf("send data:%s\n", strSend);
    		}
    		Sleep(500);
    	}
    
    	closesocket(sock);
    	WSACleanup();
    
    	return 0;
    }
    

    接收代码:

    #include "pch.h"
    #include <stdio.h>  
    #include <winsock2.h>  
    #include <ws2tcpip.h>  
    #pragma comment(lib, "ws2_32.lib")
    
    int main()
    {
    	int iRet = 0;
    	WSADATA wsaData;
    	WSAStartup(MAKEWORD(2, 2), &wsaData);
    
    	SOCKET sock = socket(AF_INET, SOCK_DGRAM, 0);
    
    	sockaddr_in addr;
    	addr.sin_family = AF_INET;
    	//addr.sin_addr.S_un.S_addr = INADDR_ANY;
    	addr.sin_addr.S_un.S_addr = inet_addr("192.168.4.184");//修改本地IP
    	addr.sin_port = htons(8119);//修改组播端口
    
    	bool bOptval = true;
    	iRet = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char*)&bOptval, sizeof(bOptval));
    	if (iRet != 0) {
    		printf("setsockopt fail:%d", WSAGetLastError());
    		return -1;
    	}
    
    	iRet = bind(sock, (sockaddr*)&addr, sizeof(addr));
    	if (iRet != 0) {
    		printf("bind fail:%d", WSAGetLastError());
    		return -1;
    	}
    	printf("socket:%d bind success\n", sock);
    
    	// 加入组播  
    	ip_mreq multiCast;
    	//multiCast.imr_interface.S_un.S_addr = INADDR_ANY;
    	multiCast.imr_interface.S_un.S_addr = inet_addr("192.168.4.184");//修改本机IP
    	multiCast.imr_multiaddr.S_un.S_addr = inet_addr("224.16.132.22");//修改组播IP
    	iRet = setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&multiCast, sizeof(multiCast));
    	if (iRet != 0) {
    		printf("setsockopt fail:%d", WSAGetLastError());
    		return -1;
    	}
    
    	printf("udp group start\n");
    
    	int len = sizeof(sockaddr);
    	char strRecv[1024] = { 0 };
    	while (true)
    	{
    		memset(strRecv, 0, sizeof(strRecv));
    		iRet = recvfrom(sock, strRecv, sizeof(strRecv) - 1, 0, (sockaddr*)&addr, &len);
    		if (iRet <= 0) {
    			printf("recvfrom fail:%d", WSAGetLastError());
    			return -1;
    		}
    		printf("recv data:%s\n", strRecv);
    	}
    
    	closesocket(sock);
    	WSACleanup();
    
    	return 0;
    }
    

    组播发送和接收结果

    4.Qt测试组播接收和发送

    打开Qt自带的组播发送和接收例程,如图所示
    左边为接受例程,右边为发送例程
    接收程序修改以下两行代码:

    udpSocket->bind(QHostAddress("192.168.4.184"),8119, QUdpSocket::ShareAddress);//本机IP和接收端口
    bool res = udpSocket->joinMulticastGroup(QHostAddress("224.2.2.1"));//加入组播组
    

    发送程序修改以下代码

    udpSocket->writeDatagram(datagram, QHostAddress("224.16.132.22"), 8119);
    

    5.SocketTool工具测试

    网络测试工具中SocketTool对组播比较好。SocketTool只能在“224.0.0.1”地址上发送数据,其他地址只能用来接收测试,配置如图所示:
    在输入框中输入组播IP和端口,可以看到数据滚动
    SocketTool链接:
    链接:https://pan.baidu.com/s/1IK8e_8evyFaV2UXewF2ogg
    提取码:gft1

    展开全文
  • TCP&UDP测试工具 创建UDP通信设置教程

    万次阅读 2016-10-14 21:52:42
    使用TCP&UDP测试工具软件以UDP的通信方式发送一数据,然后在TCP&UDP测试工具的接收区接收显示发送的数据。 需要使用路由器创建一个虚拟服务器,这样这个测试能在一台电脑上完成。 虚拟服务器 说明可以让网际网络的...
  • LWIP Sokect UDP组播

    2020-04-24 21:04:46
    1 Socket编程-udp服务端和客户端通信 (1).建立一个套接字(Socket) (2).绑定服务器端IP地址及端口号--服务器端 (3).通过SendTo()方法向指定主机发送消息 (需提供主机IP地址及端口) (4).通过ReciveFrom()方法...
  • 一、实验环境 编程语言:Java1.5(运行在JVM(Java Virsual Machine))开发工具:eclipce3.2测试环境:局域网二、实验目的社会已经进入信息时代,网络技术在飞速发展.大量应用都依赖于从一个主机向多个主机或者从多个...
  • Socket编程-UDP实现发送组播信息

    千次阅读 2018-12-02 19:39:48
    在System.net.Sockets名称空间中,UdpClient类简化了UDP套接字编程。UDP协议是无连接的协议,因此,UDP协议只有UdpClient类,而没有TcpListener类和TcpClient类。UdpClient类提供了发送和接受无连接的UDP数据报的...
  • 摘要: 本文主要是在windows平台下,设计一个UDP多播(组播)发送和接收程序。
  • 使用STM32F103芯片,通过W5500实现UDP组播通信,带UDP组播通信历程,测试工具,测试文档,W5500技术资料。
  • 该场景是用于终端Linux设备,入网后定时发送UDP组播,从而服务端可以发现同一个局域网内所有按照此协议下的设备。 不比比,直接上代码: #include <sys/types.h> #include <sys/socket.h> #include &...
  • 对于Linux上与Windows数据交互有很多方法 ,此处我来探讨利用多进行Linux上与Windows上的数据交互 首先说明多的一个性质。 简要来讲,多就是相当于只发送一次数据包,但是传播多次。多主要使用的是D类IP地址...
  • netty实现UDP

    千次阅读 2018-11-02 21:13:45
    广播方 /** * 类说明:广播 */ public class LogEventBroadcaster { private final EventLoopGroup group; private final Bootstrap bootstrap; public LogEventBroadcaster(InetSocketAddress remoteAddress)...
  • /*********************************************************************************************** * *=============================================================================================*/ ...
  • H.264流媒体UDP组播和ffmpeg解码实验

    千次阅读 2017-11-01 21:05:53
    简介:将H.264视频流从发送端通过UDP组播到接收端,并通过ffmpeg解码播放。   分为四步: 1 路由器端局域网下设置虚拟服务器 2 TCP/UDP通信测试 3 发送端与接收端ffmpeg的安装 4 通过指令对H264流媒体组播和解码 ...
  • 工具向】Android UDP与TCP工具

    千次阅读 2016-06-28 23:52:49
    什么是UDP与TCP协议? 请看此篇文章 http://www.360doc.com/content/14/0325/09/1317564_363500997.shtml   简单来说,他们都是两种协议,UDP传输时候不需要建立连接,TCP需要建立连接,同时UDP使用了数据报形式,...
  • 1 UDP局域网服务器 A 读出每一个客户端发送过来的数据包,然后fork出子进程,由子进程去处理客户端请求。 B 客户端与服务器段交换多个数据报,服务器为每一个客户端连接创建新的socket,在其上bind一个临时端口,...
  • 但是如果你要发送多数据,在有的系统上(我所测试的Win2K),即使通过每个IP都发送了多包,但是系统会自动选择一张默认的网卡来发送你的多包。 这是你可以通过设置下面这个Socket选项来更改这种默认行为: ...
  • labview UDP组播编程简介

    千次阅读 2016-11-23 15:57:06
  • 准备写一个组播升级工具,先读取一个60多M的二进制文件,读取的数据拆分成很多份 2. 每份数据加上头部数据以UDP报文格式发送出去 现在发UDP报文功能已经实现,但是如何读取二进制文件,以及如何拆分并加上头部...
  • dart如何实现udp组播,见另一篇:https://blog.csdn.net/qq_41074373/article/details/107463892 在项目开发时,在本地可以成功广播,用抓包工具也可以抓到数据包。但是当打包成apk后,在真机上广播,抓包工具没有...

空空如也

1 2 3 4 5 ... 20
收藏数 16,637
精华内容 6,654
关键字:

udp 组播工具