与基于udp协议的tracker服务器进行交互

最新推荐文章于 2023-01-07 13:26:20 发布
最新推荐文章于 2023-01-07 13:26:20 发布
阅读量4.3k 收藏 1
点赞数
分类专栏： BTCyclone开发日志 文章标签： 服务器 socket byte buffer struct interface
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lightest/article/details/261932
版权

    通常BT客户端每几分钟就要向tracker发送一次请求.对于一些比较大的BT站点,其tracker的压力是可想而知的.降低tracker的压力首先考虑到的当然是采用更低网络开销的udp协议.于是Bittorrent udp-tracker protocol应运而生.
    这个协议很简单.
    下面是实现它的封装类:

// UDPTrackerClient.h: interface for the CUDPTrackerClient class.
//
//

#if !defined(AFX_UDPTRACKERCLIENT_H__69B6ACC8_8193_4680_81D8_925B1550E92C__INCLUDED_)
#define AFX_UDPTRACKERCLIENT_H__69B6ACC8_8193_4680_81D8_925B1550E92C__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")

#ifndef _DISABLEWARNING4786_4355
#define _DISABLEWARNING4786_4355
#pragma warning( disable : 4786 )
#pragma warning( disable : 4355 )
#endif
#ifndef _ENABLEUSESTL
#define _ENABLEUSESTL
#include <list>
#include <map>
#include <set>
#include <vector>
#include <queue>
#include <string>
using namespace std;
#endif

class CPeerHostInfo
{
public:								
	DWORD		IP;//节点IP
	WORD		Port;//节点端口
};	
class CUDPTrackerClient  
{
public:
	CUDPTrackerClient();
	virtual ~CUDPTrackerClient();
	void CancelSocketOperate();
	BOOL Connect(const char * szServer,WORD wPort = 0);	
	DWORD Announcing(BYTE* pInfoHash,BYTE * pPeerID,
		__int64 idownloaded,__int64 ileft,__int64 iuploaded,
		int		ievent,
		DWORD dwIP,WORD  wPort);
	
	BOOL Disconnect();
public:	
	SOCKET			m_socket;
	DWORD			m_dwIP;
	WORD			m_wPort;	
	__int64			m_iConnection_id;
	DWORD			m_dwConnectTick;
	string			m_strError;		//如果请求失败,此变量保存错误信息
	DWORD m_dwDonePeers;	//种子数
	DWORD m_dwNumPeers;	//当前下载者个数
	DWORD m_dwInterval;	//查询间隔时间
	list<CPeerHostInfo> m_listPeers;
};

#endif // !defined(AFX_UDPTRACKERCLIENT_H__69B6ACC8_8193_4680_81D8_925B1550E92C__INCLUDED_)

// UDPTrackerClient.cpp: implementation of the CUDPTrackerClient class.
//
//

#include "stdafx.h"
#include "UDPTrackerClient.h"

#include "DataStream.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//
// Construction/Destruction
//
#define RECVBUFSIZE 2048

CUDPTrackerClient::CUDPTrackerClient()
{
	m_socket = INVALID_SOCKET;	
	m_iConnection_id = 0;
	m_dwConnectTick = 0;
	m_dwIP = 0;
	m_wPort = 0;
	m_dwDonePeers = 0;	//种子数
	m_dwNumPeers = 0;	//当前下载者个数
	m_dwInterval = 0;	//查询间隔时间
}

CUDPTrackerClient::~CUDPTrackerClient()
{
	Disconnect();

}
void CUDPTrackerClient::CancelSocketOperate()
{
	if(m_socket != INVALID_SOCKET)
	{
		LINGER lingerStruct;    
		// If we're supposed to abort the connection, set the linger value
		// on the socket to 0.    
		lingerStruct.l_onoff = 1;
		lingerStruct.l_linger = 0;
		setsockopt(m_socket, SOL_SOCKET, SO_LINGER,
			(char *)&lingerStruct, sizeof(lingerStruct) );
	}
}
BOOL CUDPTrackerClient::Disconnect()
{
	m_iConnection_id = 0;
	m_dwDonePeers = 0;	//种子数
	m_dwNumPeers = 0;	//当前下载者个数
	m_dwInterval = 0;	//查询间隔时间
	if ( m_socket != INVALID_SOCKET )
	{
		m_dwIP = 0;
		m_wPort = 0;
		// Now close the socket handle.  This will do an abortive or 
		// graceful close, as requested.      
		shutdown(m_socket,SD_BOTH);
		closesocket(m_socket);
		m_socket = INVALID_SOCKET;
		return TRUE;
	}
	return FALSE;
}

