1 /*
   2  * Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package jdk.internal.module;
  27 
  28 import java.io.DataInput;
  29 import java.io.DataInputStream;
  30 import java.io.EOFException;
  31 import java.io.IOException;
  32 import java.io.InputStream;
  33 import java.io.UncheckedIOException;
  34 import java.lang.module.InvalidModuleDescriptorException;
  35 import java.lang.module.ModuleDescriptor;
  36 import java.lang.module.ModuleDescriptor.Builder;
  37 import java.lang.module.ModuleDescriptor.Requires;
  38 import java.lang.module.ModuleDescriptor.Exports;
  39 import java.lang.module.ModuleDescriptor.Opens;
  40 import java.nio.ByteBuffer;
  41 import java.nio.BufferUnderflowException;
  42 import java.util.ArrayList;
  43 import java.util.HashMap;
  44 import java.util.HashSet;
  45 import java.util.List;
  46 import java.util.Map;
  47 import java.util.Set;
  48 import java.util.function.Supplier;
  49 
  50 import jdk.internal.access.JavaLangModuleAccess;
  51 import jdk.internal.access.SharedSecrets;
  52 
  53 import static jdk.internal.module.ClassFileConstants.*;
  54 
  55 
  56 /**
  57  * Read module information from a {@code module-info} class file.
  58  *
  59  * @implNote The rationale for the hand-coded reader is startup performance
  60  * and fine control over the throwing of InvalidModuleDescriptorException.
  61  */
  62 
  63 public final class ModuleInfo {
  64 
  65     private final int JAVA_MIN_SUPPORTED_VERSION = 53;
  66     private final int JAVA_MAX_SUPPORTED_VERSION = 57;
  67 
  68     private static final JavaLangModuleAccess JLMA
  69         = SharedSecrets.getJavaLangModuleAccess();
  70 
  71     // supplies the set of packages when ModulePackages attribute not present
  72     private final Supplier<Set<String>> packageFinder;
  73 
  74     // indicates if the ModuleHashes attribute should be parsed
  75     private final boolean parseHashes;
  76 
  77     private ModuleInfo(Supplier<Set<String>> pf, boolean ph) {
  78         packageFinder = pf;
  79         parseHashes = ph;
  80     }
  81 
  82     private ModuleInfo(Supplier<Set<String>> pf) {
  83         this(pf, true);
  84     }
  85 
  86     /**
  87      * A holder class for the ModuleDescriptor that is created by reading the
  88      * Module and other standard class file attributes. It also holds the objects
  89      * that represent the non-standard class file attributes that are read from
  90      * the class file.
  91      */
  92     public static final class Attributes {
  93         private final ModuleDescriptor descriptor;
  94         private final ModuleTarget target;
  95         private final ModuleHashes recordedHashes;
  96         private final ModuleResolution moduleResolution;
  97         Attributes(ModuleDescriptor descriptor,
  98                    ModuleTarget target,
  99                    ModuleHashes recordedHashes,
 100                    ModuleResolution moduleResolution) {
 101             this.descriptor = descriptor;
 102             this.target = target;
 103             this.recordedHashes = recordedHashes;
 104             this.moduleResolution = moduleResolution;
 105         }
 106         public ModuleDescriptor descriptor() {
 107             return descriptor;
 108         }
 109         public ModuleTarget target() {
 110             return target;
 111         }
 112         public ModuleHashes recordedHashes() {
 113             return recordedHashes;
 114         }
 115         public ModuleResolution moduleResolution() {
 116             return moduleResolution;
 117         }
 118     }
 119 
 120 
 121     /**
 122      * Reads a {@code module-info.class} from the given input stream.
 123      *
 124      * @throws InvalidModuleDescriptorException
 125      * @throws IOException
 126      */
 127     public static Attributes read(InputStream in, Supplier<Set<String>> pf)
 128         throws IOException
 129     {
 130         try {
 131             return new ModuleInfo(pf).doRead(new DataInputStream(in));
 132         } catch (IllegalArgumentException | IllegalStateException e) {
 133             throw invalidModuleDescriptor(e.getMessage());
 134         } catch (EOFException x) {
 135             throw truncatedModuleDescriptor();
 136         }
 137     }
 138 
 139     /**
 140      * Reads a {@code module-info.class} from the given byte buffer.
 141      *
 142      * @throws InvalidModuleDescriptorException
 143      * @throws UncheckedIOException
 144      */
 145     public static Attributes read(ByteBuffer bb, Supplier<Set<String>> pf) {
 146         try {
 147             return new ModuleInfo(pf).doRead(new DataInputWrapper(bb));
 148         } catch (IllegalArgumentException | IllegalStateException e) {
 149             throw invalidModuleDescriptor(e.getMessage());
 150         } catch (EOFException x) {
 151             throw truncatedModuleDescriptor();
 152         } catch (IOException ioe) {
 153             throw new UncheckedIOException(ioe);
 154         }
 155     }
 156 
 157     /**
 158      * Reads a {@code module-info.class} from the given byte buffer
 159      * but ignore the {@code ModuleHashes} attribute.
 160      *
 161      * @throws InvalidModuleDescriptorException
 162      * @throws UncheckedIOException
 163      */
 164     public static Attributes readIgnoringHashes(ByteBuffer bb, Supplier<Set<String>> pf) {
 165         try {
 166             return new ModuleInfo(pf, false).doRead(new DataInputWrapper(bb));
 167         } catch (IllegalArgumentException | IllegalStateException e) {
 168             throw invalidModuleDescriptor(e.getMessage());
 169         } catch (EOFException x) {
 170             throw truncatedModuleDescriptor();
 171         } catch (IOException ioe) {
 172             throw new UncheckedIOException(ioe);
 173         }
 174     }
 175 
 176     /**
 177      * Reads the input as a module-info class file.
 178      *
 179      * @throws IOException
 180      * @throws InvalidModuleDescriptorException
 181      * @throws IllegalArgumentException if thrown by the ModuleDescriptor.Builder
 182      *         because an identifier is not a legal Java identifier, duplicate
 183      *         exports, and many other reasons
 184      */
 185     private Attributes doRead(DataInput in) throws IOException {
 186 
 187         int magic = in.readInt();
 188         if (magic != 0xCAFEBABE)
 189             throw invalidModuleDescriptor("Bad magic number");
 190 
 191         int minor_version = in.readUnsignedShort();
 192         int major_version = in.readUnsignedShort();
 193         if (major_version < JAVA_MIN_SUPPORTED_VERSION ||
 194                 major_version > JAVA_MAX_SUPPORTED_VERSION) {
 195             throw invalidModuleDescriptor("Unsupported major.minor version "
 196                                           + major_version + "." + minor_version);
 197         }
 198 
 199         ConstantPool cpool = new ConstantPool(in);
 200 
 201         int access_flags = in.readUnsignedShort();
 202         if (access_flags != ACC_MODULE)
 203             throw invalidModuleDescriptor("access_flags should be ACC_MODULE");
 204 
 205         int this_class = in.readUnsignedShort();
 206         String mn = cpool.getClassName(this_class);
 207         if (!"module-info".equals(mn))
 208             throw invalidModuleDescriptor("this_class should be module-info");
 209 
 210         int super_class = in.readUnsignedShort();
 211         if (super_class > 0)
 212             throw invalidModuleDescriptor("bad #super_class");
 213 
 214         int interfaces_count = in.readUnsignedShort();
 215         if (interfaces_count > 0)
 216             throw invalidModuleDescriptor("Bad #interfaces");
 217 
 218         int fields_count = in.readUnsignedShort();
 219         if (fields_count > 0)
 220             throw invalidModuleDescriptor("Bad #fields");
 221 
 222         int methods_count = in.readUnsignedShort();
 223         if (methods_count > 0)
 224             throw invalidModuleDescriptor("Bad #methods");
 225 
 226         int attributes_count = in.readUnsignedShort();
 227 
 228         // the names of the attributes found in the class file
 229         Set<String> attributes = new HashSet<>();
 230 
 231         Builder builder = null;
 232         Set<String> allPackages = null;
 233         String mainClass = null;
 234         ModuleTarget moduleTarget = null;
 235         ModuleHashes moduleHashes = null;
 236         ModuleResolution moduleResolution = null;
 237 
 238         for (int i = 0; i < attributes_count ; i++) {
 239             int name_index = in.readUnsignedShort();
 240             String attribute_name = cpool.getUtf8(name_index);
 241             int length = in.readInt();
 242 
 243             boolean added = attributes.add(attribute_name);
 244             if (!added && isAttributeAtMostOnce(attribute_name)) {
 245                 throw invalidModuleDescriptor("More than one "
 246                                               + attribute_name + " attribute");
 247             }
 248 
 249             switch (attribute_name) {
 250 
 251                 case MODULE :
 252                     builder = readModuleAttribute(in, cpool, major_version);
 253                     break;
 254 
 255                 case MODULE_PACKAGES :
 256                     allPackages = readModulePackagesAttribute(in, cpool);
 257                     break;
 258 
 259                 case MODULE_MAIN_CLASS :
 260                     mainClass = readModuleMainClassAttribute(in, cpool);
 261                     break;
 262 
 263                 case MODULE_TARGET :
 264                     moduleTarget = readModuleTargetAttribute(in, cpool);
 265                     break;
 266 
 267                 case MODULE_HASHES :
 268                     if (parseHashes) {
 269                         moduleHashes = readModuleHashesAttribute(in, cpool);
 270                     } else {
 271                         in.skipBytes(length);
 272                     }
 273                     break;
 274 
 275                 case MODULE_RESOLUTION :
 276                     moduleResolution = readModuleResolution(in, cpool);
 277                     break;
 278 
 279                 default:
 280                     if (isAttributeDisallowed(attribute_name)) {
 281                         throw invalidModuleDescriptor(attribute_name
 282                                                       + " attribute not allowed");
 283                     } else {
 284                         in.skipBytes(length);
 285                     }
 286 
 287             }
 288         }
 289 
 290         // the Module attribute is required
 291         if (builder == null) {
 292             throw invalidModuleDescriptor(MODULE + " attribute not found");
 293         }
 294 
 295         // ModuleMainClass  attribute
 296         if (mainClass != null) {
 297             builder.mainClass(mainClass);
 298         }
 299 
 300         // If the ModulePackages attribute is not present then the packageFinder
 301         // is used to find the set of packages
 302         boolean usedPackageFinder = false;
 303         if (allPackages == null && packageFinder != null) {
 304             try {
 305                 allPackages = packageFinder.get();
 306             } catch (UncheckedIOException x) {
 307                 throw x.getCause();
 308             }
 309             usedPackageFinder = true;
 310         }
 311         if (allPackages != null) {
 312             Set<String> knownPackages = JLMA.packages(builder);
 313             if (!allPackages.containsAll(knownPackages)) {
 314                 Set<String> missingPackages = new HashSet<>(knownPackages);
 315                 missingPackages.removeAll(allPackages);
 316                 assert !missingPackages.isEmpty();
 317                 String missingPackage = missingPackages.iterator().next();
 318                 String tail;
 319                 if (usedPackageFinder) {
 320                     tail = " not found in module";
 321                 } else {
 322                     tail = " missing from ModulePackages class file attribute";
 323                 }
 324                 throw invalidModuleDescriptor("Package " + missingPackage + tail);
 325 
 326             }
 327             builder.packages(allPackages);
 328         }
 329 
 330         ModuleDescriptor descriptor = builder.build();
 331         return new Attributes(descriptor,
 332                               moduleTarget,
 333                               moduleHashes,
 334                               moduleResolution);
 335     }
 336 
 337     /**
 338      * Reads the Module attribute, returning the ModuleDescriptor.Builder to
 339      * build the corresponding ModuleDescriptor.
 340      */
 341     private Builder readModuleAttribute(DataInput in, ConstantPool cpool, int major)
 342         throws IOException
 343     {
 344         // module_name
 345         int module_name_index = in.readUnsignedShort();
 346         String mn = cpool.getModuleName(module_name_index);
 347 
 348         int module_flags = in.readUnsignedShort();
 349 
 350         Set<ModuleDescriptor.Modifier> modifiers = new HashSet<>();
 351         boolean open = ((module_flags & ACC_OPEN) != 0);
 352         if (open)
 353             modifiers.add(ModuleDescriptor.Modifier.OPEN);
 354         if ((module_flags & ACC_SYNTHETIC) != 0)
 355             modifiers.add(ModuleDescriptor.Modifier.SYNTHETIC);
 356         if ((module_flags & ACC_MANDATED) != 0)
 357             modifiers.add(ModuleDescriptor.Modifier.MANDATED);
 358 
 359         Builder builder = JLMA.newModuleBuilder(mn, false, modifiers);
 360 
 361         int module_version_index = in.readUnsignedShort();
 362         if (module_version_index != 0) {
 363             String vs = cpool.getUtf8(module_version_index);
 364             builder.version(vs);
 365         }
 366 
 367         int requires_count = in.readUnsignedShort();
 368         boolean requiresJavaBase = false;
 369         for (int i=0; i<requires_count; i++) {
 370             int requires_index = in.readUnsignedShort();
 371             String dn = cpool.getModuleName(requires_index);
 372 
 373             int requires_flags = in.readUnsignedShort();
 374             Set<Requires.Modifier> mods;
 375             if (requires_flags == 0) {
 376                 mods = Set.of();
 377             } else {
 378                 mods = new HashSet<>();
 379                 if ((requires_flags & ACC_TRANSITIVE) != 0)
 380                     mods.add(Requires.Modifier.TRANSITIVE);
 381                 if ((requires_flags & ACC_STATIC_PHASE) != 0)
 382                     mods.add(Requires.Modifier.STATIC);
 383                 if ((requires_flags & ACC_SYNTHETIC) != 0)
 384                     mods.add(Requires.Modifier.SYNTHETIC);
 385                 if ((requires_flags & ACC_MANDATED) != 0)
 386                     mods.add(Requires.Modifier.MANDATED);
 387             }
 388 
 389             int requires_version_index = in.readUnsignedShort();
 390             if (requires_version_index == 0) {
 391                 builder.requires(mods, dn);
 392             } else {
 393                 String vs = cpool.getUtf8(requires_version_index);
 394                 JLMA.requires(builder, mods, dn, vs);
 395             }
 396 
 397             if (dn.equals("java.base")) {
 398                 if (major >= 54
 399                     && (mods.contains(Requires.Modifier.TRANSITIVE)
 400                         || mods.contains(Requires.Modifier.STATIC))) {
 401                     String flagName;
 402                     if (mods.contains(Requires.Modifier.TRANSITIVE)) {
 403                         flagName = "ACC_TRANSITIVE";
 404                     } else {
 405                         flagName = "ACC_STATIC_PHASE";
 406                     }
 407                     throw invalidModuleDescriptor("The requires entry for java.base"
 408                                                   + " has " + flagName + " set");
 409                 }
 410                 requiresJavaBase = true;
 411             }
 412         }
 413         if (mn.equals("java.base")) {
 414             if (requires_count > 0) {
 415                 throw invalidModuleDescriptor("The requires table for java.base"
 416                                               + " must be 0 length");
 417             }
 418         } else if (!requiresJavaBase) {
 419             throw invalidModuleDescriptor("The requires table must have"
 420                                           + " an entry for java.base");
 421         }
 422 
 423         int exports_count = in.readUnsignedShort();
 424         if (exports_count > 0) {
 425             for (int i=0; i<exports_count; i++) {
 426                 int exports_index = in.readUnsignedShort();
 427                 String pkg = cpool.getPackageName(exports_index);
 428 
 429                 Set<Exports.Modifier> mods;
 430                 int exports_flags = in.readUnsignedShort();
 431                 if (exports_flags == 0) {
 432                     mods = Set.of();
 433                 } else {
 434                     mods = new HashSet<>();
 435                     if ((exports_flags & ACC_SYNTHETIC) != 0)
 436                         mods.add(Exports.Modifier.SYNTHETIC);
 437                     if ((exports_flags & ACC_MANDATED) != 0)
 438                         mods.add(Exports.Modifier.MANDATED);
 439                 }
 440 
 441                 int exports_to_count = in.readUnsignedShort();
 442                 if (exports_to_count > 0) {
 443                     Set<String> targets = new HashSet<>(exports_to_count);
 444                     for (int j=0; j<exports_to_count; j++) {
 445                         int exports_to_index = in.readUnsignedShort();
 446                         String target = cpool.getModuleName(exports_to_index);
 447                         if (!targets.add(target)) {
 448                             throw invalidModuleDescriptor(pkg + " exported to "
 449                                                           + target + " more than once");
 450                         }
 451                     }
 452                     builder.exports(mods, pkg, targets);
 453                 } else {
 454                     builder.exports(mods, pkg);
 455                 }
 456             }
 457         }
 458 
 459         int opens_count = in.readUnsignedShort();
 460         if (opens_count > 0) {
 461             if (open) {
 462                 throw invalidModuleDescriptor("The opens table for an open"
 463                                               + " module must be 0 length");
 464             }
 465             for (int i=0; i<opens_count; i++) {
 466                 int opens_index = in.readUnsignedShort();
 467                 String pkg = cpool.getPackageName(opens_index);
 468 
 469                 Set<Opens.Modifier> mods;
 470                 int opens_flags = in.readUnsignedShort();
 471                 if (opens_flags == 0) {
 472                     mods = Set.of();
 473                 } else {
 474                     mods = new HashSet<>();
 475                     if ((opens_flags & ACC_SYNTHETIC) != 0)
 476                         mods.add(Opens.Modifier.SYNTHETIC);
 477                     if ((opens_flags & ACC_MANDATED) != 0)
 478                         mods.add(Opens.Modifier.MANDATED);
 479                 }
 480 
 481                 int open_to_count = in.readUnsignedShort();
 482                 if (open_to_count > 0) {
 483                     Set<String> targets = new HashSet<>(open_to_count);
 484                     for (int j=0; j<open_to_count; j++) {
 485                         int opens_to_index = in.readUnsignedShort();
 486                         String target = cpool.getModuleName(opens_to_index);
 487                         if (!targets.add(target)) {
 488                             throw invalidModuleDescriptor(pkg + " opened to "
 489                                                           + target + " more than once");
 490                         }
 491                     }
 492                     builder.opens(mods, pkg, targets);
 493                 } else {
 494                     builder.opens(mods, pkg);
 495                 }
 496             }
 497         }
 498 
 499         int uses_count = in.readUnsignedShort();
 500         if (uses_count > 0) {
 501             for (int i=0; i<uses_count; i++) {
 502                 int index = in.readUnsignedShort();
 503                 String sn = cpool.getClassName(index);
 504                 builder.uses(sn);
 505             }
 506         }
 507 
 508         int provides_count = in.readUnsignedShort();
 509         if (provides_count > 0) {
 510             for (int i=0; i<provides_count; i++) {
 511                 int index = in.readUnsignedShort();
 512                 String sn = cpool.getClassName(index);
 513                 int with_count = in.readUnsignedShort();
 514                 List<String> providers = new ArrayList<>(with_count);
 515                 for (int j=0; j<with_count; j++) {
 516                     index = in.readUnsignedShort();
 517                     String pn = cpool.getClassName(index);
 518                     if (!providers.add(pn)) {
 519                         throw invalidModuleDescriptor(sn + " provides " + pn
 520                                                       + " more than once");
 521                     }
 522                 }
 523                 builder.provides(sn, providers);
 524             }
 525         }
 526 
 527         return builder;
 528     }
 529 
 530     /**
 531      * Reads the ModulePackages attribute
 532      */
 533     private Set<String> readModulePackagesAttribute(DataInput in, ConstantPool cpool)
 534         throws IOException
 535     {
 536         int package_count = in.readUnsignedShort();
 537         Set<String> packages = new HashSet<>(package_count);
 538         for (int i=0; i<package_count; i++) {
 539             int index = in.readUnsignedShort();
 540             String pn = cpool.getPackageName(index);
 541             boolean added = packages.add(pn);
 542             if (!added) {
 543                 throw invalidModuleDescriptor("Package " + pn + " in ModulePackages"
 544                                               + "attribute more than once");
 545             }
 546         }
 547         return packages;
 548     }
 549 
 550     /**
 551      * Reads the ModuleMainClass attribute
 552      */
 553     private String readModuleMainClassAttribute(DataInput in, ConstantPool cpool)
 554         throws IOException
 555     {
 556         int index = in.readUnsignedShort();
 557         return cpool.getClassName(index);
 558     }
 559 
 560     /**
 561      * Reads the ModuleTarget attribute
 562      */
 563     private ModuleTarget readModuleTargetAttribute(DataInput in, ConstantPool cpool)
 564         throws IOException
 565     {
 566         String targetPlatform = null;
 567 
 568         int index = in.readUnsignedShort();
 569         if (index != 0)
 570             targetPlatform = cpool.getUtf8(index);
 571 
 572         return new ModuleTarget(targetPlatform);
 573     }
 574 
 575     /**
 576      * Reads the ModuleHashes attribute
 577      */
 578     private ModuleHashes readModuleHashesAttribute(DataInput in, ConstantPool cpool)
 579         throws IOException
 580     {
 581         int algorithm_index = in.readUnsignedShort();
 582         String algorithm = cpool.getUtf8(algorithm_index);
 583 
 584         int hash_count = in.readUnsignedShort();
 585         Map<String, byte[]> map = new HashMap<>(hash_count);
 586         for (int i=0; i<hash_count; i++) {
 587             int module_name_index = in.readUnsignedShort();
 588             String mn = cpool.getModuleName(module_name_index);
 589             int hash_length = in.readUnsignedShort();
 590             if (hash_length == 0) {
 591                 throw invalidModuleDescriptor("hash_length == 0");
 592             }
 593             byte[] hash = new byte[hash_length];
 594             in.readFully(hash);
 595             map.put(mn, hash);
 596         }
 597 
 598         return new ModuleHashes(algorithm, map);
 599     }
 600 
 601     /**
 602      * Reads the ModuleResolution attribute.
 603      */
 604     private ModuleResolution readModuleResolution(DataInput in,
 605                                                   ConstantPool cpool)
 606         throws IOException
 607     {
 608         int flags = in.readUnsignedShort();
 609 
 610         int reason = 0;
 611         if ((flags & WARN_DEPRECATED) != 0)
 612             reason = WARN_DEPRECATED;
 613         if ((flags & WARN_DEPRECATED_FOR_REMOVAL) != 0) {
 614             if (reason != 0)
 615                 throw invalidModuleDescriptor("Bad module resolution flags:" + flags);
 616             reason = WARN_DEPRECATED_FOR_REMOVAL;
 617         }
 618         if ((flags & WARN_INCUBATING) != 0) {
 619             if (reason != 0)
 620                 throw invalidModuleDescriptor("Bad module resolution flags:" + flags);
 621         }
 622 
 623         return new ModuleResolution(flags);
 624     }
 625 
 626     /**
 627      * Returns true if the given attribute can be present at most once
 628      * in the class file. Returns false otherwise.
 629      */
 630     private static boolean isAttributeAtMostOnce(String name) {
 631 
 632         if (name.equals(MODULE) ||
 633                 name.equals(SOURCE_FILE) ||
 634                 name.equals(SDE) ||
 635                 name.equals(MODULE_PACKAGES) ||
 636                 name.equals(MODULE_MAIN_CLASS) ||
 637                 name.equals(MODULE_TARGET) ||
 638                 name.equals(MODULE_HASHES) ||
 639                 name.equals(MODULE_RESOLUTION))
 640             return true;
 641 
 642         return false;
 643     }
 644 
 645     /**
 646      * Return true if the given attribute name is the name of a pre-defined
 647      * attribute in JVMS 4.7 that is not allowed in a module-info class.
 648      */
 649     private static boolean isAttributeDisallowed(String name) {
 650         Set<String> notAllowed = predefinedNotAllowed;
 651         if (notAllowed == null) {
 652             notAllowed = Set.of(
 653                     "ConstantValue",
 654                     "Code",
 655                     "Deprecated",
 656                     "StackMapTable",
 657                     "Exceptions",
 658                     "EnclosingMethod",
 659                     "Signature",
 660                     "LineNumberTable",
 661                     "LocalVariableTable",
 662                     "LocalVariableTypeTable",
 663                     "RuntimeVisibleParameterAnnotations",
 664                     "RuntimeInvisibleParameterAnnotations",
 665                     "RuntimeVisibleTypeAnnotations",
 666                     "RuntimeInvisibleTypeAnnotations",
 667                     "Synthetic",
 668                     "AnnotationDefault",
 669                     "BootstrapMethods",
 670                     "MethodParameters");
 671             predefinedNotAllowed = notAllowed;
 672         }
 673         return notAllowed.contains(name);
 674     }
 675 
 676     // lazily created set the pre-defined attributes that are not allowed
 677     private static volatile Set<String> predefinedNotAllowed;
 678 
 679 
 680     /**
 681      * The constant pool in a class file.
 682      */
 683     private static class ConstantPool {
 684         static final int CONSTANT_Utf8 = 1;
 685         static final int CONSTANT_Integer = 3;
 686         static final int CONSTANT_Float = 4;
 687         static final int CONSTANT_Long = 5;
 688         static final int CONSTANT_Double = 6;
 689         static final int CONSTANT_Class = 7;
 690         static final int CONSTANT_String = 8;
 691         static final int CONSTANT_Fieldref = 9;
 692         static final int CONSTANT_Methodref = 10;
 693         static final int CONSTANT_InterfaceMethodref = 11;
 694         static final int CONSTANT_NameAndType = 12;
 695         static final int CONSTANT_MethodHandle = 15;
 696         static final int CONSTANT_MethodType = 16;
 697         static final int CONSTANT_InvokeDynamic = 18;
 698         static final int CONSTANT_Module = 19;
 699         static final int CONSTANT_Package = 20;
 700 
 701         private static class Entry {
 702             protected Entry(int tag) {
 703                 this.tag = tag;
 704             }
 705             final int tag;
 706         }
 707 
 708         private static class IndexEntry extends Entry {
 709             IndexEntry(int tag, int index) {
 710                 super(tag);
 711                 this.index = index;
 712             }
 713             final int index;
 714         }
 715 
 716         private static class Index2Entry extends Entry {
 717             Index2Entry(int tag, int index1, int index2) {
 718                 super(tag);
 719                 this.index1 = index1;
 720                 this.index2 = index2;
 721             }
 722             final int index1,  index2;
 723         }
 724 
 725         private static class ValueEntry extends Entry {
 726             ValueEntry(int tag, Object value) {
 727                 super(tag);
 728                 this.value = value;
 729             }
 730             final Object value;
 731         }
 732 
 733         final Entry[] pool;
 734 
 735         ConstantPool(DataInput in) throws IOException {
 736             int count = in.readUnsignedShort();
 737             pool = new Entry[count];
 738 
 739             for (int i = 1; i < count; i++) {
 740                 int tag = in.readUnsignedByte();
 741                 switch (tag) {
 742 
 743                     case CONSTANT_Utf8:
 744                         String svalue = in.readUTF();
 745                         pool[i] = new ValueEntry(tag, svalue);
 746                         break;
 747 
 748                     case CONSTANT_Class:
 749                     case CONSTANT_Package:
 750                     case CONSTANT_Module:
 751                     case CONSTANT_String:
 752                         int index = in.readUnsignedShort();
 753                         pool[i] = new IndexEntry(tag, index);
 754                         break;
 755 
 756                     case CONSTANT_Double:
 757                         double dvalue = in.readDouble();
 758                         pool[i] = new ValueEntry(tag, dvalue);
 759                         i++;
 760                         break;
 761 
 762                     case CONSTANT_Fieldref:
 763                     case CONSTANT_InterfaceMethodref:
 764                     case CONSTANT_Methodref:
 765                     case CONSTANT_InvokeDynamic:
 766                     case CONSTANT_NameAndType:
 767                         int index1 = in.readUnsignedShort();
 768                         int index2 = in.readUnsignedShort();
 769                         pool[i] = new Index2Entry(tag, index1, index2);
 770                         break;
 771 
 772                     case CONSTANT_MethodHandle:
 773                         int refKind = in.readUnsignedByte();
 774                         index = in.readUnsignedShort();
 775                         pool[i] = new Index2Entry(tag, refKind, index);
 776                         break;
 777 
 778                     case CONSTANT_MethodType:
 779                         index = in.readUnsignedShort();
 780                         pool[i] = new IndexEntry(tag, index);
 781                         break;
 782 
 783                     case CONSTANT_Float:
 784                         float fvalue = in.readFloat();
 785                         pool[i] = new ValueEntry(tag, fvalue);
 786                         break;
 787 
 788                     case CONSTANT_Integer:
 789                         int ivalue = in.readInt();
 790                         pool[i] = new ValueEntry(tag, ivalue);
 791                         break;
 792 
 793                     case CONSTANT_Long:
 794                         long lvalue = in.readLong();
 795                         pool[i] = new ValueEntry(tag, lvalue);
 796                         i++;
 797                         break;
 798 
 799                     default:
 800                         throw invalidModuleDescriptor("Bad constant pool entry: "
 801                                                       + i);
 802                 }
 803             }
 804         }
 805 
 806         String getClassName(int index) {
 807             checkIndex(index);
 808             Entry e = pool[index];
 809             if (e.tag != CONSTANT_Class) {
 810                 throw invalidModuleDescriptor("CONSTANT_Class expected at entry: "
 811                                               + index);
 812             }
 813             String value = getUtf8(((IndexEntry) e).index);
 814             checkUnqualifiedName("CONSTANT_Class", index, value);
 815             return value.replace('/', '.');  // internal form -> binary name
 816         }
 817 
 818         String getPackageName(int index) {
 819             checkIndex(index);
 820             Entry e = pool[index];
 821             if (e.tag != CONSTANT_Package) {
 822                 throw invalidModuleDescriptor("CONSTANT_Package expected at entry: "
 823                                               + index);
 824             }
 825             String value = getUtf8(((IndexEntry) e).index);
 826             checkUnqualifiedName("CONSTANT_Package", index, value);
 827             return value.replace('/', '.');  // internal form -> binary name
 828         }
 829 
 830         String getModuleName(int index) {
 831             checkIndex(index);
 832             Entry e = pool[index];
 833             if (e.tag != CONSTANT_Module) {
 834                 throw invalidModuleDescriptor("CONSTANT_Module expected at entry: "
 835                                               + index);
 836             }
 837             String value = getUtf8(((IndexEntry) e).index);
 838             return decodeModuleName(index, value);
 839         }
 840 
 841         String getUtf8(int index) {
 842             checkIndex(index);
 843             Entry e = pool[index];
 844             if (e.tag != CONSTANT_Utf8) {
 845                 throw invalidModuleDescriptor("CONSTANT_Utf8 expected at entry: "
 846                                               + index);
 847             }
 848             return (String) (((ValueEntry) e).value);
 849         }
 850 
 851         void checkIndex(int index) {
 852             if (index < 1 || index >= pool.length)
 853                 throw invalidModuleDescriptor("Index into constant pool out of range");
 854         }
 855 
 856         void checkUnqualifiedName(String what, int index, String value) {
 857             int len = value.length();
 858             if (len == 0) {
 859                 throw invalidModuleDescriptor(what + " at entry " + index
 860                                               + " has zero length");
 861             }
 862             for (int i=0; i<len; i++) {
 863                 char c = value.charAt(i);
 864                 if (c == '.' || c == ';' || c == '[') {
 865                     throw invalidModuleDescriptor(what + " at entry " + index
 866                                                   + " has illegal character: '"
 867                                                   + c + "'");
 868                 }
 869             }
 870         }
 871 
 872         /**
 873          * "Decode" a module name that has been read from the constant pool.
 874          */
 875         String decodeModuleName(int index, String value) {
 876             int len = value.length();
 877             if (len == 0) {
 878                 throw invalidModuleDescriptor("CONSTANT_Module at entry "
 879                                               + index + " is zero length");
 880             }
 881             int i = 0;
 882             while (i < len) {
 883                 int cp = value.codePointAt(i);
 884                 if (cp == ':' || cp == '@' || cp < 0x20) {
 885                     throw invalidModuleDescriptor("CONSTANT_Module at entry "
 886                                                   + index + " has illegal character: "
 887                                                   + Character.getName(cp));
 888                 }
 889 
 890                 // blackslash is the escape character
 891                 if (cp == '\\')
 892                     return decodeModuleName(index, i, value);
 893 
 894                 i += Character.charCount(cp);
 895             }
 896             return value;
 897         }
 898 
 899         /**
 900          * "Decode" a module name that has been read from the constant pool and
 901          * partly checked for illegal characters (up to position {@code i}).
 902          */
 903         String decodeModuleName(int index, int i, String value) {
 904             StringBuilder sb = new StringBuilder();
 905 
 906             // copy the code points that have been checked
 907             int j = 0;
 908             while (j < i) {
 909                 int cp = value.codePointAt(j);
 910                 sb.appendCodePoint(cp);
 911                 j += Character.charCount(cp);
 912             }
 913 
 914             // decode from position {@code i} to end
 915             int len = value.length();
 916             while (i < len) {
 917                 int cp = value.codePointAt(i);
 918                 if (cp == ':' || cp == '@' || cp < 0x20) {
 919                     throw invalidModuleDescriptor("CONSTANT_Module at entry "
 920                                                   + index + " has illegal character: "
 921                                                   + Character.getName(cp));
 922                 }
 923 
 924                 // blackslash is the escape character
 925                 if (cp == '\\') {
 926                     j = i + Character.charCount(cp);
 927                     if (j >= len) {
 928                         throw invalidModuleDescriptor("CONSTANT_Module at entry "
 929                                                        + index + " has illegal "
 930                                                        + "escape sequence");
 931                     }
 932                     int next = value.codePointAt(j);
 933                     if (next != '\\' && next != ':' && next != '@') {
 934                         throw invalidModuleDescriptor("CONSTANT_Module at entry "
 935                                                       + index + " has illegal "
 936                                                       + "escape sequence");
 937                     }
 938                     sb.appendCodePoint(next);
 939                     i += Character.charCount(next);
 940                 } else {
 941                     sb.appendCodePoint(cp);
 942                 }
 943 
 944                 i += Character.charCount(cp);
 945             }
 946             return sb.toString();
 947         }
 948     }
 949 
 950     /**
 951      * A DataInput implementation that reads from a ByteBuffer.
 952      */
 953     private static class DataInputWrapper implements DataInput {
 954         private final ByteBuffer bb;
 955 
 956         DataInputWrapper(ByteBuffer bb) {
 957             this.bb = bb;
 958         }
 959 
 960         @Override
 961         public void readFully(byte b[]) throws IOException {
 962             readFully(b, 0, b.length);
 963         }
 964 
 965         @Override
 966         public void readFully(byte b[], int off, int len) throws IOException {
 967             try {
 968                 bb.get(b, off, len);
 969             } catch (BufferUnderflowException e) {
 970                 throw new EOFException(e.getMessage());
 971             }
 972         }
 973 
 974         @Override
 975         public int skipBytes(int n) {
 976             int skip = Math.min(n, bb.remaining());
 977             bb.position(bb.position() + skip);
 978             return skip;
 979         }
 980 
 981         @Override
 982         public boolean readBoolean() throws IOException {
 983             try {
 984                 int ch = bb.get();
 985                 return (ch != 0);
 986             } catch (BufferUnderflowException e) {
 987                 throw new EOFException(e.getMessage());
 988             }
 989         }
 990 
 991         @Override
 992         public byte readByte() throws IOException {
 993             try {
 994                 return bb.get();
 995             } catch (BufferUnderflowException e) {
 996                 throw new EOFException(e.getMessage());
 997             }
 998         }
 999 
1000         @Override
1001         public int readUnsignedByte() throws IOException {
1002             try {
1003                 return ((int) bb.get()) & 0xff;
1004             } catch (BufferUnderflowException e) {
1005                 throw new EOFException(e.getMessage());
1006             }
1007         }
1008 
1009         @Override
1010         public short readShort() throws IOException {
1011             try {
1012                 return bb.getShort();
1013             } catch (BufferUnderflowException e) {
1014                 throw new EOFException(e.getMessage());
1015             }
1016         }
1017 
1018         @Override
1019         public int readUnsignedShort() throws IOException {
1020             try {
1021                 return ((int) bb.getShort()) & 0xffff;
1022             } catch (BufferUnderflowException e) {
1023                 throw new EOFException(e.getMessage());
1024             }
1025         }
1026 
1027         @Override
1028         public char readChar() throws IOException {
1029             try {
1030                 return bb.getChar();
1031             } catch (BufferUnderflowException e) {
1032                 throw new EOFException(e.getMessage());
1033             }
1034         }
1035 
1036         @Override
1037         public int readInt() throws IOException {
1038             try {
1039                 return bb.getInt();
1040             } catch (BufferUnderflowException e) {
1041                 throw new EOFException(e.getMessage());
1042             }
1043         }
1044 
1045         @Override
1046         public long readLong() throws IOException {
1047             try {
1048                 return bb.getLong();
1049             } catch (BufferUnderflowException e) {
1050                 throw new EOFException(e.getMessage());
1051             }
1052         }
1053 
1054         @Override
1055         public float readFloat() throws IOException {
1056             try {
1057                 return bb.getFloat();
1058             } catch (BufferUnderflowException e) {
1059                 throw new EOFException(e.getMessage());
1060             }
1061         }
1062 
1063         @Override
1064         public double readDouble() throws IOException {
1065             try {
1066                 return bb.getDouble();
1067             } catch (BufferUnderflowException e) {
1068                 throw new EOFException(e.getMessage());
1069             }
1070         }
1071 
1072         @Override
1073         public String readLine() {
1074             throw new RuntimeException("not implemented");
1075         }
1076 
1077         @Override
1078         public String readUTF() throws IOException {
1079             // ### Need to measure the performance and feasibility of using
1080             // the UTF-8 decoder instead.
1081             return DataInputStream.readUTF(this);
1082         }
1083     }
1084 
1085     /**
1086      * Returns an InvalidModuleDescriptorException with the given detail
1087      * message
1088      */
1089     private static InvalidModuleDescriptorException
1090     invalidModuleDescriptor(String msg) {
1091         return new InvalidModuleDescriptorException(msg);
1092     }
1093 
1094     /**
1095      * Returns an InvalidModuleDescriptorException with a detail message to
1096      * indicate that the class file is truncated.
1097      */
1098     private static InvalidModuleDescriptorException truncatedModuleDescriptor() {
1099         return invalidModuleDescriptor("Truncated module-info.class");
1100     }
1101 
1102 }
--- EOF ---