1 /*
2  * File    : PeerManagerImpl.java
3  * Created : 28-Dec-2003
4  * By      : parg
5  *
6  * Azureus - a Java Bittorrent client
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details ( see the LICENSE file ).
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  */
22 
23 package org.gudy.azureus2.pluginsimpl.local.peers;
24 
25 /**
26  * @author parg
27  *
28  */
29 
30 import java.util.*;
31 
32 import org.gudy.azureus2.core3.disk.DiskManagerFileInfo;
33 import org.gudy.azureus2.core3.disk.DiskManagerListener;
34 import org.gudy.azureus2.core3.disk.DiskManagerPiece;
35 import org.gudy.azureus2.core3.disk.DiskManagerReadRequest;
36 import org.gudy.azureus2.core3.peer.*;
37 import org.gudy.azureus2.core3.util.AEMonitor;
38 import org.gudy.azureus2.core3.util.Debug;
39 import org.gudy.azureus2.core3.util.TorrentUtils;
40 import org.gudy.azureus2.plugins.disk.DiskManager;
41 import org.gudy.azureus2.plugins.download.*;
42 import org.gudy.azureus2.plugins.peers.*;
43 import org.gudy.azureus2.plugins.torrent.Torrent;
44 import org.gudy.azureus2.plugins.utils.PooledByteBuffer;
45 import org.gudy.azureus2.pluginsimpl.local.PluginCoreUtils;
46 import org.gudy.azureus2.pluginsimpl.local.disk.DiskManagerImpl;
47 import org.gudy.azureus2.pluginsimpl.local.download.DownloadManagerImpl;
48 import org.gudy.azureus2.pluginsimpl.local.utils.PooledByteBufferImpl;
49 
50 import com.aelitis.azureus.core.networkmanager.NetworkManager;
51 import com.aelitis.azureus.core.peermanager.peerdb.PeerItem;
52 
53 public class
54 PeerManagerImpl
55 	implements PeerManager
56 {
57 	private static final String	PEPEER_DATA_KEY	= PeerManagerImpl.class.getName();
58 
59 	protected PEPeerManager	manager;
60 
61 	protected static AEMonitor	pm_map_mon	= new AEMonitor( "PeerManager:Map" );
62 
63 	public static PeerManagerImpl
getPeerManager( PEPeerManager _manager )64 	getPeerManager(
65 		PEPeerManager	_manager )
66 	{
67 		try{
68 			pm_map_mon.enter();
69 
70 			PeerManagerImpl	res = (PeerManagerImpl)_manager.getData( "PluginPeerManager" );
71 
72 			if ( res == null ){
73 
74 				res = new PeerManagerImpl( _manager );
75 
76 				_manager.setData( "PluginPeerManager", res );
77 			}
78 
79 			return( res );
80 		}finally{
81 
82 			pm_map_mon.exit();
83 		}
84 	}
85 
86 	private Map		foreign_map		= new HashMap();
87 
88 	private Map<PeerManagerListener,PEPeerManagerListener>	listener_map1 	= new HashMap<PeerManagerListener,PEPeerManagerListener>();
89 	private Map<PeerManagerListener2,CoreListener>	listener_map2 	= new HashMap<PeerManagerListener2,CoreListener>();
90 
91 	protected AEMonitor	this_mon	= new AEMonitor( "PeerManager" );
92 
93 	private final DiskManagerPiece[]	dm_pieces;
94 	private final PEPiece[]				pe_pieces;
95 	private pieceFacade[]				piece_facades;
96 
97 	private boolean	destroyed;
98 
99 	protected
PeerManagerImpl( PEPeerManager _manager )100 	PeerManagerImpl(
101 		PEPeerManager	_manager )
102 	{
103 		manager	= _manager;
104 
105 		dm_pieces	= _manager.getDiskManager().getPieces();
106 		pe_pieces	= _manager.getPieces();
107 
108 		manager.addListener(
109 			new PEPeerManagerListenerAdapter()
110 			{
111 				 public void
112 				 peerRemoved(
113 					PEPeerManager 	manager,
114 					PEPeer 			peer )
115 				 {
116 					 PeerImpl	dele = getPeerForPEPeer( peer );
117 
118 					 if ( dele != null ){
119 
120 						 dele.closed();
121 					 }
122 				 }
123 
124 				 public void
125 				 destroyed()
126 				 {
127 					 synchronized( foreign_map ){
128 
129 						 destroyed	= true;
130 
131 						 Iterator it = foreign_map.values().iterator();
132 
133 						 while( it.hasNext()){
134 
135 							 try{
136 								 ((PeerForeignDelegate)it.next()).stop();
137 
138 							 }catch( Throwable e ){
139 
140 								 Debug.printStackTrace( e );
141 							 }
142 						 }
143 					 }
144 				 }
145 			});
146 	}
147 
148 	public PEPeerManager
getDelegate()149 	getDelegate()
150 	{
151 		return( manager );
152 	}
153 
154 	public DiskManager
getDiskManager()155 	getDiskManager()
156 	{
157 		return( new DiskManagerImpl( manager.getDiskManager()));
158 	}
159 
160 	public PeerManagerStats
getStats()161 	getStats()
162 	{
163 		return(new PeerManagerStatsImpl( manager));
164 	}
165 
166 	public boolean
isSeeding()167 	isSeeding()
168 	{
169 		// this is the wrong thing to check for seeding..
170 		return( manager.getDiskManager().getRemainingExcludingDND() == 0 ); //yuck
171 	}
172 
173 	public boolean
isSuperSeeding()174 	isSuperSeeding()
175 	{
176 		return( manager.isSuperSeedMode());
177 	}
178 
179 	public Download
getDownload()180 	getDownload()
181 
182 		throws DownloadException
183 	{
184 		return( DownloadManagerImpl.getDownloadStatic( manager.getDiskManager().getTorrent()));
185 	}
186 
187 	public Piece[]
getPieces()188 	getPieces()
189 	{
190 		if ( piece_facades == null ){
191 
192 			pieceFacade[]	pf = new pieceFacade[manager.getDiskManager().getNbPieces()];
193 
194 			for (int i=0;i<pf.length;i++){
195 
196 				pf[i] = new pieceFacade(i);
197 			}
198 
199 			piece_facades	= pf;
200 		}
201 
202 		return( piece_facades );
203 	}
204 
205 	public PeerStats
createPeerStats( Peer peer )206 	createPeerStats(
207 		Peer	peer )
208 	{
209 		PEPeer	delegate = mapForeignPeer( peer );
210 
211 		return( new PeerStatsImpl( this, peer, manager.createPeerStats( delegate )));
212 	}
213 
214 
215 	public void
requestComplete( PeerReadRequest request, PooledByteBuffer data, Peer sender)216 	requestComplete(
217 		PeerReadRequest		request,
218 		PooledByteBuffer 	data,
219 		Peer 				sender)
220 	{
221 		manager.writeBlock(
222 			request.getPieceNumber(),
223 			request.getOffset(),
224 			((PooledByteBufferImpl)data).getBuffer(),
225 			mapForeignPeer( sender ),
226             false);
227 
228 		PeerForeignDelegate	delegate = lookupForeignPeer( sender );
229 
230 		if ( delegate != null ){
231 
232 			delegate.dataReceived();
233 		}
234 	}
235 
236 	public void
requestCancelled( PeerReadRequest request, Peer sender )237 	requestCancelled(
238 		PeerReadRequest		request,
239 		Peer				sender )
240 	{
241 		manager.requestCanceled((DiskManagerReadRequest)request );
242 	}
243 
244 	protected int
getPartitionID()245 	getPartitionID()
246 	{
247 		return( manager.getPartitionID());
248 	}
249 
250 		// these are foreign peers
251 
252 	public void
addPeer( Peer peer )253 	addPeer(
254 		Peer		peer )
255 	{
256 			// no private check here, we come through here for webseeds for example
257 
258 		manager.addPeer(mapForeignPeer( peer ));
259 	}
260 
261 	public void
removePeer( Peer peer )262 	removePeer(
263 		Peer		peer )
264 	{
265 		manager.removePeer(mapForeignPeer( peer ));
266 	}
267 
268 	protected void
removePeer( Peer peer, String reason )269 	removePeer(
270 		Peer		peer,
271 		String		reason )
272 	{
273 		manager.removePeer(mapForeignPeer( peer ), reason );
274 	}
275 
276 	public void
addPeer( String ip_address, int tcp_port )277 	addPeer(
278 		String 	ip_address,
279 		int 	tcp_port )
280 	{
281 		addPeer(
282 			ip_address,
283 			tcp_port,
284 			0,
285 			NetworkManager.getCryptoRequired( NetworkManager.CRYPTO_OVERRIDE_NONE ));
286 	}
287 
288 	public void
addPeer( String ip_address, int tcp_port, boolean use_crypto )289 	addPeer(
290 		String 		ip_address,
291 		int 		tcp_port,
292 		boolean 	use_crypto )
293 	{
294 		addPeer( ip_address, tcp_port, 0, use_crypto );
295 	}
296 
297 	public void
addPeer( String ip_address, int tcp_port, int udp_port, boolean use_crypto )298 	addPeer(
299 		String 		ip_address,
300 		int 		tcp_port,
301 		int			udp_port,
302 		boolean 	use_crypto )
303 	{
304 		addPeer( ip_address, tcp_port, udp_port, use_crypto, null );
305 	}
306 
307 	public void
addPeer( String ip_address, int tcp_port, int udp_port, boolean use_crypto, Map user_data )308 	addPeer(
309 		String 		ip_address,
310 		int 		tcp_port,
311 		int			udp_port,
312 		boolean 	use_crypto,
313 		Map			user_data )
314 	{
315 		checkIfPrivate();
316 
317 		if ( pluginPeerSourceEnabled()){
318 
319 			manager.addPeer( ip_address, tcp_port, udp_port, use_crypto, user_data );
320 		}
321 	}
322 
323 	public void
peerDiscovered( String peer_source, String ip_address, int tcp_port, int udp_port, boolean use_crypto )324 	peerDiscovered(
325 		String		peer_source,
326 		String 		ip_address,
327 		int 		tcp_port,
328 		int			udp_port,
329 		boolean 	use_crypto )
330 	{
331 		checkIfPrivate();
332 
333 		if ( manager.isPeerSourceEnabled( peer_source )){
334 
335 			manager.peerDiscovered( peer_source, ip_address, tcp_port, udp_port, use_crypto );
336 		}
337 	}
338 
339 	protected boolean
pluginPeerSourceEnabled()340 	pluginPeerSourceEnabled()
341 	{
342 		if ( manager.isPeerSourceEnabled( PEPeerSource.PS_PLUGIN )){
343 
344 			return( true );
345 
346 		}else{
347 
348 			Debug.out( "Plugin peer source disabled for " + manager.getDisplayName());
349 
350 			return( false );
351 		}
352 	}
353 
354 	protected void
checkIfPrivate()355 	checkIfPrivate()
356 	{
357 		Download dl;
358 
359 		try{
360 			dl = getDownload();
361 
362 		}catch( Throwable e ){
363 
364 			// if this didn't work then nothing much else will so just fall through
365 
366 			return;
367 		}
368 
369 		Torrent t = dl.getTorrent();
370 
371 		if ( t != null ){
372 
373 			if (  TorrentUtils.isReallyPrivate( PluginCoreUtils.unwrap( t ))){
374 
375 				throw( new RuntimeException( "Torrent is private, peer addition not permitted" ));
376 			}
377 		}
378 	}
379 
380 	public Peer[]
getPeers()381 	getPeers()
382 	{
383 		List	l = manager.getPeers();
384 
385 		Peer[]	res= new Peer[l.size()];
386 
387 			// this is all a bit shagged as we should maintain the PEPeer -> Peer link rather
388 			// than continually creating new PeerImpls...
389 
390 		for (int i=0;i<res.length;i++){
391 
392 			res[i] = getPeerForPEPeer((PEPeer)l.get(i));
393 		}
394 
395 		return( res );
396 	}
397 
398 	public Peer[]
getPeers( String address )399 	getPeers(
400 		String		address )
401 	{
402 		List	l = manager.getPeers( address );
403 
404 		Peer[]	res= new Peer[l.size()];
405 
406 			// this is all a bit shagged as we should maintain the PEPeer -> Peer link rather
407 			// than continually creating new PeerImpls...
408 
409 		for (int i=0;i<res.length;i++){
410 
411 			res[i] = getPeerForPEPeer((PEPeer)l.get(i));
412 		}
413 
414 		return( res );
415 	}
416 
417 
418 	public PeerDescriptor[]
getPendingPeers()419   	getPendingPeers()
420   	{
421   		return( manager.getPendingPeers());
422   	}
423 
424 	public PeerDescriptor[]
getPendingPeers( String address )425 	getPendingPeers(
426 		String		address )
427 	{
428 		return( manager.getPendingPeers( address ));
429 	}
430 
431 	public long
getTimeSinceConnectionEstablished( Peer peer )432 	getTimeSinceConnectionEstablished(
433 		Peer		peer )
434 	{
435 		if ( peer instanceof PeerImpl ){
436 
437 			return(((PeerImpl)peer).getDelegate().getTimeSinceConnectionEstablished());
438 		}else{
439 			PeerForeignDelegate	delegate = lookupForeignPeer( peer );
440 
441 			if ( delegate != null ){
442 
443 				return( delegate.getTimeSinceConnectionEstablished());
444 
445 			}else{
446 
447 				return( 0 );
448 			}
449 		}
450 	}
451 	public PEPeer
mapForeignPeer( Peer _foreign )452 	mapForeignPeer(
453 		Peer	_foreign )
454 	{
455 		if ( _foreign instanceof PeerImpl ){
456 
457 			return(((PeerImpl)_foreign).getDelegate());
458 		}
459 
460 		synchronized( foreign_map ){
461 
462 			PEPeer	local = (PEPeer)foreign_map.get( _foreign );
463 
464 			if ( local != null && local.isClosed()){
465 
466 				foreign_map.remove( _foreign );
467 
468 				local = null;
469 			}
470 
471 			if( local == null ){
472 
473 				if ( destroyed ){
474 
475 					Debug.out( "Peer added to destroyed peer manager" );
476 
477 					return( null );
478 				}
479 
480 				local 	= new PeerForeignDelegate( this, _foreign );
481 
482 				_foreign.setUserData( PeerManagerImpl.class, local );
483 
484 				foreign_map.put( _foreign, local );
485 			}
486 
487 			return( local );
488 		}
489 	}
490 
491 	protected PeerForeignDelegate
lookupForeignPeer( Peer _foreign )492 	lookupForeignPeer(
493 		Peer	_foreign )
494 	{
495 		return((PeerForeignDelegate)_foreign.getUserData( PeerManagerImpl.class ));
496 	}
497 
498 	public List
mapForeignPeers( Peer[] _foreigns )499 	mapForeignPeers(
500 		Peer[]	_foreigns )
501 	{
502 		List	res = new ArrayList();
503 
504 		for (int i=0;i<_foreigns.length;i++){
505 
506 			PEPeer	local = mapForeignPeer( _foreigns[i]);
507 
508 				// could already be there if torrent contains two identical seeds (for whatever reason)
509 
510 			if ( !res.contains( local )){
511 
512 				res.add( local );
513 			}
514 		}
515 
516 		return( res );
517 	}
518 
519 	public static PeerImpl
getPeerForPEPeer( PEPeer pe_peer )520 	getPeerForPEPeer(
521 		PEPeer	pe_peer )
522 	{
523 		PeerImpl	peer = (PeerImpl)pe_peer.getData( PEPEER_DATA_KEY );
524 
525 		if ( peer == null ){
526 
527 			peer = new PeerImpl( pe_peer );
528 
529 			pe_peer.setData( PEPEER_DATA_KEY, peer );
530 		}
531 
532 		return( peer );
533 	}
534 
535 	public int
getUploadRateLimitBytesPerSecond()536 	getUploadRateLimitBytesPerSecond()
537 	{
538 		return( manager.getUploadRateLimitBytesPerSecond());
539 	}
540 
541 	public int
getDownloadRateLimitBytesPerSecond()542 	getDownloadRateLimitBytesPerSecond()
543 	{
544 		return( manager.getDownloadRateLimitBytesPerSecond());
545 	}
546 
547 	public void
addListener( final PeerManagerListener l )548 	addListener(
549 		final PeerManagerListener	l )
550 	{
551 		try{
552 			this_mon.enter();
553 
554 			final Map	peer_map = new HashMap();
555 
556 			PEPeerManagerListener core_listener = new PEPeerManagerListenerAdapter() {
557 				public void peerAdded( PEPeerManager manager, PEPeer peer ) {
558 					PeerImpl pi = getPeerForPEPeer( peer );
559 					peer_map.put( peer, pi );
560 					l.peerAdded( PeerManagerImpl.this, pi );
561 				}
562 
563 				public void peerRemoved( PEPeerManager manager, PEPeer peer ) {
564 					PeerImpl  pi = (PeerImpl)peer_map.remove( peer );
565 
566 					if ( pi == null ){
567 						// somewhat inconsistently we get told here about the removal of
568 						// peers that never connected (and weren't added)
569 						// Debug.out( "PeerManager: peer not found");
570 					}
571 					else{
572 						l.peerRemoved( PeerManagerImpl.this, pi );
573 					}
574 				}
575 			};
576 
577 			listener_map1.put( l, core_listener );
578 
579 			manager.addListener( core_listener );
580 		}finally{
581 
582 			this_mon.exit();
583 		}
584 	}
585 
586 	public void
removeListener( PeerManagerListener l )587 	removeListener(
588 		PeerManagerListener	l )
589 	{
590 		try{
591 			this_mon.enter();
592 
593 			PEPeerManagerListener core_listener	= (PEPeerManagerListener)listener_map1.remove( l );
594 
595 			if ( core_listener != null ){
596 
597 				manager.removeListener( core_listener );
598 			}
599 
600 		}finally{
601 			this_mon.exit();
602 		}
603 	}
604 
605 	public void
addListener( final PeerManagerListener2 l )606 	addListener(
607 		final PeerManagerListener2	l )
608 	{
609 		try{
610 			this_mon.enter();
611 
612 			CoreListener core_listener = new CoreListener( l );
613 
614 			listener_map2.put( l, core_listener );
615 
616 			manager.addListener( core_listener );
617 
618 			manager.getDiskManager().addListener( core_listener );
619 		}finally{
620 
621 			this_mon.exit();
622 		}
623 	}
624 
625 	public void
removeListener( PeerManagerListener2 l )626 	removeListener(
627 		PeerManagerListener2	l )
628 	{
629 		try{
630 			this_mon.enter();
631 
632 			CoreListener core_listener	= listener_map2.remove( l );
633 
634 			if ( core_listener != null ){
635 
636 				manager.removeListener( core_listener );
637 
638 				manager.getDiskManager().removeListener( core_listener );
639 			}
640 
641 		}finally{
642 
643 			this_mon.exit();
644 		}
645 	}
646 
647 	protected class
648 	pieceFacade
649 		implements Piece
650 	{
651 		private final int	index;
652 
653 		protected
pieceFacade( int _index )654 		pieceFacade(
655 			int		_index )
656 		{
657 			index	= _index;
658 		}
659 
660 		public int
getIndex()661 		getIndex()
662 		{
663 			return( index );
664 		}
665 
666 		public int
getLength()667 		getLength()
668 		{
669 			return( dm_pieces[index].getLength());
670 		}
671 
672 		public boolean
isDone()673 		isDone()
674 		{
675 			return( dm_pieces[index].isDone());
676 		}
677 
678 		public boolean
isNeeded()679 		isNeeded()
680 		{
681 			return( dm_pieces[index].isNeeded());
682 		}
683 
684 		public boolean
isDownloading()685 		isDownloading()
686 		{
687 			return( pe_pieces[index] != null );
688 		}
689 
690 		public boolean
isFullyAllocatable()691 		isFullyAllocatable()
692 		{
693 			if ( pe_pieces[index] != null ){
694 
695 				return( false );
696 			}
697 
698 			return( dm_pieces[index].isInteresting());
699 		}
700 
701 		public int
getAllocatableRequestCount()702 		getAllocatableRequestCount()
703 		{
704 			PEPiece	pe_piece = pe_pieces[index];
705 
706 			if ( pe_piece != null ){
707 
708 				return( pe_piece.getNbUnrequested());
709 			}
710 
711 			if ( dm_pieces[index].isInteresting() ){
712 
713 				return( dm_pieces[index].getNbBlocks());
714 			}
715 
716 			return( 0 );
717 		}
718 
719 		public Peer
getReservedFor()720 		getReservedFor()
721 		{
722 			PEPiece piece = pe_pieces[index];
723 
724 			if ( piece != null ){
725 
726 				String ip = piece.getReservedBy();
727 
728 				if ( ip != null ){
729 
730 					List<PEPeer> peers = manager.getPeers( ip );
731 
732 					if ( peers.size() > 0 ){
733 
734 						return( getPeerForPEPeer( peers.get(0)));
735 					}
736 				}
737 			}
738 
739 			return( null );
740 		}
741 
742 		public void
setReservedFor( Peer peer )743 		setReservedFor(
744 			Peer	peer )
745 		{
746 			PEPiece piece = pe_pieces[index];
747 
748 			PEPeer mapped_peer = mapForeignPeer( peer );
749 
750 			if ( piece != null && mapped_peer != null ){
751 
752 				piece.setReservedBy( peer.getIp());
753 
754 				mapped_peer.addReservedPieceNumber( index );
755 			}
756 		}
757 	}
758 
759 	private class
760 	CoreListener
761 		implements PEPeerManagerListener, DiskManagerListener
762 	{
763 		private PeerManagerListener2		listener;
764 		private Map<PEPeer, Peer>			peer_map = new HashMap<PEPeer, Peer>();
765 
766 		private
CoreListener( PeerManagerListener2 _listener )767 		CoreListener(
768 			PeerManagerListener2		_listener )
769 		{
770 			listener	= _listener;
771 		}
772 
773 		public void
peerAdded( PEPeerManager manager, PEPeer peer )774 		peerAdded(
775 			PEPeerManager manager, PEPeer peer )
776 		{
777 			PeerImpl pi = getPeerForPEPeer( peer );
778 
779 			peer_map.put( peer, pi );
780 
781 			fireEvent(
782 				PeerManagerEvent.ET_PEER_ADDED,
783 				pi,
784 				null,
785 				null );
786 		}
787 
788 		public void
peerRemoved( PEPeerManager manager, PEPeer peer )789 		peerRemoved(
790 			PEPeerManager manager,
791 			PEPeer peer )
792 		{
793 			PeerImpl  pi = (PeerImpl)peer_map.remove( peer );
794 
795 			if ( pi == null ){
796 
797 			}else{
798 
799 				fireEvent(
800 					PeerManagerEvent.ET_PEER_REMOVED,
801 					pi,
802 					null,
803 					null );
804 			}
805 		}
806 
807 		public void
peerDiscovered( PEPeerManager manager, PeerItem peer_item, PEPeer finder )808 		peerDiscovered(
809 			PEPeerManager 	manager,
810 			PeerItem 		peer_item,
811 			PEPeer 			finder )
812 		{
813 			PeerImpl	pi;
814 
815 			if ( finder != null ){
816 
817 				pi = getPeerForPEPeer( finder );
818 
819 				peer_map.put( finder, pi );
820 
821 			}else{
822 
823 				pi = null;
824 			}
825 
826 			fireEvent(
827 				PeerManagerEvent.ET_PEER_DISCOVERED,
828 				pi,
829 				peer_item,
830 				null );
831 		}
832 
833 		public void
pieceAdded( PEPeerManager manager, PEPiece piece, PEPeer for_peer )834 		pieceAdded(
835 			PEPeerManager 	manager,
836 			PEPiece 		piece,
837 			PEPeer 			for_peer )
838 		{
839 			PeerImpl pi = for_peer==null?null:getPeerForPEPeer( for_peer );
840 
841 			fireEvent(
842 					PeerManagerEvent.ET_PIECE_ACTIVATED,
843 					pi,
844 					null,
845 					new pieceFacade( piece.getPieceNumber()));
846 		}
847 
848 		public void
pieceRemoved( PEPeerManager manager, PEPiece piece )849 		pieceRemoved(
850 			PEPeerManager 	manager,
851 			PEPiece 		piece )
852 		{
853 			fireEvent(
854 					PeerManagerEvent.ET_PIECE_DEACTIVATED,
855 					null,
856 					null,
857 					new pieceFacade( piece.getPieceNumber()));
858 		}
859 
860 		public void
peerSentBadData( PEPeerManager manager, PEPeer peer, int pieceNumber)861 		peerSentBadData(
862 			PEPeerManager 	manager,
863 			PEPeer 			peer,
864 			int 			pieceNumber)
865 		{
866 			PeerImpl pi = getPeerForPEPeer( peer );
867 
868 			peer_map.put( peer, pi );
869 
870 			fireEvent(
871 				PeerManagerEvent.ET_PEER_SENT_BAD_DATA,
872 				pi,
873 				null,
874 				new Integer( pieceNumber ));
875 
876 		}
877 
878 		public void
pieceCorrupted( PEPeerManager manager, int piece_number)879 		pieceCorrupted(
880 			PEPeerManager 	manager,
881 			int 			piece_number)
882 		{
883 		}
884 
885 			// disk manager methods
886 
887 		public void
stateChanged( int oldState, int newState )888 		stateChanged(
889 			int oldState,
890 			int	newState )
891 		{
892 		}
893 
894 		public void
filePriorityChanged( DiskManagerFileInfo file )895 		filePriorityChanged(
896 			DiskManagerFileInfo		file )
897 		{
898 		}
899 
900 		public void
pieceDoneChanged( DiskManagerPiece piece )901 		pieceDoneChanged(
902 			DiskManagerPiece		piece )
903 		{
904 			fireEvent(
905 					PeerManagerEvent.ET_PIECE_COMPLETION_CHANGED,
906 					null,
907 					null,
908 					new pieceFacade( piece.getPieceNumber()));
909 		}
910 
911 		public void
fileAccessModeChanged( DiskManagerFileInfo file, int old_mode, int new_mode )912 		fileAccessModeChanged(
913 			DiskManagerFileInfo		file,
914 			int						old_mode,
915 			int						new_mode )
916 		{
917 		}
918 
919 		protected void
fireEvent( final int type, final Peer peer, final PeerItem peer_item, final Object data )920 		fireEvent(
921 			final int			type,
922 			final Peer			peer,
923 			final PeerItem		peer_item,
924 			final Object		data )
925 		{
926 			listener.eventOccurred(
927 				new PeerManagerEvent()
928 				{
929 					public PeerManager
930 					getPeerManager()
931 					{
932 						return( PeerManagerImpl.this );
933 					}
934 
935 					public int
936 					getType()
937 					{
938 						return( type );
939 					}
940 
941 					public Peer
942 					getPeer()
943 					{
944 						return( peer );
945 					}
946 
947 					public PeerDescriptor
948 					getPeerDescriptor()
949 					{
950 						return( peer_item );
951 					}
952 
953 					public Object
954 					getData()
955 					{
956 						return( data );
957 					}
958 				});
959 		}
960 
961 
962 		public void
destroyed()963 		destroyed()
964 		{
965 		}
966 	}
967 }
968