//szServer连接的主机,可以是下列形式的字符串:
//easeso.com:1000
//easeso.com
//如果wPort不为0,则szServer不应该包含端口信息
BOOL CUDPTrackerClient::Connect(const char * szServer,WORD wPort)
{
	m_strError = "";
	BOOL bRes = FALSE;
	if ( m_socket == INVALID_SOCKET )
	{
		//用UDP初始化套接字
		BOOL optval = TRUE;			
		m_socket =socket(AF_INET,SOCK_DGRAM,0);
		if(m_socket == INVALID_SOCKET)
			return FALSE;
		//设置超时时间
		int TimeOut=10000;
		int err = setsockopt (m_socket, SOL_SOCKET,SO_RCVTIMEO,(CHAR *) &TimeOut,sizeof (TimeOut));
	}
	if(m_dwIP == 0)
	{
		CString strServer = szServer;
		CString strHost;
		if(wPort == 0)
		{
			int iNext = strServer.Find(':');
			if(iNext>0)
			{			
				strHost = strServer.Mid(0,iNext);			
				CString strPort = strServer.Mid(iNext+1);			
				m_wPort = (WORD)atoi(strPort);
			}
			else
				strHost = strServer;
		}
		else
		{
			strHost = strServer;
			m_wPort = wPort;
		}
		if(m_wPort == 0)
			m_wPort = 80;		

		//Check if address is an IP or a Domain Name
		int a = strHost[0];
		if (a > 47 && a < 58) 
			m_dwIP = inet_addr(strHost);
		else
		{
			struct hostent *pHost;
			pHost = gethostbyname(strHost);
			if(pHost != NULL)
				m_dwIP = *((ULONG*)pHost->h_addr);
			else
				m_dwIP = 0;
		}
	}
	if((GetTickCount()-m_dwConnectTick)>30000)
	{
		m_dwConnectTick = 0;
		m_iConnection_id = 0;
	}
	if(m_socket != INVALID_SOCKET && m_dwIP && m_wPort && m_iConnection_id ==0)
	{
		DWORD dwTransaction_id = GetTickCount();
		SOCKADDR_IN		from;
		int fromlength=sizeof(SOCKADDR);

		char buf[RECVBUFSIZE];
		from.sin_family=AF_INET;
		from.sin_addr.s_addr=m_dwIP;
		from.sin_port=htons(m_wPort);
		CDataStream sendstream(buf,2047);
		sendstream.clear();
		__int64 iCID = 0x41727101980;
		sendstream.writeint64(CNetworkByteOrder::convert(iCID));
		sendstream.writedword(CNetworkByteOrder::convert((int)0));
		sendstream.writedword(dwTransaction_id);
		
		int iRes = 0;
		int iTimes = 6;
		while(iTimes>0&&m_dwIP)
		{
			sendto(m_socket,sendstream.getbuffer(),sendstream.size(),0,(struct sockaddr FAR *)&from,sizeof(from));
			iRes = recvfrom(m_socket,buf,RECVBUFSIZE-1,0,(struct sockaddr FAR *)&from,(int FAR *)&fromlength);
			if(iRes >=0)
				break;
			iTimes--;
		}
		if(iRes>=16)
		{
			CDataStream recvstream(buf,RECVBUFSIZE-1);
			DWORD dwAction = (DWORD)CNetworkByteOrder::convert((int)recvstream.readdword());
			DWORD dwTIDResp= recvstream.readdword();
			if(dwTIDResp == dwTransaction_id)
			{
				if(dwAction == 0)
				{
					m_iConnection_id = recvstream.readint64();			
					//BitComet将回复0x16字节数据,最后6字节是服务器查看到的本地IP和UDP端口
				}
				else if(dwAction == 3)//得到一个错误信息包
				{
					buf[iRes]=0;
					m_strError = recvstream.readstring();
				}
			}
		}
	}
	if(m_iConnection_id)
		bRes = TRUE;
	return bRes;
}
//提交请求
//pInfoHash 20字节的数据缓冲区指针
//pPeerID	20字节的数据缓冲区指针
//ievent参数值:
//none = 0 
//completed = 1 
//started = 2 
//stopped = 3 

