test.java

这是一个基于java编写的torrent的P2P源码

							}
						}catch( Throwable e ){
							
							e.printStackTrace();
						}
					}else if ( command == 'q' ){
						
						try{
							int	index = Integer.parseInt( rhs );
					
							dht = dhts[index];
	
							dht.destroy();
							
						}catch( Throwable e ){
							
							e.printStackTrace();
						}
					}else if ( command == 't' ){
						
						try{
							int	index = Integer.parseInt( rhs );
					
							dht = dhts[index];
	
							stats_before = dht.getTransport().getStats().snapshot();
							
							((DHTTransportUDPImpl)transports[index]).testInstanceIDChange();
							
							dht.integrate( true );
	
						}catch( Throwable e ){
							
							e.printStackTrace();
						}
					}else if ( command == 's' ){
						
						try{
							int	index = Integer.parseInt( rhs );
					
							dht = dhts[index];
	
							stats_before = dht.getTransport().getStats().snapshot();
							
							((DHTTransportUDPImpl)transports[index]).testTransportIDChange();
							
						}catch( Throwable e ){
							
							e.printStackTrace();
						}
					}else if ( command == 'a' ){
						
						int	net = DEFAULT_NETWORK;
						
						try{
							net = Integer.parseInt( rhs );
							
						}catch( Throwable e ){
							
						}
						
						createDHT( dhts, transports, net, num_dhts++ );
						
						dht	= dhts[num_dhts-1];
						
						stats_before = transports[num_dhts-1].getStats().snapshot();
						
						ByteArrayOutputStream	baos = new ByteArrayOutputStream();
						
						DataOutputStream	daos = new DataOutputStream( baos );
						
						List	ok_t = new ArrayList();
						
						for (int i=0;i<num_dhts-1;i++){
							
							DHTTransport	t = transports[i];
							
							if ( t.getNetwork() == net ){
								
								ok_t.add( t );
							}
						}
						
						if ( ok_t.size() > 0 ){
							
							DHTTransport	r_t = (DHTTransport)ok_t.get((int)(Math.random()*(ok_t.size()-1)));
						
							r_t.getLocalContact().exportContact( daos );
							
							daos.close();
						
							transports[num_dhts-1].importContact( new DataInputStream( new ByteArrayInputStream( baos.toByteArray())));
						}else{
							
							System.out.println( "No comaptible networks found" );
							
						}
						
						dht.integrate( true );
	
						dht.print();
						
					}else if ( command == 'r' ){
						
						System.out.println( "read - dht0 -> dht1" );
											
						byte[]	res = 
							dhts[0].getTransport().readTransfer(
									new DHTTransportProgressListener()
									{
										public void
										reportSize(
											long	size )
										{
											System.out.println( "   read size: " + size );
										}
										
										public void
										reportActivity(
											String	str )
										{
											System.out.println( "   read act: " + str );
										}
										
										public void
										reportCompleteness(
											int		percent )
										{
											System.out.println( "   read %: " + percent );
										}
									},
									dhts[1].getTransport().getLocalContact(),
									th_key,
									new byte[]{1,2,3,4},
									30000 );
		
						System.out.println( "res = " + res );
						
					}else if ( command == 'w' ){
						
						System.out.println( "write - dht0 -> dht1" );
											
						dhts[0].getTransport().writeTransfer(
									new DHTTransportProgressListener()
									{
										public void
										reportSize(
											long	size )
										{
											System.out.println( "   write size: " + size );
										}
										
										public void
										reportActivity(
											String	str )
										{
											System.out.println( "   write act: " + str );
										}
										
										public void
										reportCompleteness(
											int		percent )
										{
											System.out.println( "   write %: " + percent );
										}
									},
									dhts[1].getTransport().getLocalContact(),
									th_key,
									new byte[]{1,2,3,4},
									new byte[1000],
									60000 );
		
					}else if ( command == 'c' ){
						
						System.out.println( "call - dht0 <-> dht1" );
											
						byte[] res = 
							dhts[0].getTransport().writeReadTransfer(
									new DHTTransportProgressListener()
									{
										public void
										reportSize(
											long	size )
										{
											System.out.println( "   readWrite size: " + size );
										}
										
										public void
										reportActivity(
											String	str )
										{
											System.out.println( "   readWrite act: " + str );
										}
										
										public void
										reportCompleteness(
											int		percent )
										{
											System.out.println( "   readWrite %: " + percent );
										}
									},
									dhts[1].getTransport().getLocalContact(),
									th_key,
									new byte[1000],
									60000 );
						
						System.out.println( "    reply: len = " + res.length );
						
					}else if ( command == 'b' ){
						
						if ( rhs.equals("1")){
							
							System.out.println( "rendezvous bind: dht2 -> rdv dht1" );
						
							DHTNATPuncherImpl	puncher = (DHTNATPuncherImpl)dhts[2].getNATPuncher();
						
							puncher.setRendezvous( 
								dhts[2].getTransport().getLocalContact(),
								dhts[1].getTransport().getLocalContact());

						}else if ( rhs.equals("2" )){
							
							System.out.println( "rendezvous punch: dht0 -> rdv dht2" );
							
							DHTNATPuncherImpl	puncher = (DHTNATPuncherImpl)dhts[0].getNATPuncher();

							Map	originator_data = new HashMap();
							
							originator_data.put( "hello", "mum" );
							
							Map client_data = puncher.punch( "Test", dhts[2].getTransport().getLocalContact(), null, originator_data);
							
							System.out.println( "   punch client data: " + client_data );
						}
					}else if ( command == 'k' ){
						
						int	sp = rhs.indexOf(' ');
						
						String	key_block;
						boolean	add;
						
						if ( sp == -1 ){
							key_block = rhs;
							add	= true;
						}else{
							key_block = rhs.substring(0,sp);
							add = false;
						}
						
						String	mod = "123";
						String	exp = "567";
						
						
						KeyFactory key_factory = KeyFactory.getInstance("RSA");
						
						RSAPrivateKeySpec 	private_key_spec = 
							new RSAPrivateKeySpec( new BigInteger(mod,16), new BigInteger(exp,16));
				
						RSAPrivateKey	key = (RSAPrivateKey)key_factory.generatePrivate( private_key_spec );
						
						byte[]	req = new byte[ 8 + 20 ];
						
						req[0]	= (byte)(add?0x01:0x00);
						
						int	time = (int)(System.currentTimeMillis()/1000);
						
						req[4] = (byte)(time>>24);
						req[5] = (byte)(time>>16);
						req[6] = (byte)(time>>8);
						req[7] = (byte)(time);
						
						System.arraycopy( new SHA1Simple().calculateHash(key_block.getBytes()), 0, req, 8, 20 );
						
						Signature	sig = Signature.getInstance("MD5withRSA" );
						
						sig.initSign( key );
						
						sig.update( req );
						
						dhts[1].getTransport().getLocalContact().sendKeyBlock(
							new DHTTransportReplyHandlerAdapter()
							{
								public void
								keyBlockReply(
									DHTTransportContact 	_contact )
								{
									System.out.println( "key block sent ok" );
								}
								
								public void
								failed(
									DHTTransportContact 	contact,
									Throwable				error )
								{
									System.out.println( "key block failed" );
									
									error.printStackTrace();
								}
							},
							req,
							sig.sign());
						
					}else{
						
						usage();
					}
									
					if ( stats_before != null ){
						
						DHTTransportStats	stats_after = dht.getTransport().getStats().snapshot();
	
						System.out.println( "before:" + stats_before.getString());
						System.out.println( "after:" + stats_after.getString());
					}
				}catch( Throwable e ){
					
					e.printStackTrace();
				}
			}
		}catch( Throwable e ){
			
			e.printStackTrace();
		}
	}
	
	protected void
	createDHT(
		DHT[]			dhts,
		DHTTransport[]	transports,
		int				network,
		int				i )
	
		throws DHTTransportException
	{
		DHTTransport	transport;
		
		if ( udp_protocol ){
			
			Integer	next_port = (Integer)port_map.get( new Integer( network ));
			
			if ( next_port == null ){
				
				next_port = new Integer(0);
				
			}else{
				
				next_port = new Integer( next_port.intValue() + 1 );
			}
			
			port_map.put( new Integer( network ), next_port );
			
			byte protocol = network==0?DHTTransportUDP.PROTOCOL_VERSION_MAIN:DHTTransportUDP.PROTOCOL_VERSION_CVS; 
			
			// byte protocol = i%2==0?DHTTransportUDP.PROTOCOL_VERSION_MAIN:DHTTransportUDP.PROTOCOL_VERSION_CVS; 

			
			transport = DHTTransportFactory.createUDP( 
							protocol,
							network, 
							null, 
							null, 
							6890 + next_port.intValue(), 
							5, 
							3, 
							udp_timeout, 
							50, 
							25, 
							false, 
							false,
							logger );
			
		}else{
			
			transport = DHTTransportFactory.createLoopback(ID_BYTES);
		}
		
		transport.registerTransferHandler(
			th_key,
			new DHTTransportTransferHandler()
			{
				public String
				getName()
				{
					return( "test" );
				}
				
				public byte[]
				handleRead(
					DHTTransportContact	originator,
					byte[]				key )
				{
					byte[]	data = new byte[1000];
					
					System.out.println("handle read -> length = " + data.length );
					
					return( data );
				}
				
				public byte[]
				handleWrite(
					DHTTransportContact	originator,
					byte[]				key,
					byte[]				value )
				{
					byte[]	reply = null;
					
					if ( value.length == 1000 ){
						
						reply = new byte[4];
					}
					
					System.out.println("handle write -> length = " + value.length +", reply = " + reply );
					
					return( reply );
				}
			});
		
		/*
		HashWrapper	id = new HashWrapper( transport.getLocalContact().getID());
		
		if ( check.get(id) != null ){
			
			System.out.println( "Duplicate ID - aborting" );
			
			return;
		}
		
		check.put(id,"");
		*/
		
		DHTStorageAdapter	storage_adapter = new DHTPluginStorageManager( network, logger, new File( "C:\\temp\\dht\\" + i));

		DHT	dht = DHTFactory.create( transport, dht_props, storage_adapter, this, logger );
		
		dhts[i]	= dht;					

		transports[i] = transport;
	}
	
	/*
	public DHTStorageKey
	keyCreated(
		HashWrapper		key,
		boolean			local )
	{
		System.out.println( "key created" );
		
		return( 
				new DHTStorageKey()
				{
					public byte
					getDiversificationType()
					{
						return( DHT.DT_NONE );
					}
					public void
					serialiseStats(
						DataOutputStream		os )
					
						throws IOException
					{	
						os.writeInt( 45 );
					}
				});
	}
	
	public void
	keyDeleted(
		DHTStorageKey		key )
	{
		System.out.println( "key deleted" );
	}
	
	public void
	keyRead(
		DHTStorageKey			adapter_key,
		DHTTransportContact		contact )
	{
		System.out.println( "value read" );
	}
	
	public void
	valueAdded(
		DHTStorageKey		key,
		DHTTransportValue	value )
	{
		System.out.println( "value added" );
	}
	
	public void
	valueUpdated(
		DHTStorageKey		key,
		DHTTransportValue	old_value,
		DHTTransportValue	new_value)
	{
		System.out.println( "value updated" );
	}
	
	public void
	valueDeleted(
		DHTStorageKey		key,
		DHTTransportValue	value )
	{
		System.out.println( "value deleted" );
	}
	
	public byte[][]
	getExistingDiversification(
		byte[]			key,
		boolean			put_operation )
	{
		System.out.println( "getExistingDiversification: put = " + put_operation );

		return( new byte[][]{ key });
	}
	
	public byte[][]
	createNewDiversification(
		byte[]			key,
		boolean			put_operation,
		int				diversification_type )
	{
		System.out.println( "createNewDiversification: put = " + put_operation + ", type = " + diversification_type );

		return( new byte[0][] );
	}
	*/
	
	public Map
	getClientData(
		InetSocketAddress	originator,
		Map					originator_data )
	{
		System.out.println( "getClientData - " + originator_data + "/" + originator );

		Map	res = new HashMap();
		
		res.put( "udp_data_port", new Long( 1234 ));
		res.put( "tcp_data_port", new Long( 5678 ));
		
		return( res );
	}
	
	protected static void
	usage()
	{
		System.out.println( "syntax: [p g] <key>[=<value>]" );
	}
}