package org.apache.maven.plugin.gpg;
   
   /*
    * 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 java.io.BufferedReader;
  import java.io.ByteArrayInputStream;
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  
  import org.apache.maven.plugin.MojoExecutionException;
  import org.apache.maven.project.MavenProject;
  import org.codehaus.plexus.util.Os;
  import org.codehaus.plexus.util.StringUtils;
  import org.codehaus.plexus.util.cli.CommandLineException;
  import org.codehaus.plexus.util.cli.CommandLineUtils;
  import org.codehaus.plexus.util.cli.Commandline;
  import org.codehaus.plexus.util.cli.DefaultConsumer;
  
  public class GpgSigner
  {
  
      public static final String SIGNATURE_EXTENSION = ".asc";
  
      private String executable;
   
      private boolean useAgent;
  
      private boolean isInteractive = true;
  
      private boolean defaultKeyring = true;
  
      private String keyname;
  
      private String passphrase;
  
      private File outputDir;
  
      private File buildDir;
  
      private File baseDir;
  
      private File homeDir;
  
      private String secretKeyring;
  
      private String publicKeyring;
  
      public void setExecutable( String executable )
      {
          this.executable = executable;
      }
  
      public void setInteractive( boolean b )
      {
          isInteractive = b;
      }
  
      public void setUseAgent( boolean b )
      {
          useAgent = b;
      }
  
      public void setDefaultKeyring( boolean enabled )
      {
          defaultKeyring = enabled;
      }
  
      public void setKeyName( String s )
      {
          keyname = s;
      }
  
      public void setPassPhrase( String s )
      {
          passphrase = s;
      }
  
      public void setOutputDirectory( File out )
      {
          outputDir = out;
     }
 
     public void setBuildDirectory( File out )
     {
         buildDir = out;
     }
 
     public void setBaseDirectory( File out )
     {
         baseDir = out;
     }
 
     public void setHomeDirectory( File homeDirectory )
     {
         homeDir = homeDirectory;
     }
 
     public void setSecretKeyring( String path )
     {
         secretKeyring = path;
     }
 
     public void setPublicKeyring( String path )
     {
         publicKeyring = path;
     }
 
     public File generateSignatureForArtifact( File file )
         throws MojoExecutionException
     {
         File signature = new File( file + SIGNATURE_EXTENSION );
 
         boolean isInBuildDir = false;
         if ( buildDir != null )
         {
             File parent = signature.getParentFile();
             if ( buildDir.equals( parent ) )
             {
                 isInBuildDir = true;
             }
         }
         if ( !isInBuildDir && outputDir != null )
         {
             String fileDirectory = "";
             File signatureDirectory = signature;
 
             while ( ( signatureDirectory = signatureDirectory.getParentFile() ) != null )
             {
                 if ( !signatureDirectory.equals( baseDir ) )
                 {
                     fileDirectory = signatureDirectory.getName() + File.separatorChar + fileDirectory;
                 }
                 else
                 {
                     break;
                 }
             }
             signatureDirectory = new File( outputDir, fileDirectory );
             if ( !signatureDirectory.exists() )
             {
                 signatureDirectory.mkdirs();
             }
             signature = new File( signatureDirectory, file.getName() + SIGNATURE_EXTENSION );
         }
 
         if ( signature.exists() )
         {
             signature.delete();
         }
 
         Commandline cmd = new Commandline();
 
         if ( StringUtils.isNotEmpty( executable ) )
         {
             cmd.setExecutable( executable );
         }
         else
         {
             cmd.setExecutable( "gpg" + ( Os.isFamily( Os.FAMILY_WINDOWS ) ? ".exe" : "" ) );
         }
 
         if ( homeDir != null )
         {
             cmd.createArg().setValue( "--homedir" );
             cmd.createArg().setFile( homeDir );
         }
 
         if ( useAgent )
         {
             cmd.createArg().setValue( "--use-agent" );
         }
         else
         {
             cmd.createArg().setValue( "--no-use-agent" );
         }
 
         InputStream in = null;
         if ( null != passphrase )
         {
             // make --passphrase-fd effective in gpg2
             cmd.createArg().setValue( "--batch" );
 
             cmd.createArg().setValue( "--passphrase-fd" );
 
             cmd.createArg().setValue( "0" );
 
             // Prepare the input stream which will be used to pass the passphrase to the executable
             in = new ByteArrayInputStream( passphrase.getBytes() );
         }
 
         if ( null != keyname )
         {
             cmd.createArg().setValue( "--local-user" );
 
             cmd.createArg().setValue( keyname );
         }
 
         cmd.createArg().setValue( "--armor" );
 
         cmd.createArg().setValue( "--detach-sign" );
 
         if ( !isInteractive )
         {
             cmd.createArg().setValue( "--no-tty" );
         }
 
         if ( !defaultKeyring )
         {
             cmd.createArg().setValue( "--no-default-keyring" );
         }
 
         if ( StringUtils.isNotEmpty( secretKeyring ) )
         {
             cmd.createArg().setValue( "--secret-keyring" );
             cmd.createArg().setValue( secretKeyring );
         }
 
         if ( StringUtils.isNotEmpty( publicKeyring ) )
         {
             cmd.createArg().setValue( "--keyring" );
             cmd.createArg().setValue( publicKeyring );
         }
 
         cmd.createArg().setValue( "--output" );
         cmd.createArg().setFile( signature );
 
         cmd.createArg().setFile( file );
 
         try
         {
             int exitCode = CommandLineUtils.executeCommandLine( cmd, in, new DefaultConsumer(), new DefaultConsumer() );
 
             if ( exitCode != 0 )
             {
                 throw new MojoExecutionException( "Exit code: " + exitCode );
             }
         }
         catch ( CommandLineException e )
         {
             throw new MojoExecutionException( "Unable to execute gpg command", e );
         }
 
         return signature;
     }
 
     private MavenProject findReactorProject( MavenProject prj )
     {
         if ( prj.getParent() != null && prj.getParent().getBasedir() != null && prj.getParent().getBasedir().exists() )
         {
             return findReactorProject( prj.getParent() );
         }
         return prj;
     }
 
     public String getPassphrase( MavenProject project )
         throws IOException
     {
         String pass = null;
 
         if ( project != null )
         {
             pass = project.getProperties().getProperty( "gpg.passphrase" );
             if ( pass == null )
             {
                 MavenProject prj2 = findReactorProject( project );
                 pass = prj2.getProperties().getProperty( "gpg.passphrase" );
             }
         }
         if ( pass == null )
         {
             // TODO: with JDK 1.6, we could call System.console().readPassword("GPG Passphrase: ", null);
 
             BufferedReader in = new BufferedReader( new InputStreamReader( System.in ) );
             while ( System.in.available() != 0 )
             {
                 // there's some junk already on the input stream, consume it
                 // so we can get the real passphrase
                 System.in.read();
             }
 
             System.out.print( "GPG Passphrase:  " );
             MaskingThread thread = new MaskingThread();
             thread.start();
 
             pass = in.readLine();
 
             // stop masking
             thread.stopMasking();
         }
         if ( project != null )
         {
             findReactorProject( project ).getProperties().setProperty( "gpg.passphrase", pass );
         }
         return pass;
     }
 
     // based on ideas from http://java.sun.com/developer/technicalArticles/Security/pwordmask/
     class MaskingThread
         extends Thread
     {
         private volatile boolean stop;
 
         /**
          * Begin masking until asked to stop.
          */
         public void run()
         {
             // this needs to be high priority to make sure the characters don't
             // really get to the screen.
 
             int priority = Thread.currentThread().getPriority();
             Thread.currentThread().setPriority( Thread.MAX_PRIORITY );
 
             try
             {
                 stop = false;
                 while ( !stop )
                 {
                     // print a backspace + * to overwrite anything they type
                     System.out.print( "\010*" );
                     try
                     {
                         // attempt masking at this rate
                         Thread.sleep( 1 );
                     }
                     catch ( InterruptedException iex )
                     {
                         Thread.currentThread().interrupt();
                         return;
                     }
                 }
             }
             finally
             {
                 // restore the original priority
                 Thread.currentThread().setPriority( priority );
             }
         }
 
         /**
          * Instruct the thread to stop masking.
          */
         public void stopMasking()
         {
             this.stop = true;
         }
     }
 
 }