DWORD CUDPTrackerClient::Announcing(BYTE* pInfoHash,BYTE * pPeerID,
									__int64 idownloaded,__int64 ileft,__int64 iuploaded,
									int		ievent,
									DWORD dwIP,WORD  wPort)
{	
	m_listPeers.clear();
	m_dwNumPeers = 0;
	m_dwDonePeers = 0;
	m_strError = "";
	DWORD dwReturnCode = 0;
	if(m_iConnection_id && m_socket != INVALID_SOCKET && m_dwIP & m_wPort)
	{
		DWORD dwTransaction_id = GetTickCount();
		//srand(dwTransaction_id);
		//DWORD dwKey = rand();
		DWORD dwKey = 0x3753;
		SOCKADDR_IN		from;
		int fromlength=sizeof(SOCKADDR);
		char buf[RECVBUFSIZE];
		from.sin_family=AF_INET;
		from.sin_addr.s_addr=m_dwIP;
		from.sin_port=htons(m_wPort);
		CDataStream sendstream(buf,RECVBUFSIZE-1);
		sendstream.clear();		
		sendstream.writeint64(m_iConnection_id);
		sendstream.writedword(CNetworkByteOrder::convert((int)1));
		sendstream.writedword(dwTransaction_id);
		sendstream.writedata(pInfoHash,20);
		sendstream.writedata(pPeerID,20);
		sendstream.writeint64(CNetworkByteOrder::convert(idownloaded));
		sendstream.writeint64(CNetworkByteOrder::convert(ileft));
		sendstream.writeint64(CNetworkByteOrder::convert(iuploaded));
		sendstream.writedword(CNetworkByteOrder::convert(ievent));
		sendstream.writedword(dwIP);
		sendstream.writedword(CNetworkByteOrder::convert((int)dwKey));
		sendstream.writedword(CNetworkByteOrder::convert((int)200));
		sendstream.writedword(CNetworkByteOrder::convert(wPort));
		
		int iRes = 0;
		int iTimes = 2;
		while(iTimes>0&&m_dwIP)
		{
			sendto(m_socket,sendstream.getbuffer(),sendstream.size(),0,(struct sockaddr FAR *)&from,sizeof(from));
			iRes = recvfrom(m_socket,buf,RECVBUFSIZE-1,0,(struct sockaddr FAR *)&from,(int FAR *)&fromlength);
			if(iRes >=0)
				break;
			iTimes--;
		}
		if(iRes>=20)
		{			
			CDataStream recvstream(buf,RECVBUFSIZE-1);
			DWORD dwAction = (DWORD)CNetworkByteOrder::convert((int)recvstream.readdword());
			DWORD dwTIDResp= recvstream.readdword();
			if(dwTIDResp == dwTransaction_id)
			{
				if(dwAction == 1)
				{
					m_dwInterval = (DWORD)CNetworkByteOrder::convert((int)recvstream.readdword());
					m_dwNumPeers = (DWORD)CNetworkByteOrder::convert((int)recvstream.readdword());
					m_dwDonePeers = (DWORD)CNetworkByteOrder::convert((int)recvstream.readdword());					
					CPeerHostInfo hi;					
					for(int iCurPos = 20;iCurPos+6<=iRes;iCurPos+=6)
					{
						hi.IP= recvstream.readdword();
						hi.Port = (WORD)CNetworkByteOrder::convert((unsigned short)recvstream.readword());
						m_listPeers.push_back(hi);
					}
					if(m_dwNumPeers>m_listPeers.size())
					{
						iRes = 0;
						iTimes = 6;
						while(iTimes>0&&m_dwIP)
						{
							iRes = recvfrom(m_socket,buf,RECVBUFSIZE-1,0,(struct sockaddr FAR *)&from,(int FAR *)&fromlength);
							if(iRes >=0)
								break;
							iTimes--;
						}
						if(iRes>=6)
						{
							for(iCurPos = 0;iCurPos+6<=iRes;iCurPos+=6)
							{
								hi.IP= recvstream.readdword();
								hi.Port = (DWORD)CNetworkByteOrder::convert((int)recvstream.readword());
								m_listPeers.push_back(hi);
							}
						}						
					}
					m_dwNumPeers = m_listPeers.size();
					dwReturnCode = 200;
				}
				else if(dwAction == 3)//得到一个错误信息包
				{
					buf[iRes]=0;
					m_strError = recvstream.readstring();
					dwReturnCode = 400;
				}
			}
		}
	}
	//每次都要求重新连接
	m_iConnection_id = 0;
	return dwReturnCode;
}



