messagedispatcher.java

java语言开发的P2P流媒体系统

											{
												// Fies sein und an Zulieferer verweisen
												try
												{
													Packet redirectPacket = new RedirectPacket(peer.getSupplier());
													socket.send(redirectPacket);
												}
												catch (Exception e)
												{
													if (shutdown)
														return;
													// Keine Fehlerbehandlung
													// (dieser Peer ist schliesslich fies)
												}
												if (shutdown)
													return;
											}	
										}
										else if (peer.getMisbehavior(Commands.REDIRECT_ALL_CHILDREN_TO_SOURCE))
										{
											// Fies sein und an Zulieferer verweisen
											try
											{
												Packet redirectPacket = new RedirectPacket(peer.getServer());
												socket.send(redirectPacket);
											}
											catch (Exception e)
											{
												if (shutdown)
													return;
												// Keine Fehlerbehandlung
												// (dieser Peer ist schliesslich fies)
											}
											if (shutdown)
												return;
										}
										else
										{
											// Der neue Peer ist noch kein Kind
										
											// Steht der Peer auf der schwarzen Liste?
											if (peer.isPeerBanned(newPeer))
											{
												// Falls ein Kind verf黦bar ist: An dieses Kind verweisen
												// Sonst: unfreundlich sein und keine Antwort geben
										
												RemotePeer redirection = null;
												try
												{
													redirection = peer.getRedirectionChild();
												}
												catch (PeerException e)
												{
													// Kein Kind verf黦bar - weitermachen
													return;
												}
											
												try
												{
													Packet redirectPacket = new RedirectPacket(redirection);
													socket.send(redirectPacket);
												}
												catch (Exception e)
												{
													if (shutdown)
														return;
													// Umleitung konnte nicht gesendet werden																
													Logger.fine(c, c + ".ERROR_SENDING_REDIRECT_MESSAGE", newPeer); //$NON-NLS-1$ //$NON-NLS-2$
												}
												if (shutdown)
													return;
											}
											else // Peer steht nicht auf der schwarzen Liste
											{
												peer.removeUnconnectedChildren();
												boolean serveAnother = peer.canServeAnotherPeer();
												if (serverUsesVerifiedBandwidth && !usesVerifiedBandwidth)
												{
													peer.addLocalChild(newPeer);
													serveAnother = true;  //We can always serve another loopback child
												}
												else if (serveAnother)
													peer.addRemoteChild(newPeer);
													
												if (serveAnother)
												{		
													// Der Peer wird aufgenommen
													try
													{
														peer.addChild(newPeer);
													}
													catch (Exception e)
													{
														// Irgendwas stimmt mit dem neuen Peer nicht
														// Nicht aufnehmen
														Logger.fine(c, c + ".FAKED_JOIN_MESSAGE_RECEIVED", newPeer); //$NON-NLS-1$ //$NON-NLS-2$
														return;
													}
											
													try
													{
														Packet okPacket = createOKPacket();
														socket.send(okPacket);
													}
													catch (Exception e)
													{
														if (shutdown)
															return;
														// Die OK-Nachricht konnte nicht gesendet werden
														// Peer wieder entfernen
														Logger.fine(c, c + ".ERROR_SENDING_OK_MESSAGE", newPeer); //$NON-NLS-1$ //$NON-NLS-2$
														peer.removeChild(newPeer);
													}
													if(shutdown)
														return;
												}
												else
												{
													// An ein Kind verweisen
													
													try
													{
														RemotePeer redirection = peer.getRedirectionChild();
														Packet redirectPacket = new RedirectPacket(redirection);
					
														socket.send(redirectPacket);
													}
													catch (PeerException e)
													{
														// Neue Kinder k鰊nen nicht aufgenommen werden und es
														// gibt keine Kinder
														Logger.warning(c, c + ".TOO_LOW_BANDWIDTH_LIMIT"); //$NON-NLS-1$ //$NON-NLS-2$
													}
													catch (Exception e)
													{
														if (shutdown)
															return;
														// Umleitung konnte nicht gesendet werden.
														// Ist aber egal, der andere Peer wird es sowieso nochmals probieren
														Logger.fine(c, c + ".ERROR_SENDING_REDIRECT_MESSAGE", newPeer); //$NON-NLS-1$ //$NON-NLS-2$
													}
													if(shutdown)
														return;
												}
											}
										}
									}
								}
							}
							//else if (actionPacket instanceof)
							else if (inPacket instanceof FreeloaderReportPacket)
							{
								// Ein anderer Peer will diesem Peer einen Freeloader melden
								
								RemotePeer sender = composeAddressAndPort(requester.getAddress(), ((FreeloaderReportPacket)inPacket).getSenderPort());
								RemotePeer freeloader = ((FreeloaderReportPacket)inPacket).getFreeloader();
								
								try
								{				
									peer.processComplainAboutFreeloader(sender, freeloader);
								}
								catch (Exception e)
								{
									// Die Beschwerde war ung黮tig
									Logger.finer(c, c + ".INVALID_COMPLAINT_RECEIVED", new RemotePeer[]{sender, freeloader}); //$NON-NLS-1$ //$NON-NLS-2$
								}
								if (shutdown)
									return;
							}
							else if ((inPacket instanceof PublicKeyRequestPacket) && peer.isServer())
							{
								// Den Public Key 黚ermitteln
								
								try
								{
									Packet packet;
									
									if (Peer.signStreamPackets)
									{
										packet = new PublicKeyPacket(peer.getSignatureGenerator().getPublicKey()); 
									}
									else
									{
										if (shutdown)
											return;
										// Leeren Public Key senden
										packet = new PublicKeyPacket(new byte[0]);
									}
									
									socket.send(packet);
								}
								catch (Exception e)
								{
									if (shutdown)
										return;
									// Public Key konnte nicht gesendet werden																
									Logger.fine(c, c + ".ERROR_SENDING_PUBLIC_KEY", requester); //$NON-NLS-1$ //$NON-NLS-2$
								}
								if (shutdown)
									return;
							}
							
							else if (inPacket instanceof MonitorCommandPacket)
							{
								// Befehl vom Monitor!
						
								byte command = ((MonitorCommandPacket)inPacket).getCommand();
						
								if ((command >= 0) && (command < Commands.LAST_COMMAND))
								{
									if (!Radio.enableMonitor)
									{
										Logger.fine(c, c + ".COMMAND_WAS_IGNORED", Commands.MESSAGES[command]); //$NON-NLS-1$ //$NON-NLS-2$
									}	
									else
									{
										Logger.fine(c, c + ".COMMAND_RECEIVED", Commands.MESSAGES[command]); //$NON-NLS-1$ //$NON-NLS-2$
										
										switch(command)
										{
											case Commands.CHANGE_SUPPLIER:
												if (peer.getSupplier() != null)
												{
													peer.changeSupplier(true, false);
												}
												break;
										
											case Commands.JOIN:
												peer.join();
												break;
										
											case Commands.LEAVE:
												peer.leave();
												break;
										
											case Commands.REMOVE_ALL_CHILDREN:
												peer.removeAllChildren();
												break;
										
											default:
												peer.setMisbehavior(command, !peer.getMisbehavior(command));
										}
									}
								}
								else
								{
									Logger.fine(c, c + ".UNKNOWN_COMMAND_RECEIVED"); //$NON-NLS-1$ //$NON-NLS-2$
								}
							}
						}
						else
						{
							// Nicht erwartetes Paket erhalten
							// Nichts darauf antworten
						
							Logger.fine(c, "UNEXPECTED_PACKET_RECEIVED", inPacket); //$NON-NLS-1$ //$NON-NLS-2$
						}
					}
			}
			}
		catch (Exception e)
		{
			Logger.severe(c, "INTERNAL_ERROR", e); //$NON-NLS-1$ //$NON-NLS-2$
		}
	}
	
	private Packet createOKPacket() throws SocketException
	{
		if (!Radio.enableMonitor || (peer.getMonitorLogHandler().getMonitorAddress() == null))
		{
			return new OKPacket();
		}
		else
		{
			return new OKUseMonitorPacket(peer.getMonitorLogHandler().getMonitorAddress());
		}
	}
	
	protected RemotePeer composeAddressAndPort(DatagramPacket packet, int port)
	{
		return new RemotePeer(new InetSocketAddress(packet.getAddress(), port));
	}
	protected RemotePeer composeAddressAndPort(InetAddress address, int port)
	{
		return new RemotePeer(new InetSocketAddress(address, port));
	}
	public void shutdown()
	{
		shutdown = true;
		try {
			socket.close();
		} catch (IOException e) {
		}
		listener.getMessageDispatchers().remove(this);
		if (isServer)
			acceptedPeers.remove(requester);
		if (streamDispatcher != null)
			streamDispatcher.shutdown();
	}
	private boolean peerIsAccepted(InetSocketAddress addr)
	{
		return peerIsAccepted(new RemotePeer(addr));
	}
	private boolean peerIsAccepted(RemotePeer checkPeer)
	{
		Iterator acceptIter = acceptedPeers.iterator();
		int i = 0;
		while (acceptIter.hasNext())
		{
			//System.out.println("checkPeer" + checkPeer.getSocketAddress());
			//System.out.println("accepted" + ((RemotePeer)acceptIter.next()).getSocketAddress());
			
			if (checkPeer.getSocketAddress().equals(acceptIter.next()))
				return true;
		}
		//System.out.println("Peer is not accepted");
		return false;
	}
}