connectthread.java

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

/* Stream-2-Stream - Peer to peer television and radio
 * Project homepage: http://s2s.sourceforge.net/
 * Copyright (C) 2005-2006 Jason Hooks
 * ---------------------------------------------------------------------------
 * 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 stream2stream.network;
import stream2stream.network.*;
import java.io.IOException;
import java.net.DatagramSocket;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.SocketException;
import java.net.SocketTimeoutException;

import javax.swing.JButton;

import p2pradio.Metadata;
import p2pradio.Radio;
import p2pradio.gui.MainFrame;
import p2pradio.logging.Logger;
import p2pradio.packets.AcceptPacket;
import p2pradio.packets.ConnectPacket;
import p2pradio.packets.DenyPacket;
import p2pradio.packets.Packet;
import p2pradio.packets.PacketFactory;
import p2pradio.packets.UnknownPacket;
import stream2stream.XML.SettingsXML;
import p2pradio.event.*;

public class ConnectThread extends Thread {
	public static final int CONNECT_REQUEST_SOCKET_TIMEOUT = 1000;
	private Peer peer;
	private SettingsXML xml;
	private UniversalSocket socket;
	private Socket tcpSocket;
	private DatagramSocket udpSocket;
	private RemotePeer server;
	private boolean shutdown;
	private Metadata metadata;
	public ConnectThread(Peer peer)
	{
		super("ConnectThread");
		shutdown = false;
		this.peer = peer;
		xml = peer.getXML();
		server = peer.getServer();
		metadata = peer.getUI().getMetadata();
	}
	public void run()
	{
		int connectTryNumber = 1;
		byte[] buffer = new byte[PacketFactory.UDP_MAX_DATAGRAM_SIZE];
		try {
			udpSocket = new DatagramSocket();
			tcpSocket = new Socket();
			socket = new UniversalSocket(tcpSocket, udpSocket, UniversalSocket.TCP);
			socket.setSoTimeout(CONNECT_REQUEST_SOCKET_TIMEOUT);
			socket.setBuffer(buffer);
			socket.connect(server.getSocketAddress(), CONNECT_REQUEST_SOCKET_TIMEOUT);
		} catch (Exception e) {
			connectTryNumber++;
		}
		boolean exit = true;
		Packet outPacket = new ConnectPacket(xml.getLANUpload(), xml.getLANDownload(), xml.Get_Internet_Upload_Limit(), xml.Get_Internet_Download_Limit(), 
				xml.Get_Internet_Upload_Max(), xml.Get_Internet_Download_Max(), xml.getIP());; 
		Packet inPacket = null;
		
		boolean packetReceived = false;
		Logger.info("Peer", "Peer.CONNECTING", server); //$NON-NLS-1$ //$NON-NLS-2$
		if (shutdown)
			return;
		//+ 1 is for the TCP try
		int ntries = PacketFactory.UDP_RETRIES + 1;
		
		while (!packetReceived && (connectTryNumber <= ntries ))
		{			if (connectTryNumber == 2)
				socket.setMode(UniversalSocket.UDP);
				
			packetReceived = false;
			try
			{	
				socket.send(outPacket);
				if (shutdown)
					return;
				inPacket = socket.receive();
				packetReceived = true;
			}
			catch(SocketTimeoutException e)
			{
				Logger.fine("Peer", "Peer.SOCKET_TIMEOUT_CONNECT", server); //$NON-NLS-1$ //$NON-NLS-2$
				packetReceived = false;
			} catch (IOException e) {
				// TODO Auto-generated catch block
				
				Logger.fine("Peer", "Peer.SOCKET_TIMEOUT_CONNECT", server); //$NON-NLS-1$ //$NON-NLS-2$
			}
			if (shutdown)
				return;
			connectTryNumber++;
		}
		/*
		try {
			socket.close();
		} catch (IOException e2) {
			// TODO Auto-generated catch block
			e2.printStackTrace();
		}*/
		peer.setStartTime(System.currentTimeMillis());  //jhooks - get current time in milliseconds, used to show how long
		//The server has been serving and to calculate lag.
		if (packetReceived)
		{
			if (inPacket instanceof AcceptPacket)
			{
				exit = false;
				peer.setLagIsValid(true);
				AcceptPacket accept = (AcceptPacket) inPacket; 
				long Time_Server_Has_Been_Running_At_Startup = accept.getTimeStamp();
				Logger.info("Peer", "Peer.TIME_RECEIVED", "" + Time_Server_Has_Been_Running_At_Startup);
				peer.Set_Time_Server_Has_Been_Running_At_Startup(Time_Server_Has_Been_Running_At_Startup);
				peer.setStreamMode(accept.getStreamMode());
				
				boolean useVerified = accept.getUseVerified();
				peer.setVerifiedBandwidth(useVerified);
				boolean serverUsesVerified = accept.getServerUsesVerified();
				
				if (serverUsesVerified)
				{
					Logger.info("Peer", "Peer.VERIFIED_BANDWIDTH_RECEIVED");
					if (!useVerified)
						Logger.info("Peer", "Peer.LOCAL_BANDWIDTH_BYPASS");
				}
				else
					Logger.info("Peer", "Peer.UNVERIFIED_BANDWIDTH_RECEIVED");
				peer.setMaxUploadBandwidth();
				Logger.info("Peer", "Peer.TRYING_TO_FIND_SUPPLIER"); //$NON-NLS-1$ //$NON-NLS-2$
				peer.setMessageMode(socket.getMode());
				peer.setMulticastAddress(accept.getMulticastAddress());
				peer.setStreamMode(accept.getStreamMode());
				peer.setMulticastTTL(accept.getTTL());
				metadata.setContentType(accept.getContentType());
				metadata.setSongTitle(accept.getSongTitle());
				metadata.setSongURL(accept.getSongURL());
				metadata.setStationName(accept.getStationName());
				metadata.setStationURL(accept.getStationUrl());
				metadata.setGenre(accept.getStationGenre());
				metadata.setDescription(accept.getStationDescription());
				metadata.setHttpHeaders(accept.getHttpHeaders());
				metadata.setByterate(accept.getByterate());
				//System.out.println("accept:" + accept.getContentLength());
				if (socket.getMode() == SettingsXML.UDP)
				{
					try {
						socket.setReceivedAddress();
					} catch (SocketException e) {
					} catch (IOException e) {
					}
				}
				peer.setMessageSocket(socket);
				peer.join();
				
				
				
			}
			else if(inPacket instanceof DenyPacket)
			{
				byte reason = ((DenyPacket)inPacket).getReason();
				//System.out.println("denied" + reason);
				switch(reason)
				{
					case DenyPacket.OLD_VERSION:
						Logger.info("Peer", "Peer.DENY_VERSION", Radio.HOMEPAGE);
						break;
					case DenyPacket.IP_INCORRECT:
						Logger.info("Peer", "Peer.DENY_IP");
						break;
					case DenyPacket.VERIFIED_UPLOAD_BAD:
						Logger.info("Peer", "Peer.DENY_VERIFIED_UPLOAD_BAD");
						break;
					case DenyPacket.VERIFIED_DOWNLOAD_BAD:
						Logger.info("Peer", "Peer.DENY_VERIFIED_DOWNLOAD_BAD");
						break;
					case DenyPacket.NOT_ENOUGH_DOWNLOAD:
						Logger.info("Peer", "Peer.DENY_NOT_ENOUGH_DOWNLOAD");
						break;
					case DenyPacket.NOT_ENOUGH_UPLOAD:
						Logger.info("Peer", "Peer.DENY_NOT_ENOUGH_UPLOAD");
						break;
					default:
						Logger.info("Peer", "Peer.DENY_UNKNOWN");
						break;
				}
			}
			
			
		}
		else
		{
			Logger.info("Peer", "Peer.COULD_NOT_CONNECT", server);
		}
		if (!packetReceived || !(inPacket instanceof AcceptPacket))
		{
			UI ui = peer.getUI();
			if (shutdown)
				return;
			if (ui instanceof MainFrame)
			{
				JButton button1 = ((MainFrame)ui).getButton1();
				if (button1.isVisible())
					button1.doClick();
				else
					peer.shutdown();
			}
		}
		return;  //The threads job is done. 
		 //We connected and we were either accepted or denied.
		
	}
	public void shutdown()
	{
		shutdown = true;
		if (socket != null)
		{
			try {
				socket.close();
			} catch (IOException e) {
			}
		}
	}
}