diff --git a/.hgtags-top-repo b/.hgtags-top-repo index 31037ba1c8e8525fdb5499977e7be30c86412648..5185513066a2cc8b362fc128dcd91fd26bcd4f59 100644 --- a/.hgtags-top-repo +++ b/.hgtags-top-repo @@ -119,3 +119,4 @@ c6569c5585851dfd39b8de8e021c3c312f51af12 jdk7-b141 cfbbdb77eac0397b03eb99ee2e07ea00e0a7b81e jdk7-b142 14b8e7eee1058fd4ed5a2700a2ce14b3616278f1 jdk7-b143 7203965666a4fe63bf82f5e4204f41ce6285e716 jdk7-b144 +55e9ebf032186c333e5964ed044419830ac02693 jdk7-b145 diff --git a/corba/.hgtags b/corba/.hgtags index 4e55028e15b6ecfce41c134afe5854294b5f0b12..31388aa3f52883d7b950e5c8dc7bdffdcc88a8eb 100644 --- a/corba/.hgtags +++ b/corba/.hgtags @@ -119,3 +119,4 @@ a58635cdd921bafef353f4864184a0481353197b jdk7-b141 a2f340a048c88d10cbedc0504f5cf03d39925a40 jdk7-b142 51ed32f6f4de56f16e910ac54ba6c6f6606f4f17 jdk7-b143 7033a5756ad552d88114594d8e2d2e4dc2c05963 jdk7-b144 +77ec0541aa2aa4da27e9e385a118a2e51e7fca24 jdk7-b145 diff --git a/jaxp/.hgtags b/jaxp/.hgtags index da7c69ee607a5a27e8169d2bfc8167adc52b949e..8df6d410e1b30571fc2c8622d5fb791afefd4de8 100644 --- a/jaxp/.hgtags +++ b/jaxp/.hgtags @@ -119,3 +119,4 @@ e1b5ef243445bf836d095fd44866e1771ef99374 jdk7-b141 7d067af4b25e4b7e6b28bef48527d67f8650e6c5 jdk7-b142 16b847e9bbd747f9d27785b2fc20d4d720cca893 jdk7-b143 39bf6dcaab2336326b21743cef7042d0a2de9ba0 jdk7-b144 +10ca7570f47f2ae4132648f7e8da1a05f1a98a15 jdk7-b145 diff --git a/jaxws/.hgtags b/jaxws/.hgtags index 685b1613e11aed1c86a1bf1b8a34654a6d9291df..8c14d62472446bd77428cce9e488a3091ead3782 100644 --- a/jaxws/.hgtags +++ b/jaxws/.hgtags @@ -119,3 +119,4 @@ c025078c8362076503bb83b8e4da14ba7b347940 jdk7-b139 0ef3ef823c39eee3d670e58027c3219cb66f0283 jdk7-b142 569d1e7ea980d172046c4aba79d96b5c3afabbba jdk7-b143 6bd683f2d527c9afd47beac1cbf614506929598d jdk7-b144 +42bfba80beb7d3260b7b135b9a39202b512eb8c2 jdk7-b145 diff --git a/jdk/.hgtags b/jdk/.hgtags index 0ace621f30092e207790c0d394e74e62b3bc2a12..89306498346a6c1dcf99bb7a7af28fd497eed290 100644 --- a/jdk/.hgtags +++ b/jdk/.hgtags @@ -119,3 +119,4 @@ d80954a89b49fda47c0c5cace65a17f5a758b8bd jdk7-b139 312612e89ece62633f4809706dec00bcd5fe7c2d jdk7-b142 efbf75c24b0f31847c9c403f6dc07dc80551908d jdk7-b143 23bdcede4e3945894574892e80b848bd9f15b5f3 jdk7-b144 +1e04b38b3824a4a1d197ef681a302e6813e53f8b jdk7-b145 diff --git a/jdk/make/com/sun/tools/attach/Makefile b/jdk/make/com/sun/tools/attach/Makefile index ac5994d89bec21ecb8ac51df0b850b4504eefaaa..1179f1860b262a0b4ee5e7bad3397f939bf127e2 100644 --- a/jdk/make/com/sun/tools/attach/Makefile +++ b/jdk/make/com/sun/tools/attach/Makefile @@ -48,6 +48,9 @@ include Exportedfiles.gmk ifeq ($(PLATFORM), solaris) OTHER_LDLIBS += -ldoor endif +ifeq ($(PLATFORM), windows) +EXTRA_LIBS += psapi.lib +endif vpath %.c $(PLATFORM_SRC)/native/sun/tools/attach diff --git a/jdk/make/common/Release.gmk b/jdk/make/common/Release.gmk index 1d3762087b10928f007022670af0db92cd583ef5..ed9ac7ca87e8c087d954d8b3d4bcfb1814825c6c 100644 --- a/jdk/make/common/Release.gmk +++ b/jdk/make/common/Release.gmk @@ -900,8 +900,10 @@ initial-image-jdk-db: $(DB_ZIP_LIST) for d in $(DB_ZIP_LIST); do \ ($(CD) $(JDK_IMAGE_DIR)/db && $(UNZIP) -o $$d); \ done + $(CP) $(ABS_DB_PATH)/README-JDK.html $(JDK_IMAGE_DIR)/db $(RM) -rf $(DEMODIR)/db $(MV) $(JDK_IMAGE_DIR)/db/demo $(DEMODIR)/db + $(CP) $(ABS_DB_PATH)/README-JDK-DEMOS.html $(DEMODIR)/db/ $(RM) $(JDK_IMAGE_DIR)/db/index.html $(JDK_IMAGE_DIR)/db/register.html endif diff --git a/jdk/make/sun/security/pkcs11/Makefile b/jdk/make/sun/security/pkcs11/Makefile index c7c33504f55f50b7aa2837250ce23ee9ef832b89..a63198f5fb4f4fef4320095b5120bc1eeea936b2 100644 --- a/jdk/make/sun/security/pkcs11/Makefile +++ b/jdk/make/sun/security/pkcs11/Makefile @@ -147,7 +147,7 @@ OTHER_INCLUDES += \ # Rules # CLASSDESTDIR = $(TEMPDIR)/classes -JAVAHFLAGS += -classpath $(CLASSDESTDIR) +JAVAHFLAGS += -Xbootclasspath/p:$(CLASSDESTDIR) include $(BUILDDIR)/common/Mapfile-vers.gmk diff --git a/jdk/src/share/classes/java/lang/invoke/AdapterMethodHandle.java b/jdk/src/share/classes/java/lang/invoke/AdapterMethodHandle.java index 6c2ca8fe31e45a7b743de7d894ade6f8c84035fd..897d177b37af0068bcf2165378b1f01cb84a3e6b 100644 --- a/jdk/src/share/classes/java/lang/invoke/AdapterMethodHandle.java +++ b/jdk/src/share/classes/java/lang/invoke/AdapterMethodHandle.java @@ -405,13 +405,13 @@ class AdapterMethodHandle extends BoundMethodHandle { insertStackMove(stackMove) ); } - private static long makeSwapConv(int convOp, int srcArg, byte type, int destSlot) { + private static long makeSwapConv(int convOp, int srcArg, byte srcType, int destSlot, byte destType) { // more complex argument motion, requiring two slots to specify assert(convOp == OP_SWAP_ARGS || convOp == OP_ROT_ARGS); return ((long) srcArg << 32 | (long) convOp << CONV_OP_SHIFT | - (int) type << CONV_SRC_TYPE_SHIFT | - (int) type << CONV_DEST_TYPE_SHIFT | + (int) srcType << CONV_SRC_TYPE_SHIFT | + (int) destType << CONV_DEST_TYPE_SHIFT | (int) destSlot << CONV_VMINFO_SHIFT ); } @@ -943,24 +943,27 @@ class AdapterMethodHandle extends BoundMethodHandle { if (type2size(newType.parameterType(swapArg1)) != type2size(newType.parameterType(swapArg2))) { // turn a swap into a pair of rotates: - // [x a b c y] => [a b c y x] => [y a b c x] + // [x a b c y] rot2(-1,argc=5) => [a b c y x] rot1(+1,argc=4) => target[y a b c x] int argc = swapArg2 - swapArg1 + 1; final int ROT = 1; ArrayList> rot1Params = new ArrayList>(target.type().parameterList()); Collections.rotate(rot1Params.subList(swapArg1, swapArg1 + argc), -ROT); MethodType rot1Type = MethodType.methodType(target.type().returnType(), rot1Params); MethodHandle rot1 = makeRotateArguments(rot1Type, target, swapArg1, argc, +ROT); + assert(rot1 != null); if (argc == 2) return rot1; MethodHandle rot2 = makeRotateArguments(newType, rot1, swapArg1, argc-1, -ROT); + assert(rot2 != null); return rot2; } if (!canSwapArguments(newType, target.type(), swapArg1, swapArg2)) return null; - Class swapType = newType.parameterType(swapArg1); + Class type1 = newType.parameterType(swapArg1); + Class type2 = newType.parameterType(swapArg2); // in arglist: [0: ...keep1 | pos1: a1 | pos1+1: keep2... | pos2: a2 | pos2+1: keep3... ] // out arglist: [0: ...keep1 | pos1: a2 | pos1+1: keep2... | pos2: a1 | pos2+1: keep3... ] int swapSlot2 = newType.parameterSlotDepth(swapArg2 + 1); - long conv = makeSwapConv(OP_SWAP_ARGS, swapArg1, basicType(swapType), swapSlot2); + long conv = makeSwapConv(OP_SWAP_ARGS, swapArg1, basicType(type1), swapSlot2, basicType(type2)); return new AdapterMethodHandle(target, newType, conv); } @@ -1029,16 +1032,16 @@ class AdapterMethodHandle extends BoundMethodHandle { assert(MAX_ARG_ROTATION == 1); int srcArg, dstArg; int dstSlot; - byte basicType; - if (chunk2Slots <= chunk1Slots) { + int moveChunk; + if (rotateBy == 1) { // Rotate right/down N (rotateBy = +N, N small, c2 small): // in arglist: [0: ...keep1 | arg1: c1... | limit-N: c2 | limit: keep2... ] // out arglist: [0: ...keep1 | arg1: c2 | arg1+N: c1... | limit: keep2... ] srcArg = limit-1; dstArg = firstArg; - dstSlot = depth0 - chunk2Slots; - basicType = basicType(newType.parameterType(srcArg)); - assert(chunk2Slots == type2size(basicType)); + //dstSlot = depth0 - chunk2Slots; //chunk2Slots is not relevant + dstSlot = depth0 + MethodHandleNatives.OP_ROT_ARGS_DOWN_LIMIT_BIAS; + moveChunk = chunk2Slots; } else { // Rotate left/up N (rotateBy = -N, N small, c1 small): // in arglist: [0: ...keep1 | arg1: c1 | arg1+N: c2... | limit: keep2... ] @@ -1046,10 +1049,12 @@ class AdapterMethodHandle extends BoundMethodHandle { srcArg = firstArg; dstArg = limit-1; dstSlot = depth2; - basicType = basicType(newType.parameterType(srcArg)); - assert(chunk1Slots == type2size(basicType)); + moveChunk = chunk1Slots; } - long conv = makeSwapConv(OP_ROT_ARGS, srcArg, basicType, dstSlot); + byte srcType = basicType(newType.parameterType(srcArg)); + byte dstType = basicType(newType.parameterType(dstArg)); + assert(moveChunk == type2size(srcType)); + long conv = makeSwapConv(OP_ROT_ARGS, srcArg, srcType, dstSlot, dstType); return new AdapterMethodHandle(target, newType, conv); } diff --git a/jdk/src/share/classes/java/lang/invoke/MethodHandleImpl.java b/jdk/src/share/classes/java/lang/invoke/MethodHandleImpl.java index 5437e85a34dec8d2e74e6553716a2e2af68d3ebd..173fc5e5dcbc90b5037d9c22cef0bf2fbd55bbed 100644 --- a/jdk/src/share/classes/java/lang/invoke/MethodHandleImpl.java +++ b/jdk/src/share/classes/java/lang/invoke/MethodHandleImpl.java @@ -788,6 +788,7 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP; .insertParameterTypes(keepPosArgs, arrayType); return spreadArguments(target, newType, keepPosArgs, arrayType, arrayLength); } + // called internally only static MethodHandle spreadArgumentsFromPos(MethodHandle target, MethodType newType, int spreadArgPos) { int arrayLength = target.type().parameterCount() - spreadArgPos; return spreadArguments(target, newType, spreadArgPos, Object[].class, arrayLength); @@ -849,6 +850,12 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP; MethodType ttype = target.type(); MethodType ftype = filter.type(); assert(ftype.parameterCount() == 1); + MethodHandle result = null; + if (AdapterMethodHandle.canCollectArguments(ttype, ftype, pos, false)) { + result = AdapterMethodHandle.makeCollectArguments(target, filter, pos, false); + if (result != null) return result; + } + assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this code is deprecated MethodType rtype = ttype.changeParameterType(pos, ftype.parameterType(0)); MethodType gttype = ttype.generic(); if (ttype != gttype) { @@ -860,18 +867,11 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP; filter = convertArguments(filter, gftype, ftype, 0); ftype = gftype; } - MethodHandle result = null; - if (AdapterMethodHandle.canCollectArguments(ttype, ftype, pos, false)) { - result = AdapterMethodHandle.makeCollectArguments(target, filter, pos, false); - } - if (result == null) { - assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this code is deprecated - if (ftype == ttype) { + if (ftype == ttype) { // simple unary case - result = FilterOneArgument.make(filter, target); - } else { - result = FilterGeneric.makeArgumentFilter(pos, filter, target); - } + result = FilterOneArgument.make(filter, target); + } else { + result = FilterGeneric.makeArgumentFilter(pos, filter, target); } if (result.type() != rtype) result = result.asType(rtype); @@ -920,7 +920,7 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP; this.fallback = fallback; } static boolean preferRicochetFrame(MethodType type) { - return (type.parameterCount() >= INVOKES.length || type.hasPrimitives()); + return true; // always use RF if available } static MethodHandle make(MethodHandle test, MethodHandle target, MethodHandle fallback) { MethodType type = target.type(); @@ -931,12 +931,13 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP; MethodHandle invoke = INVOKES[nargs]; MethodType gtype = type.generic(); assert(invoke.type().dropParameterTypes(0,1) == gtype); - MethodHandle gtest = convertArguments(test, gtype.changeReturnType(boolean.class), test.type(), 0); - MethodHandle gtarget = convertArguments(target, gtype, type, 0); - MethodHandle gfallback = convertArguments(fallback, gtype, type, 0); + // Note: convertArguments(...2) avoids interface casts present in convertArguments(...0) + MethodHandle gtest = convertArguments(test, gtype.changeReturnType(boolean.class), test.type(), 2); + MethodHandle gtarget = convertArguments(target, gtype, type, 2); + MethodHandle gfallback = convertArguments(fallback, gtype, type, 2); if (gtest == null || gtarget == null || gfallback == null) return null; MethodHandle gguard = new GuardWithTest(invoke, gtest, gtarget, gfallback); - return convertArguments(gguard, type, gtype, 0); + return convertArguments(gguard, type, gtype, 2); } else { assert(MethodHandleNatives.workaroundWithoutRicochetFrames()); // this code is deprecated MethodHandle invoke = VARARGS_INVOKE; @@ -1221,11 +1222,12 @@ import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP; if (nargs < GuardWithCatch.INVOKES.length) { MethodType gtype = type.generic(); MethodType gcatchType = gtype.insertParameterTypes(0, Throwable.class); - MethodHandle gtarget = convertArguments(target, gtype, type, 0); - MethodHandle gcatcher = convertArguments(catcher, gcatchType, ctype, 0); + // Note: convertArguments(...2) avoids interface casts present in convertArguments(...0) + MethodHandle gtarget = convertArguments(target, gtype, type, 2); + MethodHandle gcatcher = convertArguments(catcher, gcatchType, ctype, 2); MethodHandle gguard = new GuardWithCatch(gtarget, exType, gcatcher); if (gtarget == null || gcatcher == null || gguard == null) return null; - return convertArguments(gguard, type, gtype, 0); + return convertArguments(gguard, type, gtype, 2); } else { MethodType gtype = MethodType.genericMethodType(0, true); MethodType gcatchType = gtype.insertParameterTypes(0, Throwable.class); diff --git a/jdk/src/share/classes/java/lang/invoke/MethodHandleNatives.java b/jdk/src/share/classes/java/lang/invoke/MethodHandleNatives.java index ef3df63a3e4f011c998af1b05e07e51917e1694c..5ad86fd0e48df6d14863bb422c255672bedec3eb 100644 --- a/jdk/src/share/classes/java/lang/invoke/MethodHandleNatives.java +++ b/jdk/src/share/classes/java/lang/invoke/MethodHandleNatives.java @@ -118,32 +118,20 @@ class MethodHandleNatives { /** Derived mode flag. Only false on some old JVM implementations. */ static final boolean HAVE_RICOCHET_FRAMES; + static final int OP_ROT_ARGS_DOWN_LIMIT_BIAS; + private static native void registerNatives(); static { - int JVM_PUSH_LIMIT_; - int JVM_STACK_MOVE_UNIT_; - int CONV_OP_IMPLEMENTED_MASK_; - try { - registerNatives(); - JVM_PUSH_LIMIT_ = getConstant(Constants.GC_JVM_PUSH_LIMIT); - JVM_STACK_MOVE_UNIT_ = getConstant(Constants.GC_JVM_STACK_MOVE_UNIT); - CONV_OP_IMPLEMENTED_MASK_ = getConstant(Constants.GC_CONV_OP_IMPLEMENTED_MASK); - //sun.reflect.Reflection.registerMethodsToFilter(MethodHandleImpl.class, "init"); - } catch (UnsatisfiedLinkError ee) { - // ignore; if we use init() methods later we'll see linkage errors - JVM_PUSH_LIMIT_ = 3; // arbitrary - JVM_STACK_MOVE_UNIT_ = -1; // arbitrary - CONV_OP_IMPLEMENTED_MASK_ = 0; - JVM_PUSH_LIMIT = JVM_PUSH_LIMIT_; - JVM_STACK_MOVE_UNIT = JVM_STACK_MOVE_UNIT_; - throw ee; // just die; hopeless to try to run with an older JVM - } - JVM_PUSH_LIMIT = JVM_PUSH_LIMIT_; - JVM_STACK_MOVE_UNIT = JVM_STACK_MOVE_UNIT_; - if (CONV_OP_IMPLEMENTED_MASK_ == 0) - CONV_OP_IMPLEMENTED_MASK_ = DEFAULT_CONV_OP_IMPLEMENTED_MASK; - CONV_OP_IMPLEMENTED_MASK = CONV_OP_IMPLEMENTED_MASK_; - HAVE_RICOCHET_FRAMES = (CONV_OP_IMPLEMENTED_MASK & (1< * Since invalidation is a global and immediate operation, * the execution of this query, on a valid switchpoint, diff --git a/jdk/src/share/classes/java/net/NetworkInterface.java b/jdk/src/share/classes/java/net/NetworkInterface.java index a53d6eb0161a77e2eb9a278e061297fb8b0ccd6f..229f113a68daa38c43a94aa6aaaf056ae78b2956 100644 --- a/jdk/src/share/classes/java/net/NetworkInterface.java +++ b/jdk/src/share/classes/java/net/NetworkInterface.java @@ -547,13 +547,8 @@ public final class NetworkInterface { if (displayName != null) { result += " (" + displayName + ")"; } - result += " index: "+index+" addresses:\n"; - for (Enumeration e = getInetAddresses(); e.hasMoreElements(); ) { - InetAddress addr = (InetAddress)e.nextElement(); - result += addr+";\n"; - } return result; } - private static native void init(); + private static native void init(); } diff --git a/jdk/src/share/classes/java/security/SignedObject.java b/jdk/src/share/classes/java/security/SignedObject.java index 8d5631d9ff96b1745e4305e04a20d01098dfbb65..1f901fa1c7789e29b330ad501142c46ed17beaab 100644 --- a/jdk/src/share/classes/java/security/SignedObject.java +++ b/jdk/src/share/classes/java/security/SignedObject.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2003, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -249,10 +249,10 @@ public final class SignedObject implements Serializable { * a stream. */ private void readObject(java.io.ObjectInputStream s) - throws java.io.IOException, ClassNotFoundException - { - s.defaultReadObject(); - content = content.clone(); - signature = signature.clone(); + throws java.io.IOException, ClassNotFoundException { + java.io.ObjectInputStream.GetField fields = s.readFields(); + content = ((byte[])fields.get("content", null)).clone(); + signature = ((byte[])fields.get("signature", null)).clone(); + thealgorithm = (String)fields.get("thealgorithm", null); } } diff --git a/jdk/src/share/classes/javax/swing/ImageIcon.java b/jdk/src/share/classes/javax/swing/ImageIcon.java index f9318abea413b3a3b2dff83c04bc21de42ce3d0e..b16a62fe6b341a09dc71eb1eb3675cd29b04fbad 100644 --- a/jdk/src/share/classes/javax/swing/ImageIcon.java +++ b/jdk/src/share/classes/javax/swing/ImageIcon.java @@ -40,8 +40,7 @@ import javax.accessibility.*; import sun.awt.AppContext; import java.lang.reflect.Field; -import java.security.PrivilegedAction; -import java.security.AccessController; +import java.security.*; /** * An implementation of the Icon interface that paints Icons @@ -81,32 +80,51 @@ public class ImageIcon implements Icon, Serializable, Accessible { ImageObserver imageObserver; String description = null; + // Fields for twisted backward compatibility only. DO NOT USE. protected final static Component component; protected final static MediaTracker tracker; static { - component = new Component() {}; - AccessController.doPrivileged(new PrivilegedAction() { - public Object run() { + component = AccessController.doPrivileged(new PrivilegedAction() { + public Component run() { try { + final Component component = createNoPermsComponent(); + // 6482575 - clear the appContext field so as not to leak it Field appContextField = - Component.class.getDeclaredField("appContext"); + + Component.class.getDeclaredField("appContext"); appContextField.setAccessible(true); appContextField.set(component, null); - } - catch (NoSuchFieldException e) { - e.printStackTrace(); - } - catch (IllegalAccessException e) { + + return component; + } catch (Throwable e) { + // We don't care about component. + // So don't prevent class initialisation. e.printStackTrace(); + return null; } - return null; } }); tracker = new MediaTracker(component); } + private static Component createNoPermsComponent() { + // 7020198 - set acc field to no permissions and no subject + // Note, will have appContext set. + return AccessController.doPrivileged( + new PrivilegedAction() { + public Component run() { + return new Component() { + }; + } + }, + new AccessControlContext(new ProtectionDomain[]{ + new ProtectionDomain(null, null) + }) + ); + } + /** * Id used in loading images from MediaTracker. */ diff --git a/jdk/src/share/classes/sun/java2d/pipe/DrawImage.java b/jdk/src/share/classes/sun/java2d/pipe/DrawImage.java index dccaba7432fb335fd0035386876a141dbe33779b..f702a68be689609ff475ac0465366471ebeece18 100644 --- a/jdk/src/share/classes/sun/java2d/pipe/DrawImage.java +++ b/jdk/src/share/classes/sun/java2d/pipe/DrawImage.java @@ -509,6 +509,9 @@ public class DrawImage implements DrawImagePipe * edges thus has to be h*2+2 in length */ int edges[] = new int[(dy2-dy1)*2+2]; + // It is important that edges[0]=edges[1]=0 when we call + // Transform in case it must return early and we would + // not want to render anything on an error condition. helper.Transform(tmpmaskblit, srcData, tmpData, AlphaComposite.Src, null, itx, interpType, diff --git a/jdk/src/share/classes/sun/misc/URLClassPath.java b/jdk/src/share/classes/sun/misc/URLClassPath.java index 011067754b70bf5724554cc39c35cabc9df41c76..5db540d60020573158cb450ef892a8f872c5afa9 100644 --- a/jdk/src/share/classes/sun/misc/URLClassPath.java +++ b/jdk/src/share/classes/sun/misc/URLClassPath.java @@ -532,15 +532,11 @@ public class URLClassPath { uc = url.openConnection(); InputStream in = uc.getInputStream(); if (uc instanceof JarURLConnection) { - /* JarURLConnection.getInputStream() returns a separate - * instance on each call. So we have to close this here. - * The jar file cache will keep the file open. - * Also, need to remember the jar file so it can be closed + /* Need to remember the jar file so it can be closed * in a hurry. */ JarURLConnection juc = (JarURLConnection)uc; jarfile = juc.getJarFile(); - in.close(); } } catch (Exception e) { return null; diff --git a/jdk/src/share/classes/sun/security/pkcs11/Config.java b/jdk/src/share/classes/sun/security/pkcs11/Config.java index 6506e40e9663d5cdf6a0daaf4f9e2fef8e593797..46a0075c5b97830762d7f70fa58a873ea8b51537 100644 --- a/jdk/src/share/classes/sun/security/pkcs11/Config.java +++ b/jdk/src/share/classes/sun/security/pkcs11/Config.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -653,6 +653,13 @@ final class Config { } } debug(keyword + ": " + lib); + + // Check to see if full path is specified to prevent the DLL + // preloading attack + if (!(new File(lib)).isAbsolute()) { + throw new ConfigurationException( + "Absolute path required for library value: " + lib); + } return lib; } diff --git a/jdk/src/share/classes/sun/security/pkcs11/Secmod.java b/jdk/src/share/classes/sun/security/pkcs11/Secmod.java index 20775444731bcc784fd1d733d497e7a171165388..4f32e33d2a8a2f7c3f6a2c993ed58933f6e88500 100644 --- a/jdk/src/share/classes/sun/security/pkcs11/Secmod.java +++ b/jdk/src/share/classes/sun/security/pkcs11/Secmod.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -236,7 +236,8 @@ public final class Secmod { throw new IllegalStateException(e); } if (modules == null) { - List modules = (List)nssGetModuleList(nssHandle); + List modules = (List)nssGetModuleList(nssHandle, + nssLibDir); this.modules = Collections.unmodifiableList(modules); } return modules; @@ -358,7 +359,7 @@ public final class Secmod { * A representation of one PKCS#11 slot in a PKCS#11 module. */ public static final class Module { - // name of the native library + // path of the native library final String libraryName; // descriptive name used by NSS final String commonName; @@ -371,8 +372,10 @@ public final class Secmod { // trust attributes. Used for the KEYSTORE and TRUSTANCHOR modules only private Map trust; - Module(String libraryName, String commonName, boolean fips, int slot) { + Module(String libraryDir, String libraryName, String commonName, + boolean fips, int slot) { ModuleType type; + if ((libraryName == null) || (libraryName.length() == 0)) { // must be softtoken libraryName = System.mapLibraryName(SOFTTOKEN_LIB_NAME); @@ -397,7 +400,7 @@ public final class Secmod { + "module: " + libraryName + ", " + commonName); } } - this.libraryName = libraryName; + this.libraryName = (new File(libraryDir, libraryName)).getPath(); this.commonName = commonName; this.slot = slot; this.type = type; @@ -752,6 +755,6 @@ public final class Secmod { private static native boolean nssInit(String functionName, long handle, String configDir); - private static native Object nssGetModuleList(long handle); + private static native Object nssGetModuleList(long handle, String libDir); } diff --git a/jdk/src/share/native/common/jdk_util.h b/jdk/src/share/native/common/jdk_util.h index 8c15a4dcc353d2854a326451c6d99534bbee3625..d64e51e658d156b42b9ddd8ab35d3417e08894e9 100644 --- a/jdk/src/share/native/common/jdk_util.h +++ b/jdk/src/share/native/common/jdk_util.h @@ -28,6 +28,7 @@ #include "jni.h" #include "jvm.h" +#include "jdk_util_md.h" #ifdef __cplusplus extern "C" { diff --git a/jdk/src/share/native/sun/awt/image/jpeg/imageioJPEG.c b/jdk/src/share/native/sun/awt/image/jpeg/imageioJPEG.c index 28af8316204a4b67cfbf42ba503f56220710bc43..0f39761750a97978cf232b3b484e8ad446d1c5f7 100644 --- a/jdk/src/share/native/sun/awt/image/jpeg/imageioJPEG.c +++ b/jdk/src/share/native/sun/awt/image/jpeg/imageioJPEG.c @@ -1971,6 +1971,13 @@ Java_com_sun_imageio_plugins_jpeg_JPEGImageReader_readImage return data->abortFlag; } + if (cinfo->output_components <= 0 || + cinfo->image_width > (0xffffffffu / (unsigned int)cinfo->output_components)) + { + JNU_ThrowByName(env, "javax/imageio/IIOException", + "Invalid number of output components"); + return data->abortFlag; + } // Allocate a 1-scanline buffer scanLinePtr = (JSAMPROW)malloc(cinfo->image_width*cinfo->output_components); diff --git a/jdk/src/share/native/sun/font/layout/SunLayoutEngine.cpp b/jdk/src/share/native/sun/font/layout/SunLayoutEngine.cpp index 553334a18951e1827022a52140723c70be7abd09..c7db94829f46a8c0826d2fc0d15d776278e9c4b3 100644 --- a/jdk/src/share/native/sun/font/layout/SunLayoutEngine.cpp +++ b/jdk/src/share/native/sun/font/layout/SunLayoutEngine.cpp @@ -186,7 +186,11 @@ JNIEXPORT void JNICALL Java_sun_font_SunLayoutEngine_nativeLayout jchar buffer[256]; jchar* chars = buffer; if (len > 256) { - chars = (jchar*)malloc(len * sizeof(jchar)); + size_t size = len * sizeof(jchar); + if (size / sizeof(jchar) != len) { + return; + } + chars = (jchar*)malloc(size); if (chars == 0) { return; } diff --git a/jdk/src/share/native/sun/java2d/loops/TransformHelper.c b/jdk/src/share/native/sun/java2d/loops/TransformHelper.c index 7ccfb0694dc754403ccce029c9e5f3b5b9a561e4..a511774747630d953a34c4f5ca67811fe9dffab6 100644 --- a/jdk/src/share/native/sun/java2d/loops/TransformHelper.c +++ b/jdk/src/share/native/sun/java2d/loops/TransformHelper.c @@ -74,6 +74,94 @@ static TransformInterpFunc BicubicInterpStub; TransformInterpFunc *pBilinearFunc = BilinearInterp; TransformInterpFunc *pBicubicFunc = BicubicInterp; +/* + * The dxydxy parameters of the inverse transform determine how + * quickly we step through the source image. For tiny scale + * factors (on the order of 1E-16 or so) the stepping distances + * are huge. The image has been scaled so small that stepping + * a single pixel in device space moves the sampling point by + * billions (or more) pixels in the source image space. These + * huge stepping values can overflow the whole part of the longs + * we use for the fixed point stepping equations and so we need + * a more robust solution. We could simply iterate over every + * device pixel, use the inverse transform to transform it back + * into the source image coordinate system and then test it for + * being in range and sample pixel-by-pixel, but that is quite + * a bit more expensive. Fortunately, if the scale factors are + * so tiny that we overflow our long values then the number of + * pixels we are planning to visit should be very tiny. The only + * exception to that rule is if the scale factor along one + * dimension is tiny (creating the huge stepping values), and + * the scale factor along the other dimension is fairly regular + * or an up-scale. In that case we have a lot of pixels along + * the direction of the larger axis to sample, but few along the + * smaller axis. Though, pessimally, with an added shear factor + * such a linearly tiny image could have bounds that cover a large + * number of pixels. Such odd transformations should be very + * rare and the absolute limit on calculations would involve a + * single reverse transform of every pixel in the output image + * which is not fast, but it should not cause an undue stall + * of the rendering software. + * + * The specific test we will use is to calculate the inverse + * transformed values of every corner of the destination bounds + * (in order to be user-clip independent) and if we can + * perform a fixed-point-long inverse transform of all of + * those points without overflowing we will use the fast + * fixed point algorithm. Otherwise we will use the safe + * per-pixel transform algorithm. + * The 4 corners are 0,0, 0,dsth, dstw,0, dstw,dsth + * Transformed they are: + * tx, ty + * tx +dxdy*H, ty +dydy*H + * tx+dxdx*W, ty+dydx*W + * tx+dxdx*W+dxdy*H, ty+dydx*W+dydy*H + */ +/* We reject coordinates not less than 1<<30 so that the distance between */ +/* any 2 of them is less than 1<<31 which would overflow into the sign */ +/* bit of a signed long value used to represent fixed point coordinates. */ +#define TX_FIXED_UNSAFE(v) (fabs(v) >= (1<<30)) +static jboolean +checkOverflow(jint dxoff, jint dyoff, + SurfaceDataBounds *pBounds, + TransformInfo *pItxInfo, + jdouble *retx, jdouble *rety) +{ + jdouble x, y; + + x = dxoff+pBounds->x1+0.5; /* Center of pixel x1 */ + y = dyoff+pBounds->y1+0.5; /* Center of pixel y1 */ + Transform_transform(pItxInfo, &x, &y); + *retx = x; + *rety = y; + if (TX_FIXED_UNSAFE(x) || TX_FIXED_UNSAFE(y)) { + return JNI_TRUE; + } + + x = dxoff+pBounds->x2-0.5; /* Center of pixel x2-1 */ + y = dyoff+pBounds->y1+0.5; /* Center of pixel y1 */ + Transform_transform(pItxInfo, &x, &y); + if (TX_FIXED_UNSAFE(x) || TX_FIXED_UNSAFE(y)) { + return JNI_TRUE; + } + + x = dxoff+pBounds->x1+0.5; /* Center of pixel x1 */ + y = dyoff+pBounds->y2-0.5; /* Center of pixel y2-1 */ + Transform_transform(pItxInfo, &x, &y); + if (TX_FIXED_UNSAFE(x) || TX_FIXED_UNSAFE(y)) { + return JNI_TRUE; + } + + x = dxoff+pBounds->x2-0.5; /* Center of pixel x2-1 */ + y = dyoff+pBounds->y2-0.5; /* Center of pixel y2-1 */ + Transform_transform(pItxInfo, &x, &y); + if (TX_FIXED_UNSAFE(x) || TX_FIXED_UNSAFE(y)) { + return JNI_TRUE; + } + + return JNI_FALSE; +} + /* * Fill the edge buffer with pairs of coordinates representing the maximum * left and right pixels of the destination surface that should be processed @@ -82,21 +170,19 @@ TransformInterpFunc *pBicubicFunc = BicubicInterp; * Only pixels that map back through the specified (inverse) transform to a * source coordinate that falls within the (0, 0, sw, sh) bounds of the * source image should be processed. - * pEdgeBuf points to an array of jints that holds MAXEDGES*2 values. - * If more storage is needed, then this function allocates a new buffer. - * In either case, a pointer to the buffer actually used to store the - * results is returned. - * The caller is responsible for freeing the buffer if the return value - * is not the same as the original pEdgeBuf passed in. + * pEdges points to an array of jints that holds 2 + numedges*2 values where + * numedges should match (pBounds->y2 - pBounds->y1). + * The first two jints in pEdges should be set to y1 and y2 and every pair + * of jints after that represent the xmin,xmax of all pixels in range of + * the transformed blit for the corresponding scanline. */ -static jint * -calculateEdges(jint *pEdgeBuf, +static void +calculateEdges(jint *pEdges, SurfaceDataBounds *pBounds, TransformInfo *pItxInfo, jlong xbase, jlong ybase, juint sw, juint sh) { - jint *pEdges; jlong dxdxlong, dydxlong; jlong dxdylong, dydylong; jlong drowxlong, drowylong; @@ -111,10 +197,8 @@ calculateEdges(jint *pEdgeBuf, dy1 = pBounds->y1; dx2 = pBounds->x2; dy2 = pBounds->y2; - if ((dy2-dy1) > MAXEDGES) { - pEdgeBuf = malloc(2 * (dy2-dy1) * sizeof (*pEdges)); - } - pEdges = pEdgeBuf; + *pEdges++ = dy1; + *pEdges++ = dy2; drowxlong = (dx2-dx1-1) * dxdxlong; drowylong = (dx2-dx1-1) * dydxlong; @@ -155,10 +239,22 @@ calculateEdges(jint *pEdgeBuf, ybase += dydylong; dy1++; } - - return pEdgeBuf; } +static void +Transform_SafeHelper(JNIEnv *env, + SurfaceDataOps *srcOps, + SurfaceDataOps *dstOps, + SurfaceDataRasInfo *pSrcInfo, + SurfaceDataRasInfo *pDstInfo, + NativePrimitive *pMaskBlitPrim, + CompositeInfo *pCompInfo, + TransformHelperFunc *pHelperFunc, + TransformInterpFunc *pInterpFunc, + RegionData *pClipInfo, TransformInfo *pItxInfo, + jint *pData, jint *pEdges, + jint dxoff, jint dyoff, jint sw, jint sh); + /* * Class: sun_java2d_loops_TransformHelper * Method: Transform @@ -187,12 +283,14 @@ Java_sun_java2d_loops_TransformHelper_Transform jint maxlinepix; TransformHelperFunc *pHelperFunc; TransformInterpFunc *pInterpFunc; - jint edgebuf[MAXEDGES * 2]; + jdouble xorig, yorig; + jint numedges; jint *pEdges; - jdouble x, y; - jlong xbase, ybase; - jlong dxdxlong, dydxlong; - jlong dxdylong, dydylong; + jint edgebuf[2 + MAXEDGES * 2]; + union { + jlong align; + jint data[LINE_SIZE]; + } rgb; #ifdef MAKE_STUBS static int th_initialized; @@ -269,39 +367,62 @@ Java_sun_java2d_loops_TransformHelper_Transform if (srcOps->Lock(env, srcOps, &srcInfo, pHelperPrim->srcflags) != SD_SUCCESS) { + /* edgeArray should already contain zeros for min/maxy */ return; } if (dstOps->Lock(env, dstOps, &dstInfo, pMaskBlitPrim->dstflags) != SD_SUCCESS) { SurfaceData_InvokeUnlock(env, srcOps, &srcInfo); + /* edgeArray should already contain zeros for min/maxy */ return; } Region_IntersectBounds(&clipInfo, &dstInfo.bounds); + numedges = (dstInfo.bounds.y2 - dstInfo.bounds.y1); + if (numedges > MAXEDGES) { + pEdges = malloc((2 + 2 * numedges) * sizeof (*pEdges)); + if (pEdges == NULL) { + SurfaceData_InvokeUnlock(env, dstOps, &dstInfo); + SurfaceData_InvokeUnlock(env, srcOps, &srcInfo); + /* edgeArray should already contain zeros for min/maxy */ + return; + } + } else { + pEdges = edgebuf; + } + Transform_GetInfo(env, itxform, &itxInfo); - dxdxlong = DblToLong(itxInfo.dxdx); - dydxlong = DblToLong(itxInfo.dydx); - dxdylong = DblToLong(itxInfo.dxdy); - dydylong = DblToLong(itxInfo.dydy); - x = dxoff+dstInfo.bounds.x1+0.5; /* Center of pixel x1 */ - y = dyoff+dstInfo.bounds.y1+0.5; /* Center of pixel y1 */ - Transform_transform(&itxInfo, &x, &y); - xbase = DblToLong(x); - ybase = DblToLong(y); - - pEdges = calculateEdges(edgebuf, &dstInfo.bounds, &itxInfo, - xbase, ybase, sx2-sx1, sy2-sy1); if (!Region_IsEmpty(&clipInfo)) { srcOps->GetRasInfo(env, srcOps, &srcInfo); dstOps->GetRasInfo(env, dstOps, &dstInfo); - if (srcInfo.rasBase && dstInfo.rasBase) { - union { - jlong align; - jint data[LINE_SIZE]; - } rgb; + if (srcInfo.rasBase == NULL || dstInfo.rasBase == NULL) { + pEdges[0] = pEdges[1] = 0; + } else if (checkOverflow(dxoff, dyoff, &dstInfo.bounds, + &itxInfo, &xorig, &yorig)) + { + Transform_SafeHelper(env, srcOps, dstOps, + &srcInfo, &dstInfo, + pMaskBlitPrim, &compInfo, + pHelperFunc, pInterpFunc, + &clipInfo, &itxInfo, rgb.data, pEdges, + dxoff, dyoff, sx2-sx1, sy2-sy1); + } else { SurfaceDataBounds span; + jlong dxdxlong, dydxlong; + jlong dxdylong, dydylong; + jlong xbase, ybase; + + dxdxlong = DblToLong(itxInfo.dxdx); + dydxlong = DblToLong(itxInfo.dydx); + dxdylong = DblToLong(itxInfo.dxdy); + dydylong = DblToLong(itxInfo.dydy); + xbase = DblToLong(xorig); + ybase = DblToLong(yorig); + + calculateEdges(pEdges, &dstInfo.bounds, &itxInfo, + xbase, ybase, sx2-sx1, sy2-sy1); Region_StartIteration(env, &clipInfo); while (Region_NextIteration(&clipInfo, &span)) { @@ -318,8 +439,8 @@ Java_sun_java2d_loops_TransformHelper_Transform /* Note - process at most one scanline at a time. */ - dx1 = pEdges[(dy1 - dstInfo.bounds.y1) * 2]; - dx2 = pEdges[(dy1 - dstInfo.bounds.y1) * 2 + 1]; + dx1 = pEdges[(dy1 - dstInfo.bounds.y1) * 2 + 2]; + dx2 = pEdges[(dy1 - dstInfo.bounds.y1) * 2 + 3]; if (dx1 < span.x1) dx1 = span.x1; if (dx2 > span.x2) dx2 = span.x2; @@ -376,21 +497,124 @@ Java_sun_java2d_loops_TransformHelper_Transform } SurfaceData_InvokeRelease(env, dstOps, &dstInfo); SurfaceData_InvokeRelease(env, srcOps, &srcInfo); + } else { + pEdges[0] = pEdges[1] = 0; } SurfaceData_InvokeUnlock(env, dstOps, &dstInfo); SurfaceData_InvokeUnlock(env, srcOps, &srcInfo); if (!JNU_IsNull(env, edgeArray)) { - (*env)->SetIntArrayRegion(env, edgeArray, 0, 1, &dstInfo.bounds.y1); - (*env)->SetIntArrayRegion(env, edgeArray, 1, 1, &dstInfo.bounds.y2); - (*env)->SetIntArrayRegion(env, edgeArray, - 2, (dstInfo.bounds.y2 - dstInfo.bounds.y1)*2, - pEdges); + (*env)->SetIntArrayRegion(env, edgeArray, 0, 2+numedges*2, pEdges); } if (pEdges != edgebuf) { free(pEdges); } } +static void +Transform_SafeHelper(JNIEnv *env, + SurfaceDataOps *srcOps, + SurfaceDataOps *dstOps, + SurfaceDataRasInfo *pSrcInfo, + SurfaceDataRasInfo *pDstInfo, + NativePrimitive *pMaskBlitPrim, + CompositeInfo *pCompInfo, + TransformHelperFunc *pHelperFunc, + TransformInterpFunc *pInterpFunc, + RegionData *pClipInfo, TransformInfo *pItxInfo, + jint *pData, jint *pEdges, + jint dxoff, jint dyoff, jint sw, jint sh) +{ + SurfaceDataBounds span; + jint dx1, dx2; + jint dy1, dy2; + jint i, iy; + + dy1 = pDstInfo->bounds.y1; + dy2 = pDstInfo->bounds.y2; + dx1 = pDstInfo->bounds.x1; + dx2 = pDstInfo->bounds.x2; + pEdges[0] = dy1; + pEdges[1] = dy2; + for (iy = dy1; iy < dy2; iy++) { + jint i = (iy - dy1) * 2; + /* row spans are set to max,min until we find a pixel in range below */ + pEdges[i + 2] = dx2; + pEdges[i + 3] = dx1; + } + + Region_StartIteration(env, pClipInfo); + while (Region_NextIteration(pClipInfo, &span)) { + dy1 = span.y1; + dy2 = span.y2; + while (dy1 < dy2) { + dx1 = span.x1; + dx2 = span.x2; + i = (dy1 - pDstInfo->bounds.y1) * 2; + while (dx1 < dx2) { + jdouble x, y; + jlong xlong, ylong; + + x = dxoff + dx1 + 0.5; + y = dyoff + dy1 + 0.5; + Transform_transform(pItxInfo, &x, &y); + xlong = DblToLong(x); + ylong = DblToLong(y); + + /* Process only pixels with centers in bounds + * Test double values to avoid overflow in conversion + * to long values and then also test the long values + * in case they rounded up and out of bounds during + * the conversion. + */ + if (x >= 0 && y >= 0 && x < sw && y < sh && + WholeOfLong(xlong) < sw && + WholeOfLong(ylong) < sh) + { + void *pDst; + + if (pEdges[i + 2] > dx1) { + pEdges[i + 2] = dx1; + } + if (pEdges[i + 3] <= dx1) { + pEdges[i + 3] = dx1 + 1; + } + + /* Get IntArgbPre pixel data from source */ + (*pHelperFunc)(pSrcInfo, + pData, 1, + xlong, 0, + ylong, 0); + + /* Interpolate result pixels if needed */ + if (pInterpFunc) { + (*pInterpFunc)(pData, 1, + FractOfLong(xlong-LongOneHalf), 0, + FractOfLong(ylong-LongOneHalf), 0); + } + + /* Store/Composite interpolated pixels into dest */ + pDst = PtrCoord(pDstInfo->rasBase, + dx1, pDstInfo->pixelStride, + dy1, pDstInfo->scanStride); + (*pMaskBlitPrim->funcs.maskblit)(pDst, pData, + 0, 0, 0, + 1, 1, + pDstInfo, pSrcInfo, + pMaskBlitPrim, + pCompInfo); + } + + /* Increment to next input pixel */ + dx1++; + } + + /* Increment to next scanline */ + dy1++; + } + } + Region_EndIteration(env, pClipInfo); +} + #define BL_INTERP_V1_to_V2_by_F(v1, v2, f) \ (((v1)<<8) + ((v2)-(v1))*(f)) diff --git a/jdk/src/share/native/sun/security/pkcs11/j2secmod.c b/jdk/src/share/native/sun/security/pkcs11/j2secmod.c index 485df26595d57cfd0b562008264fe09cb44cb084..79ad8709e125b166879e1cba5c179d3a583976b2 100644 --- a/jdk/src/share/native/sun/security/pkcs11/j2secmod.c +++ b/jdk/src/share/native/sun/security/pkcs11/j2secmod.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -74,7 +74,7 @@ JNIEXPORT jboolean JNICALL Java_sun_security_pkcs11_Secmod_nssInit } JNIEXPORT jobject JNICALL Java_sun_security_pkcs11_Secmod_nssGetModuleList - (JNIEnv *env, jclass thisClass, jlong jHandle) + (JNIEnv *env, jclass thisClass, jlong jHandle, jstring jLibDir) { FPTR_GetDBModuleList getModuleList = (FPTR_GetDBModuleList)findFunction(env, jHandle, "SECMOD_GetDefaultModuleList"); @@ -104,8 +104,8 @@ JNIEXPORT jobject JNICALL Java_sun_security_pkcs11_Secmod_nssGetModuleList jList = (*env)->NewObject(env, jListClass, jListConstructor); jModuleClass = (*env)->FindClass(env, "sun/security/pkcs11/Secmod$Module"); - jModuleConstructor = (*env)->GetMethodID - (env, jModuleClass, "", "(Ljava/lang/String;Ljava/lang/String;ZI)V"); + jModuleConstructor = (*env)->GetMethodID(env, jModuleClass, "", + "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZI)V"); while (list != NULL) { module = list->module; @@ -124,7 +124,8 @@ JNIEXPORT jobject JNICALL Java_sun_security_pkcs11_Secmod_nssGetModuleList } jFIPS = module->isFIPS; for (i = 0; i < module->slotCount; i++ ) { - jModule = (*env)->NewObject(env, jModuleClass, jModuleConstructor, jDllName, jCommonName, jFIPS, i); + jModule = (*env)->NewObject(env, jModuleClass, jModuleConstructor, + jLibDir, jDllName, jCommonName, jFIPS, i); (*env)->CallVoidMethod(env, jList, jAdd, jModule); } list = list->next; diff --git a/jdk/src/solaris/native/common/jdk_util_md.h b/jdk/src/solaris/native/common/jdk_util_md.h new file mode 100644 index 0000000000000000000000000000000000000000..6361fe01eba4faa43c57cd6b55f3562fe51b5468 --- /dev/null +++ b/jdk/src/solaris/native/common/jdk_util_md.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2011 Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +// Currently, there are no unix specific functions defined. diff --git a/jdk/src/windows/classes/sun/tools/attach/WindowsAttachProvider.java b/jdk/src/windows/classes/sun/tools/attach/WindowsAttachProvider.java index b915ab89534958626134e12348510b8c2b9f895a..cda6a73bc29fb813c4f0244cdb74f75daa8cfbaf 100644 --- a/jdk/src/windows/classes/sun/tools/attach/WindowsAttachProvider.java +++ b/jdk/src/windows/classes/sun/tools/attach/WindowsAttachProvider.java @@ -126,16 +126,6 @@ public class WindowsAttachProvider extends HotSpotAttachProvider { * of the process list. */ private List listJavaProcesses() { - // ensure that process status helper is loaded (psapi.dll) - if (!isProcessStatusHelperInitialized) { - synchronized (WindowsAttachProvider.class) { - if (!isProcessStatusHelperInitialized) { - initializeProcessStatusHelper(); - isProcessStatusHelperInitialized = true; - } - } - } - ArrayList list = new ArrayList(); @@ -172,12 +162,6 @@ public class WindowsAttachProvider extends HotSpotAttachProvider { return list; } - // indicates if psapi.dll has been initialized - private static volatile boolean isProcessStatusHelperInitialized; - - // loads psapi - private static native void initializeProcessStatusHelper(); - // enumerates processes using psapi's EnumProcesses private static native int enumProcesses(int[] processes, int max); diff --git a/jdk/src/windows/native/common/jdk_util_md.c b/jdk/src/windows/native/common/jdk_util_md.c index 05c2193df125ddab100742593d6a2ab2efa4ccaa..65d20f55b3b1bd3b8618f8bd3991673983afef44 100644 --- a/jdk/src/windows/native/common/jdk_util_md.c +++ b/jdk/src/windows/native/common/jdk_util_md.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2004, 2005, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2004, 2011, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -38,3 +38,25 @@ int JDK_InitJvmHandle() { void* JDK_FindJvmEntry(const char* name) { return (void*) GetProcAddress(jvm_handle, name); } + +JNIEXPORT HMODULE JDK_LoadSystemLibrary(const char* name) { + HMODULE handle = NULL; + char path[MAX_PATH]; + int ret; + + if (GetSystemDirectory(path, sizeof(path)) != 0) { + strcat(path, "\\"); + strcat(path, name); + handle = LoadLibrary(path); + } + + if (handle == NULL) { + if (GetWindowsDirectory(path, sizeof(path)) != 0) { + strcat(path, "\\"); + strcat(path, name); + handle = LoadLibrary(path); + } + } + return handle; +} + diff --git a/jdk/src/windows/native/common/jdk_util_md.h b/jdk/src/windows/native/common/jdk_util_md.h new file mode 100644 index 0000000000000000000000000000000000000000..0bb9149354f9bf9a396a5537837a06ce3b5a8947 --- /dev/null +++ b/jdk/src/windows/native/common/jdk_util_md.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2011 Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + + +#ifndef JDK_UTIL_MD_H +#define JDK_UTIL_MD_H + +#include "jni.h" + +#ifdef __cplusplus +extern "C" { +#endif + +JNIEXPORT HMODULE JDK_LoadSystemLibrary(const char* name); + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* __cplusplus */ + +#endif /* JDK_UTIL_MD_H */ diff --git a/jdk/src/windows/native/sun/java2d/d3d/D3DPipelineManager.cpp b/jdk/src/windows/native/sun/java2d/d3d/D3DPipelineManager.cpp index 3f0284cb073f747dd1548d3bcefa49a60fc9a766..750653ceb781169b73f76f6c0603bcc11bc49942 100644 --- a/jdk/src/windows/native/sun/java2d/d3d/D3DPipelineManager.cpp +++ b/jdk/src/windows/native/sun/java2d/d3d/D3DPipelineManager.cpp @@ -117,7 +117,7 @@ HRESULT D3DPipelineManager::InitD3D(void) { typedef IDirect3D9 * WINAPI FnDirect3DCreate9(UINT SDKVersion); - hLibD3D9 = ::LoadLibrary(TEXT("d3d9.dll")); + hLibD3D9 = JDK_LoadSystemLibrary("d3d9.dll"); if (hLibD3D9 == NULL) { J2dRlsTraceLn(J2D_TRACE_ERROR, "InitD3D: no d3d9.dll"); return E_FAIL; diff --git a/jdk/src/windows/native/sun/java2d/opengl/OGLFuncs_md.h b/jdk/src/windows/native/sun/java2d/opengl/OGLFuncs_md.h index df300e93150db49ce106b94b9a14a0e9c85f7c8b..cfeb81bf9ed59d0bd62ea6627c2383efbe9b16da 100644 --- a/jdk/src/windows/native/sun/java2d/opengl/OGLFuncs_md.h +++ b/jdk/src/windows/native/sun/java2d/opengl/OGLFuncs_md.h @@ -29,6 +29,7 @@ #include #include "J2D_GL/wglext.h" #include "OGLFuncMacros.h" +#include /** * Core WGL functions @@ -60,7 +61,7 @@ typedef const char *(GLAPIENTRY *wglGetExtensionsStringARBType)(HDC hdc); #define OGL_LIB_IS_UNINITIALIZED() \ (OGL_LIB_HANDLE == 0) #define OGL_OPEN_LIB() \ - OGL_LIB_HANDLE = LoadLibrary(L"opengl32.dll") + OGL_LIB_HANDLE = JDK_LoadSystemLibrary("opengl32.dll") #define OGL_CLOSE_LIB() \ FreeLibrary(OGL_LIB_HANDLE) #define OGL_GET_PROC_ADDRESS(f) \ diff --git a/jdk/src/windows/native/sun/nio/ch/WindowsAsynchronousSocketChannelImpl.c b/jdk/src/windows/native/sun/nio/ch/WindowsAsynchronousSocketChannelImpl.c index 6babafb2041f29a5dcdd7be725b1df61e0cf6f2c..81484da7feef97b69aa7663752768cff47db26a5 100644 --- a/jdk/src/windows/native/sun/nio/ch/WindowsAsynchronousSocketChannelImpl.c +++ b/jdk/src/windows/native/sun/nio/ch/WindowsAsynchronousSocketChannelImpl.c @@ -44,7 +44,7 @@ #define SO_UPDATE_CONNECT_CONTEXT 0x7010 #endif -typedef BOOL (*ConnectEx_t) +typedef BOOL (PASCAL *ConnectEx_t) ( SOCKET s, const struct sockaddr* name, diff --git a/jdk/src/windows/native/sun/tools/attach/WindowsAttachProvider.c b/jdk/src/windows/native/sun/tools/attach/WindowsAttachProvider.c index 8ddccd7ce21123d5af098e2b4fed7563e2fb6141..bbd6f400a24e2bf4465570bcd06c7bc833a8d345 100644 --- a/jdk/src/windows/native/sun/tools/attach/WindowsAttachProvider.c +++ b/jdk/src/windows/native/sun/tools/attach/WindowsAttachProvider.c @@ -25,6 +25,7 @@ #include #include #include +#include #include "jni.h" #include "jni_util.h" @@ -96,41 +97,6 @@ Java_sun_tools_attach_WindowsAttachProvider_volumeFlags(JNIEnv *env, jclass cls, } -/* - * Process status helper library functions - */ -static BOOL (WINAPI *_EnumProcesses) (DWORD *, DWORD, DWORD *); -static BOOL (WINAPI *_EnumProcessModules)(HANDLE, HMODULE *, DWORD, LPDWORD); -static DWORD (WINAPI *_GetModuleBaseName) (HANDLE, HMODULE, LPTSTR, DWORD); - - -/* - * Class: sun_tools_attach_WindowsAttachProvider - * Method: initializeProcessStatusHelper - * Signature: ()V - */ -JNIEXPORT void JNICALL -Java_sun_tools_attach_WindowsAttachProvider_initializeProcessStatusHelper(JNIEnv *env, jclass cls) -{ - HINSTANCE psapi = LoadLibrary("PSAPI.DLL") ; - if (psapi != NULL) { - _EnumProcesses = (BOOL(WINAPI *)(DWORD *, DWORD, DWORD *)) - GetProcAddress(psapi, "EnumProcesses") ; - _EnumProcessModules = (BOOL(WINAPI *)(HANDLE, HMODULE *, DWORD, LPDWORD)) - GetProcAddress(psapi, "EnumProcessModules"); - _GetModuleBaseName = (DWORD(WINAPI *)(HANDLE, HMODULE, LPTSTR, DWORD)) - GetProcAddress(psapi, "GetModuleBaseNameA"); - } - - if ((_EnumProcesses == NULL) || - (_EnumProcessModules == NULL) || - (_GetModuleBaseName == NULL)) - { - JNU_ThrowInternalError(env, "Unable to initialize process status helper library"); - } -} - - /* * Class: sun_tools_attach_WindowsAttachProvider * Method: enumProcesses @@ -147,7 +113,7 @@ Java_sun_tools_attach_WindowsAttachProvider_enumProcesses(JNIEnv *env, jclass cl size = max * sizeof(DWORD); ptr = (DWORD*)malloc(size); if (ptr != NULL) { - BOOL res = (*_EnumProcesses)(ptr, size, &bytesReturned); + BOOL res = EnumProcesses(ptr, size, &bytesReturned); if (res != 0) { result = (jint)(bytesReturned / sizeof(DWORD)); (*env)->SetIntArrayRegion(env, arr, 0, (jsize)result, (jint*)ptr); @@ -192,13 +158,13 @@ Java_sun_tools_attach_WindowsAttachProvider_isLibraryLoadedByProcess(JNIEnv *env size = 1024 * sizeof(HMODULE); ptr = (HMODULE*)malloc(size); if (ptr != NULL) { - BOOL res = (*_EnumProcessModules)(hProcess, ptr, size, &bytesReturned); + BOOL res = EnumProcessModules(hProcess, ptr, size, &bytesReturned); if (res != 0) { int count = bytesReturned / sizeof(HMODULE); int i = 0; while (i < count) { char base[256]; - BOOL res = (*_GetModuleBaseName)(hProcess, ptr[i], base, sizeof(base)); + BOOL res = GetModuleBaseName(hProcess, ptr[i], base, sizeof(base)); if (res != 0) { if (strcmp(base, lib) == 0) { result = JNI_TRUE; diff --git a/jdk/src/windows/native/sun/tools/attach/WindowsVirtualMachine.c b/jdk/src/windows/native/sun/tools/attach/WindowsVirtualMachine.c index 6086ddf30f0b7befcb6e377b7e0b77ee7173137c..a956730d8cad95b89a71b19cf878dfc8ccf0cdf2 100644 --- a/jdk/src/windows/native/sun/tools/attach/WindowsVirtualMachine.c +++ b/jdk/src/windows/native/sun/tools/attach/WindowsVirtualMachine.c @@ -32,13 +32,13 @@ /* kernel32 */ -typedef HINSTANCE (WINAPI* LoadLibraryFunc) (LPCTSTR); +typedef HINSTANCE (WINAPI* GetModuleHandleFunc) (LPCTSTR); typedef FARPROC (WINAPI* GetProcAddressFunc)(HMODULE, LPCSTR); /* only on Windows 64-bit or 32-bit application running under WOW64 */ typedef BOOL (WINAPI *IsWow64ProcessFunc) (HANDLE, PBOOL); -static LoadLibraryFunc _LoadLibrary; +static GetModuleHandleFunc _GetModuleHandle; static GetProcAddressFunc _GetProcAddress; static IsWow64ProcessFunc _IsWow64Process; @@ -70,7 +70,7 @@ static void jstring_to_cstring(JNIEnv* env, jstring jstr, char* cstr, int len); #define MAX_PIPE_NAME_LENGTH 256 typedef struct { - LoadLibraryFunc _LoadLibrary; + GetModuleHandleFunc _GetModuleHandle; GetProcAddressFunc _GetProcAddress; char jvmLib[MAX_LIBNAME_LENGTH]; /* "jvm.dll" */ char func1[MAX_FUNC_LENGTH]; @@ -96,7 +96,7 @@ static DWORD WINAPI thread_func(DataBlock *pData) HINSTANCE h; EnqueueOperationFunc addr; - h = pData->_LoadLibrary(pData->jvmLib); + h = pData->_GetModuleHandle(pData->jvmLib); if (h == NULL) { return ERR_OPEN_JVM_FAIL; } @@ -131,15 +131,10 @@ static void thread_end (void) { JNIEXPORT void JNICALL Java_sun_tools_attach_WindowsVirtualMachine_init (JNIEnv *env, jclass cls) { - HINSTANCE h = LoadLibrary("kernel32"); - if (h != NULL) { - _LoadLibrary = (LoadLibraryFunc) GetProcAddress(h, "LoadLibraryA"); - _GetProcAddress = (GetProcAddressFunc)GetProcAddress(h, "GetProcAddress"); - _IsWow64Process = (IsWow64ProcessFunc)GetProcAddress(h, "IsWow64Process"); - } - if (_LoadLibrary == NULL || _GetProcAddress == NULL) { - JNU_ThrowInternalError(env, "Unable to get address of LoadLibraryA or GetProcAddress"); - } + // All following APIs exist on Windows XP with SP2/Windows Server 2008 + _GetModuleHandle = (GetModuleHandleFunc)GetModuleHandle; + _GetProcAddress = (GetProcAddressFunc)GetProcAddress; + _IsWow64Process = (IsWow64ProcessFunc)IsWow64Process; } @@ -375,7 +370,7 @@ JNIEXPORT void JNICALL Java_sun_tools_attach_WindowsVirtualMachine_enqueue /* * Setup data to copy to target process */ - data._LoadLibrary = _LoadLibrary; + data._GetModuleHandle = _GetModuleHandle; data._GetProcAddress = _GetProcAddress; strcpy(data.jvmLib, "jvm"); diff --git a/jdk/src/windows/native/sun/tracing/dtrace/jvm_symbols_md.c b/jdk/src/windows/native/sun/tracing/dtrace/jvm_symbols_md.c index f7ae46ecd8f23ab7bbaef9aadb033b454e9fcf23..dd4d5d03fc868aab90ccea176e87cd90eda29a8b 100644 --- a/jdk/src/windows/native/sun/tracing/dtrace/jvm_symbols_md.c +++ b/jdk/src/windows/native/sun/tracing/dtrace/jvm_symbols_md.c @@ -35,7 +35,7 @@ JvmSymbols* lookupJvmSymbols() { JvmSymbols* syms = (JvmSymbols*)malloc(sizeof(JvmSymbols)); if (syms != NULL) { - HINSTANCE jvm = LoadLibrary("jvm.dll"); + HINSTANCE jvm = GetModuleHandle("jvm.dll"); if (jvm == NULL) { free(syms); return NULL; diff --git a/jdk/src/windows/native/sun/windows/DllUtil.cpp b/jdk/src/windows/native/sun/windows/DllUtil.cpp index 907f05dc5a97cf6f405a3b302e2de1648865a6b5..7c6d00af0bf427611d03fa9a6379480854e51f50 100644 --- a/jdk/src/windows/native/sun/windows/DllUtil.cpp +++ b/jdk/src/windows/native/sun/windows/DllUtil.cpp @@ -25,6 +25,7 @@ #include "DllUtil.h" +#include // Disable warning about using this in the initializer list. #pragma warning( disable : 4355) @@ -40,7 +41,7 @@ DllUtil::~DllUtil() HMODULE DllUtil::GetModule() { if (!module) { - module = ::LoadLibrary(name); + module = JDK_LoadSystemLibrary(name); } return module; } @@ -60,7 +61,7 @@ DwmAPI & DwmAPI::GetInstance() } DwmAPI::DwmAPI() : - DllUtil(_T("DWMAPI.DLL")), + DllUtil("DWMAPI.DLL"), DwmIsCompositionEnabledFunction((DllUtil*)this, "DwmIsCompositionEnabled"), DwmGetWindowAttributeFunction((DllUtil*)this, "DwmGetWindowAttribute") { diff --git a/jdk/src/windows/native/sun/windows/DllUtil.h b/jdk/src/windows/native/sun/windows/DllUtil.h index e2892fc01f4ce7dd80acaa6ef5fcc159e840e969..17ebae0de18b42383ab5654a7d1aa3e1621a958b 100644 --- a/jdk/src/windows/native/sun/windows/DllUtil.h +++ b/jdk/src/windows/native/sun/windows/DllUtil.h @@ -43,7 +43,7 @@ class DllUtil { FARPROC GetProcAddress(LPCSTR name); protected: - DllUtil(const TCHAR * name) : name(name), module(NULL) {} + DllUtil(const char * name) : name(name), module(NULL) {} virtual ~DllUtil(); HMODULE GetModule(); @@ -68,7 +68,7 @@ class DllUtil { }; private: - const TCHAR * const name; + const char * const name; HMODULE module; }; diff --git a/jdk/src/windows/native/sun/windows/ShellFolder2.cpp b/jdk/src/windows/native/sun/windows/ShellFolder2.cpp index 80c445d60458f050eab2668ae9b909dd040c010a..7a18213d8792a84ac821bc7036fa2858d85263ae 100644 --- a/jdk/src/windows/native/sun/windows/ShellFolder2.cpp +++ b/jdk/src/windows/native/sun/windows/ShellFolder2.cpp @@ -120,15 +120,15 @@ static BOOL initShellProcs() return TRUE; } // Load libraries - libShell32 = LoadLibrary(TEXT("shell32.dll")); + libShell32 = JDK_LoadSystemLibrary("shell32.dll"); if (libShell32 == NULL) { return FALSE; } - libUser32 = LoadLibrary(TEXT("user32.dll")); + libUser32 = JDK_LoadSystemLibrary("user32.dll"); if (libUser32 == NULL) { return FALSE; } - libComCtl32 = LoadLibrary(TEXT("comctl32.dll")); + libComCtl32 = JDK_LoadSystemLibrary("comctl32.dll"); if (libComCtl32 == NULL) { return FALSE; } @@ -1021,7 +1021,8 @@ JNIEXPORT jlong JNICALL Java_sun_awt_shell_Win32ShellFolder2_getIconResource (JNIEnv* env, jclass cls, jstring libName, jint iconID, jint cxDesired, jint cyDesired, jboolean useVGAColors) { - HINSTANCE libHandle = LoadLibrary(JNU_GetStringPlatformChars(env, libName, NULL)); + const char *pLibName = env->GetStringUTFChars(libName, NULL); + HINSTANCE libHandle = (HINSTANCE)JDK_LoadSystemLibrary(pLibName); if (libHandle != NULL) { UINT fuLoad = (useVGAColors && !IS_WINXP) ? LR_VGACOLOR : 0; return ptr_to_jlong(LoadImage(libHandle, MAKEINTRESOURCE(iconID), diff --git a/jdk/src/windows/native/sun/windows/ThemeReader.cpp b/jdk/src/windows/native/sun/windows/ThemeReader.cpp index ff683dcbf657e5094b7557ecaa0ac2397bf5f34b..be5ae611074eb9b4216d64aff83400f8e4d5150b 100644 --- a/jdk/src/windows/native/sun/windows/ThemeReader.cpp +++ b/jdk/src/windows/native/sun/windows/ThemeReader.cpp @@ -150,7 +150,7 @@ static PFNGETTHEMETRANSITIONDURATION GetThemeTransitionDuration = NULL; BOOL InitThemes() { static HMODULE hModThemes = NULL; - hModThemes = LoadLibrary(TEXT("UXTHEME.DLL")); + hModThemes = JDK_LoadSystemLibrary("UXTHEME.DLL"); DTRACE_PRINTLN1("InitThemes hModThemes = %x\n", hModThemes); if(hModThemes) { DTRACE_PRINTLN("Loaded UxTheme.dll\n"); diff --git a/jdk/src/windows/native/sun/windows/awt_FileDialog.cpp b/jdk/src/windows/native/sun/windows/awt_FileDialog.cpp index 8e2c4996ece296be3cf8ec0958d5920ddc348057..a29a1ba94e6fa233ccd0712b33f9e6af27280fb2 100644 --- a/jdk/src/windows/native/sun/windows/awt_FileDialog.cpp +++ b/jdk/src/windows/native/sun/windows/awt_FileDialog.cpp @@ -284,7 +284,7 @@ AwtFileDialog::Show(void *p) file = (jstring)env->GetObjectField(target, AwtFileDialog::fileID); if (file != NULL) { LPCTSTR tmp = JNU_GetStringPlatformChars(env, file, NULL); - _tcscpy(fileBuffer, tmp); + _tcsncpy(fileBuffer, tmp, bufferLimit - 2); // the fileBuffer is double null terminated string JNU_ReleaseStringPlatformChars(env, file, tmp); } else { fileBuffer[0] = _T('\0'); diff --git a/jdk/src/windows/native/sun/windows/awt_Mlib.cpp b/jdk/src/windows/native/sun/windows/awt_Mlib.cpp index 03eda215a0e1cefe54722e79a2928a577ecbdce0..022ebd0419aa7ee065ddecaf37f1532d5e187a66 100644 --- a/jdk/src/windows/native/sun/windows/awt_Mlib.cpp +++ b/jdk/src/windows/native/sun/windows/awt_Mlib.cpp @@ -43,12 +43,13 @@ extern "C" mlibSysFnS_t tempSysFns; mlib_status ret = MLIB_SUCCESS; - /* Try to load library. Routine should find the library successfully - * because this library is already loaded to the process space by - * the System.loadLibrary() call. Here we just need to get handle to - * initialize the pointers to required mlib routines. + /* Try to receive handle for the library. Routine should find + * the library successfully because this library is already + * loaded to the process space by the System.loadLibrary() call. + * Here we just need to get handle to initialize the pointers to + * required mlib routines. */ - hDLL = ::LoadLibrary(TEXT("mlib_image.dll")); + hDLL = ::GetModuleHandle(TEXT("mlib_image.dll")); if (hDLL == NULL) { return MLIB_FAILURE; @@ -94,9 +95,6 @@ extern "C" i++; } - if (ret != MLIB_SUCCESS) { - ::FreeLibrary(hDLL); - } return ret; } diff --git a/jdk/src/windows/native/sun/windows/awt_TextArea.cpp b/jdk/src/windows/native/sun/windows/awt_TextArea.cpp index 350efdd91b17d78c1e62b87baad5eebf8990deef..16d36ad4480a2f29285531564df4e5111d6c4294 100644 --- a/jdk/src/windows/native/sun/windows/awt_TextArea.cpp +++ b/jdk/src/windows/native/sun/windows/awt_TextArea.cpp @@ -77,7 +77,7 @@ void AwtTextArea::Dispose() LPCTSTR AwtTextArea::GetClassName() { static BOOL richedLibraryLoaded = FALSE; if (!richedLibraryLoaded) { - ::LoadLibrary(TEXT("RICHED20.DLL")); + JDK_LoadSystemLibrary("RICHED20.DLL"); richedLibraryLoaded = TRUE; } return RICHEDIT_CLASS; diff --git a/jdk/src/windows/native/sun/windows/awt_TrayIcon.cpp b/jdk/src/windows/native/sun/windows/awt_TrayIcon.cpp index c2682b3b11364d675ffb1c02884a4d1733667dc8..6cd2ce49954974d304204238d33ec73797d8635d 100644 --- a/jdk/src/windows/native/sun/windows/awt_TrayIcon.cpp +++ b/jdk/src/windows/native/sun/windows/awt_TrayIcon.cpp @@ -185,7 +185,7 @@ void AwtTrayIcon::InitNID(UINT uID) int shellVersion = 5; // WIN_2000 // MSDN: DllGetVersion should not be implicitly called, but rather // loaded using GetProcAddress - HMODULE hShell = LoadLibrary(TEXT("Shell32.dll")); + HMODULE hShell = JDK_LoadSystemLibrary("Shell32.dll"); if (hShell != NULL) { DLLGETVERSIONPROC proc = (DLLGETVERSIONPROC)GetProcAddress(hShell, "DllGetVersion"); if (proc != NULL) { diff --git a/jdk/src/windows/native/sun/windows/awt_Win32GraphicsDevice.cpp b/jdk/src/windows/native/sun/windows/awt_Win32GraphicsDevice.cpp index 87519b4649d0535f084442e548a04c6db710fd0f..ae268de14828715c7eafed5829572386524f0eff 100644 --- a/jdk/src/windows/native/sun/windows/awt_Win32GraphicsDevice.cpp +++ b/jdk/src/windows/native/sun/windows/awt_Win32GraphicsDevice.cpp @@ -673,6 +673,12 @@ LPMONITORINFO AwtWin32GraphicsDevice::GetMonitorInfo(int deviceIndex) */ void AwtWin32GraphicsDevice::ResetAllMonitorInfo() { + //IE in some circumstances generates WM_SETTINGCHANGE message on appearance + //and thus triggers this method + //but we may not have the devices list initialized yet. + if (!Devices::GetInstance()){ + return; + } Devices::InstanceAccess devices; int devicesNum = devices->GetNumDevices(); for (int deviceIndex = 0; deviceIndex < devicesNum; deviceIndex++) { diff --git a/jdk/src/windows/native/sun/windows/awt_Win32GraphicsEnv.cpp b/jdk/src/windows/native/sun/windows/awt_Win32GraphicsEnv.cpp index 937007a5fd3519ec3385e619d5d16310f526c529..bc0d6a939fa397e74a481260c907f01b99721c78 100644 --- a/jdk/src/windows/native/sun/windows/awt_Win32GraphicsEnv.cpp +++ b/jdk/src/windows/native/sun/windows/awt_Win32GraphicsEnv.cpp @@ -63,7 +63,7 @@ SetProcessDPIAwareProperty() bAlreadySet = TRUE; - HMODULE hLibUser32Dll = ::LoadLibrary(TEXT("user32.dll")); + HMODULE hLibUser32Dll = JDK_LoadSystemLibrary("user32.dll"); if (hLibUser32Dll != NULL) { SetProcessDPIAwareFunc *lpSetProcessDPIAware = diff --git a/jdk/src/windows/native/sun/windows/stdhdrs.h b/jdk/src/windows/native/sun/windows/stdhdrs.h index 68420470436177788cda57db0e8cf0483f7871ce..21aaaeb2b1824c066ed4f237aadbf8c5b11b3084 100644 --- a/jdk/src/windows/native/sun/windows/stdhdrs.h +++ b/jdk/src/windows/native/sun/windows/stdhdrs.h @@ -47,6 +47,7 @@ extern "C" { // standard Java headers #include #include +#include } // extern "C" diff --git a/jdk/src/windows/npt/npt_md.h b/jdk/src/windows/npt/npt_md.h index 394a8dc3b5ebdb757396675ba0ee7258014650ed..4cf2176db1c1b90ec76c94429e4a2220dfee2f65 100644 --- a/jdk/src/windows/npt/npt_md.h +++ b/jdk/src/windows/npt/npt_md.h @@ -47,7 +47,7 @@ _handle = NULL; \ *(pnpt) = NULL; \ buf[0] = 0; \ - jvm = LoadLibrary("jvm.dll"); \ + jvm = GetModuleHandle("jvm.dll"); \ if ( jvm == NULL ) NPT_ERROR("Cannot find jvm.dll"); \ GetModuleFileName(jvm, buf, FILENAME_MAX); \ lastSlash = strrchr(buf, '\\'); \ diff --git a/jdk/test/java/awt/image/BufferedImage/TinyScale.java b/jdk/test/java/awt/image/BufferedImage/TinyScale.java new file mode 100644 index 0000000000000000000000000000000000000000..83a5dbcccaef1edbd81a4fc30a386c38bc9dc299 --- /dev/null +++ b/jdk/test/java/awt/image/BufferedImage/TinyScale.java @@ -0,0 +1,68 @@ +/* + * @test %W% %E% + * @bug 7016495 + * @summary Test tiny scales of BufferedImage + */ + +import java.awt.*; +import java.awt.geom.*; +import java.awt.image.*; + +public class TinyScale { + static double tinyscales[] = { + 1E-0, + 1E-1, + 1E-2, + 1E-3, + 1E-4, + 1E-5, + 1E-6, + 1E-7, + 1E-8, + 1E-9, + 1E-10, + 1E-11, + 1E-12, + 1E-13, + 1E-14, + 1E-15, + 1E-16, + 1E-17, + 1E-18, + 1E-19, + 1E-20, + 1E-21, + 1E-22, + 1E-23, + 1E-24, + 1E-25, + 1E-26, + 1E-27, + 1E-28, + 1E-29, + }; + + static void test(BufferedImage rendImg, BufferedImage drawImg, double s) { + Graphics2D g = drawImg.createGraphics(); + g.transform(new AffineTransform(s, 0.0, -1.0, 1.0, 0.0, 0.0)); + g.drawImage(rendImg, + -rendImg.getWidth() / 2, + -rendImg.getHeight() / 2, + null); + g.drawImage(rendImg, 0, 0, null); + g.dispose(); + } + + public static void main(String[] args) { + BufferedImage rendImg = + new BufferedImage(100, 100, BufferedImage.TYPE_3BYTE_BGR); + BufferedImage drawImg = + new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB); + for (double s: tinyscales) { + test(rendImg, drawImg, s); + for (int i = 0; args.length > 0 && i < 10; i++) { + test(rendImg, drawImg, Math.random()*s); + } + } + } +} diff --git a/jdk/test/java/lang/invoke/PermuteArgsTest.java b/jdk/test/java/lang/invoke/PermuteArgsTest.java new file mode 100644 index 0000000000000000000000000000000000000000..e02137e256043f926f1dcce6dff29ca7ad3a373e --- /dev/null +++ b/jdk/test/java/lang/invoke/PermuteArgsTest.java @@ -0,0 +1,372 @@ +/* + * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* @test + * @summary unit tests for method handles which permute their arguments + * @run junit/othervm -ea -esa -DPermuteArgsTest.MAX_ARITY=8 test.java.lang.invoke.PermuteArgsTest + */ +/* Examples of manual runs: + * java -DPermuteArgsTest.{DRY_RUN=true,MAX_ARITY=253} test.java.lang.invoke.PermuteArgsTest + * java -DPermuteArgsTest.{VERBOSE=true,MAX_ARITY=5} test.java.lang.invoke.PermuteArgsTest + * java test.java.lang.invoke.PermuteArgsTest list3I[2,0,1] listJLJ[2,0,1] + */ + +package test.java.lang.invoke; + +import org.junit.*; + +import java.util.*; +import java.lang.reflect.*; + +import java.lang.invoke.*; +import static java.lang.invoke.MethodHandles.*; +import static java.lang.invoke.MethodType.*; + +public class PermuteArgsTest { + private static final Class CLASS = PermuteArgsTest.class; + private static final int MAX_ARITY = Integer.getInteger(CLASS.getSimpleName()+".MAX_ARITY", 8); + private static final boolean DRY_RUN = Boolean.getBoolean(CLASS.getSimpleName()+".DRY_RUN"); + private static final boolean VERBOSE = Boolean.getBoolean(CLASS.getSimpleName()+".VERBOSE") || DRY_RUN; + + static Object list2I(int x, int y) { + return Arrays.asList(x, y); + } + static Object list3I(int x, int y, int z) { + return Arrays.asList(x, y, z); + } + static Object list4I(int w, int x, int y, int z) { + return Arrays.asList(w, x, y, z); + } + static Object list2J(long x, long y) { + return Arrays.asList(x, y); + } + static Object list3J(long x, long y, long z) { + return Arrays.asList(x, y, z); + } + static Object list4J(long w, long x, long y, long z) { + return Arrays.asList(w, x, y, z); + } + static Object list2I2J(int w, int x, long y, long z) { + return Arrays.asList(w, x, y, z); + } + static Object list2J2I(long w, long x, int y, int z) { + return Arrays.asList(w, x, y, z); + } + static Object listLJJ(Object x, long y, long z) { + return Arrays.asList(x, y, z); + } + static Object listJLJ(long x, Object y, long z) { + return Arrays.asList(x, y, z); + } + static Object listJJL(long x, long y, Object z) { + return Arrays.asList(x, y, z); + } + static Object listJLL(long x, Object y, Object z) { + return Arrays.asList(x, y, z); + } + static Object listLJL(Object x, long y, Object z) { + return Arrays.asList(x, y, z); + } + static Object listLLJ(Object x, Object y, long z) { + return Arrays.asList(x, y, z); + } + static Object listJLLJ(long w, Object x, Object y, long z) { + return Arrays.asList(w, x, y, z); + } + static Object listLJJL(Object w, long x, long y, Object z) { + return Arrays.asList(w, x, y, z); + } + static Object listI_etc(int... va) { + ArrayList res = new ArrayList(); + for (int x : va) res.add(x); + return res; + } + static Object listIJL_etc(int x, long y, Object z, Object... va) { + ArrayList res = new ArrayList(); + res.addAll(Arrays.asList(x, y, z)); + res.addAll(Arrays.asList(va)); + return res; + } + + public static void main(String argv[]) throws Throwable { + if (argv.length > 0) { + for (String arg : argv) { + // arg ::= name[n,...] + int k = arg.indexOf('['); + String mhName = arg.substring(0, k).trim(); + String permString = arg.substring(k); + testOnePermutation(mhName, permString); + } + return; + } + new PermuteArgsTest().test(); + } + static int testCases; + @Test + public void test() throws Throwable { + testCases = 0; + Lookup lookup = lookup(); + for (Method m : lookup.lookupClass().getDeclaredMethods()) { + if (m.getName().startsWith("list") && + Modifier.isStatic(m.getModifiers())) { + test(m.getName(), lookup.unreflect(m)); + } + } + System.out.println("ran a total of "+testCases+" test cases"); + } + + static int jump(int i, int min, int max) { + if (i >= min && i <= max-1) { + // jump faster + int len = max-min; + if (i < min + len/2) + i = min + len/2; + else + i = max-1; + } + return i; + } + + static void test(String name, MethodHandle mh) throws Throwable { + if (VERBOSE) + System.out.println("mh = "+name+" : "+mh+" { " + +Arrays.toString(junkArgs(mh.type().parameterArray()))); + int testCases0 = testCases; + if (!mh.isVarargsCollector()) { + // normal case + testPermutations(mh); + } else { + // varargs case; add params up to MAX_ARITY + MethodType mt = mh.type(); + int posArgs = mt.parameterCount() - 1; + int arity0 = Math.max(3, posArgs); + for (int arity = arity0; arity <= MAX_ARITY; arity++) { + MethodHandle mh1; + try { + mh1 = adjustArity(mh, arity); + } catch (IllegalArgumentException ex) { + System.out.println("*** mh = "+name+" : "+mh+"; arity = "+arity+" => "+ex); + ex.printStackTrace(); + break; // cannot get this arity for this type + } + test("("+arity+")"+name, mh1); + arity = jump(arity, arity0*2, MAX_ARITY); + } + } + if (VERBOSE) + System.out.println("ran "+(testCases - testCases0)+" test cases for "+name+" }"); + } + + static MethodHandle adjustArity(MethodHandle mh, int arity) { + MethodType mt = mh.type(); + int posArgs = mt.parameterCount() - 1; + Class reptype = mt.parameterType(posArgs).getComponentType(); + MethodType mt1 = mt.dropParameterTypes(posArgs, posArgs+1); + while (mt1.parameterCount() < arity) { + Class pt = reptype; + if (pt == Object.class && posArgs > 0) + // repeat types cyclically if possible: + pt = mt1.parameterType(mt1.parameterCount() - posArgs); + mt1 = mt1.appendParameterTypes(pt); + } + return mh.asType(mt1); + } + static MethodHandle findTestMH(String name, int[] perm) throws ReflectiveOperationException { + int arity = perm.length; + Lookup lookup = lookup(); + for (Method m : lookup.lookupClass().getDeclaredMethods()) { + if (m.getName().equals(name) && + Modifier.isStatic(m.getModifiers())) { + MethodHandle mh = lookup.unreflect(m); + int mhArity = mh.type().parameterCount(); + if (mh.isVarargsCollector()) { + if (mhArity-1 <= arity) + return adjustArity(mh, arity); + } else if (mhArity == arity) { + return mh; + } + } + } + throw new RuntimeException("no such method for arity "+arity+": "+name); + } + + static void testPermutations(MethodHandle mh) throws Throwable { + HashSet done = new HashSet(); + MethodType mt = mh.type(); + int[] perm = nullPerm(mt.parameterCount()); + final int MARGIN = (perm.length <= 10 ? 2 : 0); + int testCases0 = testCases; + for (int j = 0; j <= 1; j++) { + int maxStart = perm.length-1; + if (j != 0) maxStart /= 2; + for (int start = 0; start <= maxStart; start++) { + int maxOmit = (maxStart - start) / 2; + if (start != 0) maxOmit = 2; + if (j != 0) maxOmit = 1; + for (int omit = 0; omit <= maxOmit; omit++) { + int end = perm.length - omit; + if (end - start >= 2) { + //System.out.println("testPermutations"+Arrays.asList(start, end)+(j == 0 ? "" : " (reverse)")); + testPermutations(mh, perm, start, end, done); + } + omit = jump(omit, (start == 0 && j == 0 ? MARGIN : 0), maxOmit); + } + start = jump(start, (j == 0 ? MARGIN : 0), maxStart); + } + // do everything in reverse: + reverse(perm, 0, perm.length); + } + switch (perm.length) { + case 2: assert(testCases - testCases0 == 2); break; + case 3: assert(testCases - testCases0 == 6); break; + case 4: assert(testCases - testCases0 == 24); break; + case 5: assert(testCases - testCases0 == 120); break; + case 6: assert(testCases - testCases0 > 720/3); break; + } + } + + static void testPermutations(MethodHandle mh, int[] perm, int start, int end, Set done) throws Throwable { + if (end - start <= 1) return; + for (int j = 0; j <= 1; j++) { + testRotations(mh, perm, start, end, done); + if (end - start <= 2) return; + reverse(perm, start, end); + } + if (end - start <= 3) return; + int excess4 = (end - start) - 4; + // composed rotations: + int start2 = start + 1 + excess4/3; + int end2 = end - excess4/3; + end2 = start2 + Math.min(start == 0 ? 4 : 3, end2 - start2); + int skips = (perm.length+3)/5; + for (int i = start; i < end; i++) { + rotate(perm, start, end); + if (skips > 1 && ((i-start) + (i-start)/7) % skips != 0) continue; + for (int j = 0; j <= 1; j++) { + testPermutations(mh, perm, start2, end2, done); + reverse(perm, start, end); + } + } + } + + static void testRotations(MethodHandle mh, int[] perm, int start, int end, Set done) throws Throwable { + Object[] args = junkArgs(mh.type().parameterArray()); + for (int i = start; i < end; i++) { + if (done.add(Arrays.toString(perm))) + testOnePermutation(mh, perm, args); + rotate(perm, start, end); + } + } + + static void testOnePermutation(MethodHandle mh, int[] perm, Object[] args) throws Throwable { + MethodType mt = mh.type(); + MethodType pmt = methodType(mt.returnType(), unpermuteArgs(perm, mt.parameterArray(), Class[].class)); + if (VERBOSE) + System.out.println(Arrays.toString(perm)); + testCases += 1; + if (DRY_RUN) + return; + Object res = permuteArguments(mh, pmt, perm).invokeWithArguments(unpermuteArgs(perm, args)); + String str = String.valueOf(res); + if (!Arrays.toString(args).equals(str)) { + System.out.println(Arrays.toString(perm)+" "+str+" *** WRONG ***"); + } + } + + // For reproducing failures: + static void testOnePermutation(String mhName, String permString) throws Throwable { + String s = permString; + s = s.replace('[', ' ').replace(']', ' ').replace(',', ' '); // easier to trim spaces + s = s.trim(); + int[] perm = new int[s.length()]; + int arity = 0; + while (!s.isEmpty()) { + int k = s.indexOf(' '); + if (k < 0) k = s.length(); + perm[arity++] = Integer.parseInt(s.substring(0, k)); + s = s.substring(k).trim(); + } + perm = Arrays.copyOf(perm, arity); + testOnePermutation(mhName, perm); + } + static void testOnePermutation(String mhName, int[] perm) throws Throwable { + MethodHandle mh = findTestMH(mhName, perm); + System.out.println("mh = "+mhName+" : "+mh+" { " + +Arrays.toString(junkArgs(mh.type().parameterArray()))); + Object[] args = junkArgs(mh.type().parameterArray()); + testOnePermutation(mh, perm, args); + System.out.println("}"); + } + + static Object[] junkArgs(Class[] ptypes) { + Object[] args = new Object[ptypes.length]; + for (int i = 0; i < ptypes.length; i++) { + Class pt = ptypes[i]; + Object arg; + if (pt == Void.class) arg = null; + else if (pt == int.class) arg = (int) i + 101; + else if (pt == long.class) arg = (long) i + 10_000_000_001L; + else arg = "#" + (i + 1); + args[i] = arg; + } + return args; + } + + static int[] nullPerm(int len) { + int[] perm = new int[len]; + for (int i = 0; i < len; i++) + perm[i] = i; + return perm; + } + static void rotate(int[] perm) { + rotate(perm, 0, perm.length); + } + static void rotate(int[] perm, int start, int end) { + int x = perm[end-1]; + for (int j = start; j < end; j++) { + int y = perm[j]; perm[j] = x; x = y; + } + } + static void reverse(int[] perm) { + reverse(perm, 0, perm.length); + } + static void reverse(int[] perm, int start, int end) { + int mid = start + (end - start)/2; + for (int j = start; j < mid; j++) { + int k = (end-1) - j; + int x = perm[j]; perm[j] = perm[k]; perm[k] = x; + } + } + // Permute the args according to the inverse of perm. + static Object[] unpermuteArgs(int[] perm, Object[] args) { + return unpermuteArgs(perm, args, Object[].class); + } + static T[] unpermuteArgs(int[] perm, T[] args, Class Tclass) { + T[] res = Arrays.copyOf(new Object[0], perm.length, Tclass); + for (int i = 0; i < perm.length; i++) + res[perm[i]] = args[i]; + return res; + } +} diff --git a/jdk/test/java/net/URLClassLoader/B7050028.java b/jdk/test/java/net/URLClassLoader/B7050028.java new file mode 100644 index 0000000000000000000000000000000000000000..e8f275fedb46ad10869ff0b0a9fed4609e721301 --- /dev/null +++ b/jdk/test/java/net/URLClassLoader/B7050028.java @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +import java.io.File; +import java.io.FileOutputStream; +import java.io.InputStream; +import java.io.OutputStream; +import java.net.URL; +import java.net.URLClassLoader; +import java.net.URLConnection; +import java.util.zip.CRC32; +import java.util.zip.ZipEntry; +import java.util.zip.ZipOutputStream; + +/** + * @test + * @bug 7050028 + * @summary ISE "zip file closed" from JarURLConnection.getInputStream on JDK 7 when !useCaches + * @run main/othervm B7050028 + */ + +public class B7050028 { + public static void main(String[] args) throws Exception { + URLConnection conn = B7050028.class.getResource("B7050028.class").openConnection(); + int len = conn.getContentLength(); + byte[] data = new byte[len]; + InputStream is = conn.getInputStream(); + is.read(data); + is.close(); + conn.setDefaultUseCaches(false); + File jar = File.createTempFile("B7050028", ".jar"); + jar.deleteOnExit(); + OutputStream os = new FileOutputStream(jar); + ZipOutputStream zos = new ZipOutputStream(os); + ZipEntry ze = new ZipEntry("B7050028.class"); + ze.setMethod(ZipEntry.STORED); + ze.setSize(len); + CRC32 crc = new CRC32(); + crc.update(data); + ze.setCrc(crc.getValue()); + zos.putNextEntry(ze); + zos.write(data, 0, len); + zos.closeEntry(); + zos.finish(); + zos.close(); + os.close(); + System.out.println(new URLClassLoader(new URL[] {new URL("jar:" + jar.toURI() + "!/")}, ClassLoader.getSystemClassLoader().getParent()).loadClass(B7050028.class.getName())); + } + private B7050028() {} +} diff --git a/jdk/test/java/security/Security/NoInstalledProviders.java b/jdk/test/java/security/Security/NoInstalledProviders.java index f586df6e7bb52fb9c3230e57b4ef11a006111717..c8fe02e00bf04918d143d9ec43941e88633b23d7 100644 --- a/jdk/test/java/security/Security/NoInstalledProviders.java +++ b/jdk/test/java/security/Security/NoInstalledProviders.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1999, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,8 +23,9 @@ /* * @test - * @bug 4273454 + * @bug 4273454 7052537 * @summary Make sure getProviders(filter) doesn't throw NPE + * @run main/othervm NoInstalledProviders */ import java.security.*; diff --git a/jdk/test/java/security/SignedObject/Correctness.java b/jdk/test/java/security/SignedObject/Correctness.java new file mode 100644 index 0000000000000000000000000000000000000000..26430cdbec72e6016da1fd226edf45f7fb65691e --- /dev/null +++ b/jdk/test/java/security/SignedObject/Correctness.java @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 6618658 + * @summary Deserialization allows creation of mutable SignedObject + */ + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.security.KeyPair; +import java.security.KeyPairGenerator; +import java.security.Signature; +import java.security.SignedObject; + + +public class Correctness { + + public static void main(String[] args) throws Exception { + + String SIGALG = "SHA1withRSA"; + KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA"); + KeyPair kp = kpg.generateKeyPair(); + + SignedObject so1 = new SignedObject("Hello", kp.getPrivate(), + Signature.getInstance(SIGALG)); + + ByteArrayOutputStream byteOut = new ByteArrayOutputStream(); + ObjectOutputStream out = new ObjectOutputStream(byteOut); + out.writeObject(so1); + out.close(); + + byte[] data = byteOut.toByteArray(); + + SignedObject so2 = (SignedObject)new ObjectInputStream( + new ByteArrayInputStream(data)).readObject(); + + if (!so2.getObject().equals("Hello")) { + throw new Exception("Content changed"); + } + if (!so2.getAlgorithm().equals(SIGALG)) { + throw new Exception("Signature algorithm unknown"); + } + if (!so2.verify(kp.getPublic(), Signature.getInstance(SIGALG))) { + throw new Exception("Not verified"); + } + } +} diff --git a/jdk/test/sun/security/pkcs11/Provider/Absolute.cfg b/jdk/test/sun/security/pkcs11/Provider/Absolute.cfg new file mode 100644 index 0000000000000000000000000000000000000000..7b525dacd989244d5e3e0be93f1702b084dfc2fc --- /dev/null +++ b/jdk/test/sun/security/pkcs11/Provider/Absolute.cfg @@ -0,0 +1,10 @@ +# +# Configuration file to allow the SunPKCS11 provider to utilize +# the Solaris Cryptographic Framework, if it is available +# + +name = Absolute + +description = SunPKCS11 using a relative path + +library = ./libpkcs11.so diff --git a/jdk/test/sun/security/pkcs11/Provider/Absolute.java b/jdk/test/sun/security/pkcs11/Provider/Absolute.java new file mode 100644 index 0000000000000000000000000000000000000000..e35f9c60c5841af14e8a1a675441413ec0da1922 --- /dev/null +++ b/jdk/test/sun/security/pkcs11/Provider/Absolute.java @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +/** + * @test + * @bug 7003952 + * @summary load DLLs and launch executables using fully qualified path + */ +import java.security.*; +import java.lang.reflect.*; +import sun.security.pkcs11.*; + +public class Absolute { + + public static void main(String[] args) throws Exception { + Constructor cons; + try { + Class clazz = Class.forName("sun.security.pkcs11.SunPKCS11"); + cons = clazz.getConstructor(new Class[] {String.class}); + } catch (Exception ex) { + System.out.println("Skipping test - no PKCS11 provider available"); + return; + } + + String config = + System.getProperty("test.src", ".") + "/Absolute.cfg"; + + try { + Object obj = cons.newInstance(new Object[] {config}); + } catch (InvocationTargetException ite) { + Throwable cause = ite.getCause(); + if (cause instanceof ProviderException) { + Throwable cause2 = cause.getCause(); + if ((cause2 == null) || + !cause2.getMessage().startsWith( + "Absolute path required for library value:")) { + // rethrow + throw (ProviderException) cause; + } + System.out.println("Caught expected Exception: \n" + cause2); + } + } + } +}