package org.apache.maven.scm.provider.cvslib.cvsjava.util;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  import ch.ethz.ssh2.Connection;
  import ch.ethz.ssh2.Session;
  import ch.ethz.ssh2.StreamGobbler;
  import org.netbeans.lib.cvsclient.CVSRoot;
  import org.netbeans.lib.cvsclient.command.CommandAbortedException;
  import org.netbeans.lib.cvsclient.connection.AbstractConnection;
  import org.netbeans.lib.cvsclient.connection.AuthenticationException;
  import org.netbeans.lib.cvsclient.connection.ConnectionModifier;
  import org.netbeans.lib.cvsclient.util.LoggedDataInputStream;
  import org.netbeans.lib.cvsclient.util.LoggedDataOutputStream;
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  
  /**
   * @author <a href="mailto:evenisse@apache.org">Emmanuel Venisse</a>
   *
   */
  public class ExtConnection
      extends AbstractConnection
  {
      private String host;
  
      private int port;
  
      private String userName;
  
      private String password;
  
      private Connection connection;
  
      private Session session;
  
      private BufferedReader stderrReader;
  
      public ExtConnection( CVSRoot cvsRoot )
      {
          this( cvsRoot.getHostName(), cvsRoot.getPort(), cvsRoot.getUserName(), cvsRoot.getPassword(),
                cvsRoot.getRepository() );
      }
  
      public ExtConnection( String host, int port, String username, String password, String repository )
      {
          this.userName = username;
  
          if ( this.userName == null )
          {
              this.userName = System.getProperty( "user.name" );
          }
  
          this.password = password;
  
          this.host = host;
  
          setRepository( repository );
  
          this.port = port;
  
          if ( this.port == 0 )
          {
              this.port = 22;
          }
      }
  
      /** {@inheritDoc} */
      public void open()
          throws AuthenticationException, CommandAbortedException
      {
          connection = new Connection( host, port );
  
          /* TODO: add proxy support
          ProxyData proxy = new HTTPProxyData( proxyHost, proxyPort, proxyUserName, proxyPassword );
  
          connection.setProxyData( proxy );
          */
 
         try
         {
             // TODO: connection timeout?
             connection.connect();
         }
         catch ( IOException e )
         {
             String message = "Cannot connect. Reason: " + e.getMessage();
             throw new AuthenticationException( message, e, message );
         }
 
         File privateKey = getPrivateKey();
 
         try
         {
             boolean authenticated;
             if ( privateKey != null && privateKey.exists() )
             {
                 authenticated = connection.authenticateWithPublicKey( userName, privateKey, getPassphrase() );
             }
             else
             {
                 authenticated = connection.authenticateWithPassword( userName, password );
             }
 
             if ( !authenticated )
             {
                 String message = "Authentication failed.";
                 throw new AuthenticationException( message, message );
             }
         }
         catch ( IOException e )
         {
             closeConnection();
             String message = "Cannot authenticate. Reason: " + e.getMessage();
             throw new AuthenticationException( message, e, message );
         }
 
         try
         {
             session = connection.openSession();
         }
         catch ( IOException e )
         {
             String message = "Cannot open session. Reason: " + e.getMessage();
             throw new CommandAbortedException( message, message );
         }
 
         String command = "cvs server";
         try
         {
             session.execCommand( command );
         }
         catch ( IOException e )
         {
             String message = "Cannot execute remote command: " + command;
             throw new CommandAbortedException( message, message );
         }
 
         InputStream stdout = new StreamGobbler( session.getStdout() );
         InputStream stderr = new StreamGobbler( session.getStderr() );
         stderrReader = new BufferedReader( new InputStreamReader( stderr ) );
         setInputStream( new LoggedDataInputStream( stdout ) );
         setOutputStream( new LoggedDataOutputStream( session.getStdin() ) );
     }
 
     /** {@inheritDoc} */
     public void verify()
         throws AuthenticationException
     {
         try
         {
             open();
             verifyProtocol();
             close();
         }
         catch ( Exception e )
         {
             String message = "Failed to verify the connection: " + e.getMessage();
             throw new AuthenticationException( message, e, message );
         }
     }
 
     private void closeConnection()
     {
         try
         {
             if ( stderrReader != null )
             {
                 while ( true )
                 {
                     String line = stderrReader.readLine();
                     if ( line == null )
                     {
                         break;
                     }
 
                     System.err.println( line );
                 }
             }
         }
         catch ( IOException e )
         {
             //nothing to do
         }
 
         if ( session != null )
         {
             System.out.println( "Exit code:" + session.getExitStatus().intValue() );
             session.close();
         }
 
         if ( connection != null )
         {
             connection.close();
         }
 
         reset();
     }
 
     private void reset()
     {
         connection = null;
         session = null;
         stderrReader = null;
         setInputStream( null );
         setOutputStream( null );
     }
 
     /** {@inheritDoc} */
     public void close()
         throws IOException
     {
         closeConnection();
     }
 
     /** {@inheritDoc} */
     public boolean isOpen()
     {
         return connection != null;
     }
 
     /** {@inheritDoc} */
     public int getPort()
     {
         return port;
     }
 
     /** {@inheritDoc} */
     public void modifyInputStream( ConnectionModifier modifier )
         throws IOException
     {
         modifier.modifyInputStream( getInputStream() );
     }
 
     /** {@inheritDoc} */
     public void modifyOutputStream( ConnectionModifier modifier )
         throws IOException
     {
         modifier.modifyOutputStream( getOutputStream() );
     }
 
     private File getPrivateKey()
     {
         // If user don't define a password, he want to use a private key
         File privateKey = null;
         if ( password == null )
         {
             String pk = System.getProperty( "maven.scm.cvs.java.ssh.privateKey" );
             if ( pk != null )
             {
                 privateKey = new File( pk );
             }
             else
             {
                 privateKey = findPrivateKey();
             }
         }
         return privateKey;
     }
 
     private String getPassphrase()
     {
         String passphrase = System.getProperty( "maven.scm.cvs.java.ssh.passphrase" );
 
         if ( passphrase == null )
         {
             passphrase = "";
         }
 
         return passphrase;
     }
 
     private File findPrivateKey()
     {
         String privateKeyDirectory = System.getProperty( "maven.scm.ssh.privateKeyDirectory" );
 
         if ( privateKeyDirectory == null )
         {
             privateKeyDirectory = System.getProperty( "user.home" );
         }
 
         File privateKey = new File( privateKeyDirectory, ".ssh/id_dsa" );
 
         if ( !privateKey.exists() )
         {
             privateKey = new File( privateKeyDirectory, ".ssh/id_rsa" );
         }
 
         return privateKey;
     }
 }