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

最新推荐文章于 2022-06-06 10:32:18 发布
最新推荐文章于 2022-06-06 10:32:18 发布
阅读量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
关注
专栏目录
【bt】UDP tracker protocol
突围
05-28 557
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 570
RTSP由RFC2326规范，是一种实现实时流媒体传输与播放的控制协议，可用于流媒体的点播和直播场景。 RTSP主要有两个方面的作用：一是用于协商客户端与服务端之间的实时媒体通道。二是在建立媒体通道后，通过RTSP协议定义的控制方法(Method)，实现流媒体的播放、暂停、停止、快进、倒退等控制操作。
UDP tracker protocol
Lucy有话讲
01-29 248
留存。。以作参考。。 原文：[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 3870
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 265
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 8972
 一、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 131
UDP打洞 维基百科，自由的百科全书 跳转到： 导航, 搜索 在计算机科学中，UDP打洞指的是一种普遍使用的NAT穿越技术。 [编辑] 描述 通过UDP打洞实现NAT穿越是一种在处于使用了NAT的私有网络中的Internet主机之间建立双向UDP连接的方法。由于NAT的行为是非标准化的，因此它并不能应用于所有类型的NAT。 其基本思想是这样的：让位于NA...
BitTorrent 协议规范（BT协议集合）三
11-14 938
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 831
操作系统：win10 开发工具：VS2019 (libtorrent 源码的开发环境搭建可以参考：[libtorrent] windows搭建 libtorrent 开发环境_二七-CSDN博客) (ubuntu BitTorrent 搭建可以参考：[Tracker] linux 搭建 BitTorrent_二七-CSDN博客) ...
tinyos学习笔记9--TestRPL（UDP）例程分析
霜月孤鸟&RTEMS&TinyOS
12-29 1493
1 TestRPL例程的功能 Implementation of the RadioCountToLedsapplication. RadioCountToLeds maintains a 4Hz counter, broadcasting its valuein an AM packet every time it gets updated. A RadioCountToLeds node t
【Trex】服务器端命令中文翻译
analylx2047的博客
06-06 1202
trex 服务器端命令中文版
网络编程4 udp协议传输
qq_35975827的博客
12-04 126
upd收发数据的接口 ssize_t recvfrom(int sockfd, void* buff, size_t nbytes, int flags, struct sockaddr* from, socklen_t* addrlen) ssize_t sendto(int sockfd, const void* buff, size_t nbytes, int flags, const s...
UDP监听工具使用
uuxia的专栏
11-15 7777
UDP监听工具使用说明工作模式：UDP 本地端口：18899 目的IP：根据本机IP填写，基本规则是本机IP最后一位改成255，（192.168.x.255） 目标端口：默认18899 发送接收方式：信息模式工具下载
UDP Tracker协议详解：中文翻译与低延迟优化
UDP Tracker Protocol是BitTorrent协议中的一种关键组件，用于在分布式P2P网络中定位共享相同资源的其他节点。客户端通过发送包含特定信息的UDP数据包来通告Tracker服务器，这些信息包括info_hash（资源的哈希值）、...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值