Port version changes for licensekey 3.0

DEVSIX-1715

Author: IdamkinI

kernel/src/main/java/com/itextpdf/kernel/LicenseVersionException.java

@@ -0,0 +1,116 @@
+package com.itextpdf.kernel;
+
+import com.itextpdf.io.util.MessageFormatUtil;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Exception class for License-key version exceptions throw in the Version class
+ */
+public class LicenseVersionException extends  RuntimeException{
+
+    public static final String NO_I_TEXT7_LICENSE_IS_LOADED_BUT_AN_I_TEXT5_LICENSE_IS_LOADED ="No iText7 License is loaded but an iText5 license is loaded.";
+    public static final String THE_MAJOR_VERSION_OF_THE_LICENSE_0_IS_LOWER_THAN_THE_MAJOR_VERSION_1_OF_THE_CORE_LIBRARY ="The major version of the license ({0}) is lower than the major version ({1}) of the Core library.";
+    public static final String THE_MAJOR_VERSION_OF_THE_LICENSE_0_IS_HIGHER_THAN_THE_MAJOR_VERSION_1_OF_THE_CORE_LIBRARY ="The major version of the license ({0}) is higher than the major version ({1}) of the Core library.";
+    
+    public static final String THE_MINOR_VERSION_OF_THE_LICENSE_0_IS_LOWER_THAN_THE_MINOR_VERSION_1_OF_THE_CORE_LIBRARY ="The minor version of the license ({0}) is lower than the minor version ({1}) of the Core library.";
+    public static final String THE_MINOR_VERSION_OF_THE_LICENSE_0_IS_HIGHER_THAN_THE_MINOR_VERSION_1_OF_THE_CORE_LIBRARY ="The minor version of the license ({0}) is higher than the minor version ({1}) of the Core library.";
+
+    public static final String VERSION_STRING_IS_EMPTY_AND_CANNOT_BE_PARSED = "Version string is empty and cannot be parsed.";
+    public static final String MAJOR_VERSION_IS_NOT_NUMERIC ="Major version is not numeric";
+    public static final String MINOR_VERSION_IS_NOT_NUMERIC ="Minor version is not numeric";
+    public static final String UNKNOWN_EXCEPTION_WHEN_CHECKING_LICENSE_VERSION ="Unknown Exception when checking License version";
+
+    public static final String LICENSE_FILE_NOT_LOADED = "License file not loaded.";
+    /**
+     * Object for more details
+     */
+    protected Object object;
+
+    private List<Object> messageParams;
+
+    /**
+     * Creates a new instance of PdfException.
+     *
+     * @param message the detail message.
+     */
+    public LicenseVersionException(String message) {
+        super(message);
+    }
+
+    /**
+     * Creates a new instance of PdfException.
+     *
+     * @param cause the cause (which is saved for later retrieval by {@link #getCause()} method).
+     */
+    public LicenseVersionException(Throwable cause) {
+        this(UNKNOWN_EXCEPTION_WHEN_CHECKING_LICENSE_VERSION, cause);
+    }
+
+    /**
+     * Creates a new instance of PdfException.
+     *
+     * @param message the detail message.
+     * @param obj     an object for more details.
+     */
+    public LicenseVersionException(String message, Object obj) {
+        this(message);
+        this.object = obj;
+    }
+
+    /**
+     * Creates a new instance of PdfException.
+     *
+     * @param message the detail message.
+     * @param cause   the cause (which is saved for later retrieval by {@link #getCause()} method).
+     */
+    public LicenseVersionException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    /**
+     * Creates a new instance of PdfException.
+     *
+     * @param message the detail message.
+     * @param cause   the cause (which is saved for later retrieval by {@link #getCause()} method).
+     * @param obj     an object for more details.
+     */
+    public LicenseVersionException(String message, Throwable cause, Object obj) {
+        this(message, cause);
+        this.object = obj;
+    }
+
+    @Override
+    public String getMessage() {
+        if (messageParams == null || messageParams.size() == 0) {
+            return super.getMessage();
+        } else {
+            return MessageFormatUtil.format(super.getMessage(), getMessageParams());
+        }
+    }
+
+    /**
+     * Sets additional params for Exception message.
+     *
+     * @param messageParams additional params.
+     * @return object itself.
+     */
+    public LicenseVersionException setMessageParams(Object... messageParams) {
+        this.messageParams = new ArrayList<>();
+        Collections.addAll(this.messageParams, messageParams);
+        return this;
+    }
+
+    /**
+     * Gets additional params for Exception message.
+     */
+    protected Object[] getMessageParams() {
+        Object[] parameters = new Object[messageParams.size()];
+        for (int i = 0; i < messageParams.size(); i++) {
+            parameters[i] = messageParams.get(i);
+        }
+        return parameters;
+    }
+}

