README.md

@@ -6,6 +6,12 @@ Lien vers le [document original](https://stri-online.net/FTLV/mod/resource/view.
 **But** : le but de ce projet est de créer une application répartie en Java de téléchargement de fichier en mode P2P (peer to peer ou poste à poste).
 Les étapes suivantes sont conseillées.
 
+# Usage
+
+tracker : java tracker.Tracker (interactive) or java trackerP2P.trackerP2P -- <hostname> <PORT> (default port 6969 (range 6000 -> 6999))
+server : java serveurP2P.ServeurP2P (interactive) or java serveurP2P.ServeurP2P -- <serveurHOSTNAME> <serveurPORT> <trackerHOSTNAME> <trackerPORT> (default server port: server 7070 (range 7000->7070) and tracker port 6969 (range 7000 -> 7999))
+client/serveur : java clientP2P.ClientP2P or java clientP2P.ClientP2P -- <clientTransportProtocol> <integratedServerHOSTNAME> <integratedServerPORT> <trackerHOSTNAME> <trackerPORT> (default tracker port 6969 (range 7000 -> 7999) and server port: server 7070 (range 7000->7070))
+
 ## Étape 1 : Téléchargement à la FTP
 
 La première étape doit permettre de télécharger un fichier en intégralité d'une machine vers une autre machine de façon similaire aux applications suivant le protocole FTP.
@@ -47,4 +53,4 @@ Options :
 - Permettre la recherche de fichiers à partir de leur nom ou de toute autre caractéristique. À l'issu de la recherche on devra pouvoir connaître un ensemble d'application possédant le fichier et commencer le téléchargement.
 - Gérer le protocole d'une application de téléchargement P2P existante (bittorrent, emule ou autre).
 
-Note : toute fonctionnalité supplémentaire ne sera prise en compte dans la notation que si toutes les étapes ont été correctement traitées.
+Note : toute fonctionnalité supplémentaire ne sera prise en compte dans la notation que si toutes les étapes ont été correctement traitées.

src/clientP2P/ClientP2P.java

@@ -4,12 +4,16 @@ import java.util.Scanner;
 import java.util.List;
 import clientP2P.ClientManagementUDP;
 import clientP2P.ClientManagementTCP;
+
 import serverP2P.ServerManagementUDP;
 import serverP2P.ServerManagementTCP;
 import tools.Logger;
 import tools.LogLevel;
 import tools.Directories;
 import tools.HostItem;
+import tools.ServerPortRange;
+import tools.TrackerPortRange;
+
 
 /** Client + Server implementation.
  * @author	Louis Royer
@@ -23,20 +27,17 @@ public class ClientP2P {
 	private String partsDir = ".parts/";
 	private Logger loggerServer;
 	private Logger loggerClient;
-	private String host;
-	private int port;
 	private Directories directories;
-	private static final int defaultPort = 20000;
 	private HostItem tracker;
+	private HostItem server;
 	private Scanner scanner;
-
-
+	
 	/** Initialize loggers if directories and logger are null,
 	 * else fail silently.
 	 */
 	public void initDirectoriesAndLoggers() {
 		if (directories == null && loggerServer == null && loggerClient == null) {
-			directories = new Directories("P2P_JAVA_PROJECT_" + port);
+			directories = new Directories("P2P_JAVA_PROJECT_" + server.getPort());
 			directories.createSubdir(logDir);
 			loggerServer = new Logger(directories.getDataHomeDirectory() + logDir + "server.log");
 			loggerClient = new Logger(directories.getDataHomeDirectory() + logDir + "client.log");
@@ -44,26 +45,34 @@ public class ClientP2P {
 		}
 	}
 
-	/** Constructor with portStr as parameter.
-	 * @param portStr	String containing port for server listenning.
+	/** Constructor.
+	 * @param hostnameServer	hostname to bind
+	 * @param portServer	port to bind
+	 * @param hostnameTracker	hostname of tracker
+	 * @param portTracker	port of tracker 
 	 */
-	public ClientP2P(String portStr) {
+	public ClientP2P(String hostnameServer, int portServer, String hostnameTracker, int portTracker) {
 		scanner = new Scanner(System.in);
-		tracker = new HostItem("localhost", 30000); // TODO : make it configurable
-		try{
-			port = Integer.valueOf(Integer.parseInt(portStr));
-		} catch (NumberFormatException e){
-			int oldPort = port;
-			port = defaultPort;
-			initDirectoriesAndLoggers();
-			System.err.println("Error incorrect port " + oldPort + " using default port " + defaultPort);
-			loggerServer.write("incorrect port " + oldPort + " using default port " + defaultPort, LogLevel.Info);
-		}
+		server = new HostItem(hostnameServer, portServer);
+		tracker = new HostItem(hostnameTracker, portTracker);
 		initDirectoriesAndLoggers();
-		host = "localhost";
-		System.out.println("Server will listen on port " + port + " and serve files from " + directories.getDataHomeDirectory());
+		System.out.println("Server will listen on port " + portServer + " and serve files from " + directories.getDataHomeDirectory());
 		directories.askOpenDataHomeDirectory(null, scanner);
-		System.out.println("Please enter list of servers to use; first one will be used to ask list of files");
+	}
+
+	/** Print cli usage
+	 * @param serverPortRange range of server ports
+	 * @param trackerPortRange range of tracker ports
+	 */
+	private static void printUsage(ServerPortRange serverPortRange, TrackerPortRange trackerPortRange) {
+		System.out.println("usage :");
+		System.out.println("\tjava clientP2P.ClientP2P");
+		System.out.println("or");
+		System.out.println("java clientP2P.ClientP2P -- " +
+			"<clientTransportProtocol> " +
+			"<integratedServerHOSTNAME> <integratedServerPORT> " +
+			"<trackerHOSTNAME> <trackerPORT> ");
+		System.out.println("(" + trackerPortRange + " and " + serverPortRange +")");
 	}
 
 	/** Main program entry point.
@@ -72,67 +81,121 @@ public class ClientP2P {
 	 * @param args	server listenning port
 	 */
 	public static void main(String [] args) {
-		if (args[1].equals("help") || args[1].equals("-h") || args[1].equals("h")){
-			System.out.println("usage : java -ea clientP2P.ClientP2P -- <PORT> ");
+		final String defaultHostname = "localhost";
+		String hostnameServer = "";
+		int portServer = 0;
+		String hostnameTracker = "";
+		int portTracker = 0;
+		String protocolClient = "";
+		Scanner scanner = new Scanner(System.in);
+		final ServerPortRange serverPortRange = new ServerPortRange();
+		final TrackerPortRange trackerPortRange = new TrackerPortRange();
+
+		if ((args.length != 6) && (args.length != 0)){
+			ClientP2P.printUsage(serverPortRange, trackerPortRange);
+			System.exit(1);
 		}
-		else{
-			ClientP2P c;
-			try {
-				c = new ClientP2P(args[1]);
-			} catch (IndexOutOfBoundsException e){
-				c = new ClientP2P("" + defaultPort);
+		else if(args.length == 6){
+				protocolClient = args[1];
+				hostnameServer = args[2];
+				portServer = Integer.valueOf(Integer.parseInt(args[3]));
+				hostnameTracker = args[4];
+				portTracker = Integer.valueOf(Integer.parseInt(args[5]));
+		} else{
+			System.out.println("Client, wich transport protocol do you want to use (default = TCP): ");
+			protocolClient = scanner.nextLine();
+			System.out.println("server side, enter hostname to bind (default = localhost): ");
+			hostnameServer = scanner.nextLine();
+			if(hostnameServer.equals("")){
+				hostnameServer = defaultHostname;
+				System.out.println("using default hostname : " + hostnameServer);
+			}
+			System.out.println("enter port (default = " + serverPortRange.getDefaultPort() +"): ");
+			String portServerStr = scanner.nextLine();
+			if(portServerStr.equals("")){
+				portServer = serverPortRange.getDefaultPort();
+				System.out.println("using default port : " + portServer);
+			} else {
+				portServer = Integer.valueOf(Integer.parseInt(portServerStr));
+			}
+			System.out.println("enter hostname of tracker (default = localhost): ");
+			hostnameTracker = scanner.nextLine();
+			if(hostnameTracker.equals("")){
+				hostnameTracker = defaultHostname;
+				System.out.println("tracker default hostname : " + hostnameTracker);
 			}
+			System.out.println("enter tracker's port (default = "+trackerPortRange.getDefaultPort() + "): ");
+			String portTrackerStr = scanner.nextLine();
+			if(portTrackerStr.equals("")){
+				portTracker = trackerPortRange.getDefaultPort();
+				System.out.println("using default port : " + portTracker);
+			} else {
+				portTracker = Integer.valueOf(Integer.parseInt(portTrackerStr));
+			}
+		}
 
-			// Server threads
-			ServerManagementUDP smudp = new ServerManagementUDP(c.directories.getDataHomeDirectory(), "localhost", c.port, c.loggerServer, c.tracker);
-			ServerManagementTCP smtcp = new ServerManagementTCP(c.directories.getDataHomeDirectory(), "localhost", c.port, c.loggerServer, c.tracker);
-			Thread tudp = new Thread(smudp);
-			tudp.setName("server UDP P2P-JAVA-PROJECT (port: " + c.port + ")");
-			tudp.start();
-			Thread ttcp = new Thread(smtcp);
-			ttcp.setName("server TCP P2P-JAVA-PROJECT (port: " + c.port + ")");
-			ttcp.start();
+		System.out.println("using hostname : " + hostnameServer);
+		if(serverPortRange.isPortInRange(portServer)){
+			System.out.println("using port : " + portServer);
+		}
+		else {
+			System.out.println("Port not in range. " + serverPortRange);
+			portServer = serverPortRange.getDefaultPort();
+		}
+		System.out.println("tracker hostname : " + hostnameTracker);
 
-			// Wait a bit before printing client interface
-			// This is not required, but allow to have a cleaner interface
-			try {
-				Thread.sleep(200);
-			} catch(InterruptedException e) {
-				Thread.currentThread().interrupt();
-			}
+		if(trackerPortRange.isPortInRange(portTracker)){
+			System.out.println("using port : " + portTracker);
+		}
+		else {
+			System.out.println("Port not in range. " + trackerPortRange);
+			portTracker = trackerPortRange.getDefaultPort();
+		}
+
+		ClientP2P c = new ClientP2P(hostnameServer, portServer, hostnameTracker, portTracker);
+
+		ServerManagementUDP smudp = new ServerManagementUDP(c.directories.getDataHomeDirectory(), c.server, c.tracker, c.loggerServer);
+		ServerManagementTCP smtcp = new ServerManagementTCP(c.directories.getDataHomeDirectory(), c.server, c.tracker, c.loggerServer);
+		Thread tudp = new Thread(smudp);
+		tudp.setName("server UDP P2P-JAVA-PROJECT");
+		tudp.start();
+		Thread ttcp = new Thread(smtcp);
+		ttcp.setName("server TCP P2P-JAVA-PROJECT");
+		ttcp.start();
+
+		// Wait a bit before printing client interface
+		// This is not required, but allow to have a cleaner interface
+		try {
+			Thread.sleep(200);
+		} catch(InterruptedException e) {
+			Thread.currentThread().interrupt();
+		}
 
-			// initialize Host lists
-			System.out.println("Client : Which transport protocol do you want to use? [TCP/udp]");
-			c.scanner.hasNextLine();
-			String transportchoosen = c.scanner.nextLine();
-			Thread t;
-			switch(transportchoosen){
-				case "UDP":
-				case "udp":
-				case "upd": // alias typo
-				case "2" :
-					System.out.println("Starting with UDP");
-					ClientManagementUDP cmudp = new ClientManagementUDP(c.directories.getDataHomeDirectory(), c.tracker, c.directories.getDataHomeDirectory() + c.partsDir, c.loggerClient, c.scanner);
-					t = new Thread(cmudp);
-					break;
-				case "TCP":
-				case "tcp":
-				case "1":
-				default:
-					System.out.println("Starting with TCP");
-					ClientManagementTCP cmtcp = new ClientManagementTCP(c.directories.getDataHomeDirectory(), c.tracker, c.directories.getDataHomeDirectory() + c.partsDir, c.loggerClient, c.scanner);
-					t = new Thread(cmtcp);
-					break;
-				}
-			t.setName("client P2P-JAVA-PROJECT");
-			t.start();
-			try {
-				t.join();
-			} catch (InterruptedException e) {}
-			c.scanner.close();
-			smudp.setStop();
-			smtcp.setStop();
-			
+		Thread tclient;
+		switch(protocolClient){
+			case "UDP":
+			case "udp":
+			case "upd": // to avoid users typos
+			case "2" :
+				System.out.println("Starting with UDP");
+				ClientManagementUDP cmudp = new ClientManagementUDP(c.directories.getDataHomeDirectory(), c.tracker, c.directories.getDataHomeDirectory() + c.partsDir, c.loggerClient, c.scanner);
+				tclient = new Thread(cmudp);
+				break;
+			case "TCP":
+			case "tcp":
+			case "1":
+			default:
+				System.out.println("Starting with TCP");
+				ClientManagementTCP cmtcp = new ClientManagementTCP(c.directories.getDataHomeDirectory(), c.tracker, c.directories.getDataHomeDirectory() + c.partsDir, c.loggerClient, c.scanner);
+				tclient = new Thread(cmtcp);
+				break;
 		}
+		tclient.setName("client P2P-JAVA-PROJECT");
+		tclient.start();
+		try {
+			tclient.join();
+		} catch (InterruptedException e) {}
+		smudp.setStop();
+		smtcp.setStop();
 	}
 }

src/serverP2P/ServerManagementTCP.java

@@ -56,8 +56,8 @@ public class ServerManagementTCP extends ServerManagement {
 	 * @param logger	Logger item
 	 * @param tracker	Tracker
 	 */
-	public ServerManagementTCP(String baseDirectory, String hostName, int port, Logger logger, HostItem tracker) {
-		super(baseDirectory, new HostItem(hostName, port), tracker, logger);
+	public ServerManagementTCP(String baseDirectory, HostItem server, HostItem tracker, Logger logger) {
+		super(baseDirectory, server, tracker, logger);
 		assert baseDirectory != null : "baseDirectory is null";
 		assert server != null : "server is null";
 		assert tracker != null : "tracker is null";

src/serverP2P/ServerManagementUDP.java

@@ -54,8 +54,8 @@ public class ServerManagementUDP extends ServerManagement {
 	 * @param logger	Logger item
 	 * @param tracker	Tracker
 	 */
-	public ServerManagementUDP(String baseDirectory, String hostName, int port, Logger logger, HostItem tracker) {
-		super(baseDirectory, new HostItem(hostName, port), tracker, logger);
+	public ServerManagementUDP(String baseDirectory, HostItem server, HostItem tracker, Logger logger) {
+		super(baseDirectory, server, tracker, logger);
 		assert baseDirectory != null : "baseDirectory is null";
 		assert server != null : "server is null";
 		assert tracker != null : "tracker is null";

src/serverP2P/ServerP2P.java

@@ -1,10 +1,14 @@
 package serverP2P;
+
+import java.util.Scanner;
 import serverP2P.ServerManagementUDP;
 import serverP2P.ServerManagementTCP;
 import tools.Directories;
 import tools.Logger;
 import tools.HostItem;
-import java.util.Scanner;
+import tools.ServerPortRange;
+import tools.TrackerPortRange;
+
 
 /** Server only implementation
  * First argument of main method is port listened by the server, and is mandatory.
@@ -14,46 +18,111 @@ import java.util.Scanner;
  * @version	1.0
  */
 public class ServerP2P {
-	private int port;
 	private Directories directories;
 	static private final String subdir = "seeded/";
 	private Logger logger;
 	private HostItem tracker;
+	private HostItem server;
 
-	/** Constructor with portStr containing a port number.
-	 * @param portStr	String containing port number of listening.
+	/** Constructor with portServerstr containing a port number.
+	 * @param hostnameServer	binded hostname
+	 * @param portServer	binded port
+	 * @param hostnameTracker	tracker hostname
+	 * @param portTracker	tracker port
 	 */
-	public ServerP2P(String portStr, String trackerHostname, String trackerPortStr) {
-		port = Integer.valueOf(Integer.parseInt(portStr));
-		tracker = new HostItem(trackerHostname, Integer.valueOf(Integer.parseInt(trackerPortStr)));
-		directories = new Directories("P2P_JAVA_PROJECT_SERVER_" + port);
+	public ServerP2P(String hostnameServer, int portServer, String hostnameTracker, int portTracker) {
+		Scanner scanner = new Scanner(System.in);
+		server = new HostItem(hostnameServer, portServer);
+		tracker = new HostItem(hostnameTracker, portTracker);
+		directories = new Directories("P2P_JAVA_PROJECT_SERVER_" + portServer);
 		directories.createSubdir(subdir);
 		logger = new Logger(directories.getDataHomeDirectory() + "server.log");
-		System.out.println("Server will listen on port " + port + " and serve files from " + directories.getDataHomeDirectory() + subdir);
-		Scanner scanner = new Scanner(System.in);
+		System.out.println("Server will listen on port " + portServer + " and serve files from " + directories.getDataHomeDirectory() + subdir);
 		directories.askOpenDataHomeDirectory(subdir, scanner);
 		scanner.close();
 	}
 
 	/** Main program entry point
 	 * first parameter is port number and is mandatory
-	 * to test, run with: java -ea serverP2P.ServerP2P -- <portNumber> <TrackerHostname> <TrackerPort>
+	 * to test, run with: java serverP2P.ServerP2P
 	 * @param args	parameters
 	 */
 		public static void main(String [] args) {
-			if (args[1].equals("help") || args[1].equals("-h") || args[1].equals("h")){
-				System.out.println("usage : java -ea serveurP2P.ServeurP2P -- <serveurPORT> <trackerHOSTNAME> <trackerPORT>");
+			final String defaultHostname = "localhost";
+			final ServerPortRange serverPortRange = new ServerPortRange();
+			final TrackerPortRange trackerPortRange = new TrackerPortRange();
+			String hostnameServer = "";
+			int portServer = 0;
+			String hostnameTracker = "";
+			int portTracker = 0;
+			Scanner scanner = new Scanner(System.in);
+
+			if ((args.length != 5) && (args.length != 0)){
+				System.out.println("usage : java serveurP2P.ServeurP2P (interactive) or java serveurP2P.ServeurP2P -- <serveurHOSTNAME> <serveurPORT> <trackerHOSTNAME> <trackerPORT> (" + serverPortRange + " and " + trackerPortRange +")");
+				System.exit(1);
 			}
-			else{
-				ServerP2P s = new ServerP2P(args[1], args[2], args[3]);
-				ServerManagementUDP smudp = new ServerManagementUDP(s.directories.getDataHomeDirectory() + subdir, "localhost", s.port, s.logger, s.tracker);
-				ServerManagementTCP smtcp = new ServerManagementTCP(s.directories.getDataHomeDirectory() + subdir, "localhost", s.port, s.logger, s.tracker);
-				Thread tudp = new Thread(smudp);
-				tudp.setName("server UDP P2P-JAVA-PROJECT");
-				tudp.start();
-				Thread ttcp = new Thread(smtcp);
-				ttcp.setName("server TCP P2P-JAVA-PROJECT");
-				ttcp.start();
+			else if(args.length == 5){
+					hostnameServer = args[1];
+					portServer = Integer.valueOf(Integer.parseInt(args[2]));
+					hostnameTracker = args[3];
+					portTracker = Integer.valueOf(Integer.parseInt(args[4]));
+			} else {
+				System.out.println("Server, enter hostname to bind (default = localhost): ");
+				hostnameServer = scanner.nextLine();
+				if(hostnameServer.equals("")){
+					hostnameServer = defaultHostname;
+					System.out.println("using default hostname : " + hostnameServer);
+				}
+				System.out.println("enter port (default = " + serverPortRange.getDefaultPort() + "): ");
+				String portServerStr = scanner.nextLine();
+				if(portServerStr.equals("")){
+					portServer = serverPortRange.getDefaultPort();
+					System.out.println("using default port : " + portServer);
+				} else {
+					portServer = Integer.valueOf(Integer.parseInt(portServerStr));
+				}
+				System.out.println("enter hostname of tracker (default = localhost): ");
+				hostnameTracker = scanner.nextLine();
+				if(hostnameTracker.equals("")){
+					hostnameTracker = defaultHostname;
+					System.out.println("tracker default hostname : " + hostnameTracker);
+				}
+				System.out.println("enter tracker's port (default = " + trackerPortRange.getDefaultPort() + "): ");
+				String portTrackerStr = scanner.nextLine();
+				if(portTrackerStr.equals("")){
+					portTracker = serverPortRange.getDefaultPort();
+					System.out.println("using default port : " + portTracker);
+				} else {
+					portTracker = Integer.valueOf(Integer.parseInt(portTrackerStr));
+				}
 			}
-	}
+
+			System.out.println("using hostname : " + hostnameServer);
+			if(serverPortRange.isPortInRange(portServer)) {
+				System.out.println("using port : " + portServer);
+			}
+			else {
+				System.out.println("Port not in range. " + serverPortRange);
+				portServer = serverPortRange.getDefaultPort();
+			}
+			System.out.println("tracker hostname : " + hostnameTracker);
+
+			if(trackerPortRange.isPortInRange(portTracker)) {
+				System.out.println("using port : " + portTracker);
+			}
+			else {
+				System.out.println("Port not in range. " + trackerPortRange);
+				portTracker = trackerPortRange.getDefaultPort();
+			}
+
+			ServerP2P s = new ServerP2P(hostnameServer, portServer, hostnameTracker, portTracker);
+			ServerManagementUDP smudp = new ServerManagementUDP(s.directories.getDataHomeDirectory() + subdir, s.server, s.tracker, s.logger);
+			ServerManagementTCP smtcp = new ServerManagementTCP(s.directories.getDataHomeDirectory() + subdir, s.server, s.tracker, s.logger);
+			Thread tudp = new Thread(smudp);
+			tudp.setName("server UDP P2P-JAVA-PROJECT");
+			tudp.start();
+			Thread ttcp = new Thread(smtcp);
+			ttcp.setName("server TCP P2P-JAVA-PROJECT");
+			ttcp.start();
+		}
 }

src/tools/PortRange.java

@@ -0,0 +1,49 @@
+package tools;
+
+/** Test ports.
+ * @author	Louis Royer
+ * @author	Flavien Haas
+ * @author	JS Auge
+ * @version	1.0
+ */
+public class PortRange {
+
+	protected int portMax;
+	protected int portMin;
+	protected int defaultPort;
+	protected String type;
+
+	/** Port range constructor
+	 * @param portMin	minimum port
+	 * @param portMax	maximum port
+	 * @param defaultPort	default port
+	 * @param type	type of range
+	 */
+	public PortRange(int portMin, int portMax, int defaultPort, String type) {
+		this.portMax = portMax;
+		this.portMin = portMin;
+		this.defaultPort = defaultPort;
+		this.type = type;
+	}
+
+	/** test if port given correspond a range : registered ports, can be used without superuser privileges
+	 * @return	true if port was valid
+	 */
+	public boolean isPortInRange(int port) {
+		return ((port >= portMin) && (port <= portMax));
+	}
+
+	/** To String
+	 * @return String representation
+	 */
+	 public String toString() {
+		 return "default " + type + "port: " + defaultPort + "(range: " + portMin + " -> " + portMax + ")";
+	 }
+
+	/** Default port getter
+	 * @return	default port
+	 */
+	 public int getDefaultPort() {
+		 return defaultPort;
+	 }
+}

src/tools/ServerPortRange.java

@@ -0,0 +1,10 @@
+package tools;
+import tools.PortRange;
+
+public class ServerPortRange extends PortRange {
+
+	/** Constructor */
+	public ServerPortRange() {
+		super(7000, 7999, 7070, "server");
+	}
+}

src/tools/TrackerPortRange.java

@@ -0,0 +1,10 @@
+package tools;
+import tools.PortRange;
+
+public class TrackerPortRange extends PortRange {
+
+	/** Constructor */
+	public TrackerPortRange() {
+		super(6000, 6999, 6969, "tracker");
+	}
+}

src/tracker/Tracker.java

@@ -1,9 +1,13 @@
 package tracker;
+
+import java.util.Scanner;
 import tracker.TrackerManagementTCP;
 import tracker.TrackerManagementUDP;
 import tools.Directories;
 import tools.Logger;
-import java.util.Scanner;
+import tools.LogLevel;
+import tools.TrackerPortRange;
+import tools.HostItem;
 
 /** Tracker implementation
  * First argument of main method is port listened by the tracker, and is mandatory.
@@ -13,15 +17,16 @@ import java.util.Scanner;
  * @version	1.0
  */
 public class Tracker {
-	private int port;
+	private HostItem tracker;
 	private Directories directories;
 	private Logger logger;
 
 	/** Constructor with portStr containing a port number.
-	 * @param portStr	String containing port number of listening.
+	 * @param hostname	hostname to bind
+	 * @param port	port to bind
 	 */
-	public Tracker(String portStr) {
-		port = Integer.valueOf(Integer.parseInt(portStr));
+	public Tracker(String hostname, int port) {
+		tracker = new HostItem(hostname, port);
 		directories = new Directories("P2P_JAVA_PROJECT_TRACKER_" + port);
 		logger = new Logger(directories.getDataHomeDirectory() + "tracker.log");
 		System.out.println("Tracker will listen on port " + port + " and write logs into " + directories.getDataHomeDirectory());
@@ -32,13 +37,52 @@ public class Tracker {
 
 	/** Main program entry point
 	 * first parameter is port number and is mandatory
-	 * to test, run with: java -ea serverP2P.ServerP2P -- <portNumber>
+	 * to test, run with: java serverP2P.ServerP2P
 	 * @param args	parameters
 	 */
-		public static void main(String [] args) {
-		Tracker t = new Tracker(args[1]);
-		TrackerManagementUDP tmudp = new TrackerManagementUDP(t.port, t.logger);
-		TrackerManagementTCP tmtcp = new TrackerManagementTCP(t.port, t.logger);
+	public static void main(String [] args) {
+		final TrackerPortRange trackerPortRange = new TrackerPortRange();
+		final String defaultHostname = "localhost";
+		Scanner scanner = new Scanner(System.in);
+		String hostname = "";
+		int port = 0;
+		Tracker t;
+
+		if ((args.length != 3) && (args.length != 0)){
+			System.out.println("usage : java tracker.Tracker (interactive) or java trackerP2P.trackerP2P -- <hostname> <PORT> (" + trackerPortRange +")");
+			System.exit(1);
+		} else if (args.length == 3){
+				hostname = args[1];
+				port = Integer.valueOf(Integer.parseInt(args[2]));
+		} else {
+			System.out.println("Tracker Server, enter hostname to bind (default = localhost): ");
+			hostname = scanner.nextLine();
+			if(hostname.equals("")){
+				hostname = defaultHostname;
+				System.out.println("using default hostname : " + hostname);
+			}
+			System.out.println("enter port (default = " + trackerPortRange.getDefaultPort() +"): ");
+			String portStr = scanner.nextLine();
+			if(portStr.equals("")){
+				port = trackerPortRange.getDefaultPort();
+				System.out.println("using default port : " + port);
+			} else {
+				port = Integer.valueOf(Integer.parseInt(portStr));
+			}
+		}
+
+		System.out.println("using hostname : " + hostname);
+		if(trackerPortRange.isPortInRange(port)) {
+			System.out.println("using port : " + port);
+			t = new Tracker(hostname, port);
+		}
+		else {
+			System.out.println("Port not in range. " + trackerPortRange);
+			t = new Tracker(hostname, trackerPortRange.getDefaultPort());
+		}
+
+		TrackerManagementUDP tmudp = new TrackerManagementUDP(t.tracker, t.logger);
+		TrackerManagementTCP tmtcp = new TrackerManagementTCP(t.tracker, t.logger);
 		Thread tudp = new Thread(tmudp);
 		tudp.setName("Tracker UDP P2P-JAVA-PROJECT");
 		tudp.start();
@@ -46,5 +90,4 @@ public class Tracker {
 		ttcp.setName("Tracker TCP P2P-JAVA-PROJECT");
 		ttcp.start();
 	}
-
 }

src/tracker/TrackerManagementTCP.java

@@ -1,32 +1,32 @@
 package tracker;
-import tools.Logger;
-import tools.LogLevel;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+import java.io.IOException;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.net.SocketException;
+import java.net.UnknownHostException;
+import java.net.InetAddress;
 import protocolP2P.ProtocolP2PPacketTCP;
 import protocolP2P.ProtocolP2PPacket;
 import protocolP2P.RequestResponseCode;
 import protocolP2P.Payload;
 import protocolP2P.Register;
 import protocolP2P.Unregister;
-import tools.HostItem;
-import java.util.ArrayList;
-import java.util.List;
-import java.io.IOException;
-import exception.LocalException;
-import java.util.Map;
-import java.util.HashMap;
 import protocolP2P.DiscoverRequest;
 import protocolP2P.DiscoverResponse;
 import protocolP2P.FileList;
-import localException.InternalError;
+import exception.LocalException;
 import remoteException.EmptyDirectory;
-import java.net.UnknownHostException;
-import java.net.InetAddress;
+import localException.InternalError;
 import localException.SocketClosed;
 import tracker.TrackerManagement;
-
+import tools.HostItem;
+import tools.Logger;
+import tools.LogLevel;
 
 /** Tracker management implementation with tcp
  * @author	Louis Royer
@@ -38,11 +38,11 @@ public class TrackerManagementTCP extends TrackerManagement {
 	private ServerSocket socket;
 
 	/** Constructor with port and logger.
-	 * @param port	Port used to listen.
+	 * @param tracker	hostitem of the tracker.
 	 * @param logger	Logger object
 	 */
-	public TrackerManagementTCP(int port, Logger logger) {
-		super(new HostItem("localhost", port), logger);
+	public TrackerManagementTCP(HostItem tracker, Logger logger) {
+		super(tracker, logger);
 		try {
 			socket = new ServerSocket(tracker.getPort(), 10, tracker.getInetAddress());
 		} catch (SocketException e) {
@@ -114,6 +114,7 @@ public class TrackerManagementTCP extends TrackerManagement {
 		}
 	}
 
+
 	/** Implementation of writeLog
 	 * @param text	Text to log
 	 * @param logLevel	level of logging
@@ -144,7 +145,7 @@ public class TrackerManagementTCP extends TrackerManagement {
 	protected Object getHostItemSocket(HostItem hostItem) {
 		return (Object)hostItem.getTCPSocket();
 	}
-
+	
 	/** Close HostItem socket
 	 * @param hostItem	HostItem
 	 */

src/tracker/TrackerManagementUDP.java

@@ -34,15 +34,15 @@ import tracker.TrackerManagement;
 public class TrackerManagementUDP extends TrackerManagement {
 	private DatagramSocket socket;
 	/** Constructor with port and logger.
-	 * @param port	Port used to listen.
+	 * @param tracker	hostitem of the tracker.
 	 * @param logger	Logger object
 	 */
-	public TrackerManagementUDP(int port, Logger logger) {
-		super(new HostItem("localhost", port), logger);
+	public TrackerManagementUDP(HostItem tracker, Logger logger) {
+		super(tracker, logger);
 		try {
 			socket = new DatagramSocket(tracker.getPort(), tracker.getInetAddress());
 		} catch (SocketException e) {
-			logger.writeUDP("Error: cannot listen on port " + port, LogLevel.Error);
+			logger.writeUDP("Error: cannot listen on " + tracker, LogLevel.Error);
 			System.exit(-1);
 		}
 	}