packetfactory.java

来自「java语言开发的P2P流媒体系统」· Java 代码 · 共 185 行

/* Stream-2-Stream - Peer to peer television and radio
 * January 11, 2005 - This file has been modified from the original P2P-Radio source
 * Project homepage: http://s2s.sourceforge.net/
 * Copyright (C) 2005-2006 Jason Hooks
 */

/* 
 * P2P-Radio - Peer to peer streaming system
 * Project homepage: http://p2p-radio.sourceforge.net/
 * Copyright (C) 2003-2004 Michael Kaufmann <[e-mail]>
 * 
 * ---------------------------------------------------------------------------
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * ---------------------------------------------------------------------------
 */

package p2pradio.packets;
import stream2stream.network.*;
import java.net.*;
import p2pradio.Messages;

public class PacketFactory
{
	// Ohne Ber點ksichtigung des PublicKey-Pakets
	// (dieses wird mit einem eigenen Socket empfangen)
	public static final int MESSAGE_PACKET_MAX_SIZE = 1500;
	public static final int UDP_MAX_DATAGRAM_SIZE = 1500;  //1200
	
	public static final int UDP_RETRIES = 3;
	
	public static final int STREAM_PACKET_MAX_SIZE_UDP = 1300; //10000 1000
	public static final int STREAM_PACKET_MAX_SIZE_TCP_OGG = 10000;
	public static int STREAM_PACKET_MAX_SIZE = STREAM_PACKET_MAX_SIZE_TCP_OGG;
	
	// Die Standard-Puffergr鰏se von BufferedOutputStream wird benutzt
	public static final int TCP_OUTPUTSTREAM_BUFFER = 512;
	// public static final int TCP_OUTPUTSTREAM_BUFFER = 4096;
	
	
	private PacketFactory()
	{
		// Kann nicht instantiiert werden
	}
	
	public static Packet createPacket(DatagramPacket udpPacket)
	{
		return createPacket(udpPacket.getData(), udpPacket.getLength());
	}		

	public static Packet createPacket(byte[] content, int contentLength)
	{
		// Leeres Paket erhalten?
		if (contentLength == 0)
		{
			content = new byte[1];
			content[0] = Packet.EMPTY;
						
			return new UnknownPacket(content, 1);
		}
		
		try
		{
			switch(content[0])
			{
				case Packet.JOIN:
					return new JoinPacket(content, contentLength);
				
				case Packet.OK:
					return new OKPacket(content, contentLength);
			 
				case Packet.REDIRECT:
					return new RedirectPacket(content, contentLength);
			
				case Packet.LEAVE:
					return new LeavePacket(content, contentLength);
				
				case Packet.LEAVE_AND_REDIRECT:
					return new LeaveAndRedirectPacket(content, contentLength);
				
				case Packet.FREELOADER_REPORT:
					return new FreeloaderReportPacket(content, contentLength);
					
				case Packet.FREELOADER_REDIRECT:
					return new FreeloaderRedirectPacket(content, contentLength);
			
				case Packet.IDENTIFICATION:
					return new IdentificationPacket(content, contentLength);
				
				case Packet.HEADER:
					return new HeaderPacket(content, contentLength);

				case Packet.DATA:
					return new DataPacket(content, contentLength);
				
				case Packet.METADATA:
					return new MetadataPacket(content, contentLength);
					
				case Packet.IDENTIFICATION_SEQNR:
					return new IdentificationSeqNrPacket(content, contentLength);
			
				case Packet.STANDBY:
					return new StandByPacket(content, contentLength);
					
				case Packet.MONITOR_NOTIFICATION:
					return new MonitorNotificationPacket(content, contentLength);
			
				case Packet.MONITOR_COMMAND:
					return new MonitorCommandPacket(content, contentLength);
				
				case Packet.OK_USE_MONITOR:
					return new OKUseMonitorPacket(content, contentLength);
				
				case Packet.PUBLIC_KEY_REQUEST:
					return new PublicKeyRequestPacket(content, contentLength);
					
				case Packet.PUBLIC_KEY:
					return new PublicKeyPacket(content, contentLength);
					
				case Packet.PING:
					return new PingPacket(content, contentLength);
					
				case Packet.PONG:
					return new PongPacket(content, contentLength);
				
				case Packet.TIME:
					return new TimePacket(content, contentLength);
				
				case Packet.REQUEST:
					return new RequestPacket(content, contentLength);
				
				case Packet.CONNECT:
					return new ConnectPacket(content, contentLength);
				
				case Packet.DENY:
					return new DenyPacket(content, contentLength);
				
				case Packet.ACCEPT:
					return new AcceptPacket(content, contentLength);
				
				case Packet.UDP_UPDATE:
					return new UDPUpdatePacket(content, contentLength);
				
				default:
					return new UnknownPacket(content, contentLength);
			}
		}
		catch (IllegalArgumentException e)
		{
			// Paket-Inhalt ist ung黮tig
			System.err.println(Messages.getString("PacketFactory.PacketFactory.COULD_NOT_READ_PACKET")); //$NON-NLS-1$
			e.printStackTrace();
			return new UnknownPacket(content, contentLength);
		}
		catch (Exception e)
		{
			// Es ist ein gr鯾erer Fehler aufgetreten
			System.err.println(Messages.getString("PacketFactory.PacketFactory.COULD_NOT_READ_PACKET_EXCEPTION_UNCAUGHT")); //$NON-NLS-1$
			e.printStackTrace();
			return new UnknownPacket(content, contentLength);
		}
	}
	
	public static DatagramPacket createUDPPacket(Packet packet, RemotePeer destination) throws SocketException
	{
		return createUDPPacket(packet, destination.getSocketAddress());
	}
	
	public static DatagramPacket createUDPPacket(Packet packet, SocketAddress destination) throws SocketException
	{
		return new DatagramPacket(packet.getContent(), packet.getContentLength(), destination);
	}
}