package org.apache.maven.plugin.jar;

 /*

  * 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.File;

 import java.io.InputStream;

 import java.util.ArrayList;

 import java.util.Iterator;

 import java.util.List;

 import java.util.StringTokenizer;

 import org.apache.commons.lang.SystemUtils;

 import org.apache.maven.plugin.AbstractMojo;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.logging.Log;

 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.StreamConsumer;

 /**

  * Checks the signature of a signed jar using jarsigner.

  *

  * @author <a href="jerome@coffeebreaks.org">Jerome Lacoste</a>

  * @version $Id: JarSignVerifyMojo.java 802529 2009-08-09 12:05:35Z bentmann $

  * @goal sign-verify

  * @phase package

  * @requiresProject

  * @todo refactor the common code with javadoc plugin

  * @requiresDependencyResolution runtime

  * @deprecated As of version 2.3, this goal is no longer supported in favor of the dedicated maven-jarsigner-plugin.

  */

 public class JarSignVerifyMojo

     extends AbstractMojo

 {

     /**

      * The working directory in which the jarsigner executable will be run.

      *

      * @parameter expression="${workingdir}" default-value="${basedir}"

      * @required

      */

     private File workingDirectory;

     /**

      * Directory containing the generated JAR.

      *

      * @parameter expression="${project.build.directory}"

      * @required

      * @readonly

      */

     private File basedir;

     /**

      * Name of the generated JAR (without classifier and extension).

      *

      * @parameter alias="jarname" expression="${project.build.finalName}"

      * @required

      */

     private String finalName;

     /**

      * Path of the signed jar. When specified, the finalName is ignored.

      *

      * @parameter expression="${jarpath}"

      */

     private File jarPath;

     /**

      * Check certificates. Requires {@link #setVerbose(boolean)}.

      * See <a href="http://java.sun.com/j2se/1.4.2/docs/tooldocs/windows/jarsigner.html#Options">options</a>.

      *

      * @parameter expression="${checkcerts}" default-value="false"

      */

     private boolean checkCerts;

     /**

      * Enable verbose

      * See <a href="http://java.sun.com/j2se/1.4.2/docs/tooldocs/windows/jarsigner.html#Options">options</a>.

      *

      * @parameter expression="${verbose}" default-value="false"

      */

     private boolean verbose;

     /** When <code>true</code> this will make the execute() operation fail,

      * throwing an exception, when verifying a non signed jar.

      * Primarily to keep backwards compatibility with existing code, and allow reusing the

      * bean in unattended operations when set to <code>false</code>.

      *

      * @parameter expression="${errorWhenNotSigned}" default-value="true"

      **/

     private boolean errorWhenNotSigned = true;

     /**

      * Is the jar signed ? output property set by the execute call. The value will be accessible

      * when execute() ends and if errorWhenNotSigned has been set to false.

      **/

     private boolean signed;

     File getJarFile()

     {

         if ( jarPath != null )

         {

             return jarPath;

         }

         else

         {

             return AbstractJarMojo.getJarFile( basedir, finalName, null);

         }

     }

     public void execute()

         throws MojoExecutionException

     {

         List arguments = new ArrayList();

         Commandline commandLine = new Commandline();

         commandLine.setExecutable( getJarsignerPath() );

         arguments.add( "-verify" );

         addArgIf( arguments, this.verbose, "-verbose" );

         addArgIf( arguments, this.checkCerts, "-certs" );

         arguments.add( getJarFile() );

         for ( Iterator it = arguments.iterator() ; it.hasNext() ; )

         {

             commandLine.createArgument().setValue( it.next().toString() );

         }

         commandLine.setWorkingDirectory( workingDirectory.getAbsolutePath() );

         getLog().debug("Executing: " + commandLine );

         LineMatcherStreamConsumer outConsumer = new LineMatcherStreamConsumer( "jar verified." );

         final StringBuffer errBuffer = new StringBuffer();

         StreamConsumer errConsumer = new StreamConsumer()

         {

             public void consumeLine(String line)

             {

                  errBuffer.append( line );

                  getLog().warn( line );

             }

         };

         try

         {

             int result = executeCommandLine( commandLine, null, outConsumer, errConsumer );

             if ( result != 0 )

             {

                 throw new MojoExecutionException("Result of " + commandLine

                     + " execution is: \'" + result + "\'." );

             }

             signed = outConsumer.matched;

             if ( !signed && errorWhenNotSigned )

             {

                 throw new MojoExecutionException( "Verify failed: " + outConsumer.firstOutLine );

             }

         }

         catch ( CommandLineException e )

         {

             throw new MojoExecutionException( "command execution failed", e );

         }

     }

     // checks if a consumed line matches

     // also keeps track of the first consumed line.

     class LineMatcherStreamConsumer

         implements StreamConsumer

     {

         private String toMatch;

         private boolean matched;

         private String firstOutLine;

         LineMatcherStreamConsumer( String toMatch )

         {

              this.toMatch = toMatch;

         }

         public void consumeLine(String line)

         {

             if ( firstOutLine == null )

             {

                  firstOutLine = line;

             }

             matched = matched || toMatch.equals( line );

             getLog().info( line );

         }

     }

   // taken from JavadocReport then slightly refactored

     // should probably share with other plugins that use $JAVA_HOME/bin tools

     /**

      * Get the path of jarsigner tool depending the OS.

      *

      * @return the path of the jarsigner tool

      */

     private String getJarsignerPath()

     {

         return getJDKCommandPath( "jarsigner", getLog() );

     }

     private static String getJDKCommandPath( String command, Log logger )

     {

         String path = getJDKCommandExe(command).getAbsolutePath();

         logger.debug( command + " executable=[" + path + "]" );

         return path;

     }

     private static File getJDKCommandExe( String command )

     {

         String fullCommand = command + ( SystemUtils.IS_OS_WINDOWS ? ".exe" : "" );

         File exe;

         // For IBM's JDK 1.2

         if ( SystemUtils.IS_OS_AIX )

         {

             exe = new File( SystemUtils.getJavaHome() + "/../sh", fullCommand );

         }

         else if ( SystemUtils.IS_OS_MAC_OSX )

         {

             exe = new File( SystemUtils.getJavaHome() + "/bin", fullCommand );

         }

         else

         {

             exe = new File( SystemUtils.getJavaHome() + "/../bin", fullCommand );

         }

         return exe;

     }

     // Helper methods. Could/should be shared e.g. with JavadocReport

     /**

      * Convenience method to add an argument to the <code>command line</code>

      * conditionally based on the given flag.

      *

      * @param arguments

      * @param b the flag which controls if the argument is added or not.

      * @param value the argument value to be added.

      */

     private void addArgIf( List arguments, boolean b, String value )

     {

         if ( b )

         {

             arguments.add( value );

         }

     }

     /**

      * Convenience method to add an argument to the <code>command line</code>

      * if the the value is not null or empty.

      * <p>

      * Moreover, the value could be comma separated.

      *

      * @param arguments

      * @param key the argument name.

      * @param value the argument value to be added.

      * @see #addArgIfNotEmpty(java.util.List,String,String,boolean)

      */

     private void addArgIfNotEmpty( List arguments, String key, String value )

     {

         addArgIfNotEmpty( arguments, key, value, false );

     }

     /**

      * Convenience method to add an argument to the <code>command line</code>

      * if the the value is not null or empty.

      * <p>

      * Moreover, the value could be comma separated.

      *

      * @param arguments

      * @param key the argument name.

      * @param value the argument value to be added.

      * @param repeatKey repeat or not the key in the command line

      */

     private void addArgIfNotEmpty( List arguments, String key, String value, boolean repeatKey )

     {

         if ( !StringUtils.isEmpty( value ) )

         {

             arguments.add( key );

             StringTokenizer token = new StringTokenizer( value, "," );

             while ( token.hasMoreTokens() )

             {

                 String current = token.nextToken().trim();

                 if ( !StringUtils.isEmpty( current ) )

                 {

                     arguments.add( current );

                     if ( token.hasMoreTokens() && repeatKey )

                     {

                         arguments.add( key );

                     }

                 }

             }

         }

     }

     //

     // methods used for tests purposes - allow mocking and simulate automatic setters

     //

     protected int executeCommandLine( Commandline commandLine, InputStream inputStream,

                                       StreamConsumer systemOut, StreamConsumer systemErr )

         throws CommandLineException

     {

         return CommandLineUtils.executeCommandLine( commandLine, inputStream, systemOut, systemErr );

     }

     public void setWorkingDir( File workingDir )

     {

         this.workingDirectory = workingDir;

     }

     public void setBasedir( File basedir )

     {

         this.basedir = basedir;

     }

     // hiding for now - I don't think this is required to be seen

     /*

     public void setFinalName( String finalName )

     {

         this.finalName = finalName;

     }

     */

     public void setJarPath( File jarPath )

     {

         this.jarPath = jarPath;

     }

     public void setCheckCerts( boolean checkCerts )

     {

         this.checkCerts = checkCerts;

     }

     public void setVerbose( boolean verbose )

     {

         this.verbose = verbose;

     }

     /**

      * Is the JAR file signed ? Output property set by the {@link #execute()} call.

      *

      * @return <code>true</code> if the jar was signed, <code>false</code> otherwise.

      */

     public boolean isSigned()

     {

         return signed;

     }

     /**

      * Sets a boolean that is to determine if an exception should be thrown when

      * the JAR file being verified is unsigned. If you just what to check if a

      * JAR is unsigned and then act on the result, then you probably want to

      * set this to <code>true</code>.

      */

     public void setErrorWhenNotSigned( boolean errorWhenNotSigned )

     {

         this.errorWhenNotSigned = errorWhenNotSigned;

     }

 }