// DataStream.h: interface for the CDataStream class.
//
//

#if !defined(AFX_DATASTREAM_H__D90A2534_EA73_4BEA_8B7E_87E59A3D1D26__INCLUDED_)
#define AFX_DATASTREAM_H__D90A2534_EA73_4BEA_8B7E_87E59A3D1D26__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <stdio.h> 
//数据流操作函数
class CDataStream  
{
public :
	CDataStream(char * szBuf,int isize)
	{
		m_isize = isize;
		buffer = szBuf;
		current = buffer;
	}
	~CDataStream()
	{
	}
    void clear()
	{
		current = buffer;
		current[0]=0;
	}
	//此函数不动态增加内存,一次打印的数据长度不应该超过缓冲区的三分之一,否则可能导致失败
	bool printf(const char * format,...)
	{
		if(current)
		{
			if(current - buffer > (m_isize*2)/3)
				return false;
			va_list argPtr ;
			va_start( argPtr, format ) ;
			int count = vsprintf( current, format, argPtr ) ;
			va_end( argPtr );
			current += count ;
			return true;
		}
		return false;
	}
	//此函数拷贝字符串
	bool strcpy(const char * szStr)
	{
		if(current&&szStr)
		{
			int ilen = lstrlen(szStr);
			if((m_isize-(current - buffer)) < (ilen +2))
				return false;
			memcpy(current,szStr,ilen+1);
			current += ilen;
			return true;
		}
		return false;
	}
	char * getcurrentpos()
	{
		return current;
	}
	void move(int ilen)//当前指针向后移动ilen
	{
		current += ilen;
	}
	void reset()
	{
		current = buffer;
	}
	BYTE readbyte()
	{
		current ++;
		return *(current-1);
	}
	void writebyte(BYTE btValue)
	{
		*current = btValue;
		current ++;		
	}
	WORD readword()
	{
		current +=2;
		return *((WORD*)(current-2));
	}
	void writeword(WORD wValue)
	{		
		*((WORD*)current) = wValue;
		current +=2;
	}
	DWORD readdword()
	{
		current +=4;
		return *((DWORD*)(current-4));
	}
	void writedword(DWORD dwValue)
	{
		*((DWORD*)current) = dwValue;
		current +=4;
	}
	__int64 readint64()
	{
		current +=8;
		return *((__int64*)(current-8));
	}
	void writeint64(__int64 iValue)
	{
		*((__int64*)current) = iValue;
		current +=8;
	}
	BYTE * readdata(DWORD dwLen)
	{
		current +=dwLen;
		return (BYTE*)(current-dwLen);
	}
	void writedata(BYTE * pData,DWORD dwLen)
	{
		memcpy(current,pData,dwLen);		
		current +=dwLen;
	}
	char * readstring()
	{
		char * szRes = current;
		int ilen = lstrlen(current);
		current +=(ilen+1);
		return szRes;
	}
	int size()
	{
		return (int)(current-buffer);
	}
	const char * getbuffer(){return buffer;}
private :
	char* buffer;
    char* current;
	int m_isize;
};
class CNetworkByteOrder
{
public:
	static unsigned short int convert(unsigned short int iValue)
	{
		unsigned short int iData;
		((BYTE*)&iData)[0] = ((BYTE*)&iValue)[1];
		((BYTE*)&iData)[1] = ((BYTE*)&iValue)[0];
		return iData;
	}
	static int convert(int iValue)
	{
		int iData;
		((BYTE*)&iData)[0] = ((BYTE*)&iValue)[3];
		((BYTE*)&iData)[1] = ((BYTE*)&iValue)[2];
		((BYTE*)&iData)[2] = ((BYTE*)&iValue)[1];
		((BYTE*)&iData)[3] = ((BYTE*)&iValue)[0];
		return iData;
	}
	static __int64 convert(__int64 iValue)
	{
		__int64 iData;
		((BYTE*)&iData)[0] = ((BYTE*)&iValue)[7];
		((BYTE*)&iData)[1] = ((BYTE*)&iValue)[6];
		((BYTE*)&iData)[2] = ((BYTE*)&iValue)[5];
		((BYTE*)&iData)[3] = ((BYTE*)&iValue)[4];
		((BYTE*)&iData)[4] = ((BYTE*)&iValue)[3];
		((BYTE*)&iData)[5] = ((BYTE*)&iValue)[2];
		((BYTE*)&iData)[6] = ((BYTE*)&iValue)[1];
		((BYTE*)&iData)[7] = ((BYTE*)&iValue)[0];
		return iData;
	}

};
#endif // !defined(AFX_DATASTREAM_H__D90A2534_EA73_4BEA_8B7E_87E59A3D1D26__INCLUDED_)
在逸搜(EaseSo)论坛可以下载到支持udp tracker的测试程序BTTrackerTest.
    

