bundles/org.eclipse.equinox.console.ssh/src/org/eclipse/equinox/console/ssh/SshCommand.java - equinox/rt.equinox.bundles - Git at Google

 /*******************************************************************************
  * Copyright (c) 2011, 2012 SAP AG
  * 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:
  *     Lazar Kirchev, SAP AG - initial API and implementation
  *******************************************************************************/

 package org.eclipse.equinox.console.ssh;

 import java.io.IOException;
 import java.net.BindException;
 import java.net.ServerSocket;
 import java.util.ArrayList;
 import java.util.Dictionary;
 import java.util.Hashtable;
 import java.util.List;

 import org.apache.felix.service.command.CommandProcessor;
 import org.apache.felix.service.command.Descriptor;
 import org.eclipse.equinox.console.storage.DigestUtil;
 import org.eclipse.equinox.console.storage.SecureUserStore;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.Constants;
 import org.osgi.framework.ServiceRegistration;
 import org.osgi.service.cm.ConfigurationException;
 import org.osgi.service.cm.ManagedService;

 /**
  * This class implements a command for starting/stopping a simple ssh server.
  *
  */
 public class SshCommand {
 	private String defaultHost = null;
 	private int defaultPort;
     private List<CommandProcessor> processors = new ArrayList<CommandProcessor>();
     private String host = null;
     private int port;
     private SshServ sshServ;
     private BundleContext context;
     private ServiceRegistration<?> configuratorRegistration;
     private boolean isEnabled = false;
     private final Object lock = new Object();

     private static final String DEFAULT_USER = "equinox";
     private static final String DEFAULT_PASSWORD = "equinox";
     private static final String DEFAULT_USER_STORE_PROPERTY = "osgi.console.ssh.useDefaultSecureStorage";
     private static final String HOST = "host";
     private static final String PORT = "port";
     private static final String USE_CONFIG_ADMIN_PROP = "osgi.console.useConfigAdmin";
     private static final String SSH_PID = "osgi.console.ssh";
     private static final String ENABLED = "enabled";

     public SshCommand(CommandProcessor processor, BundleContext context) {
         processors.add(processor);
         this.context = context;

         if ("true".equals(context.getProperty(USE_CONFIG_ADMIN_PROP))) {
         	Dictionary<String, String> sshProperties = new Hashtable<String, String>();
         	sshProperties.put(Constants.SERVICE_PID, SSH_PID);
         	try {
         		synchronized (lock) {
         			configuratorRegistration = context.registerService(ManagedService.class.getName(), new SshConfigurator(), sshProperties);
         		}
         	} catch (NoClassDefFoundError e) {
         		System.out.println("Configuration Admin not available!");
         		return;
         	}
         } else {
         	parseHostAndPort();
         }
     }

     private void parseHostAndPort() {
     	String sshPort = null;
         String consolePropValue = context.getProperty(SSH_PID);
         if(consolePropValue != null) {
         	int index = consolePropValue.lastIndexOf(":");
         	if (index > -1) {
         		defaultHost = consolePropValue.substring(0, index);
         	}
         	sshPort = consolePropValue.substring(index + 1);
         	isEnabled = true;
         }
         if (sshPort != null && !"".equals(sshPort)) {
         	try {
         		defaultPort = Integer.parseInt(sshPort);
 			} catch (NumberFormatException e) {
 				// do nothing
 			}
         }
     }

     public synchronized void startService() {
     	Dictionary<String, Object> properties = new Hashtable<String, Object>();
 		properties.put("osgi.command.scope", "equinox");
 		properties.put("osgi.command.function", new String[] {"ssh"});
 		if ((port > 0 || defaultPort > 0) && isEnabled == true) {
 			try{
 				ssh(new String[]{"start"});
 			} catch (Exception e) {
 				System.out.println("Cannot start ssh. Reason: " + e.getMessage());
 				e.printStackTrace();
 			}
 		}
 		context.registerService(SshCommand.class.getName(), this, properties);
     }

     @Descriptor("start/stop a ssh server")
     public synchronized void ssh(String[] arguments) throws Exception {
         String command = null;
         String newHost = null;
         int newPort = 0;

         for(int i = 0; i < arguments.length; i++) {
         	if("-?".equals(arguments[i]) || "-help".equals(arguments[i])) {
         		printHelp();
         		return;
         	} else if("start".equals(arguments[i])) {
         		command = "start";
         	} else if ("stop".equals(arguments[i])) {
         		command = "stop";
         	} else if ("-port".equals(arguments[i]) && (arguments.length > i + 1)) {
         		i++;
         		newPort = Integer.parseInt(arguments[i]);
         	} else if ("-host".equals(arguments[i]) && (arguments.length > i + 1)) {
         		i++;
         		newHost = arguments[i];
         	} else {
         		throw new Exception("Unrecognized ssh command/option " + arguments[i]);
         	}
         }

         if (command == null) {
         	throw new Exception("No ssh command specified");
         }

         if (newPort != 0) {
         	port = newPort;
         } else if (port == 0) {
         	port = defaultPort;
         }

         if (port == 0) {
         	throw new Exception("No ssh port specified");
         }

         if (newHost != null) {
         	host = newHost;
         } else {
         	host = defaultHost;
         }

         if ("start".equals(command)) {
             if (sshServ != null) {
                 throw new IllegalStateException("ssh is already running on port " + port);
             }

             checkPortAvailable(port);

             sshServ = new SshServ(processors, context, host, port);
             sshServ.setName("equinox ssh");

             if ("true".equals(context.getProperty(DEFAULT_USER_STORE_PROPERTY))) {
             	try {
             		checkUserStore();
             		registerUserAdmin();
             	} catch (NoClassDefFoundError e) {
             		System.out.println("If you want to use secure storage, please install Equinox security bundle and its dependencies");
             		sshServ = null;
     				return;
             	} catch (IOException e) {
             		e.printStackTrace();
             		sshServ = null;
     				return;
             	}
             }

             try {
 				sshServ.start();
 			} catch (RuntimeException e) {
 				sshServ = null;
 				return;
 			}
         } else if ("stop".equals(command)) {
             if (sshServ == null) {
                 System.out.println("ssh is not running.");
                 return;
             }

             sshServ.stopSshServer();
             sshServ = null;
         }
     }

     public synchronized void addCommandProcessor(CommandProcessor processor) {
     	processors.add(processor);
     	if (sshServ != null) {
     		sshServ.addCommandProcessor(processor);
     	}
     }

     public synchronized void removeCommandProcessor(CommandProcessor processor) {
     	processors.remove(processor);
     	if (sshServ != null) {
     		sshServ.removeCommandProcessor(processor);
     	}
     }

     private void checkPortAvailable(int port) throws Exception {
     	ServerSocket socket = null;
     	try {
     		socket = new ServerSocket(port);
     	} catch (BindException e) {
     		throw new Exception ("Port " + port + " already in use");
     	} finally {
     		if (socket != null) {
     			socket.close();
     		}
     	}
     }

     /*
      * Register user administration commands
      */
     private void registerUserAdmin() {
     	Dictionary<String, Object> properties = new Hashtable<String, Object>();
 		properties.put("osgi.command.scope", "equinox");
 		properties.put("osgi.command.function", new String[] {"addUser", "addUser", "deleteUser", "resetPassword", "setPassword", "addRoles", "removeRoles", "listUsers"});
 		context.registerService(UserAdminCommand.class.getName(), new UserAdminCommand(), properties);
     }

     /*
      * Create user store if not available. Add the default user, if there is no other user in the store.
      */
     private void checkUserStore() throws Exception {
     	SecureUserStore.initStorage();
     	if(SecureUserStore.getUserNames().length == 0) {
     		SecureUserStore.putUser(DEFAULT_USER, DigestUtil.encrypt(DEFAULT_PASSWORD), null );
     	}
     }

     private void printHelp() {
     	StringBuffer help = new StringBuffer();
     	help.append("ssh - start simple ssh server");
     	help.append("\n");
     	help.append("Usage: ssh start | stop [-port port] [-host host]");
     	help.append("\n");
     	help.append("\t");
     	help.append("-port");
     	help.append("\t");
     	help.append("listen port (default=");
     	help.append(defaultPort);
     	help.append(")");
     	help.append("\n");
     	help.append("\t");
     	help.append("-host");
     	help.append("\t");
     	help.append("local host address to listen on (default is none - listen on all network interfaces)");
     	help.append("\n");
     	help.append("\t");
     	help.append("-?, -help");
     	help.append("\t");
     	help.append("show help");
     	System.out.println(help.toString());
     }

     class SshConfigurator implements ManagedService {
     	@SuppressWarnings("rawtypes")
 		private Dictionary properties;
 		@SuppressWarnings({ "rawtypes", "unchecked" })
 		public synchronized void updated(Dictionary props) throws ConfigurationException {
 			if (props != null) {
 				this.properties = props;
 				properties.put(Constants.SERVICE_PID, SSH_PID);
 			} else {
 				return;
 			}

 			defaultPort = Integer.parseInt(((String)properties.get(PORT)));
 			defaultHost = (String)properties.get(HOST);
 			if (properties.get(ENABLED) == null) {
 				isEnabled = false;
 			} else {
 				isEnabled = Boolean.parseBoolean((String)properties.get(ENABLED));
 			}
 			synchronized (lock) {
 				configuratorRegistration.setProperties(properties);
 			}
 			if (sshServ == null && isEnabled == true) {
 				try {
 					ssh(new String[]{"start"});
 				} catch (Exception e) {
 					System.out.println("Cannot start ssh: " + e.getMessage());
 					e.printStackTrace();
 				}
 			}
 		}

     }
 }
	/*******************************************************************************
	* Copyright (c) 2011, 2012 SAP AG
	* 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:
	* Lazar Kirchev, SAP AG - initial API and implementation
	*******************************************************************************/

	package org.eclipse.equinox.console.ssh;

	import java.io.IOException;
	import java.net.BindException;
	import java.net.ServerSocket;
	import java.util.ArrayList;
	import java.util.Dictionary;
	import java.util.Hashtable;
	import java.util.List;

	import org.apache.felix.service.command.CommandProcessor;
	import org.apache.felix.service.command.Descriptor;
	import org.eclipse.equinox.console.storage.DigestUtil;
	import org.eclipse.equinox.console.storage.SecureUserStore;
	import org.osgi.framework.BundleContext;
	import org.osgi.framework.Constants;
	import org.osgi.framework.ServiceRegistration;
	import org.osgi.service.cm.ConfigurationException;
	import org.osgi.service.cm.ManagedService;

	/**
	* This class implements a command for starting/stopping a simple ssh server.
	*
	*/
	public class SshCommand {
	private String defaultHost = null;
	private int defaultPort;
	private List<CommandProcessor> processors = new ArrayList<CommandProcessor>();
	private String host = null;
	private int port;
	private SshServ sshServ;
	private BundleContext context;
	private ServiceRegistration<?> configuratorRegistration;
	private boolean isEnabled = false;
	private final Object lock = new Object();

	private static final String DEFAULT_USER = "equinox";
	private static final String DEFAULT_PASSWORD = "equinox";
	private static final String DEFAULT_USER_STORE_PROPERTY = "osgi.console.ssh.useDefaultSecureStorage";
	private static final String HOST = "host";
	private static final String PORT = "port";
	private static final String USE_CONFIG_ADMIN_PROP = "osgi.console.useConfigAdmin";
	private static final String SSH_PID = "osgi.console.ssh";
	private static final String ENABLED = "enabled";

	public SshCommand(CommandProcessor processor, BundleContext context) {
	processors.add(processor);
	this.context = context;

	if ("true".equals(context.getProperty(USE_CONFIG_ADMIN_PROP))) {
	Dictionary<String, String> sshProperties = new Hashtable<String, String>();
	sshProperties.put(Constants.SERVICE_PID, SSH_PID);
	try {
	synchronized (lock) {
	configuratorRegistration = context.registerService(ManagedService.class.getName(), new SshConfigurator(), sshProperties);
	}
	} catch (NoClassDefFoundError e) {
	System.out.println("Configuration Admin not available!");
	return;
	}
	} else {
	parseHostAndPort();
	}
	}

	private void parseHostAndPort() {
	String sshPort = null;
	String consolePropValue = context.getProperty(SSH_PID);
	if(consolePropValue != null) {
	int index = consolePropValue.lastIndexOf(":");
	if (index > -1) {
	defaultHost = consolePropValue.substring(0, index);
	}
	sshPort = consolePropValue.substring(index + 1);
	isEnabled = true;
	}
	if (sshPort != null && !"".equals(sshPort)) {
	try {
	defaultPort = Integer.parseInt(sshPort);
	} catch (NumberFormatException e) {
	// do nothing
	}
	}
	}

	public synchronized void startService() {
	Dictionary<String, Object> properties = new Hashtable<String, Object>();
	properties.put("osgi.command.scope", "equinox");
	properties.put("osgi.command.function", new String[] {"ssh"});
	if ((port > 0 \|\| defaultPort > 0) && isEnabled == true) {
	try{
	ssh(new String[]{"start"});
	} catch (Exception e) {
	System.out.println("Cannot start ssh. Reason: " + e.getMessage());
	e.printStackTrace();
	}
	}
	context.registerService(SshCommand.class.getName(), this, properties);
	}

	@Descriptor("start/stop a ssh server")
	public synchronized void ssh(String[] arguments) throws Exception {
	String command = null;
	String newHost = null;
	int newPort = 0;

	for(int i = 0; i < arguments.length; i++) {
	if("-?".equals(arguments[i]) \|\| "-help".equals(arguments[i])) {
	printHelp();
	return;
	} else if("start".equals(arguments[i])) {
	command = "start";
	} else if ("stop".equals(arguments[i])) {
	command = "stop";
	} else if ("-port".equals(arguments[i]) && (arguments.length > i + 1)) {
	i++;
	newPort = Integer.parseInt(arguments[i]);
	} else if ("-host".equals(arguments[i]) && (arguments.length > i + 1)) {
	i++;
	newHost = arguments[i];
	} else {
	throw new Exception("Unrecognized ssh command/option " + arguments[i]);
	}
	}

	if (command == null) {
	throw new Exception("No ssh command specified");
	}

	if (newPort != 0) {
	port = newPort;
	} else if (port == 0) {
	port = defaultPort;
	}

	if (port == 0) {
	throw new Exception("No ssh port specified");
	}

	if (newHost != null) {
	host = newHost;
	} else {
	host = defaultHost;
	}

	if ("start".equals(command)) {
	if (sshServ != null) {
	throw new IllegalStateException("ssh is already running on port " + port);
	}

	checkPortAvailable(port);

	sshServ = new SshServ(processors, context, host, port);
	sshServ.setName("equinox ssh");

	if ("true".equals(context.getProperty(DEFAULT_USER_STORE_PROPERTY))) {
	try {
	checkUserStore();
	registerUserAdmin();
	} catch (NoClassDefFoundError e) {
	System.out.println("If you want to use secure storage, please install Equinox security bundle and its dependencies");
	sshServ = null;
	return;
	} catch (IOException e) {
	e.printStackTrace();
	sshServ = null;
	return;
	}
	}

	try {
	sshServ.start();
	} catch (RuntimeException e) {
	sshServ = null;
	return;
	}
	} else if ("stop".equals(command)) {
	if (sshServ == null) {
	System.out.println("ssh is not running.");
	return;
	}

	sshServ.stopSshServer();
	sshServ = null;
	}
	}

	public synchronized void addCommandProcessor(CommandProcessor processor) {
	processors.add(processor);
	if (sshServ != null) {
	sshServ.addCommandProcessor(processor);
	}
	}

	public synchronized void removeCommandProcessor(CommandProcessor processor) {
	processors.remove(processor);
	if (sshServ != null) {
	sshServ.removeCommandProcessor(processor);
	}
	}

	private void checkPortAvailable(int port) throws Exception {
	ServerSocket socket = null;
	try {
	socket = new ServerSocket(port);
	} catch (BindException e) {
	throw new Exception ("Port " + port + " already in use");
	} finally {
	if (socket != null) {
	socket.close();
	}
	}
	}

	/*
	* Register user administration commands
	*/
	private void registerUserAdmin() {
	Dictionary<String, Object> properties = new Hashtable<String, Object>();
	properties.put("osgi.command.scope", "equinox");
	properties.put("osgi.command.function", new String[] {"addUser", "addUser", "deleteUser", "resetPassword", "setPassword", "addRoles", "removeRoles", "listUsers"});
	context.registerService(UserAdminCommand.class.getName(), new UserAdminCommand(), properties);
	}

	/*
	* Create user store if not available. Add the default user, if there is no other user in the store.
	*/
	private void checkUserStore() throws Exception {
	SecureUserStore.initStorage();
	if(SecureUserStore.getUserNames().length == 0) {
	SecureUserStore.putUser(DEFAULT_USER, DigestUtil.encrypt(DEFAULT_PASSWORD), null );
	}
	}

	private void printHelp() {
	StringBuffer help = new StringBuffer();
	help.append("ssh - start simple ssh server");
	help.append("\n");
	help.append("Usage: ssh start \| stop [-port port] [-host host]");
	help.append("\n");
	help.append("\t");
	help.append("-port");
	help.append("\t");
	help.append("listen port (default=");
	help.append(defaultPort);
	help.append(")");
	help.append("\n");
	help.append("\t");
	help.append("-host");
	help.append("\t");
	help.append("local host address to listen on (default is none - listen on all network interfaces)");
	help.append("\n");
	help.append("\t");
	help.append("-?, -help");
	help.append("\t");
	help.append("show help");
	System.out.println(help.toString());
	}

	class SshConfigurator implements ManagedService {
	@SuppressWarnings("rawtypes")
	private Dictionary properties;
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public synchronized void updated(Dictionary props) throws ConfigurationException {
	if (props != null) {
	this.properties = props;
	properties.put(Constants.SERVICE_PID, SSH_PID);
	} else {
	return;
	}

	defaultPort = Integer.parseInt(((String)properties.get(PORT)));
	defaultHost = (String)properties.get(HOST);
	if (properties.get(ENABLED) == null) {
	isEnabled = false;
	} else {
	isEnabled = Boolean.parseBoolean((String)properties.get(ENABLED));
	}
	synchronized (lock) {
	configuratorRegistration.setProperties(properties);
	}
	if (sshServ == null && isEnabled == true) {
	try {
	ssh(new String[]{"start"});
	} catch (Exception e) {
	System.out.println("Cannot start ssh: " + e.getMessage());
	e.printStackTrace();
	}
	}
	}

	}
	}