| /* |
| * Copyright (c) 2002, 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. |
| */ |
| |
| package com.sun.jndi.ldap; |
| |
| import java.util.Locale; |
| import java.util.Arrays; // JDK 1.2 |
| import java.io.OutputStream; |
| import javax.naming.ldap.Control; |
| import java.lang.reflect.Method; |
| import javax.net.SocketFactory; |
| |
| /** |
| * Represents identity information about an anonymous LDAP connection. |
| * This base class contains the following information: |
| * - protocol version number |
| * - server's hostname (case-insensitive) |
| * - server's port number |
| * - prototype type (plain or ssl) |
| * - controls to be sent with the LDAP bind request |
| * |
| * All other identity classes must be a subclass of ClientId. |
| * Identity subclasses would add more distinguishing information, depending |
| * on the type of authentication that the connection is to have. |
| * |
| * The equals() and hashCode() methods of this class and its subclasses are |
| * important because they are used to determine whether two requests for |
| * the same connection are identical, and thus whether the same connection |
| * may be shared. This is especially important for authenticated connections |
| * because a mistake would result in a serious security violation. |
| * |
| * @author Rosanna Lee |
| */ |
| class ClientId { |
| final private int version; |
| final private String hostname; |
| final private int port; |
| final private String protocol; |
| final private Control[] bindCtls; |
| final private OutputStream trace; |
| final private String socketFactory; |
| final private int myHash; |
| final private int ctlHash; |
| |
| private SocketFactory factory = null; |
| private Method sockComparator = null; |
| private boolean isDefaultSockFactory = false; |
| final public static boolean debug = false; |
| |
| ClientId(int version, String hostname, int port, String protocol, |
| Control[] bindCtls, OutputStream trace, String socketFactory) { |
| this.version = version; |
| this.hostname = hostname.toLowerCase(Locale.ENGLISH); // ignore case |
| this.port = port; |
| this.protocol = protocol; |
| this.bindCtls = (bindCtls != null ? bindCtls.clone() : null); |
| this.trace = trace; |
| // |
| // Needed for custom socket factory pooling |
| // |
| this.socketFactory = socketFactory; |
| if ((socketFactory != null) && |
| !socketFactory.equals(LdapCtx.DEFAULT_SSL_FACTORY)) { |
| try { |
| Class<?> socketFactoryClass = |
| Obj.helper.loadClass(socketFactory); |
| Class<?> objClass = Class.forName("java.lang.Object"); |
| this.sockComparator = socketFactoryClass.getMethod( |
| "compare", new Class<?>[]{objClass, objClass}); |
| Method getDefault = socketFactoryClass.getMethod( |
| "getDefault", new Class<?>[]{}); |
| this.factory = |
| (SocketFactory)getDefault.invoke(null, new Object[]{}); |
| } catch (Exception e) { |
| // Ignore it here, the same exceptions are/will be handled by |
| // LdapPoolManager and Connection classes. |
| if (debug) { |
| System.out.println("ClientId received an exception"); |
| e.printStackTrace(); |
| } |
| } |
| } else { |
| isDefaultSockFactory = true; |
| } |
| |
| // The SocketFactory field is not used in the myHash |
| // computation as there is no right way to compute the hash code |
| // for this field. There is no harm in skipping it from the hash |
| // computation |
| myHash = version + port |
| + (trace != null ? trace.hashCode() : 0) |
| + (this.hostname != null ? this.hostname.hashCode() : 0) |
| + (protocol != null ? protocol.hashCode() : 0) |
| + (ctlHash=hashCodeControls(bindCtls)); |
| } |
| |
| public boolean equals(Object obj) { |
| if (!(obj instanceof ClientId)) { |
| return false; |
| } |
| |
| ClientId other = (ClientId)obj; |
| |
| return myHash == other.myHash |
| && version == other.version |
| && port == other.port |
| && trace == other.trace |
| && (hostname == other.hostname // null OK |
| || (hostname != null && hostname.equals(other.hostname))) |
| && (protocol == other.protocol // null OK |
| || (protocol != null && protocol.equals(other.protocol))) |
| && ctlHash == other.ctlHash |
| && (equalsControls(bindCtls, other.bindCtls)) |
| && (equalsSockFactory(other)); |
| } |
| |
| public int hashCode() { |
| return myHash; |
| } |
| |
| private static int hashCodeControls(Control[] c) { |
| if (c == null) { |
| return 0; |
| } |
| |
| int code = 0; |
| for (int i = 0; i < c.length; i++) { |
| code = code * 31 + c[i].getID().hashCode(); |
| } |
| return code; |
| } |
| |
| private static boolean equalsControls(Control[] a, Control[] b) { |
| if (a == b) { |
| return true; // both null or same |
| } |
| if (a == null || b == null) { |
| return false; // one is non-null |
| } |
| if (a.length != b.length) { |
| return false; |
| } |
| |
| for (int i = 0; i < a.length; i++) { |
| if (!a[i].getID().equals(b[i].getID()) |
| || a[i].isCritical() != b[i].isCritical() |
| || !Arrays.equals(a[i].getEncodedValue(), |
| b[i].getEncodedValue())) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| private boolean equalsSockFactory(ClientId other) { |
| if (this.isDefaultSockFactory && other.isDefaultSockFactory) { |
| return true; |
| } |
| else if (!other.isDefaultSockFactory) { |
| return invokeComparator(other, this); |
| } else { |
| return invokeComparator(this, other); |
| } |
| } |
| |
| // delegate the comparison work to the SocketFactory class |
| // as there is no enough information here, to do the comparison |
| private boolean invokeComparator(ClientId c1, ClientId c2) { |
| Object ret; |
| try { |
| ret = (c1.sockComparator).invoke( |
| c1.factory, c1.socketFactory, c2.socketFactory); |
| } catch(Exception e) { |
| if (debug) { |
| System.out.println("ClientId received an exception"); |
| e.printStackTrace(); |
| } |
| // Failed to invoke the comparator; flag unequality |
| return false; |
| } |
| if (((Integer) ret) == 0) { |
| return true; |
| } |
| return false; |
| } |
| |
| private static String toStringControls(Control[] ctls) { |
| if (ctls == null) { |
| return ""; |
| } |
| StringBuffer str = new StringBuffer(); |
| for (int i = 0; i < ctls.length; i++) { |
| str.append(ctls[i].getID()); |
| str.append(' '); |
| } |
| return str.toString(); |
| } |
| |
| public String toString() { |
| return (hostname + ":" + port + ":" + |
| (protocol != null ? protocol : "") + ":" + |
| toStringControls(bindCtls) + ":" + |
| socketFactory); |
| } |
| } |