到此,第一阶段工作完成,下面要做的就是peer之间的交互了.
Lightest
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
【bt】UDP tracker protocol
突围
05-28 540
UDP 跟踪器协议 DP 跟踪器协议 UDP 跟踪器协议是一种高性能的低开销 BitTorrent 跟踪器协议。此协议的 URL 类似于 udp://tracker:port。 Azureus、XBT Client和XBT Tracker支持此协议。 所有值都以网络字节顺序（大端）发送。不要期望数据包具有特定大小。未来的扩展可能会增加数据包的大小。 将n设置为0。 如果在60 * 2 ^ n秒后没有收到响应，则重新发送连接请求并增加n。 如果收到响应，则将 n 重置为 0。 HTTP 与
一文详解RTSP协议：流媒体传输控制协议
最新发布
bjxiaxueliang的CODING技术小馆
02-02 454
RTSP由RFC2326规范，是一种实现实时流媒体传输与播放的控制协议，可用于流媒体的点播和直播场景。 RTSP主要有两个方面的作用：一是用于协商客户端与服务端之间的实时媒体通道。二是在建立媒体通道后，通过RTSP协议定义的控制方法(Method)，实现流媒体的播放、暂停、停止、快进、倒退等控制操作。
UDP Tracker Protocol中文翻译
05-10
BT协议中的UDP Tracker协议规范的全文中文翻译
UDP tracker protocol
Lucy有话讲
01-29 240
留存。。以作参考。。 原文：[url]http://xbtt.sourceforge.net/udp_tracker_protocol.html[/url] UDP tracker protocol Introduction The UDP tracker protocol is a high-performance low-overhead BitTorrent trac...
BitTorrent扩展协议(5)–UDP Tracker Protocol for BitTorrent
mergerly的专栏
12-05 3853
Contents IntroductionOverheadUDP connections / spoofingTime outsExamplesUDP tracker protocolExisting implementationsIPv6ExtensionsReferences and Footnotes Introduction To discover other
BitTorrent-Tracker-Protocol:从跟踪器（UDP）获取种子信息
05-09
BitTorrent跟踪器协议 状态：不完整（排序） 从跟踪器（UDP）获取种子信息 为了发现群中的其他对等方，客户端将UDP数据包发送给跟踪器，以宣布其存在。 请求和响应都很短。 如果使用TCP，则必须打开和关闭连接，这会带来额外的开销。 因此，使用UDP（无连接协议）来避免此类开销。
BT协议详解与实现(c++ 完整版)
06-14
1. **Tracker通信模块**：实现与Tracker服务器的HTTP/UDP交互，获取其他客户端的网络信息。 2. **Metainfo解析模块**：读取.torrent文件，提取所需信息。 3. **TCP连接模块**：建立并维护与其它客户端的P2P连接。 4....
基于Linux的P2P视频点播系统的设计与实现 (2011年)
04-27
超级节点启动时需向Tracker服务器注册，并与Tracker服务器交互信息。这部分功能由Tracker UDP Client类完成。此外，超级节点还接收发布服务器发布的视频信息，这部分功能由CSTCP Server类实现。超级节点与普通节点...
Http协议的基础认识
wxlbzy99的博客
05-15 232
http协议是什么 http协议是一中超文本类型并且应用广泛的应用层协议，是网页端和服务器进行交互的媒介（浏览器向服务器发送http请求，服务器），也是程序员打交道最多的协议，并且http在传输层是基于TCP实现的，应用层协议就是把传输的字节流赋予一定的含义，例如把一串数据转化为图片格式，视频格式的可视化文件 现有的http有三个版本 http1（基于tcp实现，也是应用最为广泛的协议） http2（相比于版本1增加了安全性能） http3（基于udp主要是提高效率） 补充：在已知的网络层
Extended BitTorrent Client and Tracker-开源
05-03
BitTorrent是一种分布式文件分发协议，它通过网络中的多个参与者（称为对等方或peers）共享文件，显著减轻了服务器的压力。"Extended BitTorrent Client and Tracker" 是一个专为这个协议设计的开源项目，旨在提供更...
Tracker HTTP协议和Tracker UDP协议
wenxinfly的专栏
02-07 8891
 一、Tracker HTTP协议   Tracker是一种HTTP/HTTPS服务， 它是专门为BitTorrent而设计的，和普通HTTP协议一样，采取请求和应答方式。BT客户端得到有关下载文件的各种动态信息，最主要的是下载同一文件的其他下载者。.Tracker使用CGI方法提出申请，如"param1=value & param2 = val"注意：所有不在0-9、a-z,、A-Z,和 $
