/*******************************************************************************
 * Copyright (c) 2000, 2006 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:
 *     Atsuhiko Yamanaka, JCraft,Inc. - initial API and implementation.
 *     IBM Corporation - ongoing maintenance
 *******************************************************************************/
package org.eclipse.team.internal.ccvs.ssh2;
import java.io.*;
import java.net.NoRouteToHostException;
import java.net.UnknownHostException;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.osgi.util.NLS;
import org.eclipse.team.internal.ccvs.core.ICVSRepositoryLocation;
import org.eclipse.team.internal.ccvs.core.IServerConnection;
import org.eclipse.team.internal.ccvs.core.connection.CVSAuthenticationException;
import org.eclipse.team.internal.ccvs.ssh.SSHServerConnection;
import org.eclipse.team.internal.core.streams.*;

import com.jcraft.jsch.*;

/**
 * SSH2 connection method. Has the property of defaulting to SSH1 if the server
 * doesn't support SSH2. 
 */
public class CVSSSH2ServerConnection implements IServerConnection {
	private final class SSH2IOException extends IOException {
        private static final long serialVersionUID = 1L;

        private final JSchException e;

        private SSH2IOException(String s, JSchException e) {
            super(s);
            this.e = e;
        }

        public Throwable getCause() {
            return e;
        }
    }
    private static final String COMMAND = "cvs server"; //$NON-NLS-1$
	private ICVSRepositoryLocation location;
	private String password;
	private InputStream inputStream;
	private OutputStream outputStream;
	private JSchSession session;
	private Channel channel;
	private IServerConnection ssh1;
	
	protected CVSSSH2ServerConnection(ICVSRepositoryLocation location, String password) {
		this.location = location;
		this.password = password;
	}
	public void close() throws IOException {
		if (ssh1 != null) {
			ssh1.close();
			ssh1 = null;
			return;
		}
		try {
			if (inputStream != null) {
				try {
					inputStream.close();
				} catch (IOException e) {
					// Ignore I/O Exception on close
				}
			}
		} finally {
			try {
				if (outputStream != null) {
					try {
						outputStream.close();
					} catch (IOException e) {
						// Ignore I/O Exception on close
					}
				}
			} finally {
				if (channel != null)
					channel.disconnect();
			}
		} 
	}
	public InputStream getInputStream() {
		if (ssh1 != null) {
			return ssh1.getInputStream();
		}
		return inputStream;
	}
	public OutputStream getOutputStream() {
		if (ssh1 != null) {
			return ssh1.getOutputStream();
		}
		return outputStream;
	}
	public void open(IProgressMonitor monitor) throws IOException, CVSAuthenticationException {
		if (ssh1 != null) {
			ssh1.open(monitor);
			return;
		}
		monitor.subTask(NLS.bind(CVSSSH2Messages.CVSSSH2ServerConnection_open, new String[] { location.getHost() })); 
		monitor.worked(1);
		internalOpen(monitor);
	}
	/**
	 * @param monitor
	 * @throws IOException
	 * @throws CVSAuthenticationException
	 */
	private void internalOpen(IProgressMonitor monitor) throws IOException, CVSAuthenticationException {
		try {
			OutputStream channel_out = null;
			InputStream channel_in = null;
            boolean firstTime = true;
            boolean tryAgain = false;
			while (firstTime || tryAgain) {
                tryAgain = false; // reset the try again flag
				session = JSchSession.getSession(location, location.getUsername(), password, location.getHost(), location.getPort(), monitor);
				channel = session.getSession().openChannel("exec"); //$NON-NLS-1$
				((ChannelExec) channel).setCommand(COMMAND);
				channel_out = channel.getOutputStream();
				channel_in = channel.getInputStream();
				try {
					channel.connect();
				} catch (JSchException ee) {
                    // This strange logic is here due to how the JSch client shares sessions.
                    // It is possible that we have obtained a session that thinks it is connected
                    // but is not. Channel connection only works if the session is connected so the
                    // above channel connect may fail because the session is down. For this reason,
                    // we want to retry if the connection fails.
                    try {
                        if (firstTime && (isSessionDownError(ee) || isChannelNotOpenError(ee))) {
                            tryAgain = true;
                        }
                        if (!tryAgain) {
                            throw ee;
                        }
                    } finally {
                        // Always dispose of the current session when a failure occurs so we can start from scratch
                        session.dispose();
                    }
				}
                firstTime = false; // the first time is done
			}
			int timeout = location.getTimeout();
			inputStream = new PollingInputStream(new TimeoutInputStream(new FilterInputStream(channel_in) {
						public void close() throws IOException {
							// Don't close the underlying stream as it belongs to the session
						}
					},
					8192 /*bufferSize*/, 1000 /*readTimeout*/, -1 /*closeTimeout*/, true /* growWhenFull */), timeout > 0 ? timeout : 1, monitor);
			outputStream = new PollingOutputStream(new TimeoutOutputStream(new FilterOutputStream(channel_out) {
						public void close() throws IOException {
							// Don't close the underlying stream as it belongs to the session
						}
					},
					8192 /*buffersize*/, 1000 /*writeTimeout*/, 1000 /*closeTimeout*/), timeout > 0 ? timeout : 1, monitor);
		} catch (final JSchException e) {
			if (isSSH2Unsupported(e)) {
                ssh1 = new SSHServerConnection(location, password);
                if (ssh1 == null) {
                    throw new SSH2IOException(e.toString(), e);
                }
                ssh1.open(monitor);
            } else {
			    String message = e.getMessage();
			    if (JSchSession.isAuthenticationFailure(e)) {
                    // Do not retry as the Jsh library has it's own retry logic
                    throw new CVSAuthenticationException(CVSSSH2Messages.CVSSSH2ServerConnection_0, CVSAuthenticationException.NO_RETRY, e); 
			    } else if (message.startsWith("Session.connect: ")) { //$NON-NLS-1$
			        // Jsh has messages formatted like "Session.connect: java.net.NoRouteToHostException: ..."
			        // Strip of the exception and try to convert it to a more meaningfull string
			        int start = message.indexOf(": ") + 1; //$NON-NLS-1$
			        if (start != -1) {
				        int end = message.indexOf(": ", start); //$NON-NLS-1$
				        if (end != -1) {
				            String exception = message.substring(start, end).trim();
				            if (exception.indexOf("NoRouteToHostException") != -1) { //$NON-NLS-1$
				                message = NLS.bind(CVSSSH2Messages.CVSSSH2ServerConnection_1, new String[] { location.getHost() }); 
				                throw new NoRouteToHostException(message);
				            } else if (exception.indexOf("java.net.UnknownHostException") != -1) { //$NON-NLS-1$
				                throw new UnknownHostException(location.getHost());
				            } else {
				                message = message.substring(end + 1).trim();
				            }
				        }
			        }
			    }
 				throw new SSH2IOException(message, e);
			}
		}
	}
    
    private boolean isChannelNotOpenError(JSchException ee) {
        return ee.getMessage().indexOf("channel is not opened") != -1; //$NON-NLS-1$
    }
    private boolean isSessionDownError(JSchException ee) {
        return ee.getMessage().equals("session is down"); //$NON-NLS-1$
    }
    private boolean isSSH2Unsupported(JSchException e) {
        return e.toString().indexOf("invalid server's version string") != -1; //$NON-NLS-1$
    }
}
