import org.eclipse.core.runtime.IPath;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.PartInitException;

	static IDEWorkbenchAdvisor getInstance() {

		return workbenchAdvisor;

	}

			runStartupCommand(Platform.getCommandLineArgs());

	 * Runs a command specified on the command line, if any

	 */

	boolean runStartupCommand(String[] arguments) {

		if (arguments.length == 0)

			return false;

		// if the last command line argument is a file, open that file in an

		// editor

		final IPath path = new Path(arguments[arguments.length - 1]);

		if (!path.toFile().exists())

			return false;

		IWorkbenchWindow window = PlatformUI.getWorkbench()

				.getActiveWorkbenchWindow();

		if (window == null) {

			IWorkbenchWindow[] windows = PlatformUI.getWorkbench()

					.getWorkbenchWindows();

			if (windows.length > 0)

				window = windows[0];

		}

		if (window == null)

			return false;

		final IWorkbenchPage page = window.getActivePage();

		if (page == null)

			return false;

		window.getShell().getDisplay().syncExec(new Runnable() {

			public void run() {

				try {

					IDE.openEditorOnFileStore(page, EFS.getLocalFileSystem()

							.getStore(path));

				} catch (PartInitException e) {

					IDEWorkbenchPlugin.log(

							"Error opening editor on path: " + path, e); //$NON-NLS-1$

				}

			}

		});

		return true;

	}

	/**

        //check if someone is listening that we can pass our command line to

        if (launchData.getPort() != 0) {

        	if (new IDECommunication().writeToPort(launchData.getPort(), launchData.getIPCAuthorization())) {

        		//we successfully punted this application's command line to another instance,

        		//so we can just shutdown this instance.

        		return false;

        	}

        }

                    int[] ipcData = new IDECommunication().listen();

                    if (ipcData != null) {

                    	launchData.setPort(ipcData[0]);

                    	launchData.setIPCAuthorization(ipcData[1]);

                    }

/*******************************************************************************

 * Copyright (c) 2008 IBM Corporation and others.

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 ******************************************************************************/

package org.eclipse.ui.internal.ide.application;

import java.security.SecureRandom;

import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;

import java.io.*;

import java.net.*;

import org.eclipse.core.runtime.*;

import org.eclipse.core.runtime.jobs.Job;

/**

 * A helper class that deals with interprocess communication between applications.

 * <p>

 * This class uses a socket connection on a random available port to establish

 * communication between applications. The client must provide an authorization

 * code to protect against communication from arbitrary port sniffing applications.

 * 

 * @since 3.5

 */

class IDECommunication {

	/**

	 * A job that listens on a socket for a command, and then invokes the

	 * workbench advisor to handle the command.

	 */

	class ListenJob extends Job {

		private ServerSocket server;

		private int auth;

		public ListenJob(ServerSocket server, int auth) {

			super("Listen"); //$NON-NLS-1$

			this.server = server;

			this.auth = auth;

			setSystem(true);

		}

		/* (non-Javadoc)

		 * @see org.eclipse.core.runtime.jobs.Job#canceling()

		 */

		protected void canceling() {

			try {

				server.close();

			} catch (IOException e) {

				//ignore

			}

		}

		/* (non-Javadoc)

		 * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)

		 */

		protected IStatus run(IProgressMonitor monitor) {

			if (server.isClosed())

				return Status.OK_STATUS;

			Socket client = null;

			DataInputStream in = null;

			DataOutputStream out = null;

			try {

				client = server.accept();

				in = new DataInputStream(client.getInputStream());

				out = new DataOutputStream(client.getOutputStream());

				//read the protocol version

				int version = in.readInt();

				String[] args = null;

				if (version == PROTOCOL_VERSION_ONE) {

					//read the authorization checksum

					int receivedAuth = in.readInt();

					//abort immediately if we failed to read the authorization integer

					if (receivedAuth != auth) {

						schedule(SCHEDULE_DELAY);

						return new Status(IStatus.ERROR, IDEWorkbenchPlugin.IDE_WORKBENCH, "Connection from unauthorized client on port " + server.getLocalPort()); //$NON-NLS-1$

					}

					args = new String[in.readInt()];

					for (int i = 0; i < args.length; i++) {

						args[i] = in.readUTF();

					}

				}

				//pass the read arguments to the workbench advisor

				IDEWorkbenchAdvisor advisor = IDEWorkbenchAdvisor.getInstance();

				if (advisor != null && args != null) {

					if (advisor.runStartupCommand(args))

						out.writeUTF(OK);

					else

						out.writeUTF(FAIL);

				}

			} catch (IOException e) {

				IDEWorkbenchPlugin.log("Error communicating with client", e); //$NON-NLS-1$

			} finally {

				safeClose(in);

				safeClose(out);

				safeClose(client);

			}

			//reschedule

			schedule(SCHEDULE_DELAY);

			return Status.OK_STATUS;

		}

	}

