Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 11 java.naming.jmod - Naming Module
JDK 11 java.naming.jmod is the JMOD file for JDK 11 Naming module.
JDK 11 Naming module compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\java.naming.jmod.
JDK 11 Naming module compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.
JDK 11 Naming module source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\java.naming.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ com/sun/jndi/ldap/LdapPoolManager.java
/* * Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package com.sun.jndi.ldap; import java.io.PrintStream; import java.io.OutputStream; import java.util.Hashtable; import java.util.Locale; import java.util.StringTokenizer; import javax.naming.ldap.Control; import javax.naming.NamingException; import javax.naming.CommunicationException; import java.security.AccessController; import java.security.PrivilegedAction; import com.sun.jndi.ldap.pool.PoolCleaner; import com.sun.jndi.ldap.pool.Pool; import jdk.internal.misc.InnocuousThread; /** * Contains utilities for managing connection pools of LdapClient. * Contains method for * - checking whether attempted connection creation may be pooled * - creating a pooled connection * - closing idle connections. * * If a timeout period has been configured, then it will automatically * close and remove idle connections (those that have not been * used for the duration of the timeout period). * * @author Rosanna Lee */ public final class LdapPoolManager { private static final String DEBUG = "com.sun.jndi.ldap.connect.pool.debug"; public static final boolean debug = "all".equalsIgnoreCase(getProperty(DEBUG, null)); public static final boolean trace = debug || "fine".equalsIgnoreCase(getProperty(DEBUG, null)); // ---------- System properties for connection pooling // Authentication mechanisms of connections that may be pooled private static final String POOL_AUTH = "com.sun.jndi.ldap.connect.pool.authentication"; // Protocol types of connections that may be pooled private static final String POOL_PROTOCOL = "com.sun.jndi.ldap.connect.pool.protocol"; // Maximum number of identical connections per pool private static final String MAX_POOL_SIZE = "com.sun.jndi.ldap.connect.pool.maxsize"; // Preferred number of identical connections per pool private static final String PREF_POOL_SIZE = "com.sun.jndi.ldap.connect.pool.prefsize"; // Initial number of identical connections per pool private static final String INIT_POOL_SIZE = "com.sun.jndi.ldap.connect.pool.initsize"; // Milliseconds to wait before closing idle connections private static final String POOL_TIMEOUT = "com.sun.jndi.ldap.connect.pool.timeout"; // Properties for DIGEST private static final String SASL_CALLBACK = "java.naming.security.sasl.callback"; // --------- Constants private static final int DEFAULT_MAX_POOL_SIZE = 0; private static final int DEFAULT_PREF_POOL_SIZE = 0; private static final int DEFAULT_INIT_POOL_SIZE = 1; private static final int DEFAULT_TIMEOUT = 0; // no timeout private static final String DEFAULT_AUTH_MECHS = "none simple"; private static final String DEFAULT_PROTOCOLS = "plain"; private static final int NONE = 0; // indices into pools private static final int SIMPLE = 1; private static final int DIGEST = 2; // --------- static fields private static final long idleTimeout;// ms to wait before closing idle conn private static final int maxSize; // max num of identical conns/pool private static final int prefSize; // preferred num of identical conns/pool private static final int initSize; // initial num of identical conns/pool private static boolean supportPlainProtocol = false; private static boolean supportSslProtocol = false; // List of pools used for different auth types private static final Pool[] pools = new Pool[3]; static { maxSize = getInteger(MAX_POOL_SIZE, DEFAULT_MAX_POOL_SIZE); prefSize = getInteger(PREF_POOL_SIZE, DEFAULT_PREF_POOL_SIZE); initSize = getInteger(INIT_POOL_SIZE, DEFAULT_INIT_POOL_SIZE); idleTimeout = getLong(POOL_TIMEOUT, DEFAULT_TIMEOUT); // Determine supported authentication mechanisms String str = getProperty(POOL_AUTH, DEFAULT_AUTH_MECHS); StringTokenizer parser = new StringTokenizer(str); int count = parser.countTokens(); String mech; int p; for (int i = 0; i < count; i++) { mech = parser.nextToken().toLowerCase(Locale.ENGLISH); if (mech.equals("anonymous")) { mech = "none"; } p = findPool(mech); if (p >= 0 && pools[p] == null) { pools[p] = new Pool(initSize, prefSize, maxSize); } } // Determine supported protocols str= getProperty(POOL_PROTOCOL, DEFAULT_PROTOCOLS); parser = new StringTokenizer(str); count = parser.countTokens(); String proto; for (int i = 0; i < count; i++) { proto = parser.nextToken(); if ("plain".equalsIgnoreCase(proto)) { supportPlainProtocol = true; } else if ("ssl".equalsIgnoreCase(proto)) { supportSslProtocol = true; } else { // ignore } } if (idleTimeout > 0) { // Create cleaner to expire idle connections PrivilegedAction<Void> pa = new PrivilegedAction<Void>() { public Void run() { Thread t = InnocuousThread.newSystemThread( "LDAP PoolCleaner", new PoolCleaner(idleTimeout, pools)); assert t.getContextClassLoader() == null; t.setDaemon(true); t.start(); return null; }}; AccessController.doPrivileged(pa); } if (debug) { showStats(System.err); } } // Cannot instantiate one of these private LdapPoolManager() { } /** * Find the index of the pool for the specified mechanism. If not * one of "none", "simple", "DIGEST-MD5", or "GSSAPI", * return -1. * @param mech mechanism type */ private static int findPool(String mech) { if ("none".equalsIgnoreCase(mech)) { return NONE; } else if ("simple".equalsIgnoreCase(mech)) { return SIMPLE; } else if ("digest-md5".equalsIgnoreCase(mech)) { return DIGEST; } return -1; } /** * Determines whether pooling is allowed given information on how * the connection will be used. * * Non-configurable rejections: * - nonstandard socketFactory has been specified: the pool manager * cannot track input or parameters used by the socket factory and * thus has no way of determining whether two connection requests * are equivalent. Maybe in the future it might add a list of allowed * socket factories to be configured * - trace enabled (except when debugging) * - for Digest authentication, if a callback handler has been specified: * the pool manager cannot track input collected by the handler * and thus has no way of determining whether two connection requests are * equivalent. Maybe in the future it might add a list of allowed * callback handlers. * * Configurable tests: * - Pooling for the requested protocol (plain or ssl) is supported * - Pooling for the requested authentication mechanism is supported * */ static boolean isPoolingAllowed(String socketFactory, OutputStream trace, String authMech, String protocol, Hashtable<?,?> env) throws NamingException { if (trace != null && !debug // Requesting plain protocol but it is not supported || (protocol == null && !supportPlainProtocol) // Requesting ssl protocol but it is not supported || ("ssl".equalsIgnoreCase(protocol) && !supportSslProtocol)) { d("Pooling disallowed due to tracing or unsupported pooling of protocol"); return false; } // pooling of custom socket factory is possible only if the // socket factory interface implements java.util.comparator String COMPARATOR = "java.util.Comparator"; boolean foundSockCmp = false; if ((socketFactory != null) && !socketFactory.equals(LdapCtx.DEFAULT_SSL_FACTORY)) { try { Class<?> socketFactoryClass = Obj.helper.loadClass(socketFactory); Class<?>[] interfaces = socketFactoryClass.getInterfaces(); for (int i = 0; i < interfaces.length; i++) { if (interfaces[i].getCanonicalName().equals(COMPARATOR)) { foundSockCmp = true; } } } catch (Exception e) { CommunicationException ce = new CommunicationException("Loading the socket factory"); ce.setRootCause(e); throw ce; } if (!foundSockCmp) { return false; } } // Cannot use pooling if authMech is not a supported mechs // Cannot use pooling if authMech contains multiple mechs int p = findPool(authMech); if (p < 0 || pools[p] == null) { d("authmech not found: ", authMech); return false; } d("using authmech: ", authMech); switch (p) { case NONE: case SIMPLE: return true; case DIGEST: // Provider won't be able to determine connection identity // if an alternate callback handler is used return (env == null || env.get(SASL_CALLBACK) == null); } return false; } /** * Obtains a pooled connection that either already exists or is * newly created using the parameters supplied. If it is newly * created, it needs to go through the authentication checks to * determine whether an LDAP bind is necessary. * * Caller needs to invoke ldapClient.authenticateCalled() to * determine whether ldapClient.authenticate() needs to be invoked. * Caller has that responsibility because caller needs to deal * with the LDAP bind response, which might involve referrals, * response controls, errors, etc. This method is responsible only * for establishing the connection. * * @return an LdapClient that is pooled. */ static LdapClient getLdapClient(String host, int port, String socketFactory, int connTimeout, int readTimeout, OutputStream trace, int version, String authMech, Control[] ctls, String protocol, String user, Object passwd, Hashtable<?,?> env) throws NamingException { // Create base identity for LdapClient ClientId id = null; Pool pool; int p = findPool(authMech); if (p < 0 || (pool=pools[p]) == null) { throw new IllegalArgumentException( "Attempting to use pooling for an unsupported mechanism: " + authMech); } switch (p) { case NONE: id = new ClientId(version, host, port, protocol, ctls, trace, socketFactory); break; case SIMPLE: // Add identity information used in simple authentication id = new SimpleClientId(version, host, port, protocol, ctls, trace, socketFactory, user, passwd); break; case DIGEST: // Add user/passwd/realm/authzid/qop/strength/maxbuf/mutual/policy* id = new DigestClientId(version, host, port, protocol, ctls, trace, socketFactory, user, passwd, env); break; } return (LdapClient) pool.getPooledConnection(id, connTimeout, new LdapClientFactory(host, port, socketFactory, connTimeout, readTimeout, trace)); } public static void showStats(PrintStream out) { out.println("***** start *****"); out.println("idle timeout: " + idleTimeout); out.println("maximum pool size: " + maxSize); out.println("preferred pool size: " + prefSize); out.println("initial pool size: " + initSize); out.println("protocol types: " + (supportPlainProtocol ? "plain " : "") + (supportSslProtocol ? "ssl" : "")); out.println("authentication types: " + (pools[NONE] != null ? "none " : "") + (pools[SIMPLE] != null ? "simple " : "") + (pools[DIGEST] != null ? "DIGEST-MD5 " : "")); for (int i = 0; i < pools.length; i++) { if (pools[i] != null) { out.println( (i == NONE ? "anonymous pools" : i == SIMPLE ? "simple auth pools" : i == DIGEST ? "digest pools" : "") + ":"); pools[i].showStats(out); } } out.println("***** end *****"); } /** * Closes idle connections idle since specified time. * * @param threshold Close connections idle since this time, as * specified in milliseconds since "the epoch". * @see java.util.Date */ public static void expire(long threshold) { for (int i = 0; i < pools.length; i++) { if (pools[i] != null) { pools[i].expire(threshold); } } } private static void d(String msg) { if (debug) { System.err.println("LdapPoolManager: " + msg); } } private static void d(String msg, String o) { if (debug) { System.err.println("LdapPoolManager: " + msg + o); } } private static final String getProperty(final String propName, final String defVal) { return AccessController.doPrivileged( new PrivilegedAction<String>() { public String run() { try { return System.getProperty(propName, defVal); } catch (SecurityException e) { return defVal; } } }); } private static final int getInteger(final String propName, final int defVal) { Integer val = AccessController.doPrivileged( new PrivilegedAction<Integer>() { public Integer run() { try { return Integer.getInteger(propName, defVal); } catch (SecurityException e) { return defVal; } } }); return val.intValue(); } private static final long getLong(final String propName, final long defVal) { Long val = AccessController.doPrivileged( new PrivilegedAction<Long>() { public Long run() { try { return Long.getLong(propName, defVal); } catch (SecurityException e) { return defVal; } } }); return val.longValue(); } }
⏎ com/sun/jndi/ldap/LdapPoolManager.java
Or download all of them as a single archive file:
File name: java.naming-11.0.1-src.zip File size: 461792 bytes Release date: 2018-11-04 Download
⇒ JDK 11 java.net.http.jmod - Net HTTP Module
2020-09-30, 60755👍, 0💬
Popular Posts:
JavaMail Source Code Files are provided in the source package file, httpcomponents-client-5. 2-src.zi...
What Is log4j-1.2.13.jar? I got the JAR file from logging-log4j-1.2.13.zip .log4j-1.2.13.jar is the ...
JDK 11 jdk.crypto.cryptoki.jmod is the JMOD file for JDK 11 Crypto Cryptoki module. JDK 11 Crypto KI...
JDK 17 jdk.hotspot.agent.jmod is the JMOD file for JDK 17 Hotspot Agent module. JDK 17 Hotspot Agent...
How to display XML element type information with the jaxp\TypeInfoWriter.java provided in the Apache...