kernel/src/main/java/com/itextpdf/kernel/Version.java

@@ -43,6 +43,7 @@ This file is part of the iText (R) project.
  */
 package com.itextpdf.kernel;
 
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
 /**
@@ -67,7 +68,7 @@ public final class Version {
      * iText is a registered trademark by iText Group NV.
      * Please don't change this constant.
      */
-    private static String iText = "iText\u00ae";
+    private static String iTextProductName = "iText\u00ae";
     /**
      * This String contains the version number of this iText release.
      * For debugging purposes, we request you NOT to change this constant.
@@ -79,7 +80,7 @@ public final class Version {
      * iText Group requests that you retain the iText producer line
      * in every PDF that is created or manipulated using iText.
      */
-    private String iTextVersion = iText + " " + release + " \u00a92000-2017 iText Group NV";
+    private String producerLine = iTextProductName + " " + release + " \u00a92000-2017 iText Group NV";
 
     /**
      * The license key.
@@ -98,11 +99,9 @@ public static Version getInstance() {
             version = new Version();
             synchronized (version) {
                 try {
-                    String licenseeInfoMethodName = "getLicenseeInfo";
-                    Class<?> klass = getLicenseKeyClass();
-                    if (klass != null) {
-                        Method m = klass.getMethod(licenseeInfoMethodName);
-                        String[] info = (String[]) m.invoke(klass.newInstance(), null);
+                    String coreVersion = release;
+                    String[] info = getLicenseeInfoFromLicenseKey(coreVersion);
+                    if(info != null){
                         if (info[3] != null && info[3].trim().length() > 0) {
                             version.key = info[3];
                         } else {
@@ -116,14 +115,13 @@ public static Version getInstance() {
 
                         if (info.length > 6) {
                             if (info[6] != null && info[6].trim().length() > 0) {
-                                if (! release.startsWith(info[6])) {
-                                    throw new IllegalArgumentException("Your license key version doesn't match the iText version.");
-                                }
+                                //Compare versions with this release versions
+                                checkLicenseVersion(coreVersion, info[6]);
                             }
                         }
 
                         if (info[4] != null && info[4].trim().length() > 0) {
-                            version.iTextVersion = info[4];
+                            version.producerLine = info[4];
                         } else if (info[2] != null && info[2].trim().length() > 0) {
                             version.addLicensedPostfix(info[2]);
                         } else if (info[0] != null && info[0].trim().length() > 0) {
@@ -137,9 +135,20 @@ public static Version getInstance() {
                     } else {
                         version.addAGPLPostfix(null);
                     }
-                } catch (IllegalArgumentException iae) {
-                    version.addAGPLPostfix(iae.getCause());
+                    //Catch the exception
+                } catch(LicenseVersionException lve) {
+                    //Rethrow license version exceptions
+                    throw lve;
+                }catch(ClassNotFoundException cnfe){
+                    //License key library not on classpath, switch to AGPL
+                    version.addAGPLPostfix(null);
                 } catch (Exception e) {
+                    //Check if an iText5 license is loaded
+                    if(e.getCause() != null && e.getCause().getMessage().equals(LicenseVersionException.LICENSE_FILE_NOT_LOADED)) {
+                        if (isiText5licenseLoaded()) {
+                            throw new LicenseVersionException(LicenseVersionException.NO_I_TEXT7_LICENSE_IS_LOADED_BUT_AN_I_TEXT5_LICENSE_IS_LOADED);
+                        }
+                    }
                     version.addAGPLPostfix(e.getCause());
                 }
             }
@@ -171,7 +180,7 @@ public static boolean isExpired() {
      * @return the product name
      */
     public String getProduct() {
-        return iText;
+        return iTextProductName;
     }
 
     /**
@@ -194,7 +203,7 @@ public String getRelease() {
      * @return iText version
      */
     public String getVersion() {
-        return iTextVersion;
+        return producerLine;
     }
 
     /**
@@ -207,16 +216,16 @@ public String getKey() {
     }
 
     private void addLicensedPostfix(String ownerName) {
-        iTextVersion += " (" + ownerName;
+        producerLine += " (" + ownerName;
         if (! key.toLowerCase().startsWith("trial")) {
-            iTextVersion += "; licensed version)";
+            producerLine += "; licensed version)";
         } else {
-            iTextVersion += "; " + key + ")";
+            producerLine += "; " + key + ")";
         }
     }
 
     private void addAGPLPostfix(Throwable cause) {
-        iTextVersion += AGPL;
+        producerLine += AGPL;
 
         if (cause != null && cause.getMessage() != null && cause.getMessage().contains("expired")) {
             expired = true;
@@ -228,4 +237,83 @@ private static Class<?> getLicenseKeyClass() throws ClassNotFoundException {
         return Class.forName(licenseKeyClassFullName);
     }
 
+    private static void checkLicenseVersion(String coreVersionString, String licenseVersionString){
+        String[] coreVersions = parseVersionString(coreVersionString);
+        String[] licenseVersions = parseVersionString(licenseVersionString);
+
+        int coreMajor = Integer.parseInt(coreVersions[0]);
+        int coreMinor = Integer.parseInt(coreVersions[1]);
+
+        int licenseMajor = Integer.parseInt(licenseVersions[0]);
+        int licenseMinor = Integer.parseInt(licenseVersions[1]);
+        //Major version check
+        if(licenseMajor < coreMajor){
+            throw new LicenseVersionException(LicenseVersionException.THE_MAJOR_VERSION_OF_THE_LICENSE_0_IS_LOWER_THAN_THE_MAJOR_VERSION_1_OF_THE_CORE_LIBRARY).setMessageParams(licenseMajor,coreMajor);
+        }
+        if(licenseMajor>coreMajor){
+            throw new LicenseVersionException(LicenseVersionException.THE_MAJOR_VERSION_OF_THE_LICENSE_0_IS_HIGHER_THAN_THE_MAJOR_VERSION_1_OF_THE_CORE_LIBRARY).setMessageParams(licenseMajor,coreMajor);
+
+        }
+        //Minor version check
+        if(licenseMinor < coreMinor){
+            throw new LicenseVersionException(LicenseVersionException.THE_MINOR_VERSION_OF_THE_LICENSE_0_IS_LOWER_THAN_THE_MINOR_VERSION_1_OF_THE_CORE_LIBRARY).setMessageParams(licenseMinor,coreMinor);
+        }
+
+    }
+
+    private static String[] parseVersionString(String version){
+        String splitRegex = "\\.";
+        String[] split = version.split(splitRegex);
+        //Guard for empty versions and throw exceptions
+        if(split.length == 0){
+            throw new LicenseVersionException(LicenseVersionException.VERSION_STRING_IS_EMPTY_AND_CANNOT_BE_PARSED);
+        }
+        //Desired Format: X.Y.Z-....
+        //Also catch X, X.Y-...
+        String major = split[0];
+        String minor ="0"; //If no minor version is present, default to 0
+        if(split.length > 1) {
+            minor = split[1].substring(0);
+        }
+        //Check if both values are numbers
+        if(!isVersionNumeric(major)) throw new LicenseVersionException(LicenseVersionException.MAJOR_VERSION_IS_NOT_NUMERIC);
+        if(!isVersionNumeric(minor)) throw new LicenseVersionException(LicenseVersionException.MINOR_VERSION_IS_NOT_NUMERIC);
+        return new String[]{major,minor};
+    }
+
+    private static String[] getLicenseeInfoFromLicenseKey(String validatorKey) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
+        String licenseeInfoMethodName = "getLicenseeInfoForVersion";
+        Class<?> klass = getLicenseKeyClass();
+        if (klass != null) {
+            Class[] cArg = {String.class};
+            Method m = klass.getMethod(licenseeInfoMethodName, cArg);
+            Object[] args = {validatorKey};
+            String[] info = (String[]) m.invoke(klass.newInstance(), args);
+            return info;
+        }
+        return null;
+    }
+
+    private static boolean isiText5licenseLoaded(){
+        String validatorKey5 = "5";
+        boolean result = false;
+        try {
+            String[] info = getLicenseeInfoFromLicenseKey(validatorKey5);
+            result = true;
+        }catch(Exception e){
+            //TODO: Log this exception?
+        }
+        return result;
+    }
+
+    private static boolean isVersionNumeric(String version){
+        //I did not want to introduce an extra dependency on apache.commons in order to use StringUtils.
+        //This small method is not the most optimal, but it should do for release
+        try{
+            Double.parseDouble(version);
+            return true;
+        }catch(NumberFormatException e){
+            return false;
+        }
+    }
 }