	/**

	 * The first communication protocol version. This version contains an authorization

	 * integer followed by a list of command line arguments. The format is: int authorizationId, int N, String[N].

	 */

	private static final int PROTOCOL_VERSION_ONE = 1;

	private static final long SCHEDULE_DELAY = 1000;

	static final String OK = "OK"; //$NON-NLS-1$

	static final String FAIL = "FAIL"; //$NON-NLS-1$

	/**

	 * Start listening for commands.

	 * @return An integer array of size two. The first integer is the port

	 * number we are listening on, and the second integer is an authorization

	 * integer used to validate connections.  Returns <code>null</code> if

	 * there was a failure to establish communication

	 */

	public int[] listen() {

		try {

			ServerSocket server = new ServerSocket(0);

			int auth = new SecureRandom().nextInt();

			new ListenJob(server, auth).schedule(SCHEDULE_DELAY);

			return new int[] {server.getLocalPort(), auth};

		} catch (IOException e) {

			return null;

		}

	}

	/**

	 * Close the given stream and ignore secondary failures.

	 */

	void safeClose(DataInputStream in) {

		try {

			if (in != null)

				in.close();

		} catch (IOException e) {

			//ignore secondary failure while closing

		}

	}

	/**

	 * Close the given stream and ignore secondary failures.

	 */

	void safeClose(DataOutputStream out) {

		try {

			if (out != null)

				out.close();

		} catch (IOException e) {

			//ignore secondary failure while closing

		}

	}

	/**

	 * Close the given socket and ignore secondary failures.

	 */

	void safeClose(Socket socket) {

		try {

			if (socket != null)

				socket.close();

		} catch (IOException e) {

			//ignore secondary failure while closing

		}

	}

	/**

	 * Writes this application's command line arguments to the given port.

	 * 

	 * @param port The port to write data to

	 * @param auth The authorization integer

	 * @return <code>true</code> if written successfully, and <code>false</code> otherwise.

	 */

	public boolean writeToPort(int port, int auth) {

		Socket socket = null;

		DataOutputStream out = null;

		DataInputStream in = null;

		try {

			socket = new Socket("localhost", port);//$NON-NLS-1$

			out = new DataOutputStream(socket.getOutputStream());

			in = new DataInputStream(socket.getInputStream());

			out.writeInt(PROTOCOL_VERSION_ONE);

			out.writeInt(auth);

			String[] args = Platform.getCommandLineArgs();

			out.writeInt(args.length);

			for (int i = 0; i < args.length; i++)

				out.writeUTF(args[i]);

			//server will return OK or FAIL

			return in.readUTF().equals(OK);

		} catch (UnknownHostException e) {

			return false;

		} catch (IOException e) {

			return false;

		} finally {

			safeClose(socket);

			safeClose(out);

			safeClose(in);

		}

	}

}

    /**

     * The port on which an instance of this configuration is already listening for remote communication.

     * This value is 0 if nobody is already listening.

     */

    private int port = 0;

    /**

     * An authorization integer that a client must provide when communication with

     * this application. This is a simple security measure to prevent a port scanner 

     * from executing commands in this application.

     */

    private int ipcAuth = 0;

    /**

     * Sets the port on which an instance is listening for remote communication.

     * @param port The port, or 0 to indicate not listening.

     */

    public void setPort(int port) {

    	this.port = port;

    }

    /**

     * Sets an authorization integer that a client must provide to establish

     * remote communication.  This is used to prevent a port sniffer from

     * executing commands.

     */

    public void setIPCAuthorization(int auth) {

    	this.ipcAuth = auth;

    }

    /**

     * Returns the port on which an instance of this same configuration is

     * already listening for remote communication, or 0 if nobody is listening.

     * @return The port number, or 0.

     */

    public int getPort() {

    	return port;

    }

    /**

     * Returns the authorization integer for establishing interprocess communication.

     * @return The authorization integer

     */

    public int getIPCAuthorization() {

    	return ipcAuth;

    }

		// 6. store the interprocess communication data, if any

		if (port != 0) {

			node.putInt(XML.PORT, port);

			node.putInt(XML.IPC_AUTH, ipcAuth);

		}

		// 5. load the interprocess communication data

		port = store.getInt(XML.PORT);

		ipcAuth = store.getInt(XML.IPC_AUTH);