Attachment #106356 for bug #4922




    /**
	 * This is the second version of the encode/decode protocol that uses the
	 * confi area preferences store for persistence. This version is the same as
	 * the previous version except it uses a \n character to separate the path
	 * entries instead of commas. (see bug 98467)
	 * 
	 * @since 3.3.1

    private String selection;

    private String[] recentWorkspaces;
    
    /**
     * 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;

    // xml tags
    private static interface XML {

        public static final String MAX_LENGTH = "maxLength"; //$NON-NLS-1$

        public static final String PATH = "path"; //$NON-NLS-1$

        public static final String PORT= "port"; //$NON-NLS-1$

        public static final String IPC_AUTH= "ipcAuth"; //$NON-NLS-1$
}

    /**
     * Creates a new instance, loading persistent data if its found.

		}
        initialDefault = dir;
    }
    
    /**
     * 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;
    }

    /**
     * Return the currently selected workspace or null if nothing is selected.

    public String[] getRecentWorkspaces() {
        return recentWorkspaces;
    }
    
    /**
     * 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;
    }

    /**
     * The argument workspace has been selected, update the receiver.  Does not

		// 5. store the protocol version used to encode the list
		node.putInt(IDE.Preferences.RECENT_WORKSPACES_PROTOCOL,
				PERS_ENCODING_VERSION_CONFIG_PREFS_NO_COMMAS);
		
		// 6. store the interprocess communication data, if any
		if (port != 0) {
			node.putInt(XML.PORT, port);
			node.putInt(XML.IPC_AUTH, ipcAuth);
		}

		// 7. store the node
		try {
			node.flush();
		} catch (BackingStoreException e) {

				.getString(IDE.Preferences.RECENT_WORKSPACES);
		recentWorkspaces = decodeStoredWorkspacePaths(protocol, max, workspacePathPref);

		// 5. load the interprocess communication data
		port = store.getInt(XML.PORT);
		ipcAuth = store.getInt(XML.IPC_AUTH);
		
		return true;
	}


Lines 13-19 Link Here

(-)META-INF/MANIFEST.MF (-1 / +2 lines)
13	org.eclipse.ui.navigator.resources;bundle-version="[3.2.100,4.0.0)",	13	org.eclipse.ui.navigator.resources;bundle-version="[3.2.100,4.0.0)",
14	org.eclipse.core.net;bundle-version="[1.0.0,2.0.0)",	14	org.eclipse.core.net;bundle-version="[1.0.0,2.0.0)",
15	org.eclipse.update.core;bundle-version="[3.1.100,4.0.0)",	15	org.eclipse.update.core;bundle-version="[3.1.100,4.0.0)",
16	com.ibm.icu;bundle-version="3.8.1"	16	com.ibm.icu;bundle-version="3.8.1",
		17	org.eclipse.core.filesystem;bundle-version="1.2.0"
17	Export-Package: org.eclipse.ui.internal.ide.application;x-internal:=true,	18	Export-Package: org.eclipse.ui.internal.ide.application;x-internal:=true,
18	org.eclipse.ui.internal.ide.application.dialogs;x-internal:=true	19	org.eclipse.ui.internal.ide.application.dialogs;x-internal:=true
19	Bundle-RequiredExecutionEnvironment: J2SE-1.4	20	Bundle-RequiredExecutionEnvironment: J2SE-1.4




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

import org.eclipse.ui.PartInitException;

import com.ibm.icu.text.Collator;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.*;
import org.eclipse.core.filesystem.EFS;
import java.util.Map;
import java.util.TreeMap;

import org.eclipse.core.net.proxy.IProxyService;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.resources.WorkspaceJob;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IBundleGroup;
import org.eclipse.core.runtime.IBundleGroupProvider;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.dialogs.*;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.TrayDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.ui.*;
import org.eclipse.ui.application.*;
import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
import org.eclipse.ui.application.WorkbenchAdvisor;
import org.eclipse.ui.application.WorkbenchWindowAdvisor;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.internal.*;
import org.eclipse.ui.internal.ide.*;
import org.eclipse.ui.internal.Workbench;
import org.eclipse.ui.internal.ide.AboutInfo;
import org.eclipse.ui.internal.ide.IDEInternalPreferences;
import org.eclipse.ui.internal.ide.IDEInternalWorkbenchImages;
import org.eclipse.ui.internal.ide.IDESelectionConversionService;
import org.eclipse.ui.internal.ide.IDEWorkbenchActivityHelper;
import org.eclipse.ui.internal.ide.IDEWorkbenchErrorHandler;
import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
import org.eclipse.ui.internal.ide.model.WorkbenchAdapterBuilder;
import org.eclipse.ui.internal.ide.undo.WorkspaceUndoMonitor;
import org.eclipse.ui.internal.progress.ProgressMonitorJobsDialog;

import org.eclipse.ui.statushandlers.AbstractStatusHandler;
import org.eclipse.ui.statushandlers.StatusManager;
import org.eclipse.update.core.SiteManager;
import org.osgi.framework.*;
import org.osgi.framework.ServiceReference;
import org.osgi.framework.Version;

import com.ibm.icu.text.Collator;

/**
 * IDE-specified workbench advisor which configures the workbench for use as an

	private IDEIdleHelper idleHelper;

	private Listener settingsChangeListener;

	/**
	 * Support class for monitoring workspace changes and periodically
	 * validating the undo history

	 */
	private AbstractStatusHandler ideWorkbenchErrorHandler;

	static IDEWorkbenchAdvisor getInstance() {
		return workbenchAdvisor;
	}

	/**
	 * Creates a new workbench advisor instance.
	 */

	public void initialize(IWorkbenchConfigurer configurer) {

		PluginActionBuilder.setAllowIdeLogging(true);

		// make sure we always save and restore workspace state
		configurer.setSaveAndRestore(true);


			}
		}

		// register shared images
		declareWorkbenchImages();

		// initialize the activity helper


		// initialize idle handler
		idleHelper = new IDEIdleHelper(configurer);

		// initialize the workspace undo monitor
		workspaceUndoMonitor = WorkspaceUndoMonitor.getInstance();


		Job.getJobManager().suspend();

		// Register the build actions
		IProgressService service = PlatformUI.getWorkbench().getProgressService();
		ImageDescriptor newImage = IDEInternalWorkbenchImages.getImageDescriptor(IDEInternalWorkbenchImages.IMG_ETOOL_BUILD_EXEC);
		service.registerIconForFamily(newImage, ResourcesPlugin.FAMILY_MANUAL_BUILD);
		service.registerIconForFamily(newImage, ResourcesPlugin.FAMILY_AUTO_BUILD);
		service.registerIconForFamily(newImage,
				ResourcesPlugin.FAMILY_MANUAL_BUILD);
		service.registerIconForFamily(newImage,
				ResourcesPlugin.FAMILY_AUTO_BUILD);
	}

	/*

			refreshFromLocal();
			activateProxyService();
			checkUpdates();
			((Workbench) PlatformUI.getWorkbench()).registerService(ISelectionConversionService.class, new IDESelectionConversionService());
					ISelectionConversionService.class,
					new IDESelectionConversionService());

			initializeSettingsChangeListener();
			Display.getCurrent().addListener(SWT.Settings, settingsChangeListener);
			runStartupCommand(Platform.getCommandLineArgs());
		} finally {// Resume background jobs after we startup
			Job.getJobManager().resume();
		}
	}

	/**
	 * 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;
	}

	/**
	 * Activate the proxy service by obtaining it.
	 */
	private void activateProxyService() {

		}
		if (proxyService == null) {
			IDEWorkbenchPlugin.log("Proxy service could not be found."); //$NON-NLS-1$
		}
	}

	/**

	private void initializeSettingsChangeListener() {
		settingsChangeListener = new Listener() {

			boolean currentHighContrast = Display.getCurrent().getHighContrast();
					.getHighContrast();

			public void handleEvent(org.eclipse.swt.widgets.Event event) {
				if (Display.getCurrent().getHighContrast() == currentHighContrast)

				currentHighContrast = !currentHighContrast;

				// make sure they really want to do this
				if (new MessageDialog(null, IDEWorkbenchMessages.SystemSettingsChange_title, null, IDEWorkbenchMessages.SystemSettingsChange_message, MessageDialog.QUESTION, new String[] {IDEWorkbenchMessages.SystemSettingsChange_yes, IDEWorkbenchMessages.SystemSettingsChange_no}, 1).open() == Window.OK) {
						IDEWorkbenchMessages.SystemSettingsChange_title, null,
						IDEWorkbenchMessages.SystemSettingsChange_message,
						MessageDialog.QUESTION, new String[] {
								IDEWorkbenchMessages.SystemSettingsChange_yes,
								IDEWorkbenchMessages.SystemSettingsChange_no },
						1).open() == Window.OK) {
					PlatformUI.getWorkbench().restart();
				}
			}

	 * @see org.eclipse.ui.application.WorkbenchAdvisor#preShutdown()
	 */
	public boolean preShutdown() {
		Display.getCurrent().removeListener(SWT.Settings, settingsChangeListener);
				settingsChangeListener);
		return super.preShutdown();
	}


	 * 
	 * @see org.eclipse.ui.application.WorkbenchAdvisor#createWorkbenchWindowAdvisor(org.eclipse.ui.application.IWorkbenchWindowConfigurer)
	 */
	public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(IWorkbenchWindowConfigurer configurer) {
			IWorkbenchWindowConfigurer configurer) {
		return new IDEWorkbenchWindowAdvisor(this, configurer);
	}


	 * @return boolean
	 */
	public boolean hasIntro() {
		return getWorkbenchConfigurer().getWorkbench().getIntroManager().hasIntro();
				.hasIntro();
	}

	private void refreshFromLocal() {
		String[] commandLineArgs = Platform.getCommandLineArgs();
		IPreferenceStore store = IDEWorkbenchPlugin.getDefault().getPreferenceStore();
		boolean refresh = store.getBoolean(IDEInternalPreferences.REFRESH_WORKSPACE_ON_STARTUP);
		boolean refresh = store
				.getBoolean(IDEInternalPreferences.REFRESH_WORKSPACE_ON_STARTUP);
		if (!refresh) {
			return;
		}


		final IContainer root = ResourcesPlugin.getWorkspace().getRoot();
		Job job = new WorkspaceJob(IDEWorkbenchMessages.Workspace_refreshing) {
			public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException {
					throws CoreException {
				root.refreshLocal(IResource.DEPTH_INFINITE, monitor);
				return Status.OK_STATUS;
			}

	 */
	private void disconnectFromWorkspace() {
		// save the workspace
		final MultiStatus status = new MultiStatus(IDEWorkbenchPlugin.IDE_WORKBENCH, 1, IDEWorkbenchMessages.ProblemSavingWorkbench, null);
				IDEWorkbenchPlugin.IDE_WORKBENCH, 1,
				IDEWorkbenchMessages.ProblemSavingWorkbench, null);
		IRunnableWithProgress runnable = new IRunnableWithProgress() {
			public void run(IProgressMonitor monitor) {
				try {
					status.merge(ResourcesPlugin.getWorkspace().save(true, monitor));
							monitor));
				} catch (CoreException e) {
					status.merge(e.getStatus());
				}

		try {
			new ProgressMonitorJobsDialog(null).run(true, false, runnable);
		} catch (InvocationTargetException e) {
			status.merge(new Status(IStatus.ERROR, IDEWorkbenchPlugin.IDE_WORKBENCH, 1, IDEWorkbenchMessages.InternalError, e.getTargetException()));
					.merge(new Status(IStatus.ERROR,
							IDEWorkbenchPlugin.IDE_WORKBENCH, 1,
							IDEWorkbenchMessages.InternalError, e
									.getTargetException()));
		} catch (InterruptedException e) {
			status.merge(new Status(IStatus.ERROR, IDEWorkbenchPlugin.IDE_WORKBENCH, 1, IDEWorkbenchMessages.InternalError, e));
		}
		ErrorDialog.openError(null, IDEWorkbenchMessages.ProblemsSavingWorkspace, null, status, IStatus.ERROR | IStatus.WARNING);
		}
		ErrorDialog.openError(null,
				IDEWorkbenchMessages.ProblemsSavingWorkspace, null, status,
				IStatus.ERROR | IStatus.WARNING);
		if (!status.isOK()) {
			IDEWorkbenchPlugin.log(IDEWorkbenchMessages.ProblemsSavingWorkspace, status);
					IDEWorkbenchMessages.ProblemsSavingWorkspace, status);
		}
	}


	 */
	private Map createNewBundleGroupsMap() {
		// retrieve list of installed bundle groups from last session
		IDialogSettings settings = IDEWorkbenchPlugin.getDefault().getDialogSettings();
				.getDialogSettings();
		String[] previousFeaturesArray = settings.getArray(INSTALLED_FEATURES);

		// get a map of currently installed bundle groups and store it for next


		Bundle ideBundle = Platform.getBundle(IDEWorkbenchPlugin.IDE_WORKBENCH);

		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_ETOOL_BUILD_EXEC, PATH_ETOOL + "build_exec.gif", false); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_ETOOL_BUILD_EXEC_HOVER, PATH_ETOOL + "build_exec.gif", false); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_ETOOL_BUILD_EXEC_DISABLED, PATH_DTOOL + "build_exec.gif", false); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_ETOOL_SEARCH_SRC, PATH_ETOOL + "search_src.gif", false); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_ETOOL_SEARCH_SRC_HOVER, PATH_ETOOL + "search_src.gif", false); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_ETOOL_SEARCH_SRC_DISABLED, PATH_DTOOL + "search_src.gif", false); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_ETOOL_NEXT_NAV, PATH_ETOOL + "next_nav.gif", false); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_ETOOL_PREVIOUS_NAV, PATH_ETOOL + "prev_nav.gif", false); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_WIZBAN_NEWPRJ_WIZ, PATH_WIZBAN + "newprj_wiz.png", false); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_WIZBAN_NEWFOLDER_WIZ, PATH_WIZBAN + "newfolder_wiz.png", false); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_WIZBAN_NEWFILE_WIZ, PATH_WIZBAN + "newfile_wiz.png", false); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_WIZBAN_IMPORTDIR_WIZ, PATH_WIZBAN + "importdir_wiz.png", false); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_WIZBAN_IMPORTZIP_WIZ, PATH_WIZBAN + "importzip_wiz.png", false); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_WIZBAN_EXPORTDIR_WIZ, PATH_WIZBAN + "exportdir_wiz.png", false); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_WIZBAN_EXPORTZIP_WIZ, PATH_WIZBAN + "exportzip_wiz.png", false); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_WIZBAN_RESOURCEWORKINGSET_WIZ, PATH_WIZBAN + "workset_wiz.png", false); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_DLGBAN_SAVEAS_DLG, PATH_WIZBAN + "saveas_wiz.png", false); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_DLGBAN_QUICKFIX_DLG, PATH_WIZBAN + "quick_fix.png", false); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle, IDE.SharedImages.IMG_OBJ_PROJECT, PATH_OBJECT + "prj_obj.gif", true); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDE.SharedImages.IMG_OBJ_PROJECT_CLOSED, PATH_OBJECT + "cprj_obj.gif", true); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDE.SharedImages.IMG_OPEN_MARKER, PATH_ELOCALTOOL + "gotoobj_tsk.gif", true); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_ELCL_QUICK_FIX_ENABLED, PATH_ELOCALTOOL + "smartmode_co.gif", true); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_DLCL_QUICK_FIX_DISABLED, PATH_DLOCALTOOL + "smartmode_co.gif", true); //$NON-NLS-1$
				IDEInternalWorkbenchImages.IMG_WIZBAN_NEWFILE_WIZ, PATH_WIZBAN
						+ "newfile_wiz.png", false); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle,
				IDEInternalWorkbenchImages.IMG_WIZBAN_IMPORTDIR_WIZ,
				PATH_WIZBAN + "importdir_wiz.png", false); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle,
				IDEInternalWorkbenchImages.IMG_WIZBAN_IMPORTZIP_WIZ,
				PATH_WIZBAN + "importzip_wiz.png", false); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle,
				IDEInternalWorkbenchImages.IMG_WIZBAN_EXPORTDIR_WIZ,
				PATH_WIZBAN + "exportdir_wiz.png", false); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle,
				IDEInternalWorkbenchImages.IMG_WIZBAN_EXPORTZIP_WIZ,
				PATH_WIZBAN + "exportzip_wiz.png", false); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle,
				IDEInternalWorkbenchImages.IMG_WIZBAN_RESOURCEWORKINGSET_WIZ,
				PATH_WIZBAN + "workset_wiz.png", false); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle,
				IDEInternalWorkbenchImages.IMG_DLGBAN_SAVEAS_DLG, PATH_WIZBAN
						+ "saveas_wiz.png", false); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle,
				IDEInternalWorkbenchImages.IMG_DLGBAN_QUICKFIX_DLG, PATH_WIZBAN
						+ "quick_fix.png", false); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle, IDE.SharedImages.IMG_OBJ_PROJECT,
				PATH_OBJECT + "prj_obj.gif", true); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle,
				IDE.SharedImages.IMG_OBJ_PROJECT_CLOSED, PATH_OBJECT
						+ "cprj_obj.gif", true); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDE.SharedImages.IMG_OPEN_MARKER,
				PATH_ELOCALTOOL + "gotoobj_tsk.gif", true); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle,
				IDEInternalWorkbenchImages.IMG_ELCL_QUICK_FIX_ENABLED,
				PATH_ELOCALTOOL + "smartmode_co.gif", true); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle,
				IDEInternalWorkbenchImages.IMG_DLCL_QUICK_FIX_DISABLED,
				PATH_DLOCALTOOL + "smartmode_co.gif", true); //$NON-NLS-1$

		// task objects
		// declareRegistryImage(IDEInternalWorkbenchImages.IMG_OBJS_HPRIO_TSK,

		// declareRegistryImage(IDEInternalWorkbenchImages.IMG_OBJS_LPRIO_TSK,
		// PATH_OBJECT+"lprio_tsk.gif");

		declareWorkbenchImage(ideBundle, IDE.SharedImages.IMG_OBJS_TASK_TSK, PATH_OBJECT + "taskmrk_tsk.gif", true); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDE.SharedImages.IMG_OBJS_BKMRK_TSK, PATH_OBJECT + "bkmrk_tsk.gif", true); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_OBJS_COMPLETE_TSK, PATH_OBJECT + "complete_tsk.gif", true); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_OBJS_INCOMPLETE_TSK, PATH_OBJECT + "incomplete_tsk.gif", true); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_OBJS_WELCOME_ITEM, PATH_OBJECT + "welcome_item.gif", true); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_OBJS_WELCOME_BANNER, PATH_OBJECT + "welcome_banner.gif", true); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_OBJS_ERROR_PATH, PATH_OBJECT + "error_tsk.gif", true); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_OBJS_WARNING_PATH, PATH_OBJECT + "warn_tsk.gif", true); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_OBJS_INFO_PATH, PATH_OBJECT + "info_tsk.gif", true); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_LCL_FLAT_LAYOUT, PATH_ELOCALTOOL + "flatLayout.gif", true); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_LCL_HIERARCHICAL_LAYOUT, PATH_ELOCALTOOL + "hierarchicalLayout.gif", true); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle, IDEInternalWorkbenchImages.IMG_ETOOL_PROBLEM_CATEGORY, PATH_ETOOL + "problem_category.gif", true); //$NON-NLS-1$

				IDEInternalWorkbenchImages.IMG_OBJS_WELCOME_BANNER, PATH_OBJECT
						+ "welcome_banner.gif", true); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle,
				IDEInternalWorkbenchImages.IMG_OBJS_ERROR_PATH, PATH_OBJECT
						+ "error_tsk.gif", true); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle,
				IDEInternalWorkbenchImages.IMG_OBJS_WARNING_PATH, PATH_OBJECT
						+ "warn_tsk.gif", true); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle,
				IDEInternalWorkbenchImages.IMG_OBJS_INFO_PATH, PATH_OBJECT
						+ "info_tsk.gif", true); //$NON-NLS-1$

		declareWorkbenchImage(ideBundle,
				IDEInternalWorkbenchImages.IMG_LCL_FLAT_LAYOUT, PATH_ELOCALTOOL
						+ "flatLayout.gif", true); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle,
				IDEInternalWorkbenchImages.IMG_LCL_HIERARCHICAL_LAYOUT,
				PATH_ELOCALTOOL + "hierarchicalLayout.gif", true); //$NON-NLS-1$
		declareWorkbenchImage(ideBundle,
				IDEInternalWorkbenchImages.IMG_ETOOL_PROBLEM_CATEGORY,
				PATH_ETOOL + "problem_category.gif", true); //$NON-NLS-1$
	
		// synchronization indicator objects
		// declareRegistryImage(IDEInternalWorkbenchImages.IMG_OBJS_WBET_STAT,
		// PATH_OVERLAY+"wbet_stat.gif");

	 *            <code>false</code> if this is not a shared image
	 * @see IWorkbenchConfigurer#declareImage
	 */
	private void declareWorkbenchImage(Bundle ideBundle, String symbolicName, String path, boolean shared) {
			String path, boolean shared) {
		URL url = FileLocator.find(ideBundle, new Path(path), null);
		ImageDescriptor desc = ImageDescriptor.createFromURL(url);
		getWorkbenchConfigurer().declareImage(symbolicName, desc, shared);

				ArrayList list = new ArrayList(m.size());
				for (Iterator i = m.values().iterator(); i.hasNext();) {
					AboutInfo info = (AboutInfo) i.next();
					if (info != null && info.getWelcomePerspectiveId() != null && info.getWelcomePageURL() != null) {
							&& info.getWelcomePageURL() != null) {
						list.add(info);
					}
				}

	 */
	public AbstractStatusHandler getWorkbenchErrorHandler() {
		if (ideWorkbenchErrorHandler == null) {
			ideWorkbenchErrorHandler = new IDEWorkbenchErrorHandler(getWorkbenchConfigurer());
					getWorkbenchConfigurer());
		}
		return ideWorkbenchErrorHandler;
	}