UDP打洞
weixin_30363981的博客
11-06 112
UDP打洞 维基百科，自由的百科全书 跳转到： 导航, 搜索 在计算机科学中，UDP打洞指的是一种普遍使用的NAT穿越技术。 [编辑] 描述 通过UDP打洞实现NAT穿越是一种在处于使用了NAT的私有网络中的Internet主机之间建立双向UDP连接的方法。由于NAT的行为是非标准化的，因此它并不能应用于所有类型的NAT。 其基本思想是这样的：让位于NA...
BitTorrent 协议规范（BT协议集合）三
11-14 924
Bittorrent udp-tracker protocol extension Contents introduction connecting Client sends packet: Server replies with packet: announcing Client sends packet: Server replies with packet: scraping Client
[libtorrent] tracker 逻辑及源码解析(调试)
就是那个党伟
12-22 785
操作系统：win10 开发工具：VS2019 (libtorrent 源码的开发环境搭建可以参考：[libtorrent] windows搭建 libtorrent 开发环境_二七-CSDN博客) (ubuntu BitTorrent 搭建可以参考：[Tracker] linux 搭建 BitTorrent_二七-CSDN博客) ...
BT通信
zcf396720的专栏
03-21 1016
BT通信协议举例分析       现在的很多BT下载都采用了DHT网络，这样进行BT下载就不需要中心服务器了。本文针对的是需要中心服务器的BT下载。   小弟我最近正在研究BT通信协议，网上的资料很全，但是不是那事详细和完整，因此，整理下来，一方面他日用到拿来看看，另一方面，希望对正在研究BT通信协议的有点帮助。若有不正之处，请指正。 1.        BT协议的工作过程        
UDP 广播收不到回包是什么情况
weixin_35756130的博客
01-07 826
UDP 广播收不到回包的情况可能是由于网络设置或者网络环境造成的。具体原因可能有以下几种： 广播地址被禁用：部分网络环境会禁用广播地址，这样就无法收到广播消息。 网络配置错误：如果网络设置不正确，可能会导致无法收到广播消息。 网络故障：网络故障可能会导致无法收到广播消息。 广播被阻挡：有些网络环境会对广播进行阻挡，导致无法收到广播消息。 如果遇到这种情况，建议检查网络设置是否正确，并确...
疑难杂症系列-网络UDP广播包发不出去或接收不到问题
热门推荐
Hogwarts
02-26 1万+
网络UDP广播包发不出去或接收不到问题发生背景症状代码原因禁用虚拟网卡的操作方式 发生背景 使用电脑作为client端，局域网内发送广播。手机作为server端，监听65532端口。 症状 单播情况下（指定Server端Ip地址），手机可以监听到数据； 广播情况下（Ip=255.255.255.255）,手机监听不到数据。 代码 public class UDPClient { publi...
UDP无法收到问题
liuyuinsdu的专栏
02-28 2619
场景描述： 1 环境安装的是宝塔，防火墙开启，TCP能连接到端口，能收到发送过来的数据，UDP能连接，能发送，但是收不到数据包 解决办法： 关闭防火墙 CentOS 7.0默认使用的是firewall作为防火墙 查看防火墙状态 firewall-cmd --state 停止firewall systemctl stop firewalld.service 禁止firewall开机启动 systemctl disable firewalld.service ...
RedView GPS Tracker与服务器通信协议详解
这份协议涵盖了GPS追踪设备如何与服务器进行数据交换，包括登录、命令格式规范、命令列表以及详细的命令解释，涉及位置信息和设备配置等多个方面。 GPS数据在现代科技中扮演着至关重要的角色，特别是在导航、定位、...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值