Lines 105-111 Link Here

(-)src/org/eclipse/ui/internal/ide/application/IDEApplication.java (-1 / +15 lines)
105	Platform.endSplash();	105	Platform.endSplash();
106	return EXIT_OK;	106	return EXIT_OK;
107	}	107	}
108		108
109	// create the workbench with this advisor and run it until it exits	109	// create the workbench with this advisor and run it until it exits
110	// N.B. createWorkbench remembers the advisor, and also registers	110	// N.B. createWorkbench remembers the advisor, and also registers
111	// the workbench globally so that all UI plug-ins can find it using	111	// the workbench globally so that all UI plug-ins can find it using
Lines 217-222 Link Here
217	// -data @noDefault or -data not specified, prompt and set	217	// -data @noDefault or -data not specified, prompt and set
218	ChooseWorkspaceData launchData = new ChooseWorkspaceData(instanceLoc	218	ChooseWorkspaceData launchData = new ChooseWorkspaceData(instanceLoc
219	.getDefault());	219	.getDefault());
		220
		221	//check if someone is listening that we can pass our command line to
		222	if (launchData.getPort() != 0) {
		223	if (new IDECommunication().writeToPort(launchData.getPort(), launchData.getIPCAuthorization())) {
		224	//we successfully punted this application's command line to another instance,
		225	//so we can just shutdown this instance.
		226	return false;
		227	}
		228	}
220		229
221	boolean force = false;	230	boolean force = false;
222	while (true) {	231	while (true) {
Lines 233-238 Link Here
233	// the operation will fail if the url is not a valid	242	// the operation will fail if the url is not a valid
234	// instance data area, so other checking is unneeded	243	// instance data area, so other checking is unneeded
235	if (instanceLoc.setURL(workspaceUrl, true)) {	244	if (instanceLoc.setURL(workspaceUrl, true)) {
		245	int[] ipcData = new IDECommunication().listen();
		246	if (ipcData != null) {
		247	launchData.setPort(ipcData[0]);
		248	launchData.setIPCAuthorization(ipcData[1]);
		249	}
236	launchData.writePersistedData();	250	launchData.writePersistedData();
237	writeWorkspaceVersion();	251	writeWorkspaceVersion();
238	return true;	252	return true;




/*******************************************************************************
 * 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);
		}
	}

}

Return to bug 4922

Lines 69-75 Link Here

(-)src/org/eclipse/ui/internal/ide/ChooseWorkspaceData.java (-3 / +63 lines)
69	/**	69	/**
70	* This is the second version of the encode/decode protocol that uses the	70	* This is the second version of the encode/decode protocol that uses the
71	* confi area preferences store for persistence. This version is the same as	71	* confi area preferences store for persistence. This version is the same as
72	* the previous version except it uses a \n character to seperate the path	72	* the previous version except it uses a \n character to separate the path
73	* entries instead of commas. (see bug 98467)	73	* entries instead of commas. (see bug 98467)
74	*	74	*
75	* @since 3.3.1	75	* @since 3.3.1
Lines 83-88 Link Here
83	private String selection;	83	private String selection;
84		84
85	private String[] recentWorkspaces;	85	private String[] recentWorkspaces;
		86
		87	/**
		88	* The port on which an instance of this configuration is already listening for remote communication.
		89	* This value is 0 if nobody is already listening.
		90	*/
		91	private int port = 0;
		92	/**
		93	* An authorization integer that a client must provide when communication with
		94	* this application. This is a simple security measure to prevent a port scanner
		95	* from executing commands in this application.
		96	*/
		97	private int ipcAuth = 0;
86		98
87	// xml tags	99	// xml tags
88	private static interface XML {	100	private static interface XML {
Lines 101-107 Link Here
101	public static final String MAX_LENGTH = "maxLength"; //$NON-NLS-1$	113	public static final String MAX_LENGTH = "maxLength"; //$NON-NLS-1$
102		114
103	public static final String PATH = "path"; //$NON-NLS-1$	115	public static final String PATH = "path"; //$NON-NLS-1$
104	}	116
		117	public static final String PORT= "port"; //$NON-NLS-1$
		118
		119	public static final String IPC_AUTH= "ipcAuth"; //$NON-NLS-1$
		120	}
105		121
106	/**	122	/**
107	* Creates a new instance, loading persistent data if its found.	123	* Creates a new instance, loading persistent data if its found.
Lines 151-156 Link Here
151	}	167	}
152	initialDefault = dir;	168	initialDefault = dir;
153	}	169	}
		170
		171	/**
		172	* Sets the port on which an instance is listening for remote communication.
		173	* @param port The port, or 0 to indicate not listening.
		174	*/
		175	public void setPort(int port) {
		176	this.port = port;
		177	}
		178
		179	/**
		180	* Sets an authorization integer that a client must provide to establish
		181	* remote communication. This is used to prevent a port sniffer from
		182	* executing commands.
		183	*/
		184	public void setIPCAuthorization(int auth) {
		185	this.ipcAuth = auth;
		186	}
154		187
155	/**	188	/**
156	* Return the currently selected workspace or null if nothing is selected.	189	* Return the currently selected workspace or null if nothing is selected.
Lines 173-178 Link Here
173	public String[] getRecentWorkspaces() {	206	public String[] getRecentWorkspaces() {
174	return recentWorkspaces;	207	return recentWorkspaces;
175	}	208	}
		209
		210	/**
		211	* Returns the port on which an instance of this same configuration is
		212	* already listening for remote communication, or 0 if nobody is listening.
		213	* @return The port number, or 0.
		214	*/
		215	public int getPort() {
		216	return port;
		217	}
		218
		219	/**
		220	* Returns the authorization integer for establishing interprocess communication.
		221	* @return The authorization integer
		222	*/
		223	public int getIPCAuthorization() {
		224	return ipcAuth;
		225	}
176		226
177	/**	227	/**
178	* The argument workspace has been selected, update the receiver. Does not	228	* The argument workspace has been selected, update the receiver. Does not
Lines 230-237 Link Here
230	// 5. store the protocol version used to encode the list	280	// 5. store the protocol version used to encode the list
231	node.putInt(IDE.Preferences.RECENT_WORKSPACES_PROTOCOL,	281	node.putInt(IDE.Preferences.RECENT_WORKSPACES_PROTOCOL,
232	PERS_ENCODING_VERSION_CONFIG_PREFS_NO_COMMAS);	282	PERS_ENCODING_VERSION_CONFIG_PREFS_NO_COMMAS);
		283
		284	// 6. store the interprocess communication data, if any
		285	if (port != 0) {
		286	node.putInt(XML.PORT, port);
		287	node.putInt(XML.IPC_AUTH, ipcAuth);
		288	}
233		289
234	// 6. store the node	290	// 7. store the node
235	try {	291	try {
236	node.flush();	292	node.flush();
237	} catch (BackingStoreException e) {	293	} catch (BackingStoreException e) {
Lines 405-410 Link Here
405	.getString(IDE.Preferences.RECENT_WORKSPACES);	461	.getString(IDE.Preferences.RECENT_WORKSPACES);
406	recentWorkspaces = decodeStoredWorkspacePaths(protocol, max, workspacePathPref);	462	recentWorkspaces = decodeStoredWorkspacePaths(protocol, max, workspacePathPref);
407		463
		464	// 5. load the interprocess communication data
		465	port = store.getInt(XML.PORT);
		466	ipcAuth = store.getInt(XML.IPC_AUTH);
		467
408	return true;	468	return true;
409	}	469	}
410		470

Added Link Here

(-)src/org/eclipse/ui/internal/ide/application/IDECommunication.java (+208 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	******************************************************************************/
11
12	package org.eclipse.ui.internal.ide.application;
13
14	import java.security.SecureRandom;
15
16	import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
17
18	import java.io.*;
19	import java.net.*;
20	import org.eclipse.core.runtime.*;
21	import org.eclipse.core.runtime.jobs.Job;
22
23	/**
24	* A helper class that deals with interprocess communication between applications.
25	* <p>
26	* This class uses a socket connection on a random available port to establish
27	* communication between applications. The client must provide an authorization
28	* code to protect against communication from arbitrary port sniffing applications.
29	*
30	* @since 3.5
31	*/
32	class IDECommunication {
33	/**
34	* A job that listens on a socket for a command, and then invokes the
35	* workbench advisor to handle the command.
36	*/
37	class ListenJob extends Job {
38	private ServerSocket server;
39	private int auth;
40
41	public ListenJob(ServerSocket server, int auth) {
42	super("Listen"); //$NON-NLS-1$
43	this.server = server;
44	this.auth = auth;
45	setSystem(true);
46	}
47
48	/* (non-Javadoc)
49	* @see org.eclipse.core.runtime.jobs.Job#canceling()
50	*/
51	protected void canceling() {
52	try {
53	server.close();
54	} catch (IOException e) {
55	//ignore
56	}
57	}
58
59	/* (non-Javadoc)
60	* @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)
61	*/
62	protected IStatus run(IProgressMonitor monitor) {
63	if (server.isClosed())
64	return Status.OK_STATUS;
65	Socket client = null;
66	DataInputStream in = null;
67	DataOutputStream out = null;
68	try {
69	client = server.accept();
70	in = new DataInputStream(client.getInputStream());
71	out = new DataOutputStream(client.getOutputStream());
72	//read the protocol version
73	int version = in.readInt();
74	String[] args = null;
75	if (version == PROTOCOL_VERSION_ONE) {
76	//read the authorization checksum
77	int receivedAuth = in.readInt();
78	//abort immediately if we failed to read the authorization integer
79	if (receivedAuth != auth) {
80	schedule(SCHEDULE_DELAY);
81	return new Status(IStatus.ERROR, IDEWorkbenchPlugin.IDE_WORKBENCH, "Connection from unauthorized client on port " + server.getLocalPort()); //$NON-NLS-1$
82	}
83	args = new String[in.readInt()];
84	for (int i = 0; i < args.length; i++) {
85	args[i] = in.readUTF();
86	}
87	}
88	//pass the read arguments to the workbench advisor
89	IDEWorkbenchAdvisor advisor = IDEWorkbenchAdvisor.getInstance();
90	if (advisor != null && args != null) {
91	if (advisor.runStartupCommand(args))
92	out.writeUTF(OK);
93	else
94	out.writeUTF(FAIL);
95	}
96	} catch (IOException e) {
97	IDEWorkbenchPlugin.log("Error communicating with client", e); //$NON-NLS-1$
98	} finally {
99	safeClose(in);
100	safeClose(out);
101	safeClose(client);
102	}
103	//reschedule
104	schedule(SCHEDULE_DELAY);
105	return Status.OK_STATUS;
106	}
107	}
108
109	/**
110	* The first communication protocol version. This version contains an authorization
111	* integer followed by a list of command line arguments. The format is: int authorizationId, int N, String[N].
112	*/
113	private static final int PROTOCOL_VERSION_ONE = 1;
114
115	private static final long SCHEDULE_DELAY = 1000;
116
117	static final String OK = "OK"; //$NON-NLS-1$
118	static final String FAIL = "FAIL"; //$NON-NLS-1$
119
120	/**
121	* Start listening for commands.
122	* @return An integer array of size two. The first integer is the port
123	* number we are listening on, and the second integer is an authorization
124	* integer used to validate connections. Returns <code>null</code> if
125	* there was a failure to establish communication
126	*/
127	public int[] listen() {
128	try {
129	ServerSocket server = new ServerSocket(0);
130	int auth = new SecureRandom().nextInt();
131	new ListenJob(server, auth).schedule(SCHEDULE_DELAY);
132	return new int[] {server.getLocalPort(), auth};
133	} catch (IOException e) {
134	return null;
135	}
136	}
137
138	/**
139	* Close the given stream and ignore secondary failures.
140	*/
141	void safeClose(DataInputStream in) {
142	try {
143	if (in != null)
144	in.close();
145	} catch (IOException e) {
146	//ignore secondary failure while closing
147	}
148	}
149
150	/**
151	* Close the given stream and ignore secondary failures.
152	*/
153	void safeClose(DataOutputStream out) {
154	try {
155	if (out != null)
156	out.close();
157	} catch (IOException e) {
158	//ignore secondary failure while closing
159	}
160	}
161
162	/**
163	* Close the given socket and ignore secondary failures.
164	*/
165	void safeClose(Socket socket) {
166	try {
167	if (socket != null)
168	socket.close();
169	} catch (IOException e) {
170	//ignore secondary failure while closing
171	}
172	}
173
174	/**
175	* Writes this application's command line arguments to the given port.
176	*
177	* @param port The port to write data to
178	* @param auth The authorization integer
179	* @return <code>true</code> if written successfully, and <code>false</code> otherwise.
180	*/
181	public boolean writeToPort(int port, int auth) {
182	Socket socket = null;
183	DataOutputStream out = null;
184	DataInputStream in = null;
185	try {
186	socket = new Socket("localhost", port);//$NON-NLS-1$
187	out = new DataOutputStream(socket.getOutputStream());
188	in = new DataInputStream(socket.getInputStream());
189	out.writeInt(PROTOCOL_VERSION_ONE);
190	out.writeInt(auth);
191	String[] args = Platform.getCommandLineArgs();
192	out.writeInt(args.length);
193	for (int i = 0; i < args.length; i++)
194	out.writeUTF(args[i]);
195	//server will return OK or FAIL
196	return in.readUTF().equals(OK);
197	} catch (UnknownHostException e) {
198	return false;
199	} catch (IOException e) {
200	return false;
201	} finally {
202	safeClose(socket);
203	safeClose(out);
204	safeClose(in);
205	}
206	}
207
208	}