Request 25 (accepted)

We truncated the diff of some files because they were too big. If you want to see the full diff for every file, click here.

Overview

Request 25 (accepted)

Add to Kolab:Development

Created by vanmeeuwen about 11 years ago
In state accepted

Submit ldapjdk

Submit package home:vanmeeuwen...lab:Development / ldapjdk to package Kolab:Development / ldapjdk

ldapjdk.changes Added

@@ -0,0 +1,63 @@
+-------------------------------------------------------------------
+Sun Jul 14 14:06:04 UTC 2013 - aj@ajaissle.de
+
+- Re-include jss.jar (jss4.jar, former was jss34.jar), to again fix
+ build on openSUSE < 13.1
+
+-------------------------------------------------------------------
+Thu Jul 11 10:49:06 UTC 2013 - aj@ajaissle.de
+
+- ldapjdk is now maintained by Fedora Project, not mozilla
+- New upstream version 4.18
+- No more CVS dirs to remove
+- Build with mozilla-jss
+- Clean up spec file, %fdupes on javadoc
+
+-------------------------------------------------------------------
+Thu Dec 14 17:51:31 CET 2006 - jsmeix@suse.de
+
+- Removed xml-commons-apis from BuildRequires because xerces-j2
+ already provides xml-commons-apis but xerces-j2 would be
+ deinstalled when rpm installs xml-commons-apis after xerces-j2
+ (which is rpm standard behaviour in this case) but without
+ xerces-j2 the RPM capabilities jaxp_parser_impl and
+ xml-commons-resolver are no longer provided in the
+ installed system.
+
+-------------------------------------------------------------------
+Wed Sep 20 02:07:25 CEST 2006 - ro@suse.de
+
+- set source=1.4 for java 
+
+-------------------------------------------------------------------
+Wed Jan 25 21:46:51 CET 2006 - mls@suse.de
+
+- converted neededforbuild to BuildRequires
+
+-------------------------------------------------------------------
+Tue Oct 11 17:44:31 CEST 2005 - jsmeix@suse.de
+
+- Removed jndi, jaas, jsse, from build-classpath because
+ those are not needed for build.
+
+-------------------------------------------------------------------
+Thu Jul 28 16:07:58 CEST 2005 - jsmeix@suse.de
+
+- Adjustments in the spec file.
+
+-------------------------------------------------------------------
+Mon Jul 18 16:47:41 CEST 2005 - jsmeix@suse.de
+
+- Current version 4.17 from JPackage.org
+
+-------------------------------------------------------------------
+Fri Feb 18 18:31:42 CET 2005 - skh@suse.de
+
+- disable support for java 1.3.0 
+- don't use icecream
+
+-------------------------------------------------------------------
+Thu Sep 2 18:37:52 CEST 2004 - skh@suse.de
+
+- Initial package created with version 4.1 (JPackage 1.5)
+

ldapjdk.spec Added

@@ -0,0 +1,138 @@
+#
+# spec file for package ldapjdk
+#
+# Copyright (c) 2013 SUSE LINUX Products GmbH, Nuernberg, Germany.
+#
+# All modifications and additions to the file contributed by third parties
+# remain the property of their copyright owners, unless otherwise agreed
+# upon. The license for this file, and modifications and additions to the
+# file, is the same license as for the pristine package itself (unless the
+# license for the pristine package is not an Open Source License, in which
+# case the license is the MIT License). An "Open Source License" is a
+# license that conforms to the Open Source Definition (Version 1.9)
+# published by the Open Source Initiative.
+
+# Please submit bugfixes or comments via http://bugs.opensuse.org/
+#
+
+
+Name: ldapjdk
+%define spname ldapsp
+Version: 4.18
+Release: 0
+Summary: The Mozilla LDAP Java SDK
+License: MPL-1.1 and GPL-2.0 and LGPL-2.1
+Group: Development/Libraries/Java
+Url: http://www.mozilla.org/directory/javasdk.html
+Source0: http://pki.fedoraproject.org/pki/sources/ldapjdk/%{name}-%{version}.tar.gz
+# mozilla-jss not available on openSUSE < 13.1, so we still require jss*.jar for build
+# Mozilla Network Security Services for Java (JSS)
+Source1: jss4.jar
+Patch1: ldap-javasource14.patch
+Patch2: ldapjdk-jarnamefix.patch
+Patch3: matching-rule-parsing-640750.patch
+BuildArch: noarch
+%if 0%{?suse_version} >= 1100
+BuildRequires: fdupes
+%endif
+BuildRequires: java2-devel-packages
+%if 0%{?suse_version} >= 1310
+BuildRequires: mozilla-jss
+%endif
+BuildRequires: oro
+BuildRequires: xerces-j2
+BuildRoot: %{_tmppath}/%{name}-%{version}-build
+
+Requires: jaas
+Requires: jndi
+Requires: jpackage-utils >= 1.5
+Requires: jsse
+Requires: oro
+# Provides:	jndi-ldap = 1.3.0
+
+%description
+The Mozilla LDAP SDKs enable you to write applications that access,
+manage, and update the information stored in an LDAP directory.
+
+
+%package javadoc
+PreReq: coreutils
+Summary: Javadoc for ldapjdk
+Group: Development/Libraries/Java
+Obsoletes: openjmx-javadoc
+
+%description javadoc
+The Mozilla LDAP SDKs enable you to write applications which access,
+manage, and update the information stored in an LDAP directory.
+
+This package contains the javadoc documentation for the Mozilla LDAP
+SDKs.
+
+
+%prep
+%setup -q
+%patch1
+%patch2
+%patch3
+
+%build
+# cleanup jars
+rm -fr $(find . -name "*.jar" -type f)
+mv mozilla/directory/* .
+rm -fr mozilla
+cd java-sdk
+if [ ! -e "$JAVA_HOME" ] ; then export JAVA_HOME="%{_jvmdir}/java" ; fi
+%if %{?suse_version} >= 1310
+export CLASSPATH=%{_jnidir}/jss4.jar:%(build-classpath oro)
+%else
+# mozilla-jss not available on openSUSE < 13.1, so we still require the .jar for build
+cp %{SOURCE1} .
+export CLASSPATH=`pwd`/jss4.jar:%(build-classpath oro)
+%endif
+export MOZ_SRC=`pwd`
+export JAVA_VERSION=1.4
+# Main jar
+%__make -f ldap.mk clean
+%__make -f ldap.mk
+%__make -f ldap.mk basepackage
+%__make -f ldap.mk doc
+# ldap jdndi service provides
+%__make -f ldapsp.mk clean
+%__make -f ldapsp.mk
+%__make -f ldapsp.mk basepackage
+%__make -f ldapsp.mk doc
+
+%install
+install -d -m 755 %{buildroot}%{_javadir}
+install -m 644 java-sdk/dist/packages/%{name}.jar %{buildroot}%{_javadir}/%{name}-%{version}.jar
+install -m 644 java-sdk/dist/packages/%{spname}.jar %{buildroot}%{_javadir}/%{spname}-%{version}.jar
+pushd %{buildroot}%{_javadir}
+ for jar in *-%{version}.jar ; do
+ ln -fs ${jar} $(echo $jar | sed "s|-%{version}.jar|.jar|g")
+ done
+popd
+# install -d -m 755 %%{buildroot}%%{_javadir}-1.3.0
+# 
+# pushd %%{buildroot}%%{_javadir}-1.3.0
+# 	ln -fs ../java/*%%name}.jar jndi-ldap.jar
+# popd
+install -d -m 755 %{buildroot}%{_javadocdir}/%{name}-%{version}
+cp -r java-sdk/dist/doc/* %{buildroot}%{_javadocdir}/%{name}-%{version}
+
+%if 0%{?suse_version} >= 1100
+%fdupes %{buildroot}/%{_javadocdir}/%{name}-%{version}
+%endif
+
+%files
+%defattr(0644,root,root,0755)
+%doc buildjsdk.txt java-sdk/*.htm
+%{_javadir}/%{name}*.jar
+%{_javadir}/%{spname}*.jar
+# %%{_javadir}-1.3.0/*.jar
+
+%files javadoc
+%defattr(0644,root,root,0755)
+%dir %{_javadocdir}/%{name}-%{version}
+%{_javadocdir}/%{name}-%{version}/*
+
+%changelog

ldap-javasource14.patch Added

@@ -0,0 +1,54 @@
+--- mozilla/directory/java-sdk/ldap.mk
++++ mozilla/directory/java-sdk/ldap.mk
+@@ -143,12 +143,12 @@
+ ifndef JAVAC
+   ifndef DEBUG
+      #defualt mode is debug (-g)
+-    JAVAC=$(JDKBIN)javac -g -classpath "$(JAVACLASSPATH)"
++    JAVAC=$(JDKBIN)javac -source 1.4 -g -classpath "$(JAVACLASSPATH)"
+   else
+   ifeq ($(DEBUG), 1)
+-    JAVAC=$(JDKBIN)javac -g -classpath "$(JAVACLASSPATH)"
++    JAVAC=$(JDKBIN)javac -source 1.4 -g -classpath "$(JAVACLASSPATH)"
+   else
+-    JAVAC=$(JDKBIN)javac -O -classpath "$(JAVACLASSPATH)"
++    JAVAC=$(JDKBIN)javac -source 1.4 -O -classpath "$(JAVACLASSPATH)"
+   endif
+   endif
+ endif
+@@ -158,7 +158,7 @@
+ endif
+ 
+ ifndef JAVADOC
+-  JAVADOC=$(JDKBIN)javadoc -classpath "$(JAVACLASSPATH)$(SEP)$(BASEDIR)/ldapbeans"
++  JAVADOC=$(JDKBIN)javadoc -source 1.4 -classpath "$(JAVACLASSPATH)$(SEP)$(BASEDIR)/ldapbeans"
+ endif
+ 
+ # Destination for class files and packages
+--- mozilla/directory/java-sdk/ldapsp.mk
++++ mozilla/directory/java-sdk/ldapsp.mk
+@@ -77,12 +77,12 @@
+ ifndef JAVAC
+   ifndef DEBUG
+      #defualt mode is debug (-g)
+-    JAVAC=$(JDKBIN)javac -g -classpath "$(JAVACLASSPATH)"
++    JAVAC=$(JDKBIN)javac -source 1.4 -g -classpath "$(JAVACLASSPATH)"
+   else
+   ifeq ($(DEBUG), 1)
+-    JAVAC=$(JDKBIN)javac -g -classpath "$(JAVACLASSPATH)"
++    JAVAC=$(JDKBIN)javac -source 1.4 -g -classpath "$(JAVACLASSPATH)"
+   else
+-    JAVAC=$(JDKBIN)javac -O -classpath "$(JAVACLASSPATH)"
++    JAVAC=$(JDKBIN)javac -source 1.4 -O -classpath "$(JAVACLASSPATH)"
+   endif
+   endif
+ endif
+@@ -92,7 +92,7 @@
+ endif
+ 
+ ifndef JAVADOC
+-  JAVADOC=$(JDKBIN)javadoc -classpath "$(JAVACLASSPATH)"
++  JAVADOC=$(JDKBIN)javadoc -source 1.4 -classpath "$(JAVACLASSPATH)"
+ endif
+ 
+ all: classes

ldapjdk-jarnamefix.patch Added

@@ -0,0 +1,14 @@
+diff -up ./mozilla/directory/java-sdk/build.xml.sav ./mozilla/directory/java-sdk/build.xml
+--- ./mozilla/directory/java-sdk/build.xml.sav	2009-03-20 16:41:48.000000000 -0400
++++ ./mozilla/directory/java-sdk/build.xml	2009-03-20 16:42:09.000000000 -0400
+@@ -66,8 +66,8 @@
+ 
+ 
+- <property name="ssllibs14" value="${basedir}/ldapjdk/lib/jss32_stub.jar"/>
+- <property name="ssllibs13" value="${basedir}/ldapjdk/lib/jaas.jar:${basedir}/ldapjdk/lib/jnet.jar:${basedir}/ldapjdk/lib/jsse.jar:${basedir}/ldapjdk/lib/jss32_stub.jar"/>
++ <property name="ssllibs14" value="${basedir}/ldapjdk/lib/jss4.jar"/>
++ <property name="ssllibs13" value="${basedir}/ldapjdk/lib/jaas.jar:${basedir}/ldapjdk/lib/jnet.jar:${basedir}/ldapjdk/lib/jsse.jar:${basedir}/ldapjdk/lib/jss4.jar"/>
+ 
+

matching-rule-parsing-640750.patch Added

debian-changes-4.18-1 Added

@@ -0,0 +1,54964 @@
+Description: Upstream changes introduced in version 4.18-1
+ This patch has been created by dpkg-source during the package build.
+ Here's the last changelog entry, hopefully it gives details on why
+ those changes were made:
+ .
+ ldapjdk (4.18-1) unstable; urgency=low
+ .
+ * control: Change the VCS header to point to the git repository.
+ .
+ The person named in the Author field signed this changelog entry.
+Author: Timo Aaltonen <tjaalton@ubuntu.com>
+
+---
+The information above should follow the Patch Tagging Guidelines, please
+checkout http://dep.debian.net/deps/dep3/ to learn about the format. Here
+are templates for supplementary fields that you might want to add:
+
+Origin: <vendor|upstream|other>, <url of original patch>
+Bug: <url in upstream bugtracker>
+Bug-Debian: http://bugs.debian.org/<bugnumber>
+Bug-Ubuntu: https://launchpad.net/bugs/<bugnumber>
+Forwarded: <no|not-needed|url proving that it has been forwarded>
+Reviewed-By: <name and email of someone who approved the patch>
+Last-Update: <YYYY-MM-DD>
+
+--- ldapjdk-4.18.orig/mozilla/directory/java-sdk/build.xml
++++ ldapjdk-4.18/mozilla/directory/java-sdk/build.xml
+@@ -1,262 +1,64 @@
+-<project name="Mozilla Java LDAP SDK" default="show" basedir=".">
++
+ 
+-
+-
+-
+- 
+-
+- <property file="build.properties"/>
+-
+- 
+- <property name="name" value="java-sdk" />
+- <property name="year" value="2007" />
+- <property name="version" value="4.18" />
+- <property name="sdkjarfilename" value="ldapjdk.jar" />
+- <property name="filtjarfilename" value="ldapfilt.jar" />
+- <property name="jdnijarfilename" value="ldapsp.jar" />
+- <property name="beansjarfilename" value="ldapbeans.jar" />
+- <property name="doczipfilename" value="ldapdoc.zip" />
+-
+-
+- 
+- 
+- <property name="jdk.dist" value="${basedir}/dist/classes"/>
+- <property name="filter.dist" value="${basedir}/dist/ldapfilt"/>
+- <property name="jndi.dist" value="${basedir}/dist/classes"/>
+- <property name="doc.dist" value="${basedir}/dist/doc"/>
+- <property name="package.dist" value="${basedir}/dist/packages"/>
+- <property name="src" value="."/>
+- <property name="build" value="build"/>
+- <property name="dist" value="dist"/>
+-
+- 
+- <property name="ssllibs14" value="${basedir}/ldapjdk/lib/jss32_stub.jar"/>
+- <property name="ssllibs13" value="${basedir}/ldapjdk/lib/jaas.jar:${basedir}/ldapjdk/lib/jnet.jar:${basedir}/ldapjdk/lib/jsse.jar:${basedir}/ldapjdk/lib/jss32_stub.jar"/>
+-
+- 
+- <property name="build.sysclasspath" value="ignore"/>
+-
+- 
+- <target name="show">
+- <echo>The following targets are defined:
+- dist : will build entire sdk and package all the pieces
+- dist-jdk : will build only the ldap jdk jar (ldapjdk.jar)
+- dist-filter : will build only the ldap filter jar (ldapfilt.jar)
+- dist-beans : will build only the beans jar (ldapbeans.jar)
+- dist-jndi : will build only the jndi service provider (ldapsp.jar)
+- dist-docs : will package up all the documentation (ldapdoc.zip)
+-
+- build : will compile the entire sdk but not package
+- build-jdk : will compile only the ldap jdk jar
+- build-filter : will compile only the filter classes
+- build-beans : will compile only the ldap beans
+- build-jndi : will compile only the jndi service provider
+- build-docs : will compile the complete javadocs
+-
+- clean : will remove all compiled files and packages
+- clean-dists : will remove all the jars and zips
+- clean-builds : will remove all the compiled classes
+- </echo>
+- </target>
+-
+- <target name="init">
+- <echo>compiling for jdk version=${ant.java.version}</echo>
+- <condition property="jsselibs" value="${ssllibs13}">
+- <or>
+- <equals arg1="${ant.java.version}" arg2="1.1" />
+- <equals arg1="${ant.java.version}" arg2="1.2" />
+- <equals arg1="${ant.java.version}" arg2="1.3" />
+- </or>
+- </condition>
+- <condition property="jsselibs" value="${ssllibs14}">
+- <not>
+- <or>
+- <equals arg1="${ant.java.version}" arg2="1.1" />
+- <equals arg1="${ant.java.version}" arg2="1.2" />
+- <equals arg1="${ant.java.version}" arg2="1.3" />
+- </or>
+- </not>
+- </condition>
+- <echo>ssl libraries path=${jsselibs}</echo>
+- 
+- <mkdir dir="${jdk.dist}"/>
+- <mkdir dir="${filter.dist}"/>
+- <mkdir dir="${jndi.dist}"/>
+- <mkdir dir="${doc.dist}"/>
+- <mkdir dir="${package.dist}"/>
+- </target>
++<project name="ldapsdk" default="all" basedir=".">
+ 
+- <target name="dist" depends="dist-jdk,dist-filter,dist-beans,dist-jndi,dist-docs">
+- <echo>Building all packages....</echo>
+- </target>
++ 
+ 
+- <target name="dist-jdk" depends="build-jdk">
+- 
+- <mkdir dir="${jdk.dist}/netscape/ldap/errors"/>
+- <copy todir="${jdk.dist}/netscape/ldap/errors">
+- <fileset dir="${basedir}/ldapjdk/netscape/ldap/errors">
+- <include name="*.props"/>
++ <property name="name" value="ldapsdk"/>
++ <property name="src" value="src"/>
++ <property name="build" value="build"/>
++ <property name="build.classes" value="${build}/classes"/>
++ <property name="build.doc" value="${build}/api"/>
++ <property name="build.lib" value="${build}/lib"/>
++ <property name="packagenames" value="com.*,netscape.*,org.mozilla.*"/>
++
++ 
++
++ 
++ <target name="prepare">
++ <mkdir dir="${src}"/>
++ <mkdir dir="${build}"/>
++ <mkdir dir="${build.classes}"/>
++ <mkdir dir="${build.lib}"/>
++ <mkdir dir="${build.doc}"/>
++ </target>
++
++ 
++ <target name="clean">
++ <delete dir="${build}"/>
++ <delete dir="${src}"/>
++ </target>
++
++ 
++ <target name="classes" depends="prepare">
++ <javac srcdir="${src}" classpath="/usr/share/java/jss.jar;/usr/share/java/oro.jar" destdir="${build.classes}" debug="on" 
++optimize="on"/>
++ <copy todir="${build.classes}">
++ <fileset dir="${src}">
++ <include name="**/*.properties"/>
+ </fileset>
+ </copy>
+- <jar jarfile="${package.dist}/${sdkjarfilename}"
+- basedir="${jdk.dist}"
+- excludes="cvs/**"
+- includes="netscape/ldap/*.class,netscape/ldap/client/*.class,netscape/ldap/client/opers/*.class,netscape/ldap/ber/stream/*.class,netscape/ldap/controls/*.class,netscape/ldap/factory/*.class,netscape/ldap/util/*.class,netscape/ldap/errors/*.props,com/netscape/sasl/*.class,com/netscape/sasl/mechanisms/*.class,*.class" 
+- />
+ </target>
+ 
+- <target name="dist-filter" depends="build-filter">
+- <jar jarfile="${package.dist}/${filtjarfilename}"
+- basedir="${filter.dist}"
+- excludes="cvs/**"
+- includes="netscape/ldap/util/*.class" 
+- />
+- </target>
+- 
+- <target name="dist-beans" depends="build-beans">
+- <jar jarfile="${package.dist}/${beansjarfilename}"
+- basedir="${jdk.dist}"
+- excludes="cvs/**"
+- includes="netscape/ldap/beans/*" 
+- />
++ 
++ <target name="jar" depends="classes">
++ <jar jarfile="${build.lib}/${name}.jar" basedir="${build.classes}"/>
+ </target>
+ 
+- <target name="dist-jndi" depends="build-jndi">
+- <jar jarfile="${package.dist}/${jdnijarfilename}"
+- basedir="${jdk.dist}"
+- excludes="cvs/**"
+- includes="com/netscape/jndi/ldap/*.class com/netscape/jndi/ldap/common/*.class com/netscape/jndi/ldap/schema/*.class com/netscape/jndi/ldap/controls/*.class"
++ 
++ <target name="javadoc" depends="prepare">
++ <javadoc sourcepath="${src}"
++ destdir="${build.doc}"
++ doctitle="${name} JavaDoc"
++ windowtitle="${name} JavaDoc"
++ package="true"
++ author="true"
++ version="true"
++ packagenames="${packagenames}"
+ />
+ </target>
+ 
+- <target name="dist-docs" depends="build-docs">
+- <jar jarfile="${package.dist}/${doczipfilename}"
+- update="no"
+- basedir="${doc.dist}"
+- excludes="cvs/**"
+- includes="*.html *.css netscape/ldap/*.html netscape/ldap/beans/*.html netscape/ldap/controls/*.html netscape/ldap/util/*.html netscape/ldap/ber/stream/*.html" 
+- />
+- </target>
+-
+-
+-
+-
+- <target name="build" depends="build-jdk,build-filter,build-beans,build-jndi"/>
+-
+- <target name="build-jdk" depends="init">
+- 
+- <javac srcdir="${basedir}/ldapjdk/com" destdir="${jdk.dist}"
+- excludes="cvs/**"
+- classpath="${jsselibs}"
+- />
+- <javac srcdir="${basedir}/ldapjdk/netscape" destdir="${jdk.dist}"
+- excludes="cvs/**"
+- classpath="${jsselibs}"
+- />
+- <javac srcdir="${basedir}/tools" destdir="${jdk.dist}"
+- excludes="cvs/**"
+- classpath="${jsselibs}"
+- />
+- </target>
+-
+- <target name="build-filter" depends="init,build-jdk">
+- <javac srcdir="${basedir}/ldapfilter" destdir="${filter.dist}"
+- excludes="cvs/**"
+- classpath="${jdk.dist}:${jsselibs}"
+- />
+- </target>
+-
+- <target name="build-beans" depends="init">
+- 
+- <javac srcdir="${basedir}/ldapbeans" destdir="${jdk.dist}"
+- excludes="cvs/**"
+- classpath="${jsselibs}"
+- />
+- </target>
+-
+- <target name="build-jndi" depends="init,build-jdk">
+- 
+- <javac srcdir="${basedir}/ldapsp" destdir="${jndi.dist}"
+- excludes="cvs/**"
+- classpath="${jsselibs}:${basedir}/ldapsp/lib/jndi.jar"
+- />
+- </target>
+-
+- <target name="build-docs">
+- 
+- 
+- <javadoc 
+- packagenames="netscape.ldap.*,netscape.ldap.beans.*,netscape.ldap.controls.*,netscape.ldap.util.*,netscape.ldap.factory.*,com.netscape.sasl.*,com.netscape.sasl.mechanisms.*,netscape.ldap.ber.stream.*"
+- sourcepath="${basedir}/ldapbeans:${basedir}/ldapjdk"
+- sourcefiles="${basedir}/tools/LDAPDelete.java,${basedir}/tools/LDAPModify.java,${basedir}/tools/LDAPSearch.java,${basedir}/tools/LDAPTool.java"
+- destdir="${doc.dist}"
+- author="true"
+- version="true"
+- use="true"
+- classpath="${basedir}/ldapjdk:${basedir}/ldapjdk/lib/jss32_stub.jar:${basedir}/ldapbeans" >
+- </javadoc>
+-
+- <javadoc packagenames="com.netscape.jndi.ldap.controls.*"
+- sourcepath="${basedir}/ldapsp" 
+- destdir="${doc.dist}/ldapsp"
+- classpath="${jndi.dist}:${basedir}/ldapsp:${basedir}/ldapsp/lib/jndi.jar"
+- author="true"
+- version="true"
+- use="true">
+- </javadoc>
+- </target>
+-
+- <target name="clean" depends="clean-dists,clean-builds"/>
+-
+- <target name="clean-dists">
+- 
+- <delete includeEmptyDirs="true">
+- <fileset dir="${package.dist}" includes="*.jar *.zip" />
+- </delete>
+- </target>
+-
+- <target name="clean-builds">
+- 
+- <delete includeEmptyDirs="true">
+- <fileset dir="${basedir}/dist" excludes="**/*.jar **/*.zip"/>
+- </delete>
+- </target>
++ 
++ <target name="all" depends="jar,javadoc"/>
+ 
+ </project>
+--- /dev/null
++++ ldapjdk-4.18/mozilla/directory/java-sdk/src/netscape/ldap/LDAPSearchListener.java
+@@ -0,0 +1,197 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
++ *
++ * ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org code.
++ *
++ * The Initial Developer of the Original Code is
++ * Netscape Communications Corporation.
++ * Portions created by the Initial Developer are Copyright (C) 1999
++ * the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++package netscape.ldap;
++
++import java.util.*;
++import netscape.ldap.client.*;
++
++/**
++ * Manages search results, references and responses returned on one or 
++ * more search requests
++ *
++ */
++public class LDAPSearchListener extends LDAPMessageQueue {
++
++ static final long serialVersionUID = -7163312406176592277L;
++ // this instance variable is only for cache purpose
++ private Long m_key = null;
++ private LDAPSearchConstraints m_constraints;
++
++ /**
++ * Constructs a LDAP search listener.
++ * @param asynchOp a boolean flag indicating whether the object is used 
++ * for asynchronous LDAP operations
++ * @param cons LDAP search constraints
++ * @see netscape.ldap.LDAPAsynchronousConnection
++ */
++ LDAPSearchListener ( boolean asynchOp,
++ LDAPSearchConstraints cons ) {
++ super ( asynchOp );
++ m_constraints = cons;
++ }
++
++ /**
++ * Block until all results are in. Used for synchronous search with 
++ * batch size of zero.
++ * @return search response message.
++ * @exception Network exception error
++ */
++ LDAPResponse completeSearchOperation () throws LDAPException{
++ return completeRequest();
++ }
++
++
++ /**
++ * Blocks until a search result, reference or response is available,
 * or until all operations associated with the object have completed
 * or been canceled.
++ *
++ * @return a search result, search reference, search response message,
++ * or null if there are no more outstanding requests. 
++ * @exception LDAPException Network error exception
++ * @exception LDAPInterruptedException The invoking thread was interrupted
++ * @see LDAPResponse
++ * @see LDAPSearchResult
++ * @see LDAPSearchResultReference
++ */
++ public LDAPMessage getResponse () throws LDAPException{
++ return nextMessage();
++ }
++
++
++ /**
++ * Override nextMessage to wake up the LDAPConnThread if 
++ * backlog limit has been reached 
++ */
++ LDAPMessage nextMessage() throws LDAPException{
++ LDAPMessage result = super.nextMessage();
++
++ // Notify LDAPConnThread to wake up if backlog limit has been reached
++ if (result instanceof LDAPSearchResult || result instanceof LDAPSearchResultReference) {
++ LDAPConnThread connThread = getConnThread(result.getMessageID());
++ if (connThread != null) {
++ connThread.resultRetrieved();
++ }
++ }
++ 
++ return result;
++ }
++
++ /**
++ * Merge two response listeners.
++ * Move/append the content from another response listener to this one.
++ * 
++ * To be used for synchronization of asynchronous LDAP operations where
++ * requests are sent by one thread but processed by another one.
++ * 
++ * A client may be implemented in such a way that one thread makes LDAP
++ * requests and calls l.getMessageIDs(), while another thread
++ * is responsible for
++ * processing of responses (call l.getResponse()). Both threads are using
++ * the same listener objects. In such a case, a race
++ * condition may occur, where a LDAP response message is retrieved and
++ * the request terminated (request ID removed) before the first thread
++ * has a chance to execute l.getMessageIDs().
++ * The proper way to handle this scenario is to create a separate listener
++ * for each new request, and after l.getMessageIDs() has been invoked,
++ * merge the new request with the existing one.
++ * @param listener2 the listener with which to merge
++ */
++ public void merge(LDAPSearchListener listener2) {
++ super.merge(listener2);
++ }
++ 
++ /**
++ * Reports true if a response has been received from the server.
++ *
++ * @return a flag indicating whether the response message queue is empty.
++ */
++ public boolean isResponseReceived() {
++ return super.isMessageReceived();
++ }
++
++ /**
++ * Returns message IDs for all outstanding requests
++ * @return message ID array.
++ */
++ public int[] getMessageIDs() {
++ return super.getMessageIDs();
++ }
++ 
++ /**
++ * Return the search constraints used to create this object.
++ * @return the search constraints used to create this object.
++ */
++ LDAPSearchConstraints getSearchConstraints() {
++ return m_constraints;
++ }
++
++ /**
++ * Set new search constraints object.
++ * @param cons LDAP search constraints
++ */
++ void setSearchConstraints(LDAPSearchConstraints cons) {
++ m_constraints = cons;
++ }
++
++ /**
++ * Resets the state of this object, so it can be recycled.
++ * Used by LDAPConnection synchronous operations.
++ */
++ void reset () {
++ super.reset();
++ m_constraints = null;
++ }
++ 
++ /**
++ * Set the key of the cache entry. The listener needs to know this value
++ * when the results get processed in the queue. After the results have been
++ * saved in the vector, then the key and a vector of results are put in
++ * the cache.
++ * @param key the key of the cache entry
++ */
++ void setKey(Long key) {
++ m_key = key;
++ }
++
++ /**
++ * Get the key of the cache entry.
++ * @return the key of the cache entry.
++ */
++ Long getKey() {
++ return m_key;
++ }
++}
+--- /dev/null
++++ ldapjdk-4.18/mozilla/directory/java-sdk/src/netscape/ldap/LDAPEntryComparator.java
+@@ -0,0 +1,81 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
++ *
++ * ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org code.
++ *
++ * The Initial Developer of the Original Code is
++ * Netscape Communications Corporation.
++ * Portions created by the Initial Developer are Copyright (C) 1999
++ * the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++package netscape.ldap;
++
++/**
++ * The <CODE>LDAPEntryComparator</CODE> interface represents the
++ * algorithm used to sort the search results. This interface specifies
++ * one method, <CODE>isGreater</CODE>, which compares two entries and
++ * determines the order in which the two entries should be sorted.
++ * 
++ *
++ * The <CODE>netscape.ldap</CODE> package includes a class that
++ * implements this interface. The <CODE>LDAPCompareAttrNames</CODE>
++ * class represents a comparator that sorts the two entries alphabetically,
++ * based on the value of one or more attributes.
++ * 
++ *
++ * When calling the <CODE>sort</CODE> method of the
++ * <CODE>LDAPSearchResults</CODE> class, you need to specify
++ * a class that implements the <CODE>LDAPEntryComparator</CODE>
++ * interface.
++ * 
++ *
++ * @version 1.0
++ * @see netscape.ldap.LDAPCompareAttrNames
++ * @see netscape.ldap.LDAPSearchResults#sort
++ */
++public interface LDAPEntryComparator {
++
++ /**
++ * Specifies the algorithm used to
++ * compare entries when sorting search results.
++ * 
++ *
++ * <CODE>isGreater</CODE> returns <CODE>true</CODE>
++ * if the entry specified in the first argument should
++ * be sorted before the entry specified in the second
++ * argument.
++ * 
++ *
++ * @see netscape.ldap.LDAPCompareAttrNames
++ * @see netscape.ldap.LDAPSearchResults#sort
++ */
++ public boolean isGreater (LDAPEntry greater, LDAPEntry less);
++
++}
+--- /dev/null
++++ ldapjdk-4.18/mozilla/directory/java-sdk/src/netscape/ldap/LDAPSaslBind.java
+@@ -0,0 +1,307 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
++ *
++ * ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org code.
++ *
++ * The Initial Developer of the Original Code is
++ * Netscape Communications Corporation.
++ * Portions created by the Initial Developer are Copyright (C) 1999
++ * the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++package netscape.ldap;
++
++import java.util.*;
++import netscape.ldap.client.*;
++import netscape.ldap.client.opers.*;
++import netscape.ldap.ber.stream.*;
++import netscape.ldap.util.*;
++import java.io.*;
++import java.net.*;
++//import javax.security.auth.callback.CallbackHandler;
++
++/**
++ * Authenticates to a server using SASL
++ */
++public class LDAPSaslBind implements LDAPBind, java.io.Serializable {
++
++ static final long serialVersionUID = -7615315715163655443L;
++
++ /**
++ * Construct an object which can authenticate to an LDAP server
++ * using the specified name and a specified SASL mechanism.
++ *
++ * @param dn if non-null and non-empty, specifies that the connection and
++ * all operations through it should authenticate with dn as the
++ * distinguished name
++ * @param mechanisms array of mechanism names, e.g. { "GSSAPI", "SKEY" }
++ * @param props optional additional properties of the desired
++ * authentication mechanism, e.g. minimum security level
++ * @param cbh a class which may be called by the SASL framework to
++ * obtain additional required information
++ */
++ public LDAPSaslBind( String dn,
++ String[] mechanisms,
++ String packageName,
++ Hashtable props,
++ /*CallbackHandler*/ Object cbh ) {
++ _dn = dn;
++ _mechanisms = mechanisms;
++ _packageName = packageName;
++ _props = props;
++ _cbh = cbh;
++
++ // 12-01-99 Disabled check for instanceof CallbackHandler so that
++ // there is no dependency on the extenal jaas.jar package. This is
++ // reqired for Communicator build where the ldap java package does not
++ // include any sasl classes.
++
++ /*if ( (cbh != null) &&
++ !(cbh instanceof javax.security.auth.callback.CallbackHandler) ) {
++ throw new IllegalArgumentException(
++ "Callback argument must implement " +
++ "javax.security.auth.callback.CallbackHandler" );
++ }*/
++ }
++
++ /**
++ * Authenticates to the LDAP server (that the object is currently
++ * connected to) using the parameter that were provided to the
++ * constructor. If the requested SASL mechanism is not
++ * available, an exception is thrown. If the object has been
++ * disconnected from an LDAP server, this method attempts to reconnect
++ * to the server. If the object had already authenticated, the old
++ * authentication is discarded.
++ *
++ * @param ldc an active connection to a server, which will have
++ * the new authentication state on return from the method
++ * @exception LDAPException Failed to authenticate to the LDAP server.
++ */
++ public void bind( LDAPConnection ldc ) throws LDAPException {
++ if ( _props == null ) {
++ _props = new Hashtable();
++ }
++ if ( (!_props.containsKey( CLIENTPKGS )) &&
++ (System.getProperty( CLIENTPKGS ) == null) ) {
++ _props.put( CLIENTPKGS, ldc.DEFAULT_SASL_PACKAGE );
++ }
++ _saslClient = getClient( ldc, _packageName );
++ if ( _saslClient != null ) {
++ bind( ldc, true );
++ return;
++ } else {
++ ldc.printDebug( "LDAPSaslBind.bind: getClient " +
++ "returned null" );
++ }
++ }
++
++ /**
++ * Get a SaslClient object from the Sasl framework
++ *
++ * @param ldc contains the host name
++ * @param packageName package containing a ClientFactory
++ * @return a SaslClient supporting one of the mechanisms
++ * of the member variable _mechanisms.
++ * @exception LDAPException on error producing a client
++ */
++ private Object getClient( LDAPConnection ldc, String packageName )
++ throws LDAPException {
++ try {
++ Object[] args = new Object[6];
++ args[0] = _mechanisms;
++ args[1] = _dn;
++ args[2] = "ldap";
++ args[3] = ldc.getHost();
++ args[4] = _props;
++ args[5] = _cbh;
++ String[] argNames = new String[6];
++ argNames[0] = "[Ljava.lang.String;";
++ argNames[1] = "java.lang.String";
++ argNames[2] = "java.lang.String";
++ argNames[3] = "java.lang.String";
++ argNames[4] = "java.util.Hashtable";
++ argNames[5] = CALLBACK_HANDLER;
++
++ // Get a mechanism driver
++ return DynamicInvoker.invokeMethod(null,
++ packageName+".Sasl",
++ "createSaslClient",
++ args, argNames);
++
++ } catch (Exception e) {
++ ldc.printDebug( "LDAPSaslBind.getClient: " +
++ packageName+".Sasl.createSaslClient: " +
++ e );
++ throw new LDAPException(e.toString(), LDAPException.OTHER);
++ }
++ }
++
++ void bind(LDAPConnection ldc, boolean rebind)
++ throws LDAPException {
++
++ if ((ldc.isConnected() && rebind) ||
++ !ldc.isConnected()) {
++ try {
++ // Get the initial request to start authentication
++ String className = _saslClient.getClass().getName();
++ ldc.printDebug( "LDAPSaslBind.bind: calling " +
++ className+".createInitialResponse" );
++ byte[] outVals =
++ (byte[])DynamicInvoker.invokeMethod(
++ _saslClient,
++ className,
++ "createInitialResponse", null, null);
++
++ String mechanismName =
++ (String)DynamicInvoker.invokeMethod(
++ _saslClient,
++ className,
++ "getMechanismName", null, null);
++ ldc.printDebug( "LDAPSaslBind.bind: mechanism " +
++ "name is " +
++ mechanismName );
++ boolean isExternal = isExternalMechanism(mechanismName);
++ int resultCode = LDAPException.SASL_BIND_IN_PROGRESS;
++ JDAPBindResponse response = null;
++ while (!checkForSASLBindCompletion(resultCode)) {
++ ldc.printDebug( "LDAPSaslBind.bind: calling " +
++ "saslBind" );
++ response = saslBind(ldc, mechanismName, outVals);
++ resultCode = response.getResultCode();
++ ldc.printDebug( "LDAPSaslBind.bind: saslBind " +
++ "returned " + resultCode );
++ if (isExternal) {
++ continue;
++ }
++
++ byte[] b = response.getCredentials();
++
++ Object[] args = {b};
++ String[] argNames = {"[B"}; // class name for byte array
++
++ outVals =
++ (byte[])DynamicInvoker.invokeMethod(
++ _saslClient,
++ className, "evaluateChallenge",
++ args, argNames);
++ }
++
++ // Make sure authentication REALLY is complete
++ Boolean bool =
++ (Boolean)DynamicInvoker.invokeMethod(
++ _saslClient,
++ className, "isComplete", null, null);
++ if (!bool.booleanValue()) {
++ // Authentication session hijacked!
++ throw new LDAPException("The server indicates that " +
++ "authentication is successful" +
++ ", but the SASL driver " +
++ "indicates that authentication" +
++ " is not yet done.",
++ LDAPException.OTHER);
++ }
++
++ Object[] args = {ldc.getInputStream()};
++ String[] argNames = {"java.io.InputStream"};
++ InputStream is =
++ (InputStream)DynamicInvoker.invokeMethod(
++ _saslClient,
++ className, "getInputStream", args, argNames);
++ ldc.setInputStream(is);
++ args[0] = ldc.getOutputStream();
++ argNames[0] = "java.io.OutputStream";
++ OutputStream os =
++ (OutputStream)DynamicInvoker.invokeMethod(
++ _saslClient,
++ className, "getOutputStream", args, argNames);
++ ldc.setOutputStream(os);
++ ldc.setBound(true);
++ } catch (LDAPException e) {
++ throw e;
++ } catch (Exception e) {
++ throw new LDAPException(e.toString(), LDAPException.OTHER);
++ }
++ }
++ }
++
++ boolean isExternalMechanism(String name) {
++ return name.equalsIgnoreCase( LDAPConnection.EXTERNAL_MECHANISM );
++ }
++
++ private boolean checkForSASLBindCompletion(int resultCode)
++ throws LDAPException{
++
++ if (resultCode == LDAPException.SUCCESS) {
++ return true;
++ } else if (resultCode == LDAPException.SASL_BIND_IN_PROGRESS) {
++ return false;
++ } else {
++ throw new LDAPException("Authentication failed", resultCode);
++ }
++ }
++
++ private JDAPBindResponse saslBind(LDAPConnection ldc,
++ String mechanismName,
++ byte[] credentials)
++ throws LDAPException {
++
++ LDAPResponseListener myListener = ldc.getResponseListener ();
++
++ try {
++ ldc.sendRequest(new JDAPBindRequest(3,
++ _dn,
++ mechanismName,
++ credentials),
++ myListener, ldc.getConstraints());
++ LDAPMessage response = myListener.getResponse();
++
++ JDAPProtocolOp protocolOp = response.getProtocolOp();
++ if (protocolOp instanceof JDAPBindResponse) {
++ return (JDAPBindResponse)protocolOp;
++ } else {
++ throw new LDAPException("Unknown response from the " +
++ "server during SASL bind",
++ LDAPException.OTHER);
++ }
++ } finally {
++ ldc.releaseResponseListener(myListener);
++ }
++ }
++
++ private static final String CALLBACK_HANDLER =
++ "javax.security.auth.callback.CallbackHandler";
++ private static final String CLIENTPKGS =
++ "javax.security.sasl.client.pkgs";
++ private String _dn;
++ private String[] _mechanisms;
++ private String _packageName;
++ private Hashtable _props;
++ private /*CallbackHandler*/ Object _cbh;
++ private Object _saslClient = null;
++}
+--- /dev/null
++++ ldapjdk-4.18/mozilla/directory/java-sdk/src/netscape/ldap/LDAPv2.java
+@@ -0,0 +1,499 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
++ *
++ * ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org code.
++ *
++ * The Initial Developer of the Original Code is
++ * Netscape Communications Corporation.
++ * Portions created by the Initial Developer are Copyright (C) 1999
++ * the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++package netscape.ldap;
++
++import java.util.*;
++import java.io.*;
++
++/**
++ * This interface summarizes the basic functionality available in the
++ * Lightweight Directory Access Protocol (LDAP) version 2. (See
++ * <A HREF="http://www.cis.ohio-state.edu/htbin/rfc/rfc1777.html" TARGET="_blank">RFC 1777</A>
++ * for the definition of the protocol.)
++ * 
++ *
++ * In the general model for this protocol, objects exist under a directory
++ * in a particular server. Objects are identified by unique, hierarchical names
++ * called Distinguished Names, commonly abreviated "DN". An example of a DN:
++ * <pre>
++ * cn=Barbara Jensen,ou=Product Development,o=Ace Industry,c=us
++ * </pre>
++ * Objects have attributes, of the form
++ * <pre>
++ * attributeName = attributeValue(s)
++ * </pre>
++ * Attribute names must be Strings, and attribute values can be any 8-bit
++ * sequence (Strings or binary values).
++ *
++ * @version 1.0
++ */
++public interface LDAPv2 {
++ /**
++ * The default port number for LDAP servers. You can specify
++ * this identifier when calling the <CODE>LDAPConnection.connect</CODE>
++ * method to connect to an LDAP server.
++ * @see netscape.ldap.LDAPConnection#connect
++ */
++ public final static int DEFAULT_PORT = 389;
++
++ /**
++ * Option specifying how aliases are dereferenced.
++ * 
++ *
++ * This option can have one of the following values:
++ * <UL>
++ * <LI><A HREF="#DEREF_NEVER"><CODE>DEREF_NEVER</CODE></A>
++ * <LI><A HREF="#DEREF_FINDING"><CODE>DEREF_FINDING</CODE></A>
++ * <LI><A HREF="#DEREF_SEARCHING"><CODE>DEREF_SEARCHING</CODE></A>
++ * <LI><A HREF="#DEREF_ALWAYS"><CODE>DEREF_ALWAYS</CODE></A>
++ * </UL>
++ * 
++ *
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#setOption
++ */
++ public static final int DEREF = 2;
++
++ /**
++ * Option specifying the maximum number of search results to
++ * return.
++ * 
++ *
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#setOption
++ */
++ public static final int SIZELIMIT = 3;
++
++ /**
++ * Option specifying the maximum number of milliseconds to
++ * wait for an operation to complete.
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#setOption
++ */
++ public static final int TIMELIMIT = 4;
++
++ /**
++ * Option specifying the maximum number of milliseconds the 
++ * server should spend returning search results before aborting
++ * the search. 
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#setOption
++ */
++ public static final int SERVER_TIMELIMIT = 5;
++
++ /**
++ * Option specifying whether or not referrals to other LDAP
++ * servers are followed automatically.
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#setOption
++ * @see netscape.ldap.LDAPRebind
++ * @see netscape.ldap.LDAPRebindAuth
++ */
++ public static final int REFERRALS = 8;
++
++ /**
++ * Option specifying the object containing the method for
++ * getting authentication information (the distinguished name
++ * and password) used during a referral. For example, when
++ * referred to another LDAP server, your client uses this object
++ * to obtain the DN and password. Your client authenticates to
++ * the LDAP server using this DN and password.
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#setOption
++ * @see netscape.ldap.LDAPRebind
++ * @see netscape.ldap.LDAPRebindAuth
++ */
++ public static final int REFERRALS_REBIND_PROC = 9;
++
++ /**
++ * Option specifying the maximum number of referrals to follow
++ * in a sequence when requesting an LDAP operation.
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#setOption
++ */
++ public static final int REFERRALS_HOP_LIMIT = 10;
++ 
++ /**
++ * Option specifying the object containing the method for
++ * authenticating to the server. 
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#setOption
++ * @see netscape.ldap.LDAPBind
++ */
++ public static final int BIND = 13;
++
++ /**
++ * Option specifying the version of the LDAP protocol
++ * used by your client when interacting with the LDAP server.
++ * If no version is set, the default version is 2. If you
++ * are planning to use LDAP v3 features (such as controls
++ * or extended operations), you should set this version to 3
++ * or specify version 3 as an argument to the <CODE>authenticate</CODE>
++ * method of the <CODE>LDAPConnection</CODE> object.
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#setOption
++ * @see netscape.ldap.LDAPConnection#authenticate(int, java.lang.String, java.lang.String)
++ */
++ public static final int PROTOCOL_VERSION = 17;
++
++ /**
++ * Option specifying the number of results to return at a time.
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#setOption
++ */
++ public static final int BATCHSIZE = 20;
++
++
++ /*
++ * Valid options for Scope
++ */
++
++ /**
++ * Specifies that the scope of a search includes
++ * only the base DN (distinguished name).
++ * @see netscape.ldap.LDAPConnection#search(java.lang.String, int, java.lang.String, java.lang.String[], boolean, netscape.ldap.LDAPSearchConstraints)
++ */
++ public static final int SCOPE_BASE = 0;
++
++ /**
++ * Specifies that the scope of a search includes
++ * only the entries one level below the base DN (distinguished name).
++ * @see netscape.ldap.LDAPConnection#search(java.lang.String, int, java.lang.String, java.lang.String[], boolean, netscape.ldap.LDAPSearchConstraints) */
++ public static final int SCOPE_ONE = 1;
++
++ /**
++ * Specifies that the scope of a search includes
++ * the base DN (distinguished name) and all entries at all levels
++ * beneath that base.
++ * @see netscape.ldap.LDAPConnection#search(java.lang.String, int, java.lang.String, java.lang.String[], boolean, netscape.ldap.LDAPSearchConstraints) */
++ public static final int SCOPE_SUB = 2;
++
++
++ /*
++ * Valid options for Dereference
++ */
++
++ /**
++ * Specifies that aliases are never dereferenced.
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#setOption
++ */
++ public static final int DEREF_NEVER = 0;
++
++ /**
++ * Specifies that aliases are dereferenced when searching the
++ * entries beneath the starting point of the search (but
++ * not when finding the starting entry).
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#setOption
++ */
++ public static final int DEREF_SEARCHING = 1;
++
++ /**
++ * Specifies that aliases are dereferenced when finding the
++ * starting point for the search (but not when searching
++ * under that starting entry).
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#setOption
++ */
++ public static final int DEREF_FINDING = 2;
++
++ /**
++ * Specifies that aliases are always dereferenced.
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#setOption
++ */
++ public static final int DEREF_ALWAYS = 3;
++
++ /**
++ * Connects to the LDAP server.
++ * @param host hostname of the LDAP server
++ * @param port port number of the LDAP server. To specify the
++ * default port, use <CODE>DEFAULT_PORT</CODE>.
++ * @exception LDAPException Failed to connect to the server.
++ */
++ public void connect (String host, int port) throws LDAPException;
++
++ /**
++ * Connects and authenticates to the LDAP server.
++ * @param host hostname of the LDAP server
++ * @param port port number of the LDAP server. To specify the
++ * default port, use <CODE>DEFAULT_PORT</CODE>.
++ * @param dn distinguished name to use for authentication
++ * @param passwd password for authentication
++ * @exception LDAPException Failed to connect and authenticate to the server.
++ */
++ public void connect (String host, int port, String dn, String passwd)
++ throws LDAPException;
++
++ /**
++ * Disconnects from the LDAP server. Subsequent operational calls
++ * will first try to re-establish the connection to the same LDAP server.
++ * @exception LDAPException Failed to disconnect from the server.
++ */
++ public void disconnect() throws LDAPException;
++
++ /** 
++ * Notifies the server to not send additional results associated with this
++ * <CODE>LDAPSearchResults</CODE> object, and discards any results already 
++ * received.
++ * @param results LDAPSearchResults object returned from a search
++ * @exception LDAPException Failed to notify the server.
++ */
++ public void abandon(LDAPSearchResults results) throws LDAPException;
++
++ /**
++ * Authenticates user with the LDAP server.
++ * @param DN distinguished name to use for authentication
++ * @param passwd password for authentication
++ * @exception LDAPException Failed to authenticate to the server.
++ */
++ public void authenticate (String DN, String passwd) throws LDAPException;
++
++ /**
++ * Authenticates user with the LDAP server.
++ * @param DN distinguished name to use for authentication
++ * @param passwd password for authentication
++ * @exception LDAPException Failed to authenticate to the server.
++ */
++ public void bind (String DN, String passwd) throws LDAPException;
++
++ /**
++ * Read the entry corresponding to the specified distinguished name (DN).
++ * @param DN distinguished name of the entry to retrieve
++ * @exception LDAPException Failed to retrieve the specified entry.
++ */
++ public LDAPEntry read (String DN) throws LDAPException;
++
++ /**
++ * Read the entry corresponding to the specified distinguished name (DN),
++ * and retrieve only the specified attributes.
++ * @param DN distinguished name of the entry to retrieve
++ * @param attrs names of attributes to retrieve
++ * @exception LDAPException Failed to retrieve the specified entry.
++ */
++ public LDAPEntry read (String DN, String attrs[]) throws LDAPException;
++
++ /**
++ * Read the entry corresponding to the specified distinguished name (DN),
++ * and retrieve only the specified attributes.
++ * @param DN distinguished name of the entry to retrieve
++ * @param attrs names of attributes to retrieve
++ * @param cons the constraints set for the read operation
++ * @exception LDAPException Failed to retrieve the specified entry.
++ */
++ public LDAPEntry read (String DN, String attrs[], LDAPSearchConstraints cons)
++ throws LDAPException;
++
++ /**
++ * Searches for entries in the directory.
++ * @param base starting point for the search in the directory
++ * (distinguished name)
++ * @param scope indicates whether the scope of the search includes
++ * only the base DN (equivalent to a read operation), only the entries
++ * one level below the base DN, or all entries at all levels beneath
++ * the base DN (including the base DN itself)
++ * @param filter String which describes the search criteria. The format
++ * of the string is described fully in
++ * <A HREF="http://www.cis.ohio-state.edu/htbin/rfc/rfc1558.html" TARGET="_blank">RFC 1558</A>.
++ * @param attrs names of the attributes to return for each matching
++ * directory entry. If <CODE>null</CODE>, all attributes are returned.
++ * @param attrsOnly if <CODE>true</CODE>, the search will return only the names of
++ * the attributes (and not their values)
++ * @exception LDAPException Failed to complete the requested search.
++ */
++ public LDAPSearchResults search (String base, int scope, String filter,
++ String[] attrs, boolean attrsOnly) throws LDAPException;
++
++ /**
++ * Searches for entries in the directory.
++ * @param base starting point for the search in the directory
++ * (distinguished name)
++ * @param scope indicates whether the scope of the search includes
++ * only the base DN (equivalent to a read operation), only the entries
++ * one level below the base DN, or all entries at all levels beneath
++ * the base DN (including the base DN itself)
++ * @param filter String which describes the search criteria. The format
++ * of the string is described fully in
++ * <A HREF="http://www.cis.ohio-state.edu/htbin/rfc/rfc1558.html" TARGET="_blank">RFC 1558</A>.
++ * @param attrs names of the attributes to return for each matching
++ * directory entry. If <CODE>null</CODE>, all attributes are returned.
++ * @param attrsOnly if <CODE>true</CODE>, the search will return only the names of
++ * the attributes (and not their values)
++ * @param cons constraints specific to the search (for example, the maximum number
++ * of entries to return or the maximum time to wait for the search operation to complete)
++ * @exception LDAPException Failed to complete the requested search.
++ */
++ public LDAPSearchResults search (String base, int scope, String filter,
++ String[] attrs, boolean attrsOnly, LDAPSearchConstraints cons)
++ throws LDAPException;
++
++ /**
++ * Compares the given entry's attribute value to the specified
++ * attribute value.
++ * @param DN distinguished name of the entry that you want compared
++ * against the specified attribute value
++ * @param attr attribute name and value to use in the comparison
++ * @exception LDAPException Failed to perform the comparison.
++ */
++ public boolean compare (String DN, LDAPAttribute attr) throws LDAPException;
++
++ /**
++ * Compares the given entry's attribute value to the specified
++ * attribute value.
++ * @param DN distinguished name of the entry that you want compared
++ * against the specified attribute value
++ * @param attr attribute name and value to use in the comparison
++ * @param cons the constraints set for the compare operation
++ * @exception LDAPException Failed to perform the comparison.
++ */
++ public boolean compare (String DN, LDAPAttribute attr,
++ LDAPConstraints cons) throws LDAPException;
++
++ /**
++ * Adds an entry to the directory.
++ * @param entry new entry to add to the directory
++ * @exception LDAPException Failed to add the entry to the directory.
++ */
++ public void add (LDAPEntry entry) throws LDAPException;
++
++ /**
++ * Adds an entry to the directory.
++ * @param entry new entry to add to the directory
++ * @param cons the constraints set for the add operation
++ * @exception LDAPException Failed to add the entry to the directory.
++ */
++ public void add (LDAPEntry entry, LDAPConstraints cons)
++ throws LDAPException;
++
++ /**
++ * Modifies an attribute of a directory entry.
++ * @param DN distinguished name identifying the entry to modify
++ * @param mod the modification to make
++ * @exception LDAPException Failed to modify the specified entry.
++ */
++ public void modify (String DN, LDAPModification mod) throws LDAPException;
++
++ /**
++ * Modifies an attribute of a directory entry.
++ * @param DN distinguished name identifying the entry to modify
++ * @param mod the modification to make
++ * @param cons the constraints set for the modify operation
++ * @exception LDAPException Failed to modify the specified entry.
++ */
++ public void modify (String DN, LDAPModification mod,
++ LDAPConstraints cons) throws LDAPException;
++
++ /**
++ * Modifies the attributes of a directory entry.
++ * @param DN distinguished name identifying the entry to modify
++ * @param mods list of the modifications to make
++ * @exception LDAPException Failed to modify the specified entry.
++ */
++ public void modify (String DN, LDAPModificationSet mods ) throws LDAPException;
++
++ /**
++ * Modifies the attributes of a directory entry.
++ * @param DN distinguished name identifying the entry to modify
++ * @param mods list of the modifications to make
++ * @param cons the constraints set for the modify operation
++ * @exception LDAPException Failed to modify the specified entry.
++ */
++ public void modify (String DN, LDAPModificationSet mods,
++ LDAPConstraints cons ) throws LDAPException;
++
++ /**
++ * Removes an entry from the directory.
++ * @param DN distinguished name identifying the entry to remove
++ * @exception LDAPException Failed to remove the entry from the directory.
++ */
++ public void delete( String DN ) throws LDAPException;
++
++ /**
++ * Removes an entry from the directory.
++ * @param DN distinguished name identifying the entry to remove
++ * @param cons the constraints set for the delete operation
++ * @exception LDAPException Failed to remove the entry from the directory.
++ */
++ public void delete( String DN, LDAPConstraints cons )
++ throws LDAPException;
++
++ /**
++ * Changes the name of an entry in the directory.
++ * @param DN distinguished name (DN) of entry
++ * @param newRDN the new relative distinguished name (RDN) of the entry
++ * @param deleteOldRDN <CODE>true</CODE> if the original RDN should no longer
++ * be an attribute of the entry; <CODE>false</CODE> if it should
++ * @exception LDAPException Failed to rename the entry in the directory.
++ */
++ public void rename ( String DN, String newRDN, boolean deleteOldRDN )
++ throws LDAPException;
++
++ /**
++ * Changes the name of an entry in the directory.
++ * @param DN distinguished name (DN) of entry
++ * @param newRDN new relative distinguished name (RDN) of the entry
++ * @param deleteOldRDN specifies whether or not the original RDN remains
++ * as an attribute of the entry. If <CODE>true</CODE>, the original RDN
++ * is no longer an attribute of the entry.
++ * @param cons the constraints set for the rename operation
++ * @exception LDAPException Failed to rename the entry in the directory.
++ */
++ public void rename ( String DN, String newRDN, boolean deleteOldRDN,
++ LDAPConstraints cons ) throws LDAPException;
++
++ /**
++ * Retrieves an option that applies to the connection.
++ * The particular meaning may be implementation-dependent.
++ * The standard options are the options described by
++ * the <CODE>LDAPSearchConstraints</CODE> and <CODE>LDAPConstraints</CODE>
++ * classes.
++ * @exception LDAPException Failed to retrieve the value of the specified option.
++ */
++ public Object getOption( int option ) throws LDAPException;
++
++ /**
++ * Sets an option that applies to the connection.
++ * The particular meaning may be implementation-dependent.
++ * The standard options are the options described by
++ * the <CODE>LDAPSearchConstraints</CODE> and <CODE>LDAPConstraints</CODE>
++ * classes.
++ * @exception LDAPException Failed to set the specified option.
++ */
++ public void setOption( int option, Object value ) throws LDAPException;
++}
+--- /dev/null
++++ ldapjdk-4.18/mozilla/directory/java-sdk/src/netscape/ldap/LDAPTLSSocketFactory.java
+@@ -0,0 +1,64 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
++ *
++ * ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org code.
++ *
++ * The Initial Developer of the Original Code is
++ * Netscape Communications Corporation.
++ * Portions created by the Initial Developer are Copyright (C) 2002
++ * the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++package netscape.ldap;
++
++import java.util.*;
++import java.io.*;
++import java.net.*;
++
++/**
++ * A socket factory interface for supporting the start TLS LDAPv3
++ * extension (RFC 2830).
++ * 
++ *
++ * @version 1.0
++ * @since LDAPJDK 4.17
++ */
++public interface LDAPTLSSocketFactory extends LDAPSocketFactory {
++ /**
++ * Creates an SSL socket layered over an existing socket.
++ * 
++ * Used for the start TLS operations (RFC2830).
++ *
++ * @param s An existing non-SSL socket
++ * @return A SSL socket layered over the input socket
++ * @exception LDAPException on error creating socket
++ * @see LDAPConnection#startTLS
++ */
++ public Socket makeSocket(Socket s) throws LDAPException;
++}
+--- /dev/null
++++ ldapjdk-4.18/mozilla/directory/java-sdk/src/netscape/ldap/LDAPResourceBundle.java
+@@ -0,0 +1,137 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
++ *
++ * ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org code.
++ *
++ * The Initial Developer of the Original Code is
++ * Netscape Communications Corporation.
++ * Portions created by the Initial Developer are Copyright (C) 1999
++ * the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++package netscape.ldap;
++
++import java.util.*;
++import java.io.*;
++
++/**
++ * This class represents a locale-specific resource for a property file.
++ * It retrieves the property file for the given base name including the
++ * absolute path name and locale. The property file has to be located in the
++ * CLASSPATH and the property file's suffix is .props.
++ * 
++ * If the specified locale is en and us and the base name of the file is
++ * netscape/ldap/errors/ErrorCodes, then the class loader will search for
++ * the file in the following order:
++ * <pre>
++ *
++ * ErrorCodes_en_us.props
++ * ErrorCodes_en.props
++ * ErrorCodes.props
++ *
++ * </pre>
++ * @see java.util.Locale
++ */
++class LDAPResourceBundle implements java.io.Serializable {
++
++ static final long serialVersionUID = -5903986665461157980L;
++ private static final boolean m_debug = false;
++ private static final String m_suffix = ".props";
++ private static final String m_locale_separator = "_";
++
++ /**
++ * Return the property resource bundle according to the base name of the
++ * property file and the locale. The class loader will find the closest match
++ * with the given locale.
++ * @return the property resource bundle.
++ * @exception IOException Gets thrown when failed to open the resource
++ * bundle file.
++ */
++ static PropertyResourceBundle getBundle(String baseName)
++ throws IOException {
++
++ return getBundle(baseName, Locale.getDefault());
++ }
++
++ /**
++ * Return the property resource bundle according to the base name of the
++ * property file and the locale. The class loader will find the closest match
++ * with the given locale.
++ * @param baseName the base name of the property file. The base name contains
++ * no locale context and no . suffix.
++ * @param l the locale
++ * @return the property resource bundle.
++ * @exception IOException Gets thrown when failed to create a property
++ * resource
++ */
++ static PropertyResourceBundle getBundle(String baseName, Locale l)
++ throws IOException {
++ String localeStr = m_locale_separator+l.toString();
++
++ InputStream fin = null;
++
++ while (true) {
++ if ((fin=getStream(baseName, localeStr)) != null) {
++ PropertyResourceBundle p = new PropertyResourceBundle(fin);
++ return p;
++ } else {
++
++ int index = localeStr.lastIndexOf(m_locale_separator);
++ if (index == -1) {
++ printDebug("File "+baseName+localeStr+m_suffix+" not found");
++ return null;
++ } else
++ localeStr = localeStr.substring(0, index);
++ }
++ }
++ }
++
++ /**
++ * Constructs the whole absolute path name of a property file and retrieves
++ * an input stream on the file.
++ * @param baseName the base name of the property file. The base name contains
++ * no locale context and no . suffix.
++ * @param the locale string to insert into the file name
++ * @return the input stream of the property file.
++ */
++ private static InputStream getStream(String baseName, String locale) {
++ String fStr = baseName+locale+m_suffix;
++ return (ClassLoader.getSystemResourceAsStream(fStr));
++ }
++
++ /**
++ * Prints debug messages if the debug mode is on.
++ * @param str the message that is printed
++ */
++ private static void printDebug(String str) {
++ if (m_debug)
++ System.out.println(str);
++ }
++}
++
+--- /dev/null
++++ ldapjdk-4.18/mozilla/directory/java-sdk/src/netscape/ldap/LDAPInterruptedException.java
+@@ -0,0 +1,75 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
++ *
++ * ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org code.
++ *
++ * The Initial Developer of the Original Code is
++ * Netscape Communications Corporation.
++ * Portions created by the Initial Developer are Copyright (C) 1999
++ * the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++package netscape.ldap;
++
++/**
++ * An exception thrown when the LDAP operation being invoked has
++ * been interrupted. For example, an application might interrupt a thread that
++ * is performing a search.
++ *
++ * @version 1.0
++ */
++public class LDAPInterruptedException extends LDAPException {
++
++ static final long serialVersionUID = 5267455101797397456L;
++
++ /**
++ * Constructs a default exception with a specified string of
++ * additional information. This string appears if you call
++ * the <CODE>toString()</CODE> method.
++ * 
++ *
++ * @param message the additional information
++ * @see netscape.ldap.LDAPInterruptedException#toString()
++ */
++ LDAPInterruptedException( String message ) {
++ super( message, LDAPException.OTHER, null);
++ }
++
++ /**
++ * Gets the string representation of the exception.
++ */
++ public String toString() {
++ String str = "netscape.ldap.LDAPInterruptedException: ";
++ String msg = super.getMessage();
++ if (msg != null) {
++ str +=msg;
++ } 
++ return str;
++ }
++}
+--- /dev/null
++++ ldapjdk-4.18/mozilla/directory/java-sdk/src/netscape/ldap/LDAPRebind.java
+@@ -0,0 +1,94 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
++ *
++ * ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org code.
++ *
++ * The Initial Developer of the Original Code is
++ * Netscape Communications Corporation.
++ * Portions created by the Initial Developer are Copyright (C) 1999
++ * the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++package netscape.ldap;
++
++import java.util.*;
++import java.io.*;
++
++/**
++ * Specifies how to retrieve authentication information automatically
++ * for referrals. If you have set up the search constraints (or the options
++ * in the <CODE>LDAPConnection</CODE> object) to use automatic referral,
++ * you must define a class that implements this interface.
++ * 
++ *
++ * If no class implements this interface, clients that follow automatic
++ * referrals are authenticated anonymously to subsequent LDAP servers.
++ * The following example is a simple class that implements this interface.
++ * Objects of the myLDAPRebind class check the host and port of the 
++ * referred LDAP server. If the host and port are "alway.mcom.com:389", 
++ * the directory manager's name and password are used to authenticate.
++ * For all other LDAP servers, anonymous authentication is used.
++ *
++ * <PRE>
++ * public class myLDAPRebind implements netscape.ldap.LDAPRebind
++ * {
++ * private String myDN;
++ * private String myPW;
++ * private LDAPRebindAuth myRebindInfo;
++
++ * public myLDAPRebind () {
++ * myDN = "c=Directory Manager,o=Universal Exports,c=UK";
++ * myPW = "alway4444";
++ * }
++ *
++ * public LDAPRebindAuth getRebindAuthentication( String host, int port ) {
++ * if ( host.equalsIgnoreCase( "alway.mcom.com" ) && ( port == 389 ) ) {
++ * myRebindInfo = new LDAPRebindAuth( myDN, myPW );
++ * } else {
++ * myRebindInfo = new LDAPRebindAuth( "", "" );
++ * }
++ * return myRebindInfo;
++ * }
++ * } </PRE>
++ *
++ *
++ * @version 1.0
++ */
++public interface LDAPRebind {
++
++ /**
++ * Returns an <CODE>LDAPRebindAuth</CODE> object, which the calling function
++ * can use to get the DN and password to use for authentication (if the client
++ * is set up to follow referrals automatically).
++ * @return LDAPRebindAuth object containing authentication information.
++ * @see netscape.ldap.LDAPRebindAuth
++ */
++ public LDAPRebindAuth getRebindAuthentication(String host,
++ int port);
++}
+--- /dev/null
++++ ldapjdk-4.18/mozilla/directory/java-sdk/src/netscape/ldap/LDAPConnSetupMgr.java
+@@ -0,0 +1,627 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
++ *
++ * ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org code.
++ *
++ * The Initial Developer of the Original Code is
++ * Netscape Communications Corporation.
++ * Portions created by the Initial Developer are Copyright (C) 1999
++ * the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++package netscape.ldap;
++
++import java.util.*;
++import java.io.*;
++import java.net.*;
++
++/**
++ * Makes a connection to a server from a list using "smart" failover.
++ * Connection attempts can be made serially from the same thread, or
++ * in parallel by creating a separate thread after the specified delay.
++ * Connection setup status is preserved for later attempts, so that servers
++ * that are more likely to be available will be tried first.
++ * 
++ * The total time spent opening a connection can be limited with the
++ * <CODE>ConnectTimeout</CODE> property.
++ * 
++ * When a connection is successfully created, a socket is opened. The socket 
++ * is passed to the LDAPConnThread. The LDAPConnThread must call
++ * invalidateConnection() if the connection is lost due to a network or 
++ * server error, or closeConnection() if the connection is deliberately terminated
++ * by the user.
++ */
++class LDAPConnSetupMgr implements java.io.Serializable {
++
++ static final long serialVersionUID = 1519402748245755307L;
++ /**
++ * Policy for opening a connection when multiple servers are used
++ */
++ private static final int SERIAL = 0;
++ private static final int PARALLEL = 1;
++ 
++ /**
++ * ServerEntry.connSetupStatus possible value. The values also represent
++ * the likelihood that the connection will be setup to a server. Lower
++ * values have higher priority. See sortDsList() method
++ */
++ private static final int CONNECTED = 0; 
++ private static final int DISCONNECTED = 1;
++ private static final int NEVER_USED = 2;
++ private static final int INTERRUPTED = 3;
++ private static final int FAILED = 4;
++ 
++ /**
++ * Representation for a server in the server list.
++ */
++ class ServerEntry {
++ LDAPUrl url;
++ int connSetupStatus;
++ Thread connSetupThread;
++
++ ServerEntry(LDAPUrl url, int status) {
++ this.url = url;
++ connSetupStatus = status;
++ connSetupThread = null;
++ } 
++ public String toString() {
++ return "{" + url + " status="+connSetupStatus+"}";
++ }
++ }
++ 
++
++ /**
++ * Socket to the connected server
++ */
++ private Socket m_socket = null;
++ 
++ /**
++ * Original, underlying socket to the server, see layerSocket()
++ */
++ private Socket m_origSocket = null;
++ 
++
++ /**
++ * Last exception occured during connection setup
++ */
++ private LDAPException m_connException = null;
++
++ /**
++ * List of server to use for the connection setup
++ */
++ ServerEntry[] m_dsList;
++ 
++ /**
++ * Index of the last connected server
++ */ 
++ private int m_dsIdx = -1;
++
++ /**
++ * Socket factory for SSL connections
++ */
++ LDAPSocketFactory m_factory;
++ 
++ /**
++ * Connection setup policy (PARALLEL or SERIAL)
++ */
++ int m_policy = SERIAL;
++ 
++ /**
++ * Delay in ms before another connection setup thread is started. 
++ */
++ int m_connSetupDelay = -1;
++
++ /**
++ * The maximum time to wait to established the connection
++ */
++ int m_connectTimeout = 0;
++
++ /**
++ * During connection setup, the current count of servers to which
++ * connection attmpt has been made 
++ */
++ private transient int m_attemptCnt = 0;
++
++ /**
++ * Constructor
++ * @param host list of host names to which to connect
++ * @param port list of port numbers corresponding to the host list
++ * @param factory socket factory for SSL connections 
++ */
++ LDAPConnSetupMgr(String[] hosts, int[] ports, LDAPSocketFactory factory) throws LDAPException{
++ m_dsList = new ServerEntry[hosts.length];
++ boolean secure = (factory != null);
++ for (int i=0; i < hosts.length; i++) {
++ String url = secure ? "ldaps://" : "ldap://"; 
++ url += hosts[i] + ":" + ports[i];
++ try { 
++ m_dsList[i] = new ServerEntry(new LDAPUrl(url), NEVER_USED);
++ }
++ catch (MalformedURLException ex) {
++ throw new LDAPException("Invalid host:port " + hosts[i]+":"+ports[i],
++ LDAPException.PARAM_ERROR); 
++ }
++ }
++ m_factory = factory;
++ }
++
++ LDAPConnSetupMgr(String[] urls, LDAPSocketFactory factory) throws LDAPException{
++ m_dsList = new ServerEntry[urls.length];
++ for (int i=0; i < urls.length; i++) {
++ try {
++ LDAPUrl url = new LDAPUrl(urls[i]);
++ m_dsList[i] = new ServerEntry(url, NEVER_USED);
++ }
++ catch (MalformedURLException ex) {
++ throw new LDAPException("Malformed LDAP URL " + urls[i],
++ LDAPException.PARAM_ERROR);
++ }
++ }
++ m_factory = factory;
++ }
++
++ LDAPConnSetupMgr(LDAPUrl[] urls, LDAPSocketFactory factory) throws LDAPException{
++ m_dsList = new ServerEntry[urls.length];
++ for (int i=0; i < urls.length; i++) {
++ m_dsList[i] = new ServerEntry(urls[i], NEVER_USED);
++ }
++ m_factory = factory;
++ }
++
++ /**
++ * Try to open the connection to any of the servers in the list, limiting
++ * the time waiting for the connection to be established
++ * @return connection socket
++ */
++ synchronized Socket openConnection() throws LDAPException{
++ 
++ long tcur=0, tmax = Long.MAX_VALUE;
++ Thread th = null; 
++ 
++ reset();
++ 
++ // If reconnecting, sort dsList so that servers more likly to
++ // be available are tried first
++ sortDsList();
++ 
++ if (m_connectTimeout == 0) {
++ // No need for a separate thread, connect time not limited
++ connect();
++ }
++ else {
++ 
++ // Wait for connection at most m_connectTimeout milliseconds
++ // Run connection setup in a separate thread to monitor the time
++ tmax = System.currentTimeMillis() + m_connectTimeout;
++ th = new Thread (new Runnable() {
++ public void run() {
++ connect();
++ }
++ }, "ConnSetupMgr");
++ th.setDaemon(true);
++ th.start();
++ 
++ while (m_socket==null && (m_attemptCnt < m_dsList.length) &&
++ (tcur = System.currentTimeMillis()) < tmax) {
++ try {
++ wait(tmax - tcur);
++ }
++ catch (InterruptedException e) {
++ th.interrupt();
++ cleanup();
++ throw new LDAPInterruptedException("Interrupted connect operation");
++ }
++ }
++ }
++
++ if (m_socket != null) {
++ return m_socket;
++ }
++
++ if ( th != null && (tcur = System.currentTimeMillis()) >= tmax) {
++ // We have timed out 
++ th.interrupt();
++ cleanup();
++ throw new LDAPException(
++ "Connect timeout, " + getServerList() + " might be unreachable",
++ LDAPException.CONNECT_ERROR);
++ }
++
++ if (m_connException != null && m_dsList.length == 1) {
++ throw m_connException;
++ }
++
++ throw new LDAPException(
++ "Failed to connect to server " + getServerList(),
++ LDAPException.CONNECT_ERROR);
++ }
++
++ private void reset() {
++ m_socket = null;
++ m_origSocket = null;
++ m_connException = null;
++ m_attemptCnt = 0;
++ 
++ for (int i=0; i < m_dsList.length; i++) {
++ m_dsList[i].connSetupThread = null;
++ } 
++ }
++ 
++ private String getServerList() {
++ StringBuffer sb = new StringBuffer();
++ for (int i=0; i < m_dsList.length; i++) {
++ sb.append(i==0 ? "" : " ");
++ sb.append(m_dsList[i].url.getHost());
++ sb.append(":");
++ sb.append(m_dsList[i].url.getPort());
++ }
++ return sb.toString();
++ }
++
++ private void connect() {
++ 
++ if (m_policy == SERIAL || m_dsList.length == 1) {
++ openSerial();
++ }
++ else {
++ openParallel();
++ } 
++ }
++
++ /**
++ * Called when the current connection is lost.
++ * Put the connected server at the end of the server list for
++ * the next connect attempt. 
++ */
++ synchronized void invalidateConnection() {
++ if (m_socket != null) {
++ m_dsList[m_dsIdx].connSetupStatus = FAILED;
++ 
++ // Move the entry to the end of the list
++ int srvCnt = m_dsList.length, j=0; 
++ ServerEntry[] newDsList = new ServerEntry[m_dsList.length];
++ for (int i=0; i < srvCnt; i++) {
++ if (i != m_dsIdx) {
++ newDsList[j++] = m_dsList[i];
++ }
++ }
++ newDsList[j] = m_dsList[m_dsIdx];
++ m_dsList = newDsList;
++ m_dsIdx = j;
++ 
++ try {
++ m_socket.close();
++ } catch (Exception e) {
++ } finally {
++ m_socket = null;
++ }
++ 
++ }
++
++ if (m_origSocket != null) {
++
++ try {
++ m_origSocket.close();
++ } catch (Exception e) {
++ } finally {
++ m_origSocket = null;
++ }
++ } 
++ }
++ 
++ /**
++ * Called when the current connection is terminated by the user.
++ * Mark the connected server status as DISCONNECTED. This will
++ * put it at top of the server list for the next connect attempt.
++ */
++ void closeConnection() {
++ if (m_socket != null) {
++
++ m_dsList[m_dsIdx].connSetupStatus = DISCONNECTED;
++ 
++ try {
++ m_socket.close();
++ } catch (Exception e) {
++ } finally {
++ m_socket = null;
++ }
++ }
++
++ if (m_origSocket != null) {
++
++ try {
++ m_origSocket.close();
++ } catch (Exception e) {
++ } finally {
++ m_origSocket = null;
++ }
++ }
++ }
++
++ Socket getSocket() {
++ return m_socket;
++ }
++
++ /**
++ * Layer a new socket over the existing one (used by startTLS)
++ */
++ void layerSocket(LDAPTLSSocketFactory factory) throws LDAPException{
++ Socket s = factory.makeSocket(m_socket);
++ m_origSocket = m_socket;
++ m_socket = s;
++ }
++ 
++ String getHost() {
++ if (m_dsIdx >= 0) {
++ return m_dsList[m_dsIdx].url.getHost();
++ }
++ return m_dsList[0].url.getHost();
++ }
++ 
++ int getPort() {
++ if (m_dsIdx >= 0) {
++ return m_dsList[m_dsIdx].url.getPort();
++ }
++ return m_dsList[0].url.getPort();
++ }
++
++ boolean isSecure() {
++ if (m_dsIdx >= 0) {
++ return m_dsList[m_dsIdx].url.isSecure();
++ }
++ return m_dsList[0].url.isSecure();
++ }
++
++ LDAPUrl getLDAPUrl() {
++ if (m_dsIdx >= 0) {
++ return m_dsList[m_dsIdx].url;
++ }
++ return m_dsList[0].url;
++ }
++
++ int getConnSetupDelay() {
++ return m_connSetupDelay/1000;
++ }
++ 
++ /**
++ * Selects the connection failover policy
++ * @param delay in seconds for the parallel connection setup policy.
++ * Possible values are: (delay=-1) use serial policy, 
++ * (delay=0) start immediately concurrent threads to each specified server
++ * (delay>0) create a new connection setup thread after delay seconds
++ */
++ void setConnSetupDelay(int delay) {
++ m_policy = (delay < 0) ? SERIAL : PARALLEL; 
++ m_connSetupDelay = delay*1000;
++ 
++ }
++ 
++ int getConnectTimeout() {
++ return m_connectTimeout/1000;
++ }
++
++ /**
++ * Sets the maximum time to spend in the openConnection() call
++ * @param timeout in seconds to wait for the connection to be established
++ */
++ void setConnectTimeout(int timeout) {
++ m_connectTimeout = timeout*1000;
++ }
++ 
++ /**
++ * Check if the user has voluntarily closed the connection
++ */
++ boolean isUserDisconnected() {
++ return (m_dsIdx >=0 &&
++ m_dsList[m_dsIdx].connSetupStatus == DISCONNECTED);
++ }
++ 
++ /**
++ * Try sequentially to open a new connection to a server. 
++ */
++ private void openSerial() {
++ for (int i=0; i < m_dsList.length; i++) {
++ m_dsList[i].connSetupThread = Thread.currentThread();
++ connectServer(i);
++ if (m_socket != null) {
++ return;
++ } 
++ } 
++ }
++ 
++ /**
++ * Try concurrently to open a new connection a server. Create a separate
++ * thread for each connection attempt.
++ */
++ private synchronized void openParallel() {
++ for (int i=0; m_socket==null && i < m_dsList.length; i++) {
++ 
++ //Create a Thread to execute connectSetver()
++ final int dsIdx = i;
++ String threadName = "ConnSetupMgr " + m_dsList[dsIdx].url;
++ Thread t = new Thread(new Runnable() {
++ public void run() {
++ connectServer(dsIdx);
++ }
++ }, threadName);
++
++ m_dsList[dsIdx].connSetupThread = t;
++ t.setDaemon(true);
++ t.start();
++ 
++ // Wait before starting another thread if the delay is not zero
++ if (m_connSetupDelay != 0 && i < (m_dsList.length-1)) {
++ try {
++ wait(m_connSetupDelay);
++ }
++ catch (InterruptedException e) {
++ return;
++ }
++ }
++ } 
++
++ // At this point all threads are started. Wait until first thread
++ // succeeds to connect or all threads terminate
++ 
++ while (m_socket == null && (m_attemptCnt < m_dsList.length)) {
++ 
++ // Wait for a thread to terminate
++ try {
++ wait();
++ }
++ catch (InterruptedException e) {}
++ }
++ }
++
++ /**
++ * Connect to the server at the given index
++ */ 
++ void connectServer(int idx) {
++ ServerEntry entry = m_dsList[idx];
++ Thread currThread = Thread.currentThread();
++ Socket sock = null;
++ LDAPException conex = null;
++
++ try {
++ /* If we are to create a socket ourselves, make sure it has
++ sufficient privileges to connect to the desired host */
++ if (!entry.url.isSecure()) {
++ sock = new Socket (entry.url.getHost(), entry.url.getPort());
++ } else {
++ LDAPSocketFactory factory = m_factory;
++ if (factory == null) {
++ factory = entry.url.getSocketFactory();
++ }
++ if (factory == null) {
++ throw new LDAPException("Can not connect, no socket factory " + entry.url,
++ LDAPException.OTHER);
++ }
++ sock = factory.makeSocket(entry.url.getHost(), entry.url.getPort());
++ }
++
++ sock.setTcpNoDelay( true );
++ }
++ catch (IOException e) { 
++ conex = new LDAPException("failed to connect to server " 
++ + entry.url, LDAPException.CONNECT_ERROR);
++ }
++ catch (LDAPException e) { 
++ conex = e;
++ }
++ 
++ if (currThread.isInterrupted()) {
++ return;
++ }
++ 
++ synchronized (this) {
++ if (m_socket == null && entry.connSetupThread == currThread) {
++ entry.connSetupThread = null;
++ if (sock != null) {
++ entry.connSetupStatus = CONNECTED;
++ m_socket = sock;
++ m_dsIdx = idx;
++ cleanup(); // Signal other concurrent threads to terminate
++ }
++ else {
++ entry.connSetupStatus = FAILED;
++ m_connException = conex;
++ }
++ m_attemptCnt++;
++ notifyAll();
++ } 
++ }
++ } 
++
++ /**
++ * Terminate all concurrently running connection setup threads
++ */
++ private synchronized void cleanup() {
++ Thread currThread = Thread.currentThread();
++ for (int i=0; i < m_dsList.length; i++) {
++ ServerEntry entry = m_dsList[i];
++ if (entry.connSetupThread != null && entry.connSetupThread != currThread) {
++ 
++ entry.connSetupStatus = INTERRUPTED;
++ //Thread.stop() is considered to be dangerous, use Thread.interrupt().
++ //interrupt() will however not work if the thread is blocked in the
++ //socket library native connect() call, but the connect() will
++ //eventually timeout and the thread will die.
++ entry.connSetupThread.interrupt();
++ 
++ entry.connSetupThread = null; 
++ }
++ }
++ } 
++
++
++ /**
++ * Sorts Server List so that servers which are more likely to be available
++ * are tried first. The likelihood of making a successful connection
++ * is determined by the connSetupStatus. Lower values have higher
++ * likelihood. Thus, the order of server access is (1) disconnected by
++ * the user (2) never used (3) interrupted connection attempt
++ * (4) connection setup failed/connection lost
++ */
++ private void sortDsList() {
++ int srvCnt = m_dsList.length;
++ for (int i=1; i < srvCnt; i++) {
++ for (int j=0; j < i; j++) {
++ if (m_dsList[i].connSetupStatus < m_dsList[j].connSetupStatus) {
++ // swap entries
++ ServerEntry entry = m_dsList[j];
++ m_dsList[j] = m_dsList[i];
++ m_dsList[i] = entry;
++ }
++ }
++ }
++ } 
++
++ /**
++ * This is used only by the ldapjdk test libaray to simulate a
++ * server problem and to test fail-over and rebind
++ * @return A flag whether the connection was closed
++ */
++ boolean breakConnection() {
++ try { 
++ m_socket.close();
++ return true;
++ }
++ catch (Exception e) {
++ return false;
++ }
++ } 
++
++ public String toString() {
++ String str = "dsIdx="+m_dsIdx+ " dsList=";
++ for (int i=0; i < m_dsList.length; i++) {
++ str += m_dsList[i]+ " ";
++ }
++ return str;
++ }
++}
+--- /dev/null
++++ ldapjdk-4.18/mozilla/directory/java-sdk/src/netscape/ldap/LDAPMatchingRuleUseSchema.java
+@@ -0,0 +1,235 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
++ *
++ * ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org code.
++ *
++ * The Initial Developer of the Original Code is
++ * Netscape Communications Corporation.
++ * Portions created by the Initial Developer are Copyright (C) 2000
++ * the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++package netscape.ldap;
++
++import java.util.*;
++
++/**
++ * The definition of a matching rule use in the schema.
++ * <A HREF="http://ds.internic.net/rfc/rfc2252.txt"
++ * TARGET="_blank">RFC 2252, Lightweight Directory Access Protocol (v3):
++ * Attribute Syntax Definitions</A> covers the types of information
++ * that need to be specified in the definition of a matching rule use.
++ * According to the RFC, the description of a matching rule use can
++ * include the following information:
++ * 
++ *
++ * <UL>
++ * <LI>an OID identifying the matching rule
++ * <LI>a name identifying the matching rule use
++ * <LI>a description of the matching rule use
++ * <LI>a list of attributes the matching rule applies to
++ * </UL>
++ * 
++ *
++ * When you construct an <CODE>LDAPMatchingRuleUseSchema</CODE> object, you can
++ * specify these types of information as arguments to the constructor or
++ * in the MatchingRuleUseDescription format specified in RFC 2252.
++ * When an LDAP client searches an LDAP server for the schema, the server
++ * returns schema information as an object with values in this
++ * format.
++ * 
++ *
++ * You can get the name, OID, and description of this matching rule use
++ * definition by using the <CODE>getName</CODE>, <CODE>getOID</CODE>, and
++ * <CODE>getDescription</CODE> methods inherited from the abstract class
++ * <CODE>LDAPSchemaElement</CODE>. Custom qualifiers are
++ * accessed with <CODE>getQualifier</CODE> and <CODE>getQualifierNames</CODE>
++ * from <CODE>LDAPSchemaElement</CODE>.
++ * 
++ *
++ * To add or remove this matching rule definition from the
++ * schema, use the <CODE>add</CODE> and <CODE>remove</CODE>
++ * methods, which this class inherits from the <CODE>LDAPSchemaElement</CODE>
++ * abstract class.
++ * 
++ * RFC 2252 defines MatchingRuleUseDescription follows:
++ * 
++ * <PRE>
++ * Values of the matchingRuleUse list the attributes which are suitable
++ * for use with an extensible matching rule.
++ *
++ * MatchingRuleUseDescription = "(" whsp
++ * numericoid whsp ; MatchingRule identifier
++ * [ "NAME" qdescrs ]
++ * [ "DESC" qdstring ]
++ * [ "OBSOLETE" ]
++ * "APPLIES" oids ; AttributeType identifiers
++ * whsp ")"
++ * </PRE>
++ * 
++ *
++ * @version 1.0
++ * @see netscape.ldap.LDAPSchemaElement
++ * @see netscape.ldap.LDAPMatchingRuleSchema
++ **/
++
++public class LDAPMatchingRuleUseSchema extends LDAPAttributeSchema {
++
++
++
++ /**
++ * Constructs a matching rule use definition, using the specified
++ * information.
++ * @param name name of the matching rule
++ * @param oid object identifier (OID) of the matching rule
++ * in dotted-decimal format (for example, "1.2.3.4")
++ * @param description description of the matching rule
++ * @param attributes array of the OIDs of the attributes for which
++ * the matching rule is applicable
++ */
++ public LDAPMatchingRuleUseSchema( String name, String oid,
++ String description,
++ String[] attributes ) {
++ if ( (oid == null) || (oid.trim().length() < 1) ) {
++ throw new IllegalArgumentException( "OID required" );
++ }
++ this.name = name;
++ this.oid = oid;
++ this.description = description;
++ attrName = "matchingruleuse";
++ this.attributes = new String[attributes.length];
++ for( int i = 0; i < attributes.length; i++ ) {
++ this.attributes[i] = attributes[i];
++ }
++ }
++
++ /**
++ * Constructs a matching rule use definition based on descriptions in
++ * the MatchingRuleUseDescription format. For information on this format,
++ * (see <A HREF="http://ds.internic.net/rfc/rfc2252.txt"
++ * TARGET="_blank">RFC 2252, Lightweight Directory Access Protocol (v3):
++ * Attribute Syntax Definitions</A>. This is the format that LDAP servers
++ * and clients use to exchange schema information. For example, when
++ * you search an LDAP server for its schema, the server returns an entry
++ * with attributes that include "matchingrule" and "matchingruleuse".
++ * The values of these attributes are matching rule descriptions
++ * in this format.
++ * 
++ *
++ * @param use definition of the use of the matching rule in the
++ * MatchingRuleUseDescription format
++ */
++ public LDAPMatchingRuleUseSchema( String use ) {
++ attrName = "matchingruleuse";
++ parseValue( use );
++	Object p = properties.get( "APPLIES" );
++	if ( p instanceof Vector ) {
++		Vector v = (Vector)p;
++		if ( v != null ) {
++			attributes = new String[v.size()];
++			v.copyInto( attributes );
++			v.removeAllElements();
++		}
++	}
++	else if ( p instanceof String ) {
++		attributes = new String[1];
++		attributes[0] = (String)p;
++ }
++ }
++
++ /**
++ * Gets the list of the OIDs of the attribute types which can be used
++ * with the matching rule.
++ * @return array of the OIDs of the attribute types which can be used
++ * with the matching rule.
++ */
++ public String[] getApplicableAttributes() {
++ return attributes;
++ }
++
++ /**
++ * Gets the matching rule use definition in the string representation
++ * of the MatchingRuleUseDescription data type defined in X.501 (see
++ * <A HREF="http://ds.internic.net/rfc/rfc2252.txt"
++ * TARGET="_blank">RFC 2252, Lightweight Directory Access Protocol
++ * (v3): Attribute Syntax Definitions</A>
++ * for a description of these formats).
++ * This is the format that LDAP servers and clients use to exchange
++ * schema information. (For example, when
++ * you search an LDAP server for its schema, the server returns an entry
++ * with the attributes "matchingrules" and "matchingruleuse". The
++ * values of these attributes are matching rule description and
++ * matching rule use description in these formats.)
++ * 
++ *
++ * @return a string in a format that can be used as the value of
++ * the <CODE>matchingruleuse</CODE> attribute (which describes the use of
++ * a matching rule in the schema) of a <CODE>subschema</CODE> object
++ */
++ public String getValue() {
++ String s = getValuePrefix();
++ if ( (attributes != null) && (attributes.length > 0) ) {
++ s += "APPLIES ( ";
++ for( int i = 0; i < attributes.length; i++ ) {
++ if ( i > 0 )
++ s += " $ ";
++ s += attributes[i];
++ }
++ s += " ) ";
++ }
++ s += ')';
++ return s;
++ }
++
++ /**
++ * Gets the definition of the matching rule use in a user friendly format.
++ * This is the format that the matching rule use definition uses when
++ * you print the matching rule or the schema.
++ * @return definition of the matching rule in a user friendly format.
++ */
++ public String toString() {
++ String s = "Name: " + name + "; OID: " + oid;
++ s += "; Description: " + description;
++ if ( attributes != null ) {
++ s += "; Applies to: ";
++ for( int i = 0; i < attributes.length; i++ ) {
++ if ( i > 0 )
++ s += ", ";
++ s += attributes[i];
++ }
++ }
++ s += getQualifierString( EXPLICIT );
++ return s;
++ }
++
++ // Qualifiers tracked explicitly
++ static final String[] EXPLICIT = { OBSOLETE };
++ 
++ private String[] attributes = null;
++}
+--- /dev/null
++++ ldapjdk-4.18/mozilla/directory/java-sdk/src/netscape/ldap/LDAPConnection.java
+@@ -0,0 +1,5443 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
++ *
++ * ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org code.
++ *
++ * The Initial Developer of the Original Code is
++ * Netscape Communications Corporation.
++ * Portions created by the Initial Developer are Copyright (C) 1999
++ * the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++package netscape.ldap;
++
++import java.util.*;
++import netscape.ldap.client.*;
++import netscape.ldap.client.opers.*;
++import netscape.ldap.ber.stream.*;
++import netscape.ldap.util.*;
++import java.io.*;
++import java.net.*;
++
++/**
++ * Represents a connection to an LDAP server. 
++ *
++ * Use objects of this class to perform LDAP operations (such as
++ * search, modify, and add) on an LDAP server. 
++ *
++ * To perform an LDAP operation on a server, you need to follow
++ * these steps: 
++ *
++ * <OL>
++ * <LI>Create a new <CODE>LDAPConnection</CODE> object.
++ * <LI>Use the <CODE>connect</CODE> method to connect to the
++ * LDAP server.
++ * <LI>Use the <CODE>authenticate</CODE> method to authenticate
++ * to server.
++ * <LI>Perform the LDAP operation.
++ * <LI>Use the <CODE>disconnect</CODE> method to disconnect from
++ * the server when done.
++ * </OL>
++ * 
++ *
++ * All operations block until completion (with the exception of
++ * the search method in which the results may not all return at
++ * the same time).
++ * 
++ *
++ * This class also specifies a default set of constraints
++ * (such as the maximum length of time to allow for an operation before timing out)
++ * which apply to all operations. To get and set these constraints,
++ * use the <CODE>getOption</CODE> and <CODE>setOption</CODE> methods.
++ * To override these constraints for an individual operation,
++ * define a new set of constraints by creating a <CODE>LDAPConstraints</CODE>
++ * object and pass the object to the method for the operation. For search 
++ * operations, additional constraints are defined in <CODE>LDAPSearchConstraints</CODE>
++ * (a subclass of <CODE>LDAPConstraints</CODE>). To override the default search
++ * constraints, create an <CODE>LDAPSearchConstraints</CODE> object and pass it
++ * to the <CODE>search</CODE> method.
++ * 
++ *
++ * If you set up your client to follow referrals automatically,
++ * an operation that results in a referral will create a new connection
++ * to the LDAP server identified in the referral. In order to have
++ * your client authenticate to that LDAP server automatically, you need
++ * to define a class that implements the <CODE>LDAPRebind</CODE> interface.
++ * In your definition of the class, you need to define a
++ * <CODE>getRebindAuthentication</CODE> method that creates an <CODE>LDAPRebindAuth</CODE>
++ * object containing the distinguished name and password to use for reauthentication.
++ * 
++ *
++ * Most errors that occur raise the same exception (<CODE>LDAPException</CODE>).
++ * In order to determine the exact problem that occurred, you can retrieve the
++ * result code from this exception and compare its value against a set of defined
++ * result codes.
++ * 
++ *
++ * @version 1.0
++ * @see netscape.ldap.LDAPConstraints
++ * @see netscape.ldap.LDAPSearchConstraints
++ * @see netscape.ldap.LDAPRebind
++ * @see netscape.ldap.LDAPRebindAuth
++ * @see netscape.ldap.LDAPException
++ */
++public class LDAPConnection
++ implements LDAPv3, LDAPAsynchronousConnection, Cloneable, Serializable {
++
++ static final long serialVersionUID = -8698420087475771145L;
++
++ /**
++ * Version of the LDAP protocol used by default.
++ * <CODE>LDAP_VERSION</CODE> is 2, so your client will
++ * attempt to authenticate to LDAP servers as an LDAP v2 client.
++ * The following is an example of some code that prints the
++ * value of this variable:
++ * 
++ *
++ * <PRE>
++ * LDAPConnection ld = new LDAPConnection();
++ * System.out.println( "The default LDAP protocol version used is "
++ * ld.LDAP_VERSION );
++ * </PRE>
++ *
++ * If you want to authenticate as an LDAP v3 client,
++ * use the <A HREF="#authenticate(int, java.lang.String, java.lang.String)"><CODE>authenticate(int version, String dn, String passwd)</CODE></A> method.
++ * For example:
++ * 
++ *
++ * <PRE>
++ * ld.authenticate( 3, myDN, myPW );
++ * </PRE>
++ *
++ * @see netscape.ldap.LDAPConnection#authenticate(int, java.lang.String, java.lang.String)
++ */
++ public final static int LDAP_VERSION = 2;
++ /**
++ * Name of the property specifying the version of the SDK. 
++ *
++ * To get the version number, pass this name to the
++ * <CODE>getProperty</CODE> method. The SDK version number
++ * is of the type <CODE>Float</CODE>. For example:
++ * <PRE>
++ * ...
++ * Float sdkVersion = ( Float )myConn.getProperty( myConn.LDAP_PROPERTY_SDK );
++ * System.out.println( "SDK version: " + sdkVersion );
++ * ... </PRE>
++ * @see netscape.ldap.LDAPConnection#getProperty(java.lang.String)
++ */
++ public final static String LDAP_PROPERTY_SDK = "version.sdk";
++ /**
++ * Name of the property specifying the highest supported version of
++ * the LDAP protocol. 
++ *
++ * To get the version number, pass this name to the
++ * <CODE>getProperty</CODE> method. The LDAP protocol version number
++ * is of the type <CODE>Float</CODE>. For example:
++ * <PRE>
++ * ...
++ * Float LDAPVersion = ( Float )myConn.getProperty( myConn.LDAP_PROPERTY_PROTOCOL );
++ * System.out.println( "Highest supported LDAP protocol version: " + LDAPVersion );
++ * ... </PRE>
++ * @see netscape.ldap.LDAPConnection#getProperty(java.lang.String)
++ */
++ public final static String LDAP_PROPERTY_PROTOCOL = "version.protocol";
++ /**
++ * Name of the property specifying the types of authentication allowed by this
++ * API (for example, anonymous authentication and simple authentication). 
++ *
++ * To get the supported types, pass this name to the
++ * <CODE>getProperty</CODE> method. The value of this property is
++ * of the type <CODE>String</CODE>. For example:
++ * <PRE>
++ * ...
++ * String authTypes = ( String )myConn.getProperty( myConn.LDAP_PROPERTY_SECURITY );
++ * System.out.println( "Supported authentication types: " + authTypes );
++ * ... </PRE>
++ * @see netscape.ldap.LDAPConnection#getProperty(java.lang.String)
++ */
++ public final static String LDAP_PROPERTY_SECURITY = "version.security";
++
++ /**
++ * Name of the property to enable/disable LDAP message trace. 
++ *
++ * The property can be specified either as a system property 
++ * (java -D command line option), or programmatically with the
++ * <CODE>setProperty</CODE> method.
++ * 
++ * When -D command line option is used, defining the property with
++ * no value will send the trace output to the standard error. If the 
++ * value is defined, it is assumed to be the name of an output file.
++ * If the file name is prefixed with a '+' character, the file is
++ * opened in append mode.
++ * 
++ * When the property is set with the <CODE>getProperty</CODE> method,
++ * the property value must be either a String (represents a file name)
++ * an OutputStream or an instance of LDAPTraceWriter. To stop tracing,
++ * <CODE>null</CODE> should be passed as the property value.
++ * 
++ * @see netscape.ldap.LDAPConnection#setProperty(java.lang.String, java.lang.Object)
++ */
++ public final static String TRACE_PROPERTY = "com.netscape.ldap.trace";
++
++ /**
++ * Specifies the serial connection setup policy when a list of hosts is
++ * passed to the <CODE>connect</CODE> method.
++ * @see netscape.ldap.LDAPConnection#setConnSetupDelay(int)
++ */ 
++ public final static int NODELAY_SERIAL = -1;
++ /**
++ * Specifies the parallel connection setup policy with no delay when a
++ * list of hosts is passed to the <CODE>connect</CODE> method.
++ * For each host in the list, a separate thread is created to attempt
++ * to connect to the host. All threads are started simultaneously.
++ * @see netscape.ldap.LDAPConnection#setConnSetupDelay(int)
++ */ 
++ public final static int NODELAY_PARALLEL = 0;
++
++ /**
++ * Constants
++ */
++ private final static String defaultFilter = "(objectClass=*)";
++ /**
++ * Internal variables
++ */
++ private LDAPSearchConstraints m_defaultConstraints =
++ new LDAPSearchConstraints();
++ 
++ // A clone of constraints for the successful bind. Used by 
++ // "smart failover" for the automatic rebind
++ private LDAPConstraints m_rebindConstraints;
++
++ private Vector m_responseListeners;
++ private Vector m_searchListeners;
++
++ private String m_boundDN;
++ private String m_boundPasswd;
++ private int m_protocolVersion = LDAP_VERSION;
++ 
++ private LDAPConnSetupMgr m_connMgr;
++ private int m_connSetupDelay = -1;
++ private int m_connectTimeout = 0;
++ private LDAPSocketFactory m_factory;
++
++ // A flag if m_factory is used to start TLS
++ private boolean m_isTLSFactory;
++ 
++ /* m_thread does all socket i/o for the object and any clones */
++ private transient LDAPConnThread m_thread = null;
++
++ /* To manage received server controls on a per-thread basis */
++ private Hashtable m_responseControlTable = new Hashtable();
++ private LDAPCache m_cache = null;
++
++ // A flag set if startTLS() called successfully
++ private boolean m_useTLS;
++
++ // OID for the extended operation startTLS
++ final static String OID_startTLS = "1.3.6.1.4.1.1466.20037"; 
++
++ private Object m_security = null;
++ private LDAPSaslBind m_saslBinder = null;
++ private Properties m_securityProperties;
++ private Hashtable m_properties = new Hashtable();
++ private LDAPConnection m_referralConnection;
++
++ /**
++ * Properties
++ */
++ private final static Float SdkVersion = new Float(4.18f);
++ private final static Float ProtocolVersion = new Float(3.0f);
++ private final static String SecurityVersion = new String("none,simple,sasl");
++ private final static Float MajorVersion = new Float(4.0f);
++ private final static Float MinorVersion = new Float(0.18f);
++ private final static String DELIM = "#";
++ private final static String PersistSearchPackageName =
++ "netscape.ldap.controls.LDAPPersistSearchControl";
++ final static String EXTERNAL_MECHANISM = "external";
++ private final static String EXTERNAL_MECHANISM_PACKAGE =
++ "com.netscape.sasl";
++ final static String DEFAULT_SASL_PACKAGE =
++ "com.netscape.sasl";
++ final static String SCHEMA_BUG_PROPERTY =
++ "com.netscape.ldap.schema.quoting";
++ final static String SASL_PACKAGE_PROPERTY =
++ "com.netscape.ldap.saslpackage";
++
++ /**
++ * Constructs a new <CODE>LDAPConnection</CODE> object,
++ * which represents a connection to an LDAP server. 
++ *
++ * Calling the constructor does not actually establish
++ * the connection. To connect to the LDAP server, use the
++ * <CODE>connect</CODE> method.
++ *
++ * @see netscape.ldap.LDAPConnection#connect(java.lang.String, int)
++ * @see netscape.ldap.LDAPConnection#authenticate(java.lang.String, java.lang.String)
++ */
++ public LDAPConnection () {
++ super();
++ m_factory = null;
++
++ m_properties.put(LDAP_PROPERTY_SDK, SdkVersion); 
++ m_properties.put(LDAP_PROPERTY_PROTOCOL, ProtocolVersion); 
++ m_properties.put(LDAP_PROPERTY_SECURITY, SecurityVersion); 
++ m_properties.put("version.major", MajorVersion); 
++ m_properties.put("version.minor", MinorVersion);
++ }
++
++ /**
++ * Constructs a new <CODE>LDAPConnection</CODE> object that
++ * will use the specified socket factory class to create
++ * socket connections. The socket factory class must implement
++ * the <CODE>LDAPSocketFactory</CODE> interface. 
++ * (For example, the <CODE>LDAPSSLSocketFactory</CODE>
++ * class implements this interface.)
++ * 
++ *
++ * Note that calling the <CODE>LDAPConnection</CODE> constructor
++ * does not actually establish a connection to an LDAP server.
++ * To connect to an LDAP server, use the
++ * <CODE>connect</CODE> method. The socket connection will be
++ * constructed when this method is called.
++ * 
++ *
++ * @see netscape.ldap.LDAPSocketFactory
++ * @see netscape.ldap.LDAPSSLSocketFactory
++ * @see netscape.ldap.LDAPConnection#connect(java.lang.String, int)
++ * @see netscape.ldap.LDAPConnection#authenticate(java.lang.String, java.lang.String)
++ * @see netscape.ldap.LDAPConnection#getSocketFactory
++ * @see netscape.ldap.LDAPConnection#setSocketFactory(netscape.ldap.LDAPSocketFactory)
++ */
++ public LDAPConnection ( LDAPSocketFactory factory ) {
++ this();
++ m_factory = factory;
++ }
++
++ /**
++ * Finalize method, which disconnects from the LDAP server.
++ * @exception LDAPException Thrown when the connection cannot be disconnected.
++ */
++ public void finalize() throws LDAPException {
++ if (isConnected()) {
++ disconnect();
++ }
++ }
++
++ /**
++ * Sets the specified <CODE>LDAPCache</CODE> object as the
++ * cache for the <CODE>LDAPConnection</CODE> object.
++ * 
++ *
++ * @param cache the <CODE>LDAPCache</CODE> object representing
++ * the cache that the current connection should use
++ * @see netscape.ldap.LDAPCache
++ * @see netscape.ldap.LDAPConnection#getCache
++ */
++ public void setCache(LDAPCache cache) {
++ if (m_cache != null) {
++ m_cache.removeReference();
++ }
++ if (cache != null) {
++ cache.addReference();
++ }
++ m_cache = cache;
++ if ( m_thread != null ) {
++ m_thread.setCache( cache );
++ }
++ }
++
++ /**
++ * Gets the <CODE>LDAPCache</CODE> object associated with
++ * the current <CODE>LDAPConnection</CODE> object.
++ * 
++ *
++ * @return the <CODE>LDAPCache</CODE> object representing
++ * the cache that the current connection should use
++ * @see netscape.ldap.LDAPCache
++ * @see netscape.ldap.LDAPConnection#setCache(netscape.ldap.LDAPCache)
++ */
++ public LDAPCache getCache() {
++ return m_cache;
++ }
++
++ /**
++ * Gets a property of a connection. 
++ *
++ * You can get the following properties for a given connection: 
++ * <UL TYPE="DISC">
++ * <LI><CODE>LDAP_PROPERTY_SDK</CODE> 
++ * To get the version of this SDK, get this property. The value of
++ * this property is of the type <CODE>Float</CODE>. 
++ * <LI><CODE>LDAP_PROPERTY_PROTOCOL</CODE> 
++ * To get the highest supported version of the LDAP protocol, get
++ * this property.
++ * The value of this property is of the type <CODE>Float</CODE>. 
++ * <LI><CODE>LDAP_PROPERTY_SECURITY</CODE> 
++ * To get a comma-separated list of the types of authentication
++ * supported, get this property. The value of this property is of the
++ * type <CODE>String</CODE>. 
++ * </UL>
++ * 
++ *
++ * For example, the following section of code gets the version of
++ * the SDK.
++ *
++ * <PRE>
++ * ...
++ * Float sdkVersion = ( Float )myConn.getProperty( myConn.LDAP_PROPERTY_SDK );
++ * System.out.println( "SDK version: " + sdkVersion );
++ * ... </PRE>
++ *
++ * @param name name of the property (for example, <CODE>LDAP_PROPERTY_SDK</CODE>) 
++ *
++ * @return the value of the property. 
++ *
++ * Since the return value is an object, you should recast it as the appropriate type.
++ * (For example, when getting the <CODE>LDAP_PROPERTY_SDK</CODE> property,
++ * recast the return value as a <CODE>Float</CODE>.) 
++ *
++ * If you pass this method an unknown property name, the method
++ * returns null. 
++ *
++ * @exception LDAPException Unable to get the value of the
++ * specified property. 
++ *
++ * @see netscape.ldap.LDAPConnection#LDAP_PROPERTY_SDK
++ * @see netscape.ldap.LDAPConnection#LDAP_PROPERTY_PROTOCOL
++ * @see netscape.ldap.LDAPConnection#LDAP_PROPERTY_SECURITY
++ */
++ public Object getProperty(String name) throws LDAPException {
++ return m_properties.get( name );
++ }
++
++ /**
++ * Change a property of a connection. 
++ *
++ * The following properties are defined: 
++ * com.netscape.ldap.schema.quoting - "standard" or "NetscapeBug" 
++ * Note: if this property is not set, the SDK will query the server 
++ * to determine if attribute syntax values and objectclass superior 
++ * values must be quoted when adding schema. 
++ * com.netscape.ldap.saslpackage - the default is "com.netscape.sasl" 
++ * 
++ *
++ * @param name name of the property to set
++ * @param val value to set
++ * @exception LDAPException Unable to set the value of the specified
++ * property.
++ */
++ public void setProperty(String name, Object val) throws LDAPException {
++ if ( name.equalsIgnoreCase( SCHEMA_BUG_PROPERTY ) ) { 
++ m_properties.put( SCHEMA_BUG_PROPERTY, val ); 
++ } else if ( name.equalsIgnoreCase( SASL_PACKAGE_PROPERTY ) ) {
++ m_properties.put( SASL_PACKAGE_PROPERTY, val ); 
++ } else if ( name.equalsIgnoreCase( "debug" ) ) {
++ debug = ((String)val).equalsIgnoreCase( "true" ); 
++
++ } else if ( name.equalsIgnoreCase( TRACE_PROPERTY ) ) {
++
++ Object traceOutput = null;
++ if (val == null) {
++ m_properties.remove(TRACE_PROPERTY);
++ } 
++ else {
++ if (m_thread != null) {
++ traceOutput = createTraceOutput(val);
++ }
++ m_properties.put( TRACE_PROPERTY, val ); 
++ }
++
++ if (m_thread != null) {
++ m_thread.setTraceOutput(traceOutput);
++ }
++
++ // This is used only by the ldapjdk test cases to simulate a
++ // server problem and to test fail-over and rebind 
++ } else if ( name.equalsIgnoreCase( "breakConnection" ) ) {
++ m_connMgr.breakConnection();
++
++ } else {
++ throw new LDAPException("Unknown property: " + name);
++ }
++ }
++
++ /**
++ * Evaluate the TRACE_PROPERTY value and create output stream.
++ * The value can be of type String, OutputStream or LDAPTraceWriter.
++ * The String value represents output file name. If the name is an empty
++ * string, the output is sent to System.err. If the file name is
++ * prefixed with a '+' character, the file is opened in append mode.
++ *
++ * @param out Trace output specifier. A file name, an output stream 
++ * or an instance of LDAPTraceWriter
++ * @return An output stream or an LDAPTraceWriter instance
++ */
++ Object createTraceOutput(Object out) throws LDAPException {
++ 
++ if (out instanceof String) { // trace file name
++ OutputStream os = null;
++ String file = (String)out;
++ if (file.length() == 0) {
++ os = System.err;
++ }
++ else {
++ try {
++ boolean appendMode = (file.charAt(0) == '+');
++ if (appendMode) {
++ file = file.substring(1);
++ } 
++ FileOutputStream fos = new FileOutputStream(file, appendMode);
++ os = new BufferedOutputStream(fos);
++ }
++ catch (IOException e) {
++ throw new LDAPException(
++ "Can not open output trace file " + file + " " + e);
++ }
++ }
++ return os;
++ } 
++ else if (out instanceof OutputStream) {
++ return out;
++ } 
++ else if (out instanceof LDAPTraceWriter) {
++ return out;
++ } 
++ else {
++ throw new LDAPException(TRACE_PROPERTY + " must be an OutputStream, a file name or an instance of LDAPTraceWriter" );
++ }
++
++ }
++ 
++ /**
++ * Sets the LDAP protocol version that your client prefers to use when
++ * connecting to the LDAP server.
++ * 
++ *
++ * @param version the LDAP protocol version that your client uses
++ */
++ private void setProtocolVersion(int version) {
++ m_protocolVersion = version;
++ }
++
++ /**
++ * Returns the host name of the LDAP server to which you are connected.
++ * @return host name of the LDAP server.
++ */
++ public String getHost () {
++ if (m_connMgr != null) {
++ return m_connMgr.getHost();
++ }
++ return null;
++ }
++
++ /**
++ * Returns the port number of the LDAP server to which you are connected.
++ * @return port number of the LDAP server.
++ */
++ public int getPort () {
++ if (m_connMgr != null) {
++ return m_connMgr.getPort();
++ }
++ return -1;
++ }
++
++ /**
++ * Returns the distinguished name (DN) used for authentication over
++ * this connection.
++ * @return distinguished name used for authentication over this connection.
++ */
++ public String getAuthenticationDN () {
++ return m_boundDN;
++ }
++
++ /**
++ * Returns the password used for authentication over this connection.
++ * @return password used for authentication over this connection.
++ */
++ public String getAuthenticationPassword () {
++ return m_boundPasswd;
++ }
++ 
++ /**
++ * Returns the maximum time to wait for the connection to be established.
++ * @return the maximum connect time in seconds or 0 (unlimited)
++ * @see netscape.ldap.LDAPConnection#setConnectTimeout
++ */
++ public int getConnectTimeout () {
++ return m_connectTimeout;
++ }
++
++ /**
++ * Specifies the maximum time to wait for the connection to be established.
++ * If the value is 0, the time is not limited.
++ * @param timeout the maximum connect time in seconds or 0 (unlimited)
++ */
++ public void setConnectTimeout (int timeout) {
++ if (timeout < 0) {
++ throw new IllegalArgumentException("Timeout value can not be negative");
++ }
++ m_connectTimeout = timeout;
++ if (m_connMgr != null) {
++ m_connMgr.setConnectTimeout(m_connectTimeout);
++ }
++ }
++ 
++ /**
++ * Returns the delay in seconds when making concurrent connection attempts to
++ * multiple servers.
++ * @return the delay in seconds between connection attempts: 
++ * <CODE>NODELAY_SERIAL</CODE> The serial connection setup policy is enabled
++ * (no concurrency). 
++ * <CODE>NODELAY_PARALLEL</CODE> The parallel connection setup policy with no delay
++ * is enabled. 
++ * <CODE>delay > 0</CODE> The parallel connection setup policy with the delay of 
++ * <CODE>delay</CODE> seconds is enabled.
++ * @see netscape.ldap.LDAPConnection#setConnSetupDelay
++ */
++ public int getConnSetupDelay () {
++ return m_connSetupDelay;
++ }
++
++ /**
++ * Specifies the delay in seconds when making concurrent connection attempts to
++ * multiple servers.
++ * Effectively, selects the connection setup policy when a list of hosts is passed
++ * to the <CODE>connect</CODE> method.
++ * 
++ * If the serial policy is selected, the default one, an attempt is made to
++ * connect to the first host in the list. The next entry in
++ * the list is tried only if the attempt to connect to the current host fails.
++ * This might cause your application to block for unacceptably long time if a host is down.
++ *
++ * If the parallel policy is selected, multiple connection attempts may run
++ * concurrently on a separate thread. A new connection attempt to the next entry
++ * in the list can be started with or without delay.
++ * You must set the <CODE>ConnSetupDelay</CODE> before making the call to the 
++ * <CODE>connect</CODE> method.
++ * 
++ * @param delay the delay in seconds between connection attempts. Possible values are: 
++ * <CODE>NODELAY_SERIAL</CODE> Use the serial connection setup policy. 
++ * <CODE>NODELAY_PARALLEL</CODE> Use the parallel connection setup policy with no delay.
++ * Start all connection setup threads immediately. 
++ * <CODE>delay > 0</CODE> Use the parallel connection setup policy with delay.
++ * Start another connection setup thread after <CODE>delay</CODE> seconds. 
++ * @see netscape.ldap.LDAPConnection#NODELAY_SERIAL
++ * @see netscape.ldap.LDAPConnection#NODELAY_PARALLEL
++ * @see netscape.ldap.LDAPConnection#connect(java.lang.String, int)
++ */
++ public void setConnSetupDelay (int delay) {
++ m_connSetupDelay = delay;
++ if (m_connMgr != null) {
++ m_connMgr.setConnSetupDelay(delay);
++ }
++ }
++
++ /**
++ * Gets the object representing the socket factory used to establish
++ * a connection to the LDAP server or for the start TLS operation.
++ * 
++ *
++ * @return the object representing the socket factory used to
++ * establish a connection to a server or for the start TLS operation.
++ * @see netscape.ldap.LDAPSocketFactory
++ * @see netscape.ldap.LDAPSSLSocketFactory
++ * @see netscape.ldap.LDAPConnection#setSocketFactory(netscape.ldap.LDAPSocketFactory)
++ * @see netscape.ldap.LDAPConnection#startTLS
++ */
++ public LDAPSocketFactory getSocketFactory () {
++ return m_factory;
++ }
++
++ /**
++ * Specifies the object representing the socket factory that you
++ * want to use to establish a connection to a server or for the
++ * start TLS operation.
++ * 
++ * If the socket factory is to be used to establish a connection 
++ * <CODE>setSocketFactory()</CODE> must be called before 
++ * <CODE>connect()</CODE>. For the start TLS operation 
++ * <CODE>setSocketFactory()</CODE> must be called after <CODE>connect()</CODE>.
++ * @param factory the object representing the socket factory that
++ * you want to use to establish a connection to a server or for
++ * the start TLS operation.
++ * @see netscape.ldap.LDAPSocketFactory
++ * @see netscape.ldap.LDAPSSLSocketFactory
++ * @see netscape.ldap.LDAPConnection#getSocketFactory
++ * @see netscape.ldap.LDAPConnection#startTLS
++ */
++ public void setSocketFactory (LDAPSocketFactory factory) {
++ m_factory = factory;
++ m_isTLSFactory = false;
++ }
++
++ /**
++ * Indicates whether the connection represented by this object
++ * is open at this time.
++ * @return <CODE>true</CODE> if connected to an LDAP server over this connection.
++ * If not connected to an LDAP server, returns <CODE>false</CODE>.
++ */
++ public synchronized boolean isConnected() {
++ return m_thread != null && m_thread.isConnected();
++ }
++
++ /**
++ * Indicates whether this client has authenticated to the LDAP server
++ * @return <CODE>true,</CODE>, if authenticated. If not
++ * authenticated, or if authenticated as an anonymous user (with
++ * either a blank name or password), returns <CODE>false</CODE>.
++ */
++ public boolean isAuthenticated () {
++ boolean bound = false;
++ synchronized (this) {
++ bound = (m_thread != null) && m_thread.isBound();
++ }
++ return bound;
++ }
++
++ /**
++ * Mark the connection bind state
++ */
++ synchronized void setBound(boolean bound) {
++ if (m_thread != null) {
++ if (!bound) {
++ m_thread.setBound(false);
++ }
++ // sasl bind
++ else if (m_saslBinder != null) {
++ m_thread.setBound(true);
++ }
++ // simple bind
++ else {
++ m_thread.setBound(!isAnonymousUser());
++ }
++ }
++ }
++
++ 
++ boolean isAnonymousUser() {
++ return (m_boundDN == null) || m_boundDN.equals("") ||
++ (m_boundPasswd == null) || m_boundPasswd.equals(""); 
++ }
++ 
++ /**
++ * Connects to the specified host and port. If this LDAPConnection object
++ * represents an open connection, the connection is closed first
++ * before the new connection is opened.
++ * 
++ *
++ * For example, the following section of code establishes a connection with
++ * the LDAP server running on the host ldap.netscape.com and the port 389.
++ * 
++ *
++ * <PRE>
++ * String ldapHost = "ldap.netscape.com";
++ * int ldapPort = 389;
++ * LDAPConnection myConn = new LDAPConnection();
++ * try {
++ * myConn.connect( ldapHost, ldapPort );
++ * } catch ( LDAPException e ) {
++ * System.out.println( "Unable to connect to " + ldapHost +
++ * " at port " + ldapPort );
++ * return;
++ * }
++ * System.out.println( "Connected to " + ldapHost + " at port " + ldapPort )
++ * </PRE>
++ *
++ * You can limit the time spent waiting for the connection to be established
++ * by calling <CODE>setConnectTimeout</CODE> before <CODE>connect</CODE>. 
++ * 
++ * @param host host name of the LDAP server to which you want to connect.
++ * This value can also be a space-delimited list of hostnames or
++ * hostnames and port numbers (using the syntax
++ * hostname:portnumber). For example, you can specify
++ * the following values for the <CODE>host</CODE> argument: 
++ *<PRE>
++ * myhost
++ * myhost hishost:389 herhost:5000 whathost
++ * myhost:686 myhost:389 hishost:5000 whathost:1024
++ *</PRE>
++ * If multiple servers are specified in the <CODE>host</CODE> list, the connection
++ * setup policy specified with the <CODE>ConnSetupDelay</CODE> property controls
++ * whether connection attempts are made serially or concurrently.
++ * 
++ * @param port port number of the LDAP server to which you want to connect.
++ * This parameter is ignored for any host in the <CODE>host</CODE>
++ * parameter which includes a colon and port number.
++ * @exception LDAPException The connection failed.
++ * @see netscape.ldap.LDAPConnection#setConnSetupDelay
++ * @see netscape.ldap.LDAPConnection#setConnectTimeout
++ */
++ public void connect(String host, int port) throws LDAPException {
++ connect( host, port, null, null, m_defaultConstraints, false );
++ }
++
++ /**
++ * Connects to the specified host and port and uses the specified DN and
++ * password to authenticate to the server. If this LDAPConnection object
++ * represents an open connection, the connection is closed first
++ * before the new connection is opened.
++ * 
++ *
++ * For example, the following section of code establishes a connection
++ * with the LDAP server running on ldap.netscape.com at port 389. The
++ * example also attempts to authenticate the client as Barbara Jensen.
++ * 
++ *
++ * <PRE>
++ * String ldapHost = "ldap.netscape.com";
++ * int ldapPort = 389;
++ * String myDN = "cn=Barbara Jensen,ou=Product Development,o=Ace Industry,c=US";
++ * String myPW = "hifalutin";
++ * LDAPConnection myConn = new LDAPConnection();
++ * try {
++ * myConn.connect( ldapHost, ldapPort, myDN, myPW );
++ * } catch ( LDAPException e ) {
++ * switch( e.getLDAPResultCode() ) {
++ * case e.NO_SUCH_OBJECT:
++ * System.out.println( "The specified user does not exist." );
++ * break;
++ * case e.INVALID_CREDENTIALS:
++ * System.out.println( "Invalid password." );
++ * break;
++ * default:
++ * System.out.println( "Error number: " + e.getLDAPResultCode() );
++ * System.out.println( "Failed to connect to " + ldapHost + " at port " + ldapPort );
++ * break;
++ * }
++ * return;
++ * }
++ * System.out.println( "Connected to " + ldapHost + " at port " + ldapPort );
++ * </PRE>
++ *
++ * You can limit the time spent waiting for the connection to be established
++ * by calling <CODE>setConnectTimeout</CODE> before <CODE>connect</CODE>. 
++ * 
++ * @param host host name of the LDAP server to which you want to connect.
++ * This value can also be a space-delimited list of hostnames or
++ * hostnames and port numbers (using the syntax
++ * hostname:portnumber). For example, you can specify
++ * the following values for the <CODE>host</CODE> argument: 
++ *<PRE>
++ * myhost
++ * myhost hishost:389 herhost:5000 whathost
++ * myhost:686 myhost:389 hishost:5000 whathost:1024
++ *</PRE>
++ * If multiple servers are specified in the <CODE>host</CODE> list, the connection
++ * setup policy specified with the <CODE>ConnSetupDelay</CODE> property controls
++ * whether connection attempts are made serially or concurrently.
++ * 
++ * @param port port number of the LDAP server to which you want to connect.
++ * This parameter is ignored for any host in the <CODE>host</CODE>
++ * parameter which includes a colon and port number.
++ * @param dn distinguished name used for authentication
++ * @param passwd password used for authentication
++ * @exception LDAPException The connection or authentication failed.
++ * @see netscape.ldap.LDAPConnection#setConnSetupDelay
++ * @see netscape.ldap.LDAPConnection#setConnectTimeout
++ */
++ public void connect(String host, int port, String dn, String passwd)
++ throws LDAPException {
++ connect(host, port, dn, passwd, m_defaultConstraints, true);
++ }
++
++ /**
++ * Connects to the specified host and port and uses the specified DN and
++ * password to authenticate to the server. If this LDAPConnection object
++ * represents an open connection, the connection is closed first
++ * before the new connection is opened. This method allows the user to 
++ * specify the preferences for the bind operation.
++ *
++ * You can limit the time spent waiting for the connection to be established
++ * by calling <CODE>setConnectTimeout</CODE> before <CODE>connect</CODE>. 
++ * 
++ * @param host host name of the LDAP server to which you want to connect.
++ * This value can also be a space-delimited list of hostnames or
++ * hostnames and port numbers (using the syntax
++ * hostname:portnumber). For example, you can specify
++ * the following values for the <CODE>host</CODE> argument: 
++ *<PRE>
++ * myhost
++ * myhost hishost:389 herhost:5000 whathost
++ * myhost:686 myhost:389 hishost:5000 whathost:1024
++ *</PRE>
++ * If multiple servers are specified in the <CODE>host</CODE> list, the connection
++ * setup policy specified with the <CODE>ConnSetupDelay</CODE> property controls
++ * whether connection attempts are made serially or concurrently.
++ * 
++ * @param port port number of the LDAP server to which you want to connect.
++ * This parameter is ignored for any host in the <CODE>host</CODE>
++ * parameter which includes a colon and port number.
++ * @param dn distinguished name used for authentication
++ * @param passwd password used for authentication
++ * @param cons preferences for the bind operation
++ * @exception LDAPException The connection or authentication failed.
++ * @see netscape.ldap.LDAPConnection#setConnSetupDelay
++ * @see netscape.ldap.LDAPConnection#setConnectTimeout
++ */
++ public void connect(String host, int port, String dn, String passwd,
++ LDAPConstraints cons) throws LDAPException {
++ connect(host, port, dn, passwd, cons, true);
++ }
++
++ /**
++ * @deprecated Please use the method signature where <CODE>cons</CODE> is
++ * <CODE>LDAPConstraints</CODE> instead of <CODE>LDAPSearchConstraints</CODE>
++ */
++ public void connect(String host, int port, String dn, String passwd,
++ LDAPSearchConstraints cons) throws LDAPException {
++ connect(host, port, dn, passwd, (LDAPConstraints)cons);
++ }
++
++
++ private void connect(String host, int port, String dn, String passwd,
++ LDAPConstraints cons, boolean doAuthenticate) 
++ throws LDAPException {
++ if ( isConnected() ) {
++ disconnect ();
++ }
++ if ((host == null) || (host.equals(""))) {
++ throw new LDAPException ( "no host for connection",
++ LDAPException.PARAM_ERROR );
++ }
++
++ /* Parse the list of hosts */ 
++ int defaultPort = port;
++ StringTokenizer st = new StringTokenizer( host );
++ String hostList[] = new String[st.countTokens()];
++ int portList[] = new int[st.countTokens()];
++ int i = 0;
++ while( st.hasMoreTokens() ) {
++ String s = st.nextToken();
++ int colon = s.indexOf( ':' );
++ if ( colon > 0 ) {
++ hostList[i] = s.substring( 0, colon );
++ portList[i] = Integer.parseInt( s.substring( colon+1 ) );
++ } else {
++ hostList[i] = s;
++ portList[i] = defaultPort;
++ }
++ i++;
++ }
++
++ /* Create the Connection Setup Manager */
++ m_connMgr = new LDAPConnSetupMgr(hostList, portList,
++ m_isTLSFactory ? null : m_factory);
++ m_connMgr.setConnSetupDelay(m_connSetupDelay);
++ m_connMgr.setConnectTimeout(m_connectTimeout);
++ 
++ connect();
++
++ if (doAuthenticate) {
++ authenticate(dn, passwd, cons);
++ }
++ }
++
++ void connect(LDAPUrl[] urls) throws LDAPException {
++ m_connMgr = new LDAPConnSetupMgr(urls, m_factory);
++ m_connMgr.setConnSetupDelay(m_connSetupDelay);
++ m_connMgr.setConnectTimeout(m_connectTimeout);
++ connect();
++ }
++ 
++ /**
++ * Connects to the specified host and port and uses the specified DN and
++ * password to authenticate to the server, with the specified LDAP
++ * protocol version. If the server does not support the requested
++ * protocol version, an exception is thrown. If this LDAPConnection
++ * object represents an open connection, the connection is closed first
++ * before the new connection is opened. This is equivalent to
++ * <CODE>connect(host, port)</CODE> followed by <CODE>authenticate(version, dn, passwd)</CODE>.
++ *
++ * @param version requested version of LDAP: currently 2 or 3
++ * @param host a hostname to which to connect or a dotted string representing
++ * the IP address of this host.
++ * Alternatively, this can be a space-delimited list of host names.
++ * Each host name may include a trailing colon and port number. In the
++ * case where more than one host name is specified, the connection setup
++ * policy specified with the <CODE>ConnSetupDelay</CODE> property controls
++ * whether connection attempts are made serially or concurrently.
++ *
++ * <PRE>
++ * Examples:
++ * "directory.knowledge.com"
++ * "199.254.1.2"
++ * "directory.knowledge.com:1050 people.catalog.com 199.254.1.2"
++ * </PRE>
++ * @param port the TCP or UDP port number to which to connect or contact.
++ * The default LDAP port is 389. "port" is ignored for any host name which
++ * includes a colon and port number.
++ * @param dn if non-null and non-empty, specifies that the connection and
++ * all operations through it should authenticate with dn as the
++ * distinguished name
++ * @param passwd if non-null and non-empty, specifies that the connection and
++ * all operations through it should authenticate with dn as the
++ * distinguished name and passwd as password.
++ * @exception LDAPException The connection or authentication failed.
++ * @see netscape.ldap.LDAPConnection#setConnSetupDelay
++ */
++ public void connect(int version, String host, int port, String dn,
++ String passwd) throws LDAPException {
++
++ connect(version, host, port, dn, passwd, m_defaultConstraints);
++ }
++
++ /**
++ * Connects to the specified host and port and uses the specified DN and
++ * password to authenticate to the server, with the specified LDAP
++ * protocol version. If the server does not support the requested
++ * protocol version, an exception is thrown. This method allows the user
++ * to specify preferences for the bind operation. If this LDAPConnection
++ * object represents an open connection, the connection is closed first
++ * before the new connection is opened. This is equivalent to
++ * <CODE>connect(host, port)</CODE> followed by <CODE>authenticate(version, dn, passwd)</CODE>.
++ *
++ * @param version requested version of LDAP: currently 2 or 3
++ * @param host a hostname to which to connect or a dotted string representing
++ * the IP address of this host.
++ * Alternatively, this can be a space-delimited list of host names.
++ * Each host name may include a trailing colon and port number. In the
++ * case where more than one host name is specified, the connection setup
++ * policy specified with the <CODE>ConnSetupDelay</CODE> property controls
++ * whether connection attempts are made serially or concurrently.
++ *
++ * <PRE>
++ * Examples:
++ * "directory.knowledge.com"
++ * "199.254.1.2"
++ * "directory.knowledge.com:1050 people.catalog.com 199.254.1.2"
++ * </PRE>
++ * @param port the TCP or UDP port number to which to connect or contact.
++ * The default LDAP port is 389. "port" is ignored for any host name which
++ * includes a colon and port number.
++ * @param dn if non-null and non-empty, specifies that the connection and
++ * all operations through it should authenticate with dn as the
++ * distinguished name
++ * @param passwd if non-null and non-empty, specifies that the connection and
++ * all operations through it should authenticate with dn as the
++ * distinguished name and passwd as password
++ * @param cons preferences for the bind operation
++ * @exception LDAPException The connection or authentication failed.
++ * @see netscape.ldap.LDAPConnection#setConnSetupDelay
++ */
++ public void connect(int version, String host, int port, String dn,
++ String passwd, LDAPConstraints cons) throws LDAPException {
++
++ setProtocolVersion(version);
++ connect(host, port, dn, passwd, cons);
++ }
++
++ /**
++ * @deprecated Please use the method signature where <CODE>cons</CODE> is
++ * <CODE>LDAPConstraints</CODE> instead of <CODE>LDAPSearchConstraints</CODE>
++ */
++ public void connect(int version, String host, int port, String dn,
++ String passwd, LDAPSearchConstraints cons) throws LDAPException {
++
++ connect(version, host, port, dn, passwd, (LDAPConstraints)cons);
++ }
++
++ /**
++ * Internal routine to connect with internal params
++ * @exception LDAPException failed to connect
++ */
++ private synchronized void connect () throws LDAPException {
++ if ( isConnected() ) {
++ return;
++ }
++
++ if (m_connMgr == null) {
++ throw new LDAPException ( "no connection parameters",
++ LDAPException.PARAM_ERROR );
++ } 
++
++ if (m_thread == null) {
++ m_thread = new LDAPConnThread(m_connMgr, m_cache, getTraceOutput());
++ }
++
++ m_thread.connect(this);
++
++ checkClientAuth();
++ }
++
++ /**
++ * Returns the trace output object if set by the user
++ */
++ Object getTraceOutput() throws LDAPException {
++ 
++ // Check first if trace output has been set using setProperty()
++ Object traceOut = m_properties.get(TRACE_PROPERTY);
++ if (traceOut != null) {
++ return createTraceOutput(traceOut);
++ }
++ 
++ // Check if the property has been set with java -Dcom.netscape.ldap.trace
++ // If the property does not have a value, send the trace to the System.err,
++ // otherwise use the value as the output file name
++ try {
++ traceOut = System.getProperty(TRACE_PROPERTY);
++ if (traceOut != null) {
++ return createTraceOutput(traceOut);
++ }
++ }
++ catch (Exception e) {
++ ;// In browser access to property might not be allowed
++ }
++ return null;
++ } 
++ 
++ 
++ /**
++ * Performs certificate-based authentication if client authentication was
++ * specified at construction time.
++ * @exception LDAPException if certificate-based authentication fails.
++ */
++ private void checkClientAuth() throws LDAPException {
++
++ // if this is SSL
++ if ((m_factory != null) &&
++ (m_factory instanceof LDAPSSLSocketFactoryExt)) {
++
++ if (((LDAPSSLSocketFactoryExt)m_factory).isClientAuth()) {
++ authenticate(null, EXTERNAL_MECHANISM,
++ EXTERNAL_MECHANISM_PACKAGE, null, null);
++ }
++ }
++ }
++
++ /**
++ * Abandons a current search operation, notifying the server not
++ * to send additional search results.
++ *
++ * @param searchResults the search results returned when the search
++ * was started
++ * @exception LDAPException Failed to notify the LDAP server.
++ * @see netscape.ldap.LDAPConnection#search(java.lang.String, int, java.lang.String, java.lang.String[], boolean, netscape.ldap.LDAPSearchConstraints)
++ * @see netscape.ldap.LDAPSearchResults
++ */
++ public void abandon( LDAPSearchResults searchResults )
++ throws LDAPException {
++ if ( (!isConnected()) || (searchResults == null) ) {
++ return;
++ }
++
++ int id = searchResults.getMessageID();
++ if ( id != -1 ) {
++ abandon( id );
++ }
++ }
++
++ /**
++ * Authenticates to the LDAP server (to which you are currently
++ * connected) using the specified name and password.
++ * If you are not connected to the LDAP server, this
++ * method attempts to reconnect to the server.
++ * 
++ *
++ * For example, the following section of code authenticates the
++ * client as Barbara Jensen. The code assumes that the client
++ * has already established a connection with an LDAP server.
++ * 
++ *
++ * <PRE>
++ * String myDN = "cn=Barbara Jensen,ou=Product Development,o=Ace Industry,c=US";
++ * String myPW = "hifalutin";
++ * try {
++ * myConn.authenticate( myDN, myPW );
++ * } catch ( LDAPException e ) {
++ * switch( e.getLDAPResultCode() ) {
++ * case e.NO_SUCH_OBJECT:
++ * System.out.println( "The specified user does not exist." );
++ * break;
++ * case e.INVALID_CREDENTIALS:
++ * System.out.println( "Invalid password." );
++ * break;
++ * default:
++ * System.out.println( "Error number: " + e.getLDAPResultCode() );
++ * System.out.println( "Failed to authentice as " + myDN );
++ * break;
++ * }
++ * return;
++ * }
++ * System.out.println( "Authenticated as " + myDN );
++ * </PRE>
++ *
++ * @param dn distinguished name used for authentication
++ * @param passwd password used for authentication
++ * @exception LDAPException Failed to authenticate to the LDAP server.
++ */
++ public void authenticate(String dn, String passwd) throws LDAPException {
++ authenticate(m_protocolVersion, dn, passwd, m_defaultConstraints);
++ }
++
++ /**
++ * Authenticates to the LDAP server (to which you are currently
++ * connected) using the specified name and password. The
++ * default protocol version (version 2) is used. If the server
++ * doesn't support the default version, an LDAPException is thrown
++ * with the error code PROTOCOL_ERROR. This method allows the
++ * user to specify the preferences for the bind operation.
++ *
++ * @param dn distinguished name used for authentication
++ * @param passwd password used for authentication
++ * @param cons preferences for the bind operation
++ * @exception LDAPException Failed to authenticate to the LDAP server.
++ */
++ public void authenticate(String dn, String passwd,
++ LDAPConstraints cons) throws LDAPException {
++ authenticate(m_protocolVersion, dn, passwd, cons);
++ }
++
++ /**
++ * @deprecated Please use the method signature where <CODE>cons</CODE> is
++ * <CODE>LDAPConstraints</CODE> instead of <CODE>LDAPSearchConstraints</CODE>
++ */
++ public void authenticate(String dn, String passwd,
++ LDAPSearchConstraints cons) throws LDAPException {
++ authenticate(dn, passwd, (LDAPConstraints)cons);
++ }
++
++ /**
++ * Authenticates to the LDAP server (that you are currently
++ * connected to) using the specified name and password, and
++ * requesting that the server use at least the specified
++ * protocol version. If the server doesn't support that
++ * level, an LDAPException is thrown with the error code
++ * PROTOCOL_ERROR.
++ *
++ * @param version required LDAP protocol version
++ * @param dn distinguished name used for authentication
++ * @param passwd password used for authentication
++ * @exception LDAPException Failed to authenticate to the LDAP server.
++ */
++ public void authenticate(int version, String dn, String passwd)
++ throws LDAPException {
++ authenticate(version, dn, passwd, m_defaultConstraints);
++ }
++
++ /**
++ * Authenticates to the LDAP server (to which you are currently
++ * connected) using the specified name and password, and
++ * requesting that the server use at least the specified
++ * protocol version. If the server doesn't support that
++ * level, an LDAPException is thrown with the error code
++ * PROTOCOL_ERROR. This method allows the user to specify the
++ * preferences for the bind operation.
++ *
++ * @param version required LDAP protocol version
++ * @param dn distinguished name used for authentication
++ * @param passwd password used for authentication
++ * @param cons preferences for the bind operation
++ * @exception LDAPException Failed to authenticate to the LDAP server.
++ */
++ public void authenticate(int version, String dn, String passwd,
++ LDAPConstraints cons) throws LDAPException {
++ m_protocolVersion = version;
++ m_boundDN = dn;
++ m_boundPasswd = passwd;
++ forceNonSharedConnection();
++ simpleBind(cons);
++ }
++
++ /**
++ * @deprecated Please use the method signature where <CODE>cons</CODE> is
++ * <CODE>LDAPConstraints</CODE> instead of <CODE>LDAPSearchConstraints</CODE>
++ */
++ public void authenticate(int version, String dn, String passwd,
++ LDAPSearchConstraints cons) throws LDAPException {
++ authenticate(version, dn, passwd, (LDAPConstraints)cons);
++ }
++
++ /**
++ * Authenticates to the LDAP server (that the object is currently
++ * connected to) using the specified name and whatever SASL mechanisms
++ * are supported by the server. Each supported mechanism in turn
++ * is tried until authentication succeeds or an exception is thrown.
++ * If the object has been disconnected from an LDAP server, this
++ * method attempts to reconnect to the server. If the object had
++ * already authenticated, the old authentication is discarded.
++ *
++ * @param dn if non-null and non-empty, specifies that the connection and
++ * all operations through it should authenticate with dn as the
++ * distinguished name
++ * @param cbh a class which the SASL framework can call to obtain 
++ * additional required information
++ * @exception LDAPException Failed to authenticate to the LDAP server.
++ */
++ public void authenticate(String dn, Hashtable props,
++ /*CallbackHandler*/ Object cbh)
++ throws LDAPException {
++
++ // Get the list of mechanisms from the server
++ String[] attrs = { "supportedSaslMechanisms" };
++ LDAPEntry entry = read( "", attrs );
++ LDAPAttribute attr = entry.getAttribute( attrs[0] );
++ if ( attr == null ) {
++ throw new LDAPException( "Not found in root DSE: " +
++ attrs[0],
++ LDAPException.NO_SUCH_ATTRIBUTE );
++ }
++ authenticate( dn, attr.getStringValueArray(), props, cbh );
++ }
++
++ /**
++ * Authenticates to the LDAP server (to which the object is currently
++ * connected) using the specified name and a specified SASL mechanism
++ * or set of mechanisms. If the requested SASL mechanism is not
++ * available, an exception is thrown. If the object has been
++ * disconnected from an LDAP server, this method attempts to reconnect
++ * to the server. If the object had already authenticated, the old
++ * authentication is discarded.
++ *
++ * @param dn if non-null and non-empty, specifies that the connection and
++ * all operations through it should authenticate with dn as the
++ * distinguished name
++ * @param mechanisms a list of acceptable mechanisms. The first one
++ * for which a Mechanism Driver can be instantiated is returned.
++ * @param cbh a class which the SASL framework can call to
++ * obtain additional required information
++ * @exception LDAPException Failed to authenticate to the LDAP server.
++ * @see netscape.ldap.LDAPConnection#authenticate(java.lang.String,
++ * java.util.Hashtable, java.lang.Object)
++ */
++ public void authenticate(String dn, String[] mechanisms,
++ Hashtable props, /*CallbackHandler*/ Object cbh)
++ throws LDAPException {
++
++ authenticate( dn, mechanisms, DEFAULT_SASL_PACKAGE, props, cbh );
++ }
++ 
++ /**
++ * Authenticates to the LDAP server (to which the object is currently
++ * connected) using the specified name and a specified SASL mechanism
++ * or set of mechanisms. If the requested SASL mechanism is not
++ * available, an exception is thrown. If the object has been
++ * disconnected from an LDAP server, this method attempts to reconnect
++ * to the server. If the object had already authenticated, the old
++ * authentication is discarded.
++ *
++ * @param dn if non-null and non-empty, specifies that the connection and
++ * all operations through it should authenticate with dn as the
++ * distinguished name
++ * @param mechanism a single mechanism name, e.g. "GSSAPI"
++ * @param packageName a package containing a SASL ClientFactory,
++ * e.g. "myclasses.SASL". If null, a system default is used.
++ * @param cbh a class which the SASL framework can call to
++ * obtain additional required information
++ * @exception LDAPException Failed to authenticate to the LDAP server.
++ * @deprecated Please use authenticate without packageName
++ * instead.
++ */
++ public void authenticate(String dn, String mechanism, String packageName,
++ Hashtable props, /*CallbackHandler*/ Object cbh)
++ throws LDAPException {
++
++ authenticate( dn, new String[] {mechanism}, packageName, props, cbh );
++ }
++
++ /**
++ * Authenticates to the LDAP server (to which the object is currently
++ * connected) using the specified name and a specified SASL mechanism
++ * or set of mechanisms. If the requested SASL mechanism is not
++ * available, an exception is thrown. If the object has been
++ * disconnected from an LDAP server, this method attempts to reconnect
++ * to the server. If the object had already authenticated, the old
++ * authentication is discarded.
++ *
++ * @param dn if non-null and non-empty, specifies that the connection and
++ * all operations through it should authenticate with dn as the
++ * distinguished name
++ * @param mechanisms a list of acceptable mechanisms. The first one
++ * for which a Mechanism Driver can be instantiated is returned.
++ * @param packageName a package containing a SASL ClientFactory,
++ * e.g. "myclasses.SASL". If null, a system default is used.
++ * @param cbh a class which the SASL framework can call to
++ * obtain additional required information
++ * @exception LDAPException Failed to authenticate to the LDAP server.
++ * @deprecated Please use authenticate without packageName
++ * instead.
++ */
++ public void authenticate(String dn, String[] mechanisms,
++ String packageName,
++ Hashtable props, /*CallbackHandler*/ Object cbh)
++ throws LDAPException {
++
++ forceNonSharedConnection();
++
++ m_boundDN = null;
++ m_protocolVersion = 3; // Must be 3 for SASL
++ if ( props == null ) {
++ props = new Hashtable();
++ }
++ m_saslBinder = new LDAPSaslBind( dn, mechanisms, packageName,
++ props, cbh );
++ m_saslBinder.bind( this );
++ m_boundDN = dn;
++ }
++ 
++ /**
++ * Authenticates to the LDAP server (that the object is currently
++ * connected to) using the specified name and password and allows you
++ * to specify constraints for this LDAP add operation by using an
++ * <CODE>LDAPConstraints</CODE> object. If the object
++ * has been disconnected from an LDAP server, this method attempts to
++ * reconnect to the server. If the object had already authenticated, the
++ * old authentication is discarded.
++ * 
++ * @param version Required LDAP protocol version.
++ * @param dn If non-null and non-empty, specifies that the connection
++ * and all operations through it should be authenticated with dn as the
++ * distinguished name.
++ * @param passwd If non-null and non-empty, specifies that the connection
++ * and all operations through it should be authenticated with dn as the
++ * distinguished name and passwd as password.
++ * @param listener Handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @param cons Constraints specific to the operation.
++ * @return LDAPResponseListener Handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ * @see netscape.ldap.LDAPResponseListener
++ * @see netscape.ldap.LDAPConstraints
++ */
++ public LDAPResponseListener authenticate(int version,
++ String dn,
++ String passwd,
++ LDAPResponseListener listener,
++ LDAPConstraints cons) 
++ throws LDAPException{
++ if (cons == null) {
++ cons = m_defaultConstraints;
++ }
++
++ m_boundDN = dn;
++ m_boundPasswd = passwd;
++ m_protocolVersion = version;
++
++ forceNonSharedConnection();
++
++ if (listener == null) {
++ listener = new LDAPResponseListener(/*asynchOp=*/true);
++ }
++
++ sendRequest(new JDAPBindRequest(version, m_boundDN, m_boundPasswd),
++ listener, cons);
++
++ return listener;
++ }
++ 
++ /**
++ * Authenticates to the LDAP server (that the object is currently
++ * connected to) using the specified name and password and allows you
++ * to specify constraints for this LDAP add operation by using an
++ * <CODE>LDAPConstraints</CODE> object. If the object
++ * has been disconnected from an LDAP server, this method attempts to
++ * reconnect to the server. If the object had already authenticated, the
++ * old authentication is discarded.
++ * 
++ * @param version Required LDAP protocol version.
++ * @param dn If non-null and non-empty, specifies that the connection
++ * and all operations through it should be authenticated with dn as the
++ * distinguished name.
++ * @param passwd If non-null and non-empty, specifies that the connection
++ * and all operations through it should be authenticated with dn as the
++ * distinguished name and passwd as password.
++ * @param listener Handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @return LDAPResponseListener Handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ * @see netscape.ldap.LDAPResponseListener
++ * @see netscape.ldap.LDAPConstraints
++ */
++ public LDAPResponseListener authenticate(int version,
++ String dn,
++ String passwd,
++ LDAPResponseListener listener) 
++ throws LDAPException{
++ return authenticate( version, dn, passwd, listener, m_defaultConstraints );
++ }
++ 
++ /** 
++ * Authenticates to the LDAP server (to which you are currently
++ * connected) using the specified name and password.
++ * If you are not already connected to the LDAP server, this
++ * method attempts to reconnect to the server.
++ * 
++ *
++ * For example, the following section of code authenticates the
++ * client as Barbara Jensen. The code assumes that the client
++ * has already established a connection with an LDAP server.
++ * 
++ *
++ * <PRE>
++ * String myDN = "cn=Barbara Jensen,ou=Product Development,o=Ace Industry,c=US";
++ * String myPW = "hifalutin";
++ * try {
++ * myConn.bind( myDN, myPW );
++ * } catch ( LDAPException e ) {
++ * switch( e.getLDAPResultCode() ) {
++ * case e.NO_SUCH_OBJECT:
++ * System.out.println( "The specified user does not exist." );
++ * break;
++ * case e.INVALID_CREDENTIALS:
++ * System.out.println( "Invalid password." );
++ * break;
++ * default:
++ * System.out.println( "Error number: " + e.getLDAPResultCode() );
++ * System.out.println( "Failed to authentice as " + myDN );
++ * break;
++ * }
++ * return;
++ * }
++ * System.out.println( "Authenticated as " + myDN );
++ * </PRE>
++ *
++ * @param dn distinguished name used for authentication
++ * @param passwd password used for authentication
++ * @exception LDAPException Failed to authenticate to the LDAP server.
++ */
++ public void bind(String dn, String passwd) throws LDAPException {
++ authenticate(m_protocolVersion, dn, passwd, m_defaultConstraints);
++ }
++
++ /**
++ * Authenticates to the LDAP server (to which you are currently
++ * connected) using the specified name and password. The
++ * default protocol version (version 2) is used. If the server
++ * doesn't support the default version, an LDAPException is thrown
++ * with the error code PROTOCOL_ERROR. This method allows the
++ * user to specify the preferences for the bind operation.
++ *
++ * @param dn distinguished name used for authentication
++ * @param passwd password used for authentication
++ * @param cons preferences for the bind operation
++ * @exception LDAPException Failed to authenticate to the LDAP server.
++ */
++ public void bind(String dn, String passwd,
++ LDAPConstraints cons) throws LDAPException {
++ authenticate(m_protocolVersion, dn, passwd, cons);
++ }
++
++ /**
++ * Authenticates to the LDAP server (to which you are currently
++ * connected) using the specified name and password, and
++ * requests that the server use at least the specified
++ * protocol version. If the server doesn't support that
++ * level, an LDAPException is thrown with the error code
++ * PROTOCOL_ERROR.
++ *
++ * @param version required LDAP protocol version
++ * @param dn distinguished name used for authentication
++ * @param passwd password used for authentication
++ * @exception LDAPException Failed to authenticate to the LDAP server.
++ */
++ public void bind(int version, String dn, String passwd)
++ throws LDAPException {
++ authenticate(version, dn, passwd, m_defaultConstraints);
++ }
++
++ /**
++ * Authenticates to the LDAP server (to which you are currently
++ * connected) using the specified name and password, and
++ * requesting that the server use at least the specified
++ * protocol version. If the server doesn't support that
++ * level, an LDAPException is thrown with the error code
++ * PROTOCOL_ERROR. This method allows the user to specify the
++ * preferences for the bind operation.
++ *
++ * @param version required LDAP protocol version
++ * @param dn distinguished name used for authentication
++ * @param passwd password used for authentication
++ * @param cons preferences for the bind operation
++ * @exception LDAPException Failed to authenticate to the LDAP server.
++ */
++ public void bind(int version, String dn, String passwd,
++ LDAPConstraints cons) throws LDAPException {
++ authenticate(version, dn, passwd, cons);
++ }
++
++ /**
++ * Authenticates to the LDAP server (to which the object is currently
++ * connected) using the specified name and whatever SASL mechanisms
++ * are supported by the server. Each supported mechanism in turn
++ * is tried until authentication succeeds or an exception is thrown.
++ * If the object has been disconnected from an LDAP server, this
++ * method attempts to reconnect to the server. If the object had
++ * already authenticated, the old authentication is discarded.
++ *
++ * @param dn if non-null and non-empty, specifies that the connection and
++ * all operations through it should authenticate with dn as the
++ * distinguished name
++ * @param cbh a class which the SASL framework can call to
++ * obtain additional required information
++ * @exception LDAPException Failed to authenticate to the LDAP server.
++ */
++ public void bind(String dn, Hashtable props,
++ /*CallbackHandler*/ Object cbh)
++ throws LDAPException {
++ authenticate(dn, props, cbh);
++ }
++
++ /**
++ * Authenticates to the LDAP server (to which the object is currently
++ * connected) using the specified name and a specified SASL mechanism
++ * or set of mechanisms. If the requested SASL mechanism is not
++ * available, an exception is thrown. If the object has been
++ * disconnected from an LDAP server, this method attempts to reconnect
++ * to the server. If the object had already authenticated, the old
++ * authentication is discarded.
++ *
++ * @param dn if non-null and non-empty, specifies that the connection and
++ * all operations through it should authenticate with dn as the
++ * distinguished name
++ * @param mechanisms a list of acceptable mechanisms. The first one
++ * for which a Mechanism Driver can be instantiated is returned.
++ * @param cbh a class which the SASL framework can call to
++ * obtain additional required information
++ * @exception LDAPException Failed to authenticate to the LDAP server.
++ * @see netscape.ldap.LDAPConnection#bind(java.lang.String,
++ * java.util.Hashtable, java.lang.Object)
++ */
++ public void bind(String dn, String[] mechanisms,
++ Hashtable props, /*CallbackHandler*/ Object cbh)
++ throws LDAPException {
++ authenticate(dn, mechanisms, props, cbh);
++ }
++
++ /**
++ * Begin using the Transport Layer Security (TLS) protocol for session
++ * privacy.
++ * 
++ * Before <CODE>startTLS()</CODE> is called, a socket factory of type
++ * <CODE>LDAPTLSSocketFactory</CODE> must be set for the connection.
++ * The factory must be set after the <CODE>connect()</CODE> call. 
++ * 
++ * <PRE>
++ * LDAPConnection ldc = new LDAPConnection();
++ * try {
++ * ldc.connect(host, port);
++ * ldc.setSocketFactory(new JSSSocketFactory());
++ * ldc.startTLS();
++ * ldc.autheticate(3, userdn, userpw);
++ * }
++ * catch (LDAPException e) {
++ * ...
++ * }
++ * </PRE>
++ * 
++ * If the socket factory of the connection is not capable of initiating a
++ * TLS session , an LDAPException is thrown with the error code
++ * TLS_NOT_SUPPORTED.
++ * 
++ * If the server does not support the transition to a TLS session, an
++ * LDAPException is thrown with the error code returned by the server.
++ * If there are outstanding LDAP operations on the connection or the 
++ * connection is already in the secure mode, an LDAPException is thrown. 
++ * 
++ * @exception LDAPException Failed to convert to a TLS session.
++ * @see netscape.ldap.LDAPTLSSocketFactory
++ * @see netscape.ldap.LDAPConnection#setSocketFactory(netscape.ldap.LDAPSocketFactory)
++ * @see netscape.ldap.LDAPConnection#isTLS
++ * @since LDAPJDK 4.17
++ */ 
++ public void startTLS() throws LDAPException { 
++
++ if (m_useTLS) {
++ throw new LDAPException("Already using TLS",
++ LDAPException.OTHER);
++ }
++
++ if (m_factory == null || !( m_factory instanceof LDAPTLSSocketFactory)) {
++ throw new LDAPException("No socket factory for the startTLS operation",
++ LDAPException.OTHER);
++ }
++
++ // Denote that m_factory is to be used from now on used for TLS and not for
++ // SSL connections.
++ m_isTLSFactory = true;
++
++ checkConnection(/*rebind=*/true);
++
++ // If some requests still in progress, throw exception
++ synchronized (this) {
++ if (isConnected() && m_thread.getRequestCount() != 0) {
++ throw new LDAPException(
++ "Connection has outstanding LDAP operations",
++ LDAPException.OTHER);
++ }
++ }
++
++ // Send startTLS extended op
++ try {
++ LDAPExtendedOperation response = 
++ extendedOperation(new LDAPExtendedOperation(OID_startTLS, null),
++ m_defaultConstraints);
++ }
++ catch (LDAPException ex) {
++ ex.setExtraMessage("Cannot start TLS");
++ throw ex;
++ }
++
++ /**
++ * Server accepted startTLS request, try to initiate TLS over the
++ * current socket.
++ */
++ try {
++ m_thread.layerSocket((LDAPTLSSocketFactory)m_factory);
++ m_useTLS = true;
++ }
++ catch (LDAPException ex) {
++ ex.setExtraMessage("Failed to start TLS");
++ throw ex;
++ }
++ catch (Exception ex) {
++ throw new LDAPException("Failed to start TLS",
++ LDAPException.OTHER);
++ }
++ }
++
++ /**
++ * Indicates if the session is currently protected by TLS.
++ * @return <CODE>true</CODE> if TLS was activated.
++ * @since LDAPJDK 4.17
++ * @see netscape.ldap.LDAPConnection#startTLS
++ */
++ public boolean isTLS() { 
++ return m_useTLS;
++ }
++
++ /**
++ * If this connection is cloned (the physical connection is shared),
++ * create a new physical connection.
++ */
++ void forceNonSharedConnection() throws LDAPException{
++ checkConnection(/*rebind=*/false);
++ if (m_thread != null && m_thread.getClientCount() > 1) {
++ reconnect(/*rebind=*/false);
++ }
++ }
++
++ /**
++ * Internal routine. Binds to the LDAP server.
++ * @exception LDAPException failed to bind
++ */
++ private void simpleBind (LDAPConstraints cons) throws LDAPException {
++
++ m_saslBinder = null;
++
++ LDAPResponseListener myListener = new LDAPResponseListener ( /*asynchOp=*/false );
++ try {
++
++ if (m_referralConnection != null && m_referralConnection.isConnected()) {
++ m_referralConnection.disconnect();
++ }
++ m_referralConnection = null;
++ 
++ setBound(false);
++ sendRequest(new JDAPBindRequest(m_protocolVersion, m_boundDN,
++ m_boundPasswd),
++ myListener, cons);
++ checkMsg( myListener.getResponse() );
++
++ setBound(true);
++ m_rebindConstraints = (LDAPConstraints)cons.clone();
++
++ } catch (LDAPReferralException e) {
++ m_referralConnection = createReferralConnection(e, cons);
++ }
++ }
++
++ /**
++ * Send a request to the server
++ */
++ synchronized void sendRequest(JDAPProtocolOp oper, LDAPMessageQueue myListener,
++ LDAPConstraints cons) throws LDAPException {
++
++ boolean requestSent=false;
++ boolean restoreTried=false;
++
++ while (!requestSent) {
++
++ try {
++ m_thread.sendRequest(this, oper, myListener, cons);
++
++ /**
++ * In Java, a lost socket connected is often not detected until
++ * a read is attempted following a write. Wait for the response
++ * from the server to be sure the connection is really there.
++ */
++ if (!myListener.isAsynchOp()) {
++ myListener.waitFirstMessage();
++ }
++
++ requestSent=true;
++ }
++
++ catch (IllegalArgumentException e) {
++ throw new LDAPException(e.getMessage(), LDAPException.PARAM_ERROR);
++ }
++ catch(NullPointerException e) {
++ if (isConnected() || restoreTried) {
++ break; // give up 
++ }
++ // else try to restore the connection
++ }
++ catch (LDAPException e) {
++ if (e.getLDAPResultCode() != e.SERVER_DOWN || restoreTried) {
++ throw e; // give up
++ }
++ // else try to restore the connection
++ }
++
++ // Try to restore the connection if needed, but no more then once
++ if (!requestSent && !restoreTried) {
++ restoreTried = true; 
++ myListener.reset();
++ boolean rebind = !(oper instanceof JDAPBindRequest);
++ restoreConnection(rebind);
++ }
++ }
++
++ if (!requestSent) {
++ throw new LDAPException("Failed to send request",
++ LDAPException.OTHER);
++ }
++ }
++
++ /**
++ * Check and restore the connection if needed.
++ * This method is used by the "smart failover" feature. If a server
++ * or network error has occurred, an attempt is made to automatically
++ * restore the connection on the next ldap operation request
++ * @param rebind true if needs rebind after reconnect
++ */
++ private void checkConnection(boolean rebind) throws LDAPException {
++
++ if (isConnected()) {
++ return;
++ }
++ // If the user has invoked disconnect() no attempt is made
++ // to restore the connection
++ if (m_connMgr == null) {
++ throw new LDAPException("not connected", LDAPException.OTHER);
++ }
++
++ restoreConnection(rebind);
++ }
++ 
++ /**
++ * Reconnect and reauthenticate
++ */
++ private void restoreConnection(boolean rebind) throws LDAPException {
++ connect();
++ if (m_useTLS) {
++ m_useTLS = false;
++ startTLS();
++ } 
++
++ if (!rebind) {
++ return;
++ }
++
++ if (m_saslBinder != null) {
++ m_saslBinder.bind(this, false);
++ }
++ else if (m_rebindConstraints != null) {
++ //Needs bind
++ simpleBind(m_rebindConstraints);
++ }
++ }
++
++ /**
++ * Gets the authentication method used to bind: 
++ * "none", "simple", or "sasl"
++ *
++ * @return the authentication method, or "none"
++ */
++ public String getAuthenticationMethod() {
++ if (!isAuthenticated()) {
++ return "none";
++ }
++ else {
++ return (m_saslBinder == null) ? "simple" : "sasl";
++ }
++ 
++ }
++
++ /**
++ * Disconnect from the server and then reconnect using the current
++ * credentials and authentication method.
++ * If TLS was enabled with the startTLS() call, reenable TLS after
++ * reconnect.
++ * @exception LDAPException if not previously connected, or if
++ * there is a failure on disconnecting or on connecting 
++ */
++ public void reconnect() throws LDAPException { 
++ reconnect(/*rebind=*/true);
++ }
++
++ void reconnect(boolean rebind) throws LDAPException {
++ // Save connect parameters that get cleared by disconnect()
++ boolean useTLS = m_useTLS;
++ LDAPConnSetupMgr connMgr = m_connMgr;
++ LDAPConstraints rebindCons = m_rebindConstraints;
++
++ disconnect();
++ m_useTLS = useTLS;
++ m_connMgr = connMgr;
++ m_rebindConstraints = rebindCons;
++ restoreConnection(rebind);
++ }
++
++ /**
++ * Disconnects from the LDAP server. Before you can perform LDAP operations
++ * again, you need to reconnect to the server by calling
++ * <CODE>connect</CODE>.
++ * @exception LDAPException Failed to disconnect from the LDAP server.
++ * @see netscape.ldap.LDAPConnection#connect(java.lang.String, int)
++ * @see netscape.ldap.LDAPConnection#connect(java.lang.String, int, java.lang.String, java.lang.String)
++ */
++ public synchronized void disconnect() throws LDAPException {
++ if (!isConnected()) {
++ return;
++ }
++
++ m_thread.deregister(this);
++
++ if (m_referralConnection != null && m_referralConnection.isConnected()) {
++ m_referralConnection.disconnect();
++ }
++ m_referralConnection = null;
++
++ if (m_cache != null) {
++ m_cache.removeReference();
++ m_cache = null;
++ }
++
++ m_responseControlTable.clear();
++ m_rebindConstraints = null;
++ m_thread = null;
++ m_connMgr = null;
++ m_useTLS = false;
++ }
++
++ /**
++ * Reads the entry for the specified distiguished name (DN) and retrieves all
++ * attributes for the entry.
++ * 
++ *
++ * For example, the following section of code reads the entry for
++ * Barbara Jensen and retrieves all attributes for that entry.
++ * 
++ *
++ * <PRE>
++ * String findDN = "cn=Barbara Jensen,ou=Product Development,o=Ace Industry,c=US";
++ * LDAPEntry foundEntry = null;
++ * try {
++ * foundEntry = myConn.read( findDN );
++ * } catch ( LDAPException e ) {
++ * switch( e.getLDAPResultCode() ) {
++ * case e.NO_SUCH_OBJECT:
++ * System.out.println( "The specified entry does not exist." );
++ * break;
++ * case e.LDAP_PARTIAL_RESULTS:
++ * System.out.println( "Entry served by a different LDAP server." );
++ * break;
++ * case e.INSUFFICIENT_ACCESS_RIGHTS:
++ * System.out.println( "You do not have the access rights to perform this operation." );
++ * break;
++ * default:
++ * System.out.println( "Error number: " + e.getLDAPResultCode() );
++ * System.out.println( "Could not read the specified entry." );
++ * break;
++ * }
++ * return;
++ * }
++ * System.out.println( "Found the specified entry." );
++ * </PRE>
++ *
++ * @param DN distinguished name of the entry to retrieve
++ * @exception LDAPException Failed to find or read the specified entry
++ * from the directory.
++ * @return LDAPEntry returns the specified entry or raises an exception
++ * if the entry is not found.
++ */
++ public LDAPEntry read (String DN) throws LDAPException {
++ return read (DN, null, m_defaultConstraints);
++ }
++
++ /**
++ * Reads the entry for the specified distiguished name (DN) and retrieves all
++ * attributes for the entry. This method allows the user to specify the
++ * preferences for the read operation.
++ * 
++ *
++ * For example, the following section of code reads the entry for
++ * Barbara Jensen and retrieves all attributes for that entry.
++ * 
++ *
++ * <PRE>
++ * String findDN = "cn=Barbara Jensen,ou=Product Development,o=Ace Industry,c=US";
++ * LDAPEntry foundEntry = null;
++ * try {
++ * foundEntry = myConn.read( findDN );
++ * } catch ( LDAPException e ) {
++ * switch( e.getLDAPResultCode() ) {
++ * case e.NO_SUCH_OBJECT:
++ * System.out.println( "The specified entry does not exist." );
++ * break;
++ * case e.LDAP_PARTIAL_RESULTS:
++ * System.out.println( "Entry served by a different LDAP server." );
++ * break;
++ * case e.INSUFFICIENT_ACCESS_RIGHTS:
++ * System.out.println( "You do not have the access rights to perform this operation." );
++ * break;
++ * default:
++ * System.out.println( "Error number: " + e.getLDAPResultCode() );
++ * System.out.println( "Could not read the specified entry." );
++ * break;
++ * }
++ * return;
++ * }
++ * System.out.println( "Found the specified entry." );
++ * </PRE>
++ *
++ * @param DN distinguished name of the entry to retrieve
++ * @param cons preferences for the read operation
++ * @exception LDAPException Failed to find or read the specified entry
++ * from the directory.
++ * @return LDAPEntry returns the specified entry or raises an exception
++ * if the entry is not found.
++ */
++ public LDAPEntry read (String DN, LDAPSearchConstraints cons)
++ throws LDAPException {
++ return read (DN, null, cons);
++ }
++
++ /**
++ * Reads the entry for the specified distinguished name (DN) and
++ * retrieves only the specified attributes from the entry.
++ * 
++ *
++ * For example, the following section of code reads the entry for
++ * Barbara Jensen and retrieves only the <CODE>cn</CODE> and
++ * <CODE>sn</CODE> attributes.
++ * The example prints out all attributes that have been retrieved
++ * (the two specified attributes).
++ * 
++ *
++ * <PRE>
++ * String findDN = "cn=Barbara Jensen,ou=Product Development,o=Ace Industry,c=US";
++ * LDAPEntry foundEntry = null;
++ * String getAttrs[] = { "cn", "sn" };
++ * try {
++ * foundEntry = myConn.read( findDN, getAttrs );
++ * } catch ( LDAPException e ) {
++ * switch( e.getLDAPResultCode() ) {
++ * case e.NO_SUCH_OBJECT:
++ * System.out.println( "The specified entry does not exist." );
++ * break;
++ * case e.LDAP_PARTIAL_RESULTS:
++ * System.out.println( "Entry served by a different LDAP server." );
++ * break;
++ * case e.INSUFFICIENT_ACCESS_RIGHTS:
++ * System.out.println( "You do not have the access " +
++ * "rights to perform this operation." );
++ * break;
++ * default:
++ * System.out.println( "Error number: " + e.getLDAPResultCode() );
++ * System.out.println( "Could not read the specified entry." );
++ * break;
++ * }
++ * return;
++ * }
++ *
++ * LDAPAttributeSet foundAttrs = foundEntry.getAttributeSet();
++ * int size = foundAttrs.size();
++ * Enumeration itrAttrs = foundAttrs.getAttributes();
++ * System.out.println( "Attributes: " );
++ *
++ * while ( itrAttrs.hasMoreElements() ) {
++ * LDAPAttribute anAttr = ( LDAPAttribute )itrAttrs.nextElement();
++ * String attrName = anAttr.getName();
++ * System.out.println( "\t" + attrName );
++ * Enumeration itrVals = anAttr.getStringValues();
++ * while ( itrVals.hasMoreElements() ) {
++ * String aVal = ( String )itrVals.nextElement();
++ * System.out.println( "\t\t" + aVal );
++ * }
++ * }
++ * </PRE>
++ *
++ * @param DN distinguished name of the entry to retrieve
++ * @param attrs names of attributes to retrieve
++ * @return LDAPEntry returns the specified entry (or raises an
++ * exception if the entry is not found).
++ * @exception LDAPException Failed to read the specified entry from
++ * the directory.
++ */
++ public LDAPEntry read (String DN, String attrs[]) throws LDAPException {
++ return read(DN, attrs, m_defaultConstraints);
++ }
++
++ public LDAPEntry read (String DN, String attrs[],
++ LDAPSearchConstraints cons) throws LDAPException {
++ LDAPSearchResults results =
++ search (DN, SCOPE_BASE,
++ "(|(objectclass=*)(objectclass=ldapsubentry))",
++ attrs, false, cons);
++ if (results == null) {
++ return null;
++ }
++ LDAPEntry entry = results.next();
++ 
++ // cleanup required for referral connections
++ while (results.hasMoreElements()) {
++ results.nextElement();
++ }
++ 
++ return entry;
++ }
++
++ /**
++ * Reads the entry specified by the LDAP URL. 
++ *
++ * When you call this method, a new connection is created automatically,
++ * using the host and port specified in the URL. After finding the entry,
++ * the method closes this connection (in other words, it disconnects from
++ * the LDAP server). 
++ *
++ * If the URL specifies a filter and scope, these are not used.
++ * Of the information specified in the URL, this method only uses
++ * the LDAP host name and port number, the base distinguished name (DN),
++ * and the list of attributes to return. 
++ *
++ * The method returns the entry specified by the base DN. 
++ *
++ * (Note: If you want to search for more than one entry, use the
++ * <CODE>search( LDAPUrl )</CODE> method instead.) 
++ *
++ * For example, the following section of code reads the entry specified
++ * by the LDAP URL.
++ * 
++ *
++ * <PRE>
++ * String flatURL = "ldap://alway.mcom.com:3890/cn=Barbara Jenson,ou=Product Development,o=Ace Industry,c=US?cn,sn,mail";
++ * LDAPUrl myURL;
++ * try {
++ * myURL = new LDAPUrl( flatURL );
++ * } catch ( java.net.MalformedURLException e ) {
++ * System.out.println( "BAD URL!!! BAD, BAD, BAD URL!!!" );
++ * return;
++ * }
++ * LDAPEntry myEntry = null;
++ * try {
++ * myEntry = myConn.read( myURL );
++ * } catch ( LDAPException e ) {
++ * int errCode = e.getLDAPResultCode();
++ * switch( errCode ) {
++ * case ( e.NO_SUCH_OBJECT ):
++ * System.out.println( "The specified entry " + myDN +
++ * " does not exist in the directory." );
++ * return;
++ * default:
++ * System.out.println( "An internal error occurred." );
++ * return;
++ * }
++ * }
++ * </PRE>
++ *
++ * @param toGet LDAP URL specifying the entry to read
++ * @return LDAPEntry returns the entry specified by the URL (or raises
++ * an exception if the entry is not found).
++ * @exception LDAPException Failed to read the specified entry from
++ * the directory.
++ * @see netscape.ldap.LDAPUrl
++ * @see netscape.ldap.LDAPConnection#search(netscape.ldap.LDAPUrl)
++ */
++ public static LDAPEntry read (LDAPUrl toGet) throws LDAPException {
++ String host = toGet.getHost ();
++ int port = toGet.getPort();
++
++ if (host == null) {
++ throw new LDAPException ( "no host for connection",
++ LDAPException.PARAM_ERROR );
++ }
++
++ String[] attributes = toGet.getAttributeArray ();
++ String DN = toGet.getDN();
++ LDAPEntry returnValue;
++
++ LDAPConnection connection = new LDAPConnection ();
++ if (toGet.isSecure()) {
++ LDAPSocketFactory factory = toGet.getSocketFactory();
++ if (factory == null) {
++ throw new LDAPException("No socket factory for LDAPUrl",
++ LDAPException.OTHER);
++ }
++ connection.setSocketFactory(factory);
++ }
++ connection.connect (host, port);
++
++ returnValue = connection.read (DN, attributes);
++ connection.disconnect ();
++
++ return returnValue;
++ }
++
++ /**
++ * Performs the search specified by the LDAP URL. 
++ *
++ * For example, the following section of code searches for all entries under
++ * the <CODE>ou=Product Development,o=Ace Industry,c=US</CODE> subtree of a
++ * directory. The example gets and prints the mail attribute for each entry
++ * found. 
++ *
++ * <PRE>
++ * String flatURL = "ldap://alway.mcom.com:3890/ou=Product Development,o=Ace Industry,c=US?mail?sub?objectclass=*";
++ * LDAPUrl myURL;
++ * try {
++ * myURL = new LDAPUrl( flatURL );
++ * } catch ( java.net.MalformedURLException e ) {
++ * System.out.println( "Incorrect URL syntax." );
++ * return;
++ * }
++ *
++ * LDAPSearchResults myResults = null;
++ * try {
++ * myResults = myConn.search( myURL );
++ * } catch ( LDAPException e ) {
++ * int errCode = e.getLDAPResultCode();
++ * System.out.println( "LDAPException: return code:" + errCode );
++ * return;
++ * }
++ *
++ * while ( myResults.hasMoreElements() ) {
++ * LDAPEntry myEntry = myResults.next();
++ * String nextDN = myEntry.getDN();
++ * System.out.println( nextDN );
++ * LDAPAttributeSet entryAttrs = myEntry.getAttributeSet();
++ * Enumeration attrsInSet = entryAttrs.getAttributes();
++ * while ( attrsInSet.hasMoreElements() ) {
++ * LDAPAttribute nextAttr = (LDAPAttribute)attrsInSet.nextElement();
++ * String attrName = nextAttr.getName();
++ * System.out.print( "\t" + attrName + ": " );
++ * Enumeration valsInAttr = nextAttr.getStringValues();
++ * while ( valsInAttr.hasMoreElements() ) {
++ * String nextValue = (String)valsInAttr.nextElement();
++ * System.out.println( nextValue );
++ * }
++ * }
++ * }
++ * </PRE>
++ * 
++ *
++ * To abandon the search, use the <CODE>abandon</CODE> method.
++ *
++ * @param toGet LDAP URL representing the search to perform
++ * @return LDAPSearchResults the results of the search as an enumeration.
++ * @exception LDAPException Failed to complete the search specified by
++ * the LDAP URL.
++ * @see netscape.ldap.LDAPUrl
++ * @see netscape.ldap.LDAPSearchResults
++ * @see netscape.ldap.LDAPConnection#abandon(netscape.ldap.LDAPSearchResults)
++ */
++ public static LDAPSearchResults search (LDAPUrl toGet) throws LDAPException {
++ return search (toGet, null);
++ }
++
++ /**
++ * Performs the search specified by the LDAP URL. This method also
++ * allows you to specify constraints for the search (such as the
++ * maximum number of entries to find or the
++ * maximum time to wait for search results). 
++ *
++ * As part of the search constraints, you can specify whether or not you
++ * want the results delivered all at once or in smaller batches.
++ * If you specify the results delivered in smaller
++ * batches, each iteration blocks until the next batch of results is
++ * returned. 
++ *
++ * For example, the following section of code retrieves the first 5
++ * matching entries for the search specified by the LDAP URL. The
++ * example accomplishes this by creating a new set of search
++ * constraints where the maximum number of search results is 5. 
++ *
++ * <PRE>
++ * LDAPSearchConstraints mySearchConstraints = myConn.getSearchConstraints();
++ * mySearchConstraints.setMaxResults( 5 );
++ * String flatURL = "ldap://alway.mcom.com:3890/ou=Product Development,o=Ace Industry,c=US?mail?sub?objectclass=*";
++ * LDAPUrl myURL;
++ * try {
++ * myURL = new LDAPUrl( flatURL );
++ * } catch ( java.net.MalformedURLException e ) {
++ * System.out.println( "Incorrect URL syntax." );
++ * return;
++ * }
++ * LDAPSearchResults myResults = null;
++ * try {
++ * myResults = myConn.search( myURL, mySearchConstraints );
++ * } catch ( LDAPException e ) {
++ * int errCode = e.getLDAPResultCode();
++ * System.out.println( "LDAPException: return code:" + errCode );
++ * return;
++ * }
++ * </PRE>
++ * 
++ *
++ * To abandon the search, use the <CODE>abandon</CODE> method.
++ *
++ * @param toGet LDAP URL representing the search to run
++ * @param cons constraints specific to the search
++ * @return LDAPSearchResults the results of the search as an enumeration.
++ * @exception LDAPException Failed to complete the search specified
++ * by the LDAP URL.
++ * @see netscape.ldap.LDAPUrl
++ * @see netscape.ldap.LDAPSearchResults
++ * @see netscape.ldap.LDAPConnection#abandon(netscape.ldap.LDAPSearchResults)
++ */
++ public static LDAPSearchResults search (LDAPUrl toGet,
++ LDAPSearchConstraints cons) throws LDAPException {
++ String host = toGet.getHost ();
++ int port = toGet.getPort();
++
++ if (host == null) {
++ throw new LDAPException ( "no host for connection",
++ LDAPException.PARAM_ERROR );
++ }
++
++ String[] attributes = toGet.getAttributeArray ();
++ String DN = toGet.getDN();
++ String filter = toGet.getFilter();
++ if (filter == null) {
++ filter = defaultFilter;
++ }
++ int scope = toGet.getScope ();
++
++ LDAPConnection connection = new LDAPConnection ();
++ if (toGet.isSecure()) {
++ LDAPSocketFactory factory = toGet.getSocketFactory();
++ if (factory == null) {
++ throw new LDAPException("No socket factory for LDAPUrl",
++ LDAPException.OTHER);
++ }
++ connection.setSocketFactory(factory);
++ } 
++ connection.connect (host, port);
++
++ LDAPSearchResults results;
++ if (cons != null) {
++ results = connection.search (DN, scope, filter, attributes, false, cons);
++ } else {
++ results = connection.search (DN, scope, filter, attributes, false);
++ }
++
++ results.closeOnCompletion(connection);
++
++ return results;
++ }
++
++ /**
++ * Performs the search specified by the criteria that you enter. 
++ *
++ * For example, the following section of code searches for all entries under
++ * the <CODE>ou=Product Development,o=Ace Industry,c=US</CODE> subtree of a
++ * directory. The example gets and prints the mail attribute for each entry
++ * found. 
++ *
++ * <PRE>
++ * String myBaseDN = "ou=Product Development,o=Ace Industry,c=US";
++ * String myFilter="(objectclass=*)";
++ * String[] myAttrs = { "mail" };
++ *
++ * LDAPSearchResults myResults = null;
++ * try {
++ * myResults = myConn.search( myBaseDN, LDAPv2.SCOPE_SUB, myFilter, myAttrs, false );
++ * } catch ( LDAPException e ) {
++ * int errCode = e.getLDAPResultCode();
++ * System.out.println( "LDAPException: return code:" + errCode );
++ * return;
++ * }
++ *
++ * while ( myResults.hasMoreElements() ) {
++ * LDAPEntry myEntry = myResults.next();
++ * String nextDN = myEntry.getDN();
++ * System.out.println( nextDN );
++ * LDAPAttributeSet entryAttrs = myEntry.getAttributeSet();
++ * Enumeration attrsInSet = entryAttrs.getAttributes();
++ * while ( attrsInSet.hasMoreElements() ) {
++ * LDAPAttribute nextAttr = (LDAPAttribute)attrsInSet.nextElement();
++ * String attrName = nextAttr.getName();
++ * System.out.println( "\t" + attrName + ":" );
++ * Enumeration valsInAttr = nextAttr.getStringValues();
++ * while ( valsInAttr.hasMoreElements() ) {
++ * String nextValue = (String)valsInAttr.nextElement();
++ * System.out.println( "\t\t" + nextValue );
++ * }
++ * }
++ * }
++ * </PRE>
++ * 
++ *
++ * To abandon the search, use the <CODE>abandon</CODE> method.
++ *
++ * @param base the base distinguished name from which to search
++ * @param scope the scope of the entries to search. You can specify one
++ * of the following: 
++ * <UL>
++ * <LI><CODE>LDAPv2.SCOPE_BASE</CODE> (search only the base DN) 
++ * <LI><CODE>LDAPv2.SCOPE_ONE</CODE>
++ * (search only entries under the base DN) 
++ * <LI><CODE>LDAPv2.SCOPE_SUB</CODE>
++ * (search the base DN and all entries within its subtree) 
++ * </UL>
++ * 
++ * @param filter search filter specifying the search criteria
++ * @param attrs list of attributes that you want returned in the
++ * search results
++ * @param attrsOnly if true, returns the names but not the values of the
++ * attributes found. If false, returns the names and values for
++ * attributes found
++ * @return LDAPSearchResults the results of the search as an enumeration.
++ * @exception LDAPException Failed to complete the specified search.
++ * @see netscape.ldap.LDAPConnection#abandon(netscape.ldap.LDAPSearchResults)
++ */
++ public LDAPSearchResults search( String base, int scope, String filter,
++ String[] attrs, boolean attrsOnly ) throws LDAPException {
++ return search( base, scope, filter, attrs, attrsOnly, m_defaultConstraints);
++ }
++
++ /**
++ * Performs the search specified by the criteria that you enter.
++ * This method also allows you to specify constraints for the search
++ * (such as the maximum number of entries to find or the
++ * maximum time to wait for search results). 
++ *
++ * As part of the search constraints, you can specify whether or not
++ * you want the
++ * results delivered all at once or in smaller batches. If you
++ * specify that you want the results delivered in smaller batches,
++ * each iteration blocks until the
++ * next batch of results is returned. 
++ *
++ * For example, the following section of code retrieves the first 5 entries
++ * matching the specified search criteria. The example accomplishes
++ * this by creating a new set of search constraints where the maximum
++ * number of search results is 5. 
++ *
++ * <PRE>
++ * String myBaseDN = "ou=Product Development,o=Ace Industry,c=US";
++ * String myFilter="(objectclass=*)";
++ * String[] myAttrs = { "mail" };
++ * LDAPSearchConstraints mySearchConstraints = myConn.getSearchConstraints();
++ * mySearchConstraints.setMaxResults( 5 );
++ *
++ * LDAPSearchResults myResults = null;
++ * try {
++ * myResults = myConn.search( myBaseDN, LDAPv2.SCOPE_SUB, myFilter, myAttrs, false, mySearchConstraints );
++ * } catch ( LDAPException e ) {
++ * int errCode = e.getLDAPResultCode();
++ * System.out.println( "LDAPException: return code:" + errCode );
++ * return;
++ * }
++ * </PRE>
++ * 
++ *
++ * To abandon the search, use the <CODE>abandon</CODE> method.
++ *
++ * @param base the base distinguished name from which to search
++ * @param scope the scope of the entries to search. You can specify one
++ * of the following: 
++ * <UL>
++ * <LI><CODE>LDAPv2.SCOPE_BASE</CODE> (search only the base DN) 
++ * <LI><CODE>LDAPv2.SCOPE_ONE</CODE>
++ * (search only entries under the base DN) 
++ * <LI><CODE>LDAPv2.SCOPE_SUB</CODE>
++ * (search the base DN and all entries within its subtree) 
++ * </UL>
++ * 
++ * @param filter search filter specifying the search criteria
++ * @param attrs list of attributes to return in the search
++ * results
++ * @param cons constraints specific to this search (for example, the
++ * maximum number of entries to return)
++ * @param attrsOnly if true, returns the names but not the values of the
++ * attributes found. If false, returns the names and values for
++ * attributes found
++ * @return LDAPSearchResults the results of the search as an enumeration.
++ * @exception LDAPException Failed to complete the specified search.
++ * @see netscape.ldap.LDAPConnection#abandon(netscape.ldap.LDAPSearchResults)
++ */
++ public LDAPSearchResults search( String base, int scope, String filter,
++ String[] attrs, boolean attrsOnly, LDAPSearchConstraints cons )
++ throws LDAPException {
++ if (cons == null) {
++ cons = m_defaultConstraints;
++ }
++
++ LDAPSearchResults returnValue =
++ new LDAPSearchResults(this, cons, base, scope, filter,
++ attrs, attrsOnly);
++ Vector cacheValue = null;
++ Long key = null;
++ boolean isKeyValid = true;
++
++ try {
++ // get entry from cache which is a vector of JDAPMessages
++ if (m_cache != null) {
++ // create key for cache entry using search arguments
++ key = m_cache.createKey(getHost(), getPort(),base, filter,
++ scope, attrs, m_boundDN, cons);
++
++ cacheValue = (Vector)m_cache.getEntry(key);
++
++ if (cacheValue != null) {
++ return (new LDAPSearchResults(cacheValue, this, cons, base, scope,
++ filter, attrs, attrsOnly));
++ }
++ }
++ } catch (LDAPException e) {
++ isKeyValid = false;
++ printDebug("Exception: "+e);
++ }
++
++ checkConnection(/*rebind=*/true);
++
++ /* Is this a persistent search? */
++ boolean isPersistentSearch = false;
++ LDAPControl[] controls =
++ (LDAPControl[])getOption(LDAPv3.SERVERCONTROLS, cons);
++ for (int i = 0; (controls != null) && (i < controls.length); i++) {
++ if ( controls[i] instanceof
++ netscape.ldap.controls.LDAPPersistSearchControl ) {
++ isPersistentSearch = true;
++ break;
++ }
++ }
++
++ // Persistent search is an asynchronous operation
++ LDAPSearchListener myListener = isPersistentSearch ? new LDAPSearchListener(/*asynchOp=*/true, cons) :
++ getSearchListener ( cons );
++
++ int deref = cons.getDereference();
++
++ JDAPSearchRequest request = null; 
++ try {
++ request = new JDAPSearchRequest (base, scope, deref,
++ cons.getMaxResults(), cons.getServerTimeLimit(),
++ attrsOnly, filter, attrs);
++ } catch (IllegalArgumentException e) {
++ throw new LDAPException(e.getMessage(), LDAPException.PARAM_ERROR);
++ }
++
++ // if using cache, then need to add the key to the search listener.
++ if ((m_cache != null) && (isKeyValid)) {
++ myListener.setKey(key);
++
++ }
++ 
++ try {
++ sendRequest (request, myListener, cons);
++ }
++ catch (LDAPException e) {
++ releaseSearchListener (myListener);
++ throw e; 
++ }
++
++ /* For a persistent search, don't wait for a first result, because
++ there may be none at this time if changesOnly was specified in
++ the control.
++ */
++ if ( isPersistentSearch ) {
++ returnValue.associatePersistentSearch (myListener);
++
++ } else if ( cons.getBatchSize() == 0 ) {
++ /* Synchronous search if all requested at once */
++ try {
++ /* Block until all results are in */
++ LDAPMessage response = myListener.completeSearchOperation();
++ Enumeration results = myListener.getAllMessages().elements();
++
++ checkSearchMsg(returnValue, response, cons, base, scope,
++ filter, attrs, attrsOnly);
++
++ while (results.hasMoreElements ()) {
++ LDAPMessage msg = (LDAPMessage)results.nextElement();
++
++ checkSearchMsg(returnValue, msg, cons, base, scope, filter, attrs,
++ attrsOnly);
++ }
++ } finally {
++ releaseSearchListener (myListener);
++ }
++ } else {
++ /*
++ * Asynchronous to retrieve one at a time, check to make sure
++ * the search didn't fail
++ */
++ LDAPMessage firstResult = myListener.nextMessage ();
++ if ( firstResult instanceof LDAPResponse ) {
++ try {
++ checkSearchMsg(returnValue, firstResult, cons, base, scope,
++ filter, attrs, attrsOnly);
++ } finally {
++ releaseSearchListener (myListener);
++ }
++ } else {
++ try {
++ checkSearchMsg(returnValue, firstResult, cons, base,
++ scope, filter, attrs, attrsOnly);
++ } catch ( LDAPException ex ) {
++ releaseSearchListener (myListener);
++ throw ex;
++ }
++
++ /* we let this listener get garbage collected.. */
++ returnValue.associate (myListener);
++ }
++ }
++ return returnValue;
++ }
++
++ void checkSearchMsg(LDAPSearchResults value, LDAPMessage msg,
++ LDAPSearchConstraints cons, String dn, int scope, String filter,
++ String attrs[], boolean attrsOnly) throws LDAPException {
++
++ value.setMsgID(msg.getMessageID());
++
++ try {
++ checkMsg (msg);
++ // not the JDAPResult
++ if (msg.getProtocolOp().getType() != JDAPProtocolOp.SEARCH_RESULT) {
++ value.add (msg);
++ }
++ } catch (LDAPReferralException e) {
++ Vector res = new Vector();
++ 
++ try {
++ performReferrals(e, cons, JDAPProtocolOp.SEARCH_REQUEST, dn,
++ scope, filter, attrs, attrsOnly, null, null, null, res);
++ }
++ catch (LDAPException ex) {
++ if (msg.getProtocolOp() instanceof JDAPSearchResultReference) {
++ // Ignore Search Result Referral Errors ?
++ if (cons.getReferralErrors() == cons.REFERRAL_ERROR_CONTINUE) {
++ return; // Don't want to miss all remaining results
++ }
++ else {
++ throw ex;
++ }
++ }
++ throw ex;
++ }
++
++ // the size of the vector can be more than 1 because it is possible
++ // to visit more than one referral url to retrieve the entries
++ for (int i=0; i<res.size(); i++) {
++ value.addReferralEntries((LDAPSearchResults)res.elementAt(i));
++ }
++
++ res = null;
++ } catch (LDAPException e) {
++ if ((e.getLDAPResultCode() == LDAPException.ADMIN_LIMIT_EXCEEDED) ||
++ (e.getLDAPResultCode() == LDAPException.TIME_LIMIT_EXCEEDED) ||
++ (e.getLDAPResultCode() == LDAPException.SIZE_LIMIT_EXCEEDED)) {
++ value.add(e);
++ } else {
++ throw e;
++ }
++ }
++ }
++
++ /**
++ * Checks to see if an entry contains an attribute with a specified value.
++ * Returns <CODE>true</CODE> if the entry has the value. Returns
++ * <CODE>false</CODE> if the entry does not have the value or the
++ * attribute. To represent the value that you want compared, you need
++ * to create an <CODE>LDAPAttribute</CODE> object.
++ *
++ * Note that only string values can be compared. 
++ *
++ * For example, the following section of code checks to see if the entry
++ * "cn=Barbara Jensen,ou=Product Development,o=Ace Industry,c=US" contains
++ * the attribute "mail" with the value "bjensen@aceindustry.com".
++ *
++ * <PRE>
++ * ...
++ * LDAPConnection myConn = new LDAPConnection();
++ * ...
++ * String myDN = "cn=Barbara Jensen,ou=Product Development,o=Ace Industry,c=US";
++ * String nameOfAttr = "mail";
++ * String valOfAttr = "bjensen@aceindustry.com";
++ * LDAPAttribute cmpThisAttr = new LDAPAttribute( nameOfAttr, valOfAttr );
++ * boolean hasValue = myConn.compare( myDN, cmpThisAttr );
++ * if ( hasValue ) {
++ * System.out.println( "Attribute and value found in entry." );
++ * } else {
++ * System.out.println( "Attribute and value not found in entry." );
++ * }
++ * ...</PRE>
++ *
++ * @param DN the distinguished name of the entry to use in
++ * the comparison
++ * @param attr the attribute to compare against the entry.
++ * (The method checks to see if the entry has an attribute with the same name
++ * and value as this attribute.)
++ * @return true if the entry contains the specified attribute and value.
++ * @exception LDAPException Failed to perform the comparison.
++ * @see netscape.ldap.LDAPAttribute
++ */
++ public boolean compare( String DN, LDAPAttribute attr )
++ throws LDAPException {
++ return compare(DN, attr, m_defaultConstraints);
++ }
++
++ public boolean compare( String DN, LDAPAttribute attr,
++ LDAPConstraints cons) throws LDAPException {
++ checkConnection(/*rebind=*/true);
++
++ LDAPResponseListener myListener = getResponseListener ();
++ Enumeration en = attr.getStringValues();
++ String val = (String)en.nextElement();
++ JDAPAVA ass = new JDAPAVA(attr.getName(), val);
++
++ LDAPMessage response;
++ try {
++ sendRequest (new JDAPCompareRequest (DN, ass), myListener, cons);
++ response = myListener.getResponse ();
++
++ int resultCode = ((JDAPResult)response.getProtocolOp()).getResultCode();
++ if (resultCode == JDAPResult.COMPARE_FALSE) {
++ return false;
++ }
++ if (resultCode == JDAPResult.COMPARE_TRUE) {
++ return true;
++ }
++
++ checkMsg (response);
++
++ } catch (LDAPReferralException e) {
++ Vector res = new Vector();
++ performReferrals(e, cons, JDAPProtocolOp.COMPARE_REQUEST,
++ DN, 0, null, null, false, null, null, attr, res);
++ boolean bool = false;
++ if (res.size() > 0) {
++ bool = ((Boolean)res.elementAt(0)).booleanValue();
++ }
++ return bool;
++ } finally {
++ releaseResponseListener (myListener);
++ }
++ return false; /* this should never be executed */
++ }
++
++ /**
++ * @deprecated Please use the method signature where <CODE>cons</CODE> is
++ * <CODE>LDAPConstraints</CODE> instead of <CODE>LDAPSearchConstraints</CODE>
++ */
++ public boolean compare( String DN, LDAPAttribute attr,
++ LDAPSearchConstraints cons) throws LDAPException {
++ return compare(DN, attr, (LDAPConstraints) cons);
++ } 
++ 
++ /**
++ * Adds an entry to the directory. 
++ *
++ * Before using this method, you need to create an
++ * <CODE>LDAPEntry</CODE> object and use it to specify the
++ * distinguished name and attributes of the new entry. Make sure
++ * to specify values for all required attributes in the
++ * entry. If all required attributes are not specified and the LDAP server
++ * checks the entry against the schema, an <CODE>LDAPException</CODE>
++ * may be thrown (where the LDAP result code is
++ * <CODE>OBJECT_CLASS_VIOLATION</CODE>).
++ *
++ * For example, the following section of code creates an
++ * <CODE>LDAPEntry</CODE> object for a new entry and uses the object
++ * to add the new entry to the directory. Because the definition of
++ * the LDAP <CODE>inetOrgPerson</CODE> class specifies that the
++ * <CODE>cn</CODE>, <CODE>sn</CODE>, and <CODE>objectclass</CODE>
++ * attributes are required, these attributes are specified as part
++ * of the new entry. (<CODE>mail</CODE> is not required but is shown
++ * here as an example of specifying additional attributes.)
++ * 
++ *
++ * <PRE>
++ * ...
++ * String myDN = "cn=Barbara Jensen,ou=Product Development,o=Ace Industry,c=US";
++ *
++ * LDAPAttribute attr1 = new LDAPAttribute( "cn", "Barbara Jensen" );
++ * LDAPAttribute attr2 = new LDAPAttribute( "sn", "Jensen" );
++ * LDAPAttribute attr3 = new LDAPAttribute( "objectclass", "top" );
++ * LDAPAttribute attr4 = new LDAPAttribute( "objectclass", "person" );
++ * LDAPAttribute attr5 = new LDAPAttribute( "objectclass", "organizationalPerson" );
++ * LDAPAttribute attr6 = new LDAPAttribute( "objectclass", "inetOrgPerson" );
++ * LDAPAttribute attr7 = new LDAPAttribute( "mail", "bjensen@aceindustry.com" );
++ *
++ * LDAPAttributeSet myAttrs = new LDAPAttributeSet();
++ * myAttrs.add( attr1 );
++ * myAttrs.add( attr2 );
++ * myAttrs.add( attr3 );
++ * myAttrs.add( attr4 );
++ * myAttrs.add( attr5 );
++ * myAttrs.add( attr6 );
++ * myAttrs.add( attr7 );
++ *
++ * LDAPEntry myEntry = new LDAPEntry( myDN, myAttrs );
++ *
++ * myConn.add( myEntry );
++ * ... </PRE>
++ *
++ * @param entry LDAPEntry object specifying the distinguished name and
++ * attributes of the new entry
++ * @exception LDAPException Failed to add the specified entry to the
++ * directory.
++ * @see netscape.ldap.LDAPEntry
++ */
++ public void add( LDAPEntry entry ) throws LDAPException {
++ add(entry, m_defaultConstraints);
++ }
++
++ /**
++ * Adds an entry to the directory and allows you to specify preferences
++ * for this LDAP add operation by using an
++ * <CODE>LDAPConstraints</CODE> object. For
++ * example, you can specify whether or not to follow referrals.
++ * You can also apply LDAP v3 controls to the operation.
++ * 
++ *
++ * @param entry LDAPEntry object specifying the distinguished name and
++ * attributes of the new entry
++ * @param cons the set of preferences to apply to this operation
++ * @exception LDAPException Failed to add the specified entry to the
++ * directory.
++ * @see netscape.ldap.LDAPEntry
++ * @see netscape.ldap.LDAPConstraints
++ */
++ public void add( LDAPEntry entry, LDAPConstraints cons )
++ throws LDAPException {
++ checkConnection(/*rebind=*/true);
++
++ LDAPResponseListener myListener = getResponseListener ();
++ LDAPAttributeSet attrs = entry.getAttributeSet ();
++ LDAPAttribute[] attrList = new LDAPAttribute[attrs.size()];
++ for( int i = 0; i < attrs.size(); i++ ) {
++ attrList[i] = (LDAPAttribute)attrs.elementAt( i );
++ }
++ int attrPosition = 0;
++ LDAPMessage response;
++ try {
++ sendRequest (new JDAPAddRequest (entry.getDN(), attrList),
++ myListener, cons);
++ response = myListener.getResponse();
++ checkMsg (response);
++ } catch (LDAPReferralException e) {
++ performReferrals(e, cons, JDAPProtocolOp.ADD_REQUEST,
++ null, 0, null, null, false, null, entry, null, null);
++ } finally {
++ releaseResponseListener (myListener);
++ }
++ }
++
++ /**
++ * @deprecated Please use the method signature where <CODE>cons</CODE> is
++ * <CODE>LDAPConstraints</CODE> instead of <CODE>LDAPSearchConstraints</CODE>
++ */
++ public void add( LDAPEntry entry, LDAPSearchConstraints cons )
++ throws LDAPException {
++ add(entry, (LDAPConstraints) cons);
++ }
++
++ /**
++ * Performs an extended operation on the directory. Extended operations
++ * are part of version 3 of the LDAP protocol.
++ *
++ * Note that in order for the extended operation to work, the server
++ * that you are connecting to must support LDAP v3 and must be configured
++ * to process the specified extended operation.
++ *
++ * @param op LDAPExtendedOperation object specifying the OID of the
++ * extended operation and the data to use in the operation
++ * @exception LDAPException Failed to execute the operation
++ * @return LDAPExtendedOperation object representing the extended response
++ * returned by the server.
++ * @see netscape.ldap.LDAPExtendedOperation
++ */
++ public LDAPExtendedOperation extendedOperation( LDAPExtendedOperation op )
++ throws LDAPException {
++
++ return extendedOperation(op, m_defaultConstraints);
++ }
++
++ /**
++ * Performs an extended operation on the directory. Extended operations
++ * are part of version 3 of the LDAP protocol. This method allows the
++ * user to set the preferences for the operation.
++ *
++ * Note that in order for the extended operation to work, the server
++ * that you are connecting to must support LDAP v3 and must be configured
++ * to process the specified extended operation.
++ *
++ * @param op LDAPExtendedOperation object specifying the OID of the
++ * extended operation and the data to use in the operation
++ * @param cons preferences for the extended operation
++ * @exception LDAPException Failed to execute the operation
++ * @return LDAPExtendedOperation object representing the extended response
++ * returned by the server.
++ * @see netscape.ldap.LDAPExtendedOperation
++ */
++ public LDAPExtendedOperation extendedOperation( LDAPExtendedOperation op,
++ LDAPConstraints cons)
++ throws LDAPException {
++ checkConnection(/*rebind=*/true);
++
++ LDAPResponseListener myListener = getResponseListener ();
++ LDAPMessage response = null;
++ byte[] results = null;
++ String resultID;
++
++ try {
++ sendRequest ( new JDAPExtendedRequest( op.getID(),
++ op.getValue() ),
++ myListener, cons );
++ response = myListener.getResponse();
++ checkMsg (response);
++ JDAPExtendedResponse res = (JDAPExtendedResponse)response.getProtocolOp();
++ results = res.getValue();
++ resultID = res.getID();
++ } catch (LDAPReferralException e) {
++ return performExtendedReferrals( e, cons, op );
++ } finally {
++ releaseResponseListener (myListener);
++ }
++ return new LDAPExtendedOperation( resultID, results );
++ }
++
++ /**
++ * @deprecated Please use the method signature where <CODE>cons</CODE> is
++ * <CODE>LDAPConstraints</CODE> instead of <CODE>LDAPSearchConstraints</CODE>
++ */
++ public LDAPExtendedOperation extendedOperation( LDAPExtendedOperation op,
++ LDAPSearchConstraints cons)
++ throws LDAPException {
++
++ return extendedOperation(op, (LDAPConstraints)cons);
++ }
++
++ /**
++ * Makes a single change to an existing entry in the directory.
++ * For example, changes the value of an attribute, adds a new
++ * attribute value, or removes an existing attribute value. 
++ *
++ * Use the <CODE>LDAPModification</CODE> object to specify the change
++ * to make and the <CODE>LDAPAttribute</CODE> object
++ * to specify the attribute value to change. The
++ * <CODE>LDAPModification</CODE> object allows you add an attribute
++ * value, change an attibute value, or remove an attribute
++ * value. 
++ *
++ * For example, the following section of code changes Barbara Jensen's email
++ * address in the directory to babs@aceindustry.com. 
++ *
++ * <PRE>
++ * ...
++ * String myEntryDN = "cn=Barbara Jensen,ou=Product Development,o=Ace Industry,c=US";
++ *
++ * LDAPAttribute attrEmail = new LDAPAttribute( "mail", "babs@aceindustry.com" );
++ * LDAPModification singleChange = new LDAPModification( LDAPModification.REPLACE, attrEmail );
++ *
++ * myConn.modify( myEntryDN, singleChange );
++ * ... </PRE>
++ *
++ * @param DN the distinguished name of the entry to modify
++ * @param mod a single change to make to the entry
++ * @exception LDAPException Failed to make the specified change to the
++ * directory entry.
++ * @see netscape.ldap.LDAPModification
++ */
++ public void modify( String DN, LDAPModification mod ) throws LDAPException {
++ modify(DN, mod, m_defaultConstraints);
++ }
++
++ /**
++ * Makes a single change to an existing entry in the directory and
++ * allows you to specify preferences for this LDAP modify operation
++ * by using an <CODE>LDAPConstraints</CODE> object.
++ * For example, you can specify whether or not to follow referrals.
++ * You can also apply LDAP v3 controls to the operation.
++ * 
++ *
++ * @param DN the distinguished name of the entry to modify
++ * @param mod a single change to make to the entry
++ * @param cons the set of preferences to apply to this operation
++ * @exception LDAPException Failed to make the specified change to the
++ * directory entry.
++ * @see netscape.ldap.LDAPModification
++ * @see netscape.ldap.LDAPConstraints
++ */
++ public void modify( String DN, LDAPModification mod,
++ LDAPConstraints cons ) throws LDAPException {
++ LDAPModification[] mods = { mod };
++ modify (DN, mods, cons);
++ }
++
++ /**
++ * @deprecated Please use the method signature where <CODE>cons</CODE> is
++ * <CODE>LDAPConstraints</CODE> instead of <CODE>LDAPSearchConstraints</CODE>
++ */
++ public void modify( String DN, LDAPModification mod,
++ LDAPSearchConstraints cons ) throws LDAPException {
++ modify (DN, mod, (LDAPConstraints)cons);
++ } 
++
++ /**
++ * Makes a set of changes to an existing entry in the directory.
++ * For example, changes attribute values, adds new attribute values,
++ * or removes existing attribute values. 
++ *
++ * Use the <CODE>LDAPModificationSet</CODE> object to specify the set
++ * of changes to make. Changes are specified in terms
++ * of attribute values. You must specify each attribute value to modify, add,
++ * or remove by an <CODE>LDAPAttribute</CODE> object.
++ * 
++ *
++ * For example, the following section of code changes Barbara Jensen's
++ * title, adds a telephone number to the entry, and removes the room
++ * number from the entry. 
++ *
++ * <PRE>
++ * ...
++ * String myEntryDN = "cn=Barbara Jensen,ou=Product Development,o=Ace Industry,c=US";
++ *
++ * LDAPModificationSet manyChanges = new LDAPModificationSet();
++ * LDAPAttribute attrTelephoneNumber = new LDAPAttribute( "telephoneNumber",
++ * "555-1212" );
++ * manyChanges.add( LDAPModification.ADD, attrTelephoneNumber );
++ * LDAPAttribute attrRoomNumber = new LDAPAttribute( "roomnumber", "222" );
++ * manyChanges.add( LDAPModification.DELETE, attrRoomNumber );
++ * LDAPAttribute attrTitle = new LDAPAttribute( "title",
++ * "Manager of Product Development" );
++ * manyChanges.add( LDAPModification.REPLACE, attrTitle );
++ *
++ * myConn.modify( myEntryDN, manyChanges );
++ * ... </PRE>
++ *
++ * @param DN the distinguished name of the entry to modify
++ * @param mods a set of changes to make to the entry
++ * @exception LDAPException Failed to make the specified changes to the
++ * directory entry.
++ * @see netscape.ldap.LDAPModificationSet
++ */
++ public void modify (String DN, LDAPModificationSet mods)
++ throws LDAPException {
++ modify(DN, mods, m_defaultConstraints);
++ }
++
++ /**
++ * Makes a set of changes to an existing entry in the directory and
++ * allows you to specify preferences for this LDAP modify operation
++ * by using an <CODE>LDAPConstraints</CODE> object.
++ * For example, you can specify whether or not to follow referrals.
++ * You can also apply LDAP v3 controls to the operation.
++ * 
++ *
++ * @param DN the distinguished name of the entry to modify
++ * @param mods a set of changes to make to the entry
++ * @param cons the set of preferences to apply to this operation
++ * @exception LDAPException Failed to make the specified changes to the
++ * directory entry.
++ * @see netscape.ldap.LDAPModificationSet
++ * @see netscape.ldap.LDAPConstraints
++ */
++ public void modify (String DN, LDAPModificationSet mods,
++ LDAPConstraints cons) throws LDAPException {
++ LDAPModification[] modList = new LDAPModification[mods.size()];
++ for( int i = 0; i < mods.size(); i++ ) {
++ modList[i] = mods.elementAt( i );
++ }
++ modify (DN, modList, cons);
++ }
++
++ /**
++ * @deprecated Please use the method signature where <CODE>cons</CODE> is
++ * <CODE>LDAPConstraints</CODE> instead of <CODE>LDAPSearchConstraints</CODE>
++ */
++ public void modify (String DN, LDAPModificationSet mods,
++ LDAPSearchConstraints cons) throws LDAPException {
++ modify(DN, mods, (LDAPConstraints)cons);
++ } 
++ 
++ /**
++ * Makes a set of changes to an existing entry in the directory.
++ * For example, changes attribute values, adds new attribute values,
++ * or removes existing attribute values. 
++ *
++ * Use an array of <CODE>LDAPModification</CODE> objects to specify the
++ * changes to make. Each change must be specified by
++ * an <CODE>LDAPModification</CODE> object, and you must specify each 
++ * attribute value to modify, add, or remove by an <CODE>LDAPAttribute</CODE> 
++ * object. 
++ *
++ * @param DN the distinguished name of the entry to modify
++ * @param mods an array of objects representing the changes to make
++ * to the entry
++ * @exception LDAPException Failed to make the specified changes to the
++ * directory entry.
++ * @see netscape.ldap.LDAPModification
++ */
++ public void modify (String DN, LDAPModification[] mods)
++ throws LDAPException {
++ modify(DN, mods, m_defaultConstraints);
++ }
++
++ /**
++ * Makes a set of changes to an existing entry in the directory and
++ * allows you to specify preferences for this LDAP modify operation
++ * by using an <CODE>LDAPConstraints</CODE> object.
++ * For example, you can specify whether or not to follow referrals.
++ * You can also apply LDAP v3 controls to the operation.
++ * 
++ *
++ * @param DN the distinguished name of the entry to modify
++ * @param mods an array of objects representing the changes to make
++ * to the entry
++ * @param cons the set of preferences to apply to this operation
++ * @exception LDAPException Failed to make the specified changes to the
++ * directory entry.
++ * @see netscape.ldap.LDAPModification
++ * @see netscape.ldap.LDAPConstraints
++ */
++ public void modify (String DN, LDAPModification[] mods,
++ LDAPConstraints cons) throws LDAPException {
++ checkConnection(/*rebind=*/true);
++
++ LDAPResponseListener myListener = getResponseListener ();
++ LDAPMessage response = null;
++ try {
++ sendRequest (new JDAPModifyRequest (DN, mods), myListener, cons);
++ response = myListener.getResponse();
++ checkMsg (response);
++ } catch (LDAPReferralException e) {
++ performReferrals(e, cons, JDAPProtocolOp.MODIFY_REQUEST,
++ DN, 0, null, null, false, mods, null, null, null);
++ } finally {
++ releaseResponseListener (myListener);
++ }
++ }
++
++ /**
++ * @deprecated Please use the method signature where <CODE>cons</CODE> is
++ * <CODE>LDAPConstraints</CODE> instead of <CODE>LDAPSearchConstraints</CODE>
++ */
++ public void modify (String DN, LDAPModification[] mods,
++ LDAPSearchConstraints cons) throws LDAPException {
++ modify(DN, mods, (LDAPConstraints)cons);
++ } 
++
++ /**
++ * Deletes the entry for the specified DN from the directory. 
++ *
++ * For example, the following section of code deletes the entry for
++ * Barbara Jensen from the directory. 
++ *
++ * <PRE>
++ * ...
++ * String myEntryDN = "cn=Barbara Jensen,ou=Product Development,o=Ace Industry,c=US";
++ * myConn.delete( myEntryDN );
++ * ... </PRE>
++ *
++ * @param DN distinguished name identifying the entry
++ * to remove from the directory
++ * @exception LDAPException Failed to delete the specified entry from
++ * the directory.
++ */
++ public void delete( String DN ) throws LDAPException {
++ delete(DN, m_defaultConstraints);
++ }
++
++ /**
++ * Deletes the entry for the specified DN from the directory and
++ * allows you to specify preferences for this LDAP delete operation
++ * by using an <CODE>LDAPConstraints</CODE> object. For
++ * example, you can specify whether or not to follow referrals.
++ * You can also apply LDAP v3 controls to the operation.
++ * 
++ *
++ * @param DN distinguished name identifying the entry 
++ * to remove from the directory
++ * @param cons the set of preferences to apply to this operation
++ * @exception LDAPException Failed to delete the specified entry from
++ * the directory.
++ * @see netscape.ldap.LDAPConstraints
++ */
++ public void delete( String DN, LDAPConstraints cons )
++ throws LDAPException {
++ checkConnection(/*rebind=*/true);
++
++ LDAPResponseListener myListener = getResponseListener ();
++ LDAPMessage response;
++ try {
++ sendRequest (new JDAPDeleteRequest (DN), myListener, cons);
++ response = myListener.getResponse();
++ checkMsg (response);
++ } catch (LDAPReferralException e) {
++ performReferrals(e, cons, JDAPProtocolOp.DEL_REQUEST,
++ DN, 0, null, null, false, null, null, null, null);
++ } finally {
++ releaseResponseListener (myListener);
++ }
++ }
++
++ /**
++ * @deprecated Please use the method signature where <CODE>cons</CODE> is
++ * <CODE>LDAPConstraints</CODE> instead of <CODE>LDAPSearchConstraints</CODE>
++ */
++ public void delete( String DN, LDAPSearchConstraints cons )
++ throws LDAPException {
++ delete(DN, (LDAPConstraints)cons);
++ }
++
++ /**
++ * Renames an existing entry in the directory. 
++ *
++ * You can specify whether or not the original name of the entry is
++ * retained as a value in the entry. For example, suppose you rename
++ * the entry "cn=Barbara" to "cn=Babs". You can keep "cn=Barbara"
++ * as a value in the entry so that the cn attribute has two values: 
++ *
++ * <PRE>
++ * cn=Barbara
++ * cn=Babs
++ * </PRE>
++ * The following example renames an entry. The old name of the entry
++ * is kept as a value in the entry. 
++ *
++ * <PRE>
++ * ...
++ * String myEntryDN = "cn=Barbara Jensen,ou=Product Development,o=Ace Industry,c=US";
++ * String newRDN = "cn=Babs Jensen";
++ * myConn.rename( myEntryDN, newRDN, false );
++ * ... </PRE>
++ *
++ * @param DN current distinguished name of the entry
++ * @param newRDN new relative distinguished name for the entry (for example,
++ * "cn=newName")
++ * @param deleteOldRDN if <CODE>true</CODE>, the old name is not retained
++ * as an attribute value (for example, the attribute value "cn=oldName" is
++ * removed). If <CODE>false</CODE>, the old name is retained
++ * as an attribute value (for example, the entry might now have two values
++ * for the cn attribute: "cn=oldName" and "cn=newName").
++ * @exception LDAPException Failed to rename the specified entry.
++ */
++ public void rename (String DN, String newRDN, boolean deleteOldRDN )
++ throws LDAPException {
++ rename(DN, newRDN, null, deleteOldRDN);
++ }
++
++ /**
++ * Renames an existing entry in the directory. 
++ *
++ * You can specify whether or not the original name of the entry is
++ * retained as a value in the entry. For example, suppose you rename
++ * the entry "cn=Barbara" to "cn=Babs". You can keep "cn=Barbara"
++ * as a value in the entry so that the cn attribute has two values: 
++ *
++ * <PRE>
++ * cn=Barbara
++ * cn=Babs
++ * </PRE>
++ * The following example renames an entry. The old name of the entry
++ * is kept as a value in the entry. 
++ *
++ * <PRE>
++ * ...
++ * String myEntryDN = "cn=Barbara Jensen,ou=Product Development,o=Ace Industry,c=US";
++ * String newRDN = "cn=Babs Jensen";
++ * myConn.rename( myEntryDN, newRDN, false );
++ * ... </PRE>
++ *
++ * @param DN current distinguished name of the entry
++ * @param newRDN new relative distinguished name for the entry (for example,
++ * "cn=newName")
++ * @param deleteOldRDN if <CODE>true</CODE>, the old name is not retained
++ * as an attribute value (for example, the attribute value "cn=oldName" is
++ * removed). If <CODE>false</CODE>, the old name is retained
++ * as an attribute value (for example, the entry might now have two values
++ * for the cn attribute: "cn=oldName" and "cn=newName").
++ * @param cons the set of preferences to apply to this operation
++ * @exception LDAPException Failed to rename the specified entry.
++ */
++ public void rename (String DN, String newRDN, boolean deleteOldRDN,
++ LDAPConstraints cons )
++ throws LDAPException {
++ rename(DN, newRDN, null, deleteOldRDN, cons);
++ }
++
++ /**
++ * @deprecated Please use the method signature where <CODE>cons</CODE> is
++ * <CODE>LDAPConstraints</CODE> instead of <CODE>LDAPSearchConstraints</CODE>
++ */
++ public void rename (String DN, String newRDN, boolean deleteOldRDN,
++ LDAPSearchConstraints cons )
++ throws LDAPException {
++ rename(DN, newRDN, deleteOldRDN, (LDAPConstraints)cons);
++ }
++
++ /**
++ * Renames an existing entry in the directory and (optionally)
++ * changes the location of the entry in the directory tree.
++ *
++ * NOTE: Netscape Directory Server 3.0 does not support the
++ * capability to move an entry to a different location in the
++ * directory tree. If you specify a value for the <CODE>newParentDN</CODE>
++ * argument, an <CODE>LDAPException</CODE> will be thrown.
++ * 
++ *
++ * @param dn current distinguished name of the entry
++ * @param newRDN new relative distinguished name for the entry (for example,
++ * "cn=newName")
++ * @param newParentDN if not null, the distinguished name for the
++ * entry under which the entry should be moved (for example, to move
++ * an entry under the Accounting subtree, specify this argument as
++ * "ou=Accounting, o=Ace Industry, c=US")
++ * @param deleteOldRDN if <CODE>true</CODE>, the old name is not retained
++ * as an attribute value (for example, the attribute value "cn=oldName" is
++ * removed). If <CODE>false</CODE>, the old name is retained
++ * as an attribute value (for example, the entry might now have two values
++ * for the cn attribute: "cn=oldName" and "cn=newName").
++ * @exception LDAPException Failed to rename the specified entry.
++ */
++ public void rename(String dn,
++ String newRDN,
++ String newParentDN,
++ boolean deleteOldRDN) throws LDAPException {
++ rename(dn, newRDN, newParentDN, deleteOldRDN, m_defaultConstraints);
++ }
++
++ /**
++ * Renames an existing entry in the directory and (optionally)
++ * changes the location of the entry in the directory tree. Also
++ * allows you to specify preferences for this LDAP modify DN operation
++ * by using an <CODE>LDAPConstraints</CODE> object. For
++ * example, you can specify whether or not to follow referrals.
++ * You can also apply LDAP v3 controls to the operation.
++ * 
++ *
++ * NOTE: Netscape Directory Server 3.0 does not support the
++ * capability to move an entry to a different location in the
++ * directory tree. If you specify a value for the <CODE>newParentDN</CODE>
++ * argument, an <CODE>LDAPException</CODE> will be thrown.
++ * 
++ *
++ * @param DN current distinguished name of the entry
++ * @param newRDN new relative distinguished name for the entry (for example,
++ * "cn=newName")
++ * @param newParentDN if not null, the distinguished name for the
++ * entry under which the entry should be moved (for example, to move
++ * an entry under the Accounting subtree, specify this argument as
++ * "ou=Accounting, o=Ace Industry, c=US")
++ * @param deleteOldRDN if <CODE>true</CODE>, the old name is not retained
++ * as an attribute value (for example, the attribute value "cn=oldName" is
++ * removed). If <CODE>false</CODE>, the old name is retained
++ * as an attribute value (for example, the entry might now have two values
++ * for the cn attribute: "cn=oldName" and "cn=newName").
++ * @param cons the set of preferences to apply to this operation
++ * @exception LDAPException Failed to rename the specified entry.
++ * @see netscape.ldap.LDAPConstraints
++ */
++ public void rename (String DN,
++ String newRDN,
++ String newParentDN,
++ boolean deleteOldRDN,
++ LDAPConstraints cons)
++ throws LDAPException {
++ checkConnection(/*rebind=*/true);
++
++ LDAPResponseListener myListener = getResponseListener ();
++ try {
++ JDAPModifyRDNRequest request = null;
++ if ( newParentDN != null ) {
++ request = new JDAPModifyRDNRequest (DN,
++ newRDN,
++ deleteOldRDN,
++ newParentDN);
++ } else {
++ request = new JDAPModifyRDNRequest (DN,
++ newRDN,
++ deleteOldRDN);
++ }
++ sendRequest (request, myListener, cons);
++ LDAPMessage response = myListener.getResponse();
++ checkMsg (response);
++ } catch (LDAPReferralException e) {
++ performReferrals(e, cons, JDAPProtocolOp.MODIFY_RDN_REQUEST,
++ DN, 0, newRDN, null, deleteOldRDN, null, null,
++ null, null);
++ } finally {
++ releaseResponseListener (myListener);
++ }
++ }
++
++ /**
++ * @deprecated Please use the method signature where <CODE>cons</CODE> is
++ * <CODE>LDAPConstraints</CODE> instead of <CODE>LDAPSearchConstraints</CODE>
++ */
++ public void rename (String DN,
++ String newRDN,
++ String newParentDN,
++ boolean deleteOldRDN,
++ LDAPSearchConstraints cons)
++ throws LDAPException {
++ rename(DN, newRDN, newParentDN, deleteOldRDN, (LDAPConstraints)cons);
++ } 
++
++ /**
++ * Adds an entry to the directory.
++ *
++ * @param entry LDAPEntry object specifying the distinguished name and
++ * attributes of the new entry
++ * @param listener handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @return LDAPResponseListener handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ * @see netscape.ldap.LDAPEntry
++ * @see netscape.ldap.LDAPResponseListener
++ */
++ public LDAPResponseListener add(LDAPEntry entry,
++ LDAPResponseListener listener)
++ throws LDAPException{
++ return add(entry, listener, m_defaultConstraints);
++ }
++ 
++ /**
++ * Adds an entry to the directory and allows you to specify constraints
++ * for this LDAP add operation by using an <CODE>LDAPConstraints</CODE>
++ * object. For example, you can specify whether or not to follow referrals.
++ * You can also apply LDAP v3 controls to the operation.
++ * 
++ *
++ * @param entry LDAPEntry object specifying the distinguished name and
++ * attributes of the new entry
++ * @param listener handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @param cons constraints specific to the operation
++ * @return LDAPResponseListener handler for messages returned from a server
++ * in response to this request
++ * @exception LDAPException Failed to send request.
++ * @see netscape.ldap.LDAPEntry
++ * @see netscape.ldap.LDAPResponseListener
++ * @see netscape.ldap.LDAPConstraints
++ */
++ public LDAPResponseListener add(LDAPEntry entry,
++ LDAPResponseListener listener,
++ LDAPConstraints cons)
++ throws LDAPException{
++
++ if (cons == null) {
++ cons = m_defaultConstraints;
++ }
++ 
++ checkConnection(/*rebind=*/true);
++
++ if (listener == null) {
++ listener = new LDAPResponseListener(/*asynchOp=*/true);
++ }
++
++ LDAPAttributeSet attrs = entry.getAttributeSet ();
++ LDAPAttribute[] attrList = new LDAPAttribute[attrs.size()];
++ for( int i = 0; i < attrs.size(); i++ )
++ attrList[i] = (LDAPAttribute)attrs.elementAt( i );
++ int attrPosition = 0;
++
++ sendRequest (new JDAPAddRequest (entry.getDN(), attrList),
++ listener, cons);
++
++ return listener;
++ }
++
++ /**
++ * Authenticates to the LDAP server (to which the object is currently
++ * connected) using the specified name and password. If the object
++ * has been disconnected from an LDAP server, this method attempts to
++ * reconnect to the server. If the object had already authenticated, the
++ * old authentication is discarded.
++ * 
++ * @param version required LDAP protocol version
++ * @param dn if non-null and non-empty, specifies that the connection
++ * and all operations through it should authenticate with dn as the
++ * distinguished name
++ * @param passwd if non-null and non-empty, specifies that the connection
++ * and all operations through it should authenticate with dn as the
++ * distinguished name and passwd as password
++ * @param listener handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @return LDAPResponseListener handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ * @see netscape.ldap.LDAPResponseListener
++ */
++ public LDAPResponseListener bind(int version,
++ String dn,
++ String passwd,
++ LDAPResponseListener listener)
++ throws LDAPException{
++ return bind(version, dn, passwd, listener, m_defaultConstraints);
++ }
++
++ /**
++ * Authenticates to the LDAP server (to which the object is currently
++ * connected) using the specified name and password. If the object
++ * has been disconnected from an LDAP server, this method attempts to
++ * reconnect to the server. If the object had already authenticated, the
++ * old authentication is discarded.
++ * 
++ * @param dn if non-null and non-empty, specifies that the connection
++ * and all operations through it should authenticate with dn as the
++ * distinguished name
++ * @param passwd if non-null and non-empty, specifies that the connection
++ * and all operations through it should authenticate with dn as the
++ * distinguished name and passwd as password
++ * @param listener handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @return LDAPResponseListener handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ * @see netscape.ldap.LDAPResponseListener
++ */
++ public LDAPResponseListener bind(String dn,
++ String passwd,
++ LDAPResponseListener listener)
++ throws LDAPException{
++ return bind(m_protocolVersion, dn, passwd, listener,
++ m_defaultConstraints);
++ }
++
++ /**
++ * Authenticates to the LDAP server (to which the object is currently
++ * connected) using the specified name and password and allows you
++ * to specify constraints for this LDAP add operation by using an
++ * <CODE>LDAPConstraints</CODE> object. If the object
++ * has been disconnected from an LDAP server, this method attempts to
++ * reconnect to the server. If the object had already authenticated, the
++ * old authentication is discarded.
++ * 
++ * @param dn if non-null and non-empty, specifies that the connection
++ * and all operations through it should authenticate with dn as the
++ * distinguished name
++ * @param passwd if non-null and non-empty, specifies that the connection
++ * and all operations through it should authenticate with dn as the
++ * distinguished name and passwd as password
++ * @param listener handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @param cons constraints specific to the operation
++ * @return LDAPResponseListener handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ * @see netscape.ldap.LDAPResponseListener
++ * @see netscape.ldap.LDAPConstraints
++ */
++ public LDAPResponseListener bind(String dn,
++ String passwd,
++ LDAPResponseListener listener,
++ LDAPConstraints cons) 
++ throws LDAPException{
++ return bind( m_protocolVersion, dn, passwd, listener, cons );
++ }
++
++ /**
++ * Authenticates to the LDAP server (to which the object is currently
++ * connected) using the specified name and password and allows you
++ * to specify constraints for this LDAP add operation by using an
++ * <CODE>LDAPConstraints</CODE> object. If the object
++ * has been disconnected from an LDAP server, this method attempts to
++ * reconnect to the server. If the object had already authenticated, the
++ * old authentication is discarded.
++ * 
++ * @param version required LDAP protocol version
++ * @param dn if non-null and non-empty, specifies that the connection
++ * and all operations through it should authenticate with dn as the
++ * distinguished name
++ * @param passwd if non-null and non-empty, specifies that the connection
++ * and all operations through it should authenticate with dn as the
++ * distinguished name and passwd as password
++ * @param listener handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @param cons constraints specific to the operation
++ * @return LDAPResponseListener handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ * @see netscape.ldap.LDAPResponseListener
++ * @see netscape.ldap.LDAPConstraints
++ */
++ public LDAPResponseListener bind(int version,
++ String dn,
++ String passwd,
++ LDAPResponseListener listener,
++ LDAPConstraints cons) 
++ throws LDAPException{
++ return authenticate( version, dn, passwd, listener, cons );
++ }
++ 
++ /**
++ * Deletes the entry for the specified DN from the directory.
++ * 
++ * @param dn distinguished name of the entry to delete
++ * @param listener handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @return LDAPResponseListener handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ * @see netscape.ldap.LDAPResponseListener
++ * @see netscape.ldap.LDAPConstraints
++ */
++ public LDAPResponseListener delete(String dn,
++ LDAPResponseListener listener)
++ throws LDAPException{
++ 
++ return delete(dn, listener, m_defaultConstraints);
++ }
++
++ /**
++ * Deletes the entry for the specified DN from the directory.
++ * 
++ * @param dn distinguished name of the entry to delete
++ * @param listener handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @param cons constraints specific to the operation
++ * @return LDAPResponseListener handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ * @see netscape.ldap.LDAPResponseListener
++ * @see netscape.ldap.LDAPConstraints
++ */
++ public LDAPResponseListener delete(String dn,
++ LDAPResponseListener listener,
++ LDAPConstraints cons)
++ throws LDAPException{
++ if (cons == null) {
++ cons = m_defaultConstraints;
++ }
++
++ checkConnection(/*rebind=*/true);
++
++ if (listener == null) {
++ listener = new LDAPResponseListener(/*asynchOp=*/true);
++ }
++ 
++ sendRequest (new JDAPDeleteRequest(dn), listener, cons);
++ 
++ return listener;
++
++ }
++ 
++ /**
++ * Makes a single change to an existing entry in the directory.
++ * For example, changes the value of an attribute, adds a new attribute
++ * value, or removes an existing attribute value. 
++ * The LDAPModification object specifies both the change to make and
++ * the LDAPAttribute value to be changed.
++ * 
++ * @param dn distinguished name of the entry to modify
++ * @param mod a single change to make to an entry
++ * @param listener handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @return LDAPResponseListener handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ * @see netscape.ldap.LDAPModification
++ * @see netscape.ldap.LDAPResponseListener
++ */
++ public LDAPResponseListener modify(String dn,
++ LDAPModification mod,
++ LDAPResponseListener listener)
++ throws LDAPException{
++
++ return modify(dn, mod, listener, m_defaultConstraints);
++ }
++ 
++ /**
++ * Makes a single change to an existing entry in the directory.
++ * For example, changes the value of an attribute, adds a new attribute
++ * value, or removes an existing attribute value. 
++ * The LDAPModification object specifies both the change to make and
++ * the LDAPAttribute value to be changed.
++ * 
++ * @param dn distinguished name of the entry to modify
++ * @param mod a single change to make to an entry
++ * @param listener handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @param cons constraints specific to the operation
++ * @return LDAPResponseListener handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ * @see netscape.ldap.LDAPModification
++ * @see netscape.ldap.LDAPResponseListener
++ * @see netscape.ldap.LDAPConstraints
++ */
++ public LDAPResponseListener modify(String dn,
++ LDAPModification mod,
++ LDAPResponseListener listener,
++ LDAPConstraints cons)
++ throws LDAPException{
++ if (cons == null) {
++ cons = m_defaultConstraints;
++ }
++
++ checkConnection(/*rebind=*/true);
++
++ if (listener == null) {
++ listener = new LDAPResponseListener(/*asynchOp=*/true);
++ }
++
++ LDAPModification[] modList = { mod };
++ sendRequest (new JDAPModifyRequest (dn, modList), listener, cons); 
++
++ return listener;
++ }
++
++ /**
++ * Makes a set of changes to an existing entry in the directory.
++ * For example, changes attribute values, adds new attribute values, or
++ * removes existing attribute values.
++ * 
++ * @param dn distinguished name of the entry to modify
++ * @param mods a set of changes to make to the entry
++ * @param listener handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @return LDAPResponseListener handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ * @see netscape.ldap.LDAPModificationSet
++ * @see netscape.ldap.LDAPResponseListener
++ */
++ public LDAPResponseListener modify(String dn,
++ LDAPModificationSet mods,
++ LDAPResponseListener listener)
++ throws LDAPException{
++ return modify(dn,mods, listener, m_defaultConstraints);
++ }
++ 
++ /**
++ * Makes a set of changes to an existing entry in the directory.
++ * For example, changes attribute values, adds new attribute values, or
++ * removes existing attribute values).
++ * 
++ * @param dn distinguished name of the entry to modify
++ * @param mods a set of changes to make to the entry
++ * @param listener handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @param cons Constraints specific to the operation
++ * @return LDAPResponseListener handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ * @see netscape.ldap.LDAPModificationSet
++ * @see netscape.ldap.LDAPResponseListener
++ * @see netscape.ldap.LDAPConstraints
++ */
++ public LDAPResponseListener modify(String dn,
++ LDAPModificationSet mods,
++ LDAPResponseListener listener,
++ LDAPConstraints cons)
++ throws LDAPException{
++ if (cons == null) {
++ cons = m_defaultConstraints;
++ }
++
++ checkConnection(/*rebind=*/true);
++
++ if (listener == null) {
++ listener = new LDAPResponseListener(/*asynchOp=*/true);
++ }
++
++ LDAPModification[] modList = new LDAPModification[mods.size()];
++ for( int i = 0; i < mods.size(); i++ ) {
++ modList[i] = mods.elementAt( i );
++ }
++
++ sendRequest (new JDAPModifyRequest (dn, modList), listener, cons); 
++ return listener;
++
++ } 
++
++ /**
++ * Renames an existing entry in the directory.
++ * 
++ * @param dn current distinguished name of the entry
++ * @param newRdn new relative distinguished name for the entry
++ * @param deleteOldRdn if true, the old name is not retained as an
++ * attribute value
++ * @param listener handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @return LDAPResponseListener handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ * @see netscape.ldap.LDAPResponseListener
++ */
++ public LDAPResponseListener rename(String dn,
++ String newRdn,
++ boolean deleteOldRdn,
++ LDAPResponseListener listener)
++ throws LDAPException{
++ return rename(dn, newRdn, deleteOldRdn, listener, m_defaultConstraints);
++ }
++
++ /**
++ * Renames an existing entry in the directory.
++ * 
++ * @param dn current distinguished name of the entry
++ * @param newRdn new relative distinguished name for the entry
++ * @param deleteOldRdn if true, the old name is not retained as an attribute
++ * value
++ * @param listener handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @param cons constraints specific to the operation
++ * @return LDAPResponseListener handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ * @see netscape.ldap.LDAPResponseListener
++ * @see netscape.ldap.LDAPConstraints
++ */
++ public LDAPResponseListener rename(String dn,
++ String newRdn,
++ boolean deleteOldRdn,
++ LDAPResponseListener listener,
++ LDAPConstraints cons)
++ throws LDAPException{
++ if (cons == null) {
++ cons = m_defaultConstraints;
++ }
++ 
++ checkConnection(/*rebind=*/true);
++
++ if (listener == null) {
++ listener = new LDAPResponseListener(/*asynchOp=*/true);
++ }
++
++ sendRequest (new JDAPModifyRDNRequest (dn, newRdn, deleteOldRdn),
++ listener, cons);
++ 
++ return listener;
++
++ }
++ 
++ 
++ /**
++ * Performs the search specified by the criteria that you enter. 
++ * To abandon the search, use the <CODE>abandon</CODE> method.
++ *
++ * @param base the base distinguished name from which to search
++ * @param scope the scope of the entries to search. You can specify one
++ * of the following: 
++ * <UL>
++ * <LI><CODE>LDAPv2.SCOPE_BASE</CODE> (search only the base DN) 
++ * <LI><CODE>LDAPv2.SCOPE_ONE</CODE>
++ * (search only entries under the base DN) 
++ * <LI><CODE>LDAPv2.SCOPE_SUB</CODE>
++ * (search the base DN and all entries within its subtree) 
++ * </UL>
++ * 
++ * @param filter search filter specifying the search criteria
++ * @param attrs list of attributes that you want returned in the
++ * search results
++ * @param typesOnly if true, returns the names but not the values of the
++ * attributes found. If false, returns the names and values for
++ * attributes found
++ * @param listener handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @return LDAPSearchListener handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ * @see netscape.ldap.LDAPConnection#abandon(netscape.ldap.LDAPSearchListener)
++ */
++ public LDAPSearchListener search(String base,
++ int scope,
++ String filter,
++ String attrs[],
++ boolean typesOnly,
++ LDAPSearchListener listener)
++ throws LDAPException {
++ 
++ return search(base, scope, filter, attrs, typesOnly,
++ listener, m_defaultConstraints);
++ }
++
++ /**
++ * Performs the search specified by the criteria that you enter.
++ * This method also allows you to specify constraints for the search
++ * (such as the maximum number of entries to find or the
++ * maximum time to wait for search results). 
++ * To abandon the search, use the <CODE>abandon</CODE> method.
++ *
++ * @param base the base distinguished name from which to search
++ * @param scope the scope of the entries to search. You can specify one
++ * of the following: 
++ * <UL>
++ * <LI><CODE>LDAPv2.SCOPE_BASE</CODE> (search only the base DN) 
++ * <LI><CODE>LDAPv2.SCOPE_ONE</CODE>
++ * (search only entries under the base DN) 
++ * <LI><CODE>LDAPv2.SCOPE_SUB</CODE>
++ * (search the base DN and all entries within its subtree) 
++ * </UL>
++ * 
++ * @param filter search filter specifying the search criteria
++ * @param attrs list of attributes that you want returned in the search
++ * results
++ * @param typesOnly if true, returns the names but not the values of the
++ * attributes found. If false, returns the names and values for
++ * attributes found.
++ * @param listener handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @param cons constraints specific to this search (for example, the
++ * maximum number of entries to return)
++ * @return LDAPSearchListener handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ * @see netscape.ldap.LDAPConnection#abandon(netscape.ldap.LDAPSearchListener)
++ */
++ public LDAPSearchListener search(String base,
++ int scope,
++ String filter,
++ String attrs[],
++ boolean typesOnly,
++ LDAPSearchListener listener,
++ LDAPSearchConstraints cons)
++ throws LDAPException {
++ if (cons == null) {
++ cons = m_defaultConstraints;
++ }
++
++ checkConnection(/*rebind=*/true);
++ 
++ if (listener == null) {
++ listener = new LDAPSearchListener(/*asynchOp=*/true, cons);
++ }
++ 
++ JDAPSearchRequest request = null; 
++ try {
++ request = new JDAPSearchRequest (base, scope, cons.getDereference(),
++ cons.getMaxResults(), cons.getServerTimeLimit(),
++ typesOnly, filter, attrs);
++ }
++ catch (IllegalArgumentException e) {
++ throw new LDAPException(e.getMessage(), LDAPException.PARAM_ERROR);
++ }
++
++ sendRequest (request, listener, cons);
++ return listener;
++ 
++ }
++ 
++ /**
++ * Compare an attribute value with one in the directory. The result can 
++ * be obtained by calling <CODE>getResultCode</CODE> on the 
++ * <CODE>LDAPResponse</CODE> from the <CODE>LDAPResponseListener</CODE>.
++ * The code will be <CODE>LDAPException.COMPARE_TRUE</CODE> or 
++ * <CODE>LDAPException.COMPARE_FALSE</CODE>. 
++ * 
++ * @param dn distinguished name of the entry to compare
++ * @param attr attribute with a value to compare
++ * @param listener handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @return LDAPResponseListener handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ */
++ public LDAPResponseListener compare(String dn, 
++ LDAPAttribute attr, 
++ LDAPResponseListener listener)
++ throws LDAPException {
++
++ return compare(dn, attr, listener, m_defaultConstraints);
++ }
++ 
++ /**
++ * Compare an attribute value with one in the directory. The result can 
++ * be obtained by calling <CODE>getResultCode</CODE> on the 
++ * <CODE>LDAPResponse</CODE> from the <CODE>LDAPResponseListener</CODE>.
++ * The code will be <CODE>LDAPException.COMPARE_TRUE</CODE> or 
++ * <CODE>LDAPException.COMPARE_FALSE</CODE>. 
++ * 
++ * @param dn distinguished name of the entry to compare
++ * @param attr attribute with a value to compare
++ * @param listener handler for messages returned from a server in response
++ * to this request. If it is null, a listener object is created internally.
++ * @param cons constraints specific to this operation
++ * @return LDAPResponseListener handler for messages returned from a server
++ * in response to this request.
++ * @exception LDAPException Failed to send request.
++ */
++ public LDAPResponseListener compare(String dn, 
++ LDAPAttribute attr, 
++ LDAPResponseListener listener,
++ LDAPConstraints cons) 
++ throws LDAPException {
++ if (cons == null) {
++ cons = m_defaultConstraints;
++ }
++ 
++ checkConnection(/*rebind=*/true);
++
++ if (listener == null) {
++ listener = new LDAPResponseListener(/*asynchOp=*/true);
++ }
++
++ Enumeration en = attr.getStringValues();
++ String val = (String)en.nextElement();
++ JDAPAVA ava = new JDAPAVA(attr.getName(), val);
++ 
++ sendRequest (new JDAPCompareRequest (dn, ava), listener, cons);
++ return listener;
++ }
++ 
++ /**
++ * Cancels the ldap request with the specified id and discards
++ * any results already received.
++ * 
++ * @param id an LDAP request id
++ * @exception LDAPException Failed to send request.
++ */
++ public void abandon(int id) throws LDAPException {
++
++ if (!isConnected()) {
++ return;
++ }
++ 
++ try {
++ /* Tell listener thread to discard results and send an abandon request */
++ LDAPControl ctrls[] = m_defaultConstraints.getServerControls();
++ m_thread.abandon( id, ctrls );
++ 
++ } catch (Exception ignore) {}
++ }
++
++ /**
++ * Cancels all outstanding search requests associated with this
++ * LDAPSearchListener object and discards any results already received.
++ * 
++ * @param searchlistener a search listener returned from a search
++ * @exception LDAPException Failed to send request.
++ */
++ public void abandon(LDAPSearchListener searchlistener)throws LDAPException {
++ int[] ids = searchlistener.getMessageIDs();
++ for (int i=0; i < ids.length; i++) {
++ searchlistener.removeRequest(ids[i]);
++ abandon(ids[i]);
++ }
++ }
++ 
++ /**
++ * Returns the value of the specified option for this
++ * <CODE>LDAPConnection</CODE> object. 
++ *
++ * These options represent the constraints for the current connection.
++ * To get all constraints for the current connection, call the
++ * <CODE>getSearchConstraints</CODE> method.
++ * 
++ *
++ * By default, the constraints apply to all operations performed
++ * through the current connection. You can change these constraints:
++ * 
++ *
++ * <UL>
++ * <LI> If you want to set a constraint only for a particular operation, 
++ * create an <CODE>LDAPConstraints</CODE> object (or a 
++ * <CODE>LDAPSearchConstraints</CODE> object for a search or find operation)
++ * with your new constraints
++ * and pass it to the <CODE>LDAPConnection</CODE> method that performs the
++ * operation.
++ * 
++ *
++ * <LI>If you want to override these constraints for all operations
++ * performed under the current connection, call the
++ * <CODE>setOption</CODE> method to change the constraint.
++ * 
++ *
++ * </UL>
++ * 
++ *
++ * For example, the following section of code gets and prints the
++ * maximum number of search results that are returned for searches
++ * performed through this connection. (This applies to all searches
++ * unless a different set of search constraints is specified in an
++ * <CODE>LDAPSearchConstraints</CODE> object.)
++ * 
++ *
++ * <PRE>
++ * LDAPConnection ld = new LDAPConnection();
++ * int sizeLimit = ( (Integer)ld.getOption( LDAPv2.SIZELIMIT ) ).intValue();
++ * System.out.println( "Maximum number of results: " + sizeLimit );
++ * </PRE>
++ *
++ * @param option you can specify one of the following options:
++ * <TABLE CELLPADDING=5>
++ * <TR VALIGN=BASELINE ALIGN=LEFT>
++ * <TH>Option</TH><TH>Data Type</TH><TH>Description</TH></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv2.PROTOCOL_VERSION</CODE></TD>
++ * <TD><CODE>Integer</CODE></TD>
++ * <TD>Specifies the version of the LDAP protocol used by the
++ * client.
++ * By default, the value of this option is 2.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv2.DEREF</CODE></TD>
++ * <TD><CODE>Integer</CODE></TD>
++ * <TD>Specifies when your client dereferences aliases.
++ *<PRE>
++ * Legal values for this option are:
++ *
++ * DEREF_NEVER Aliases are never dereferenced.
++ *
++ * DEREF_FINDING Aliases are dereferenced when find-
++ * ing the starting point for the
++ * search (but not when searching
++ * under that starting entry).
++ *
++ * DEREF_SEARCHING Aliases are dereferenced when
++ * searching the entries beneath the
++ * starting point of the search (but
++ * not when finding the starting
++ * entry).
++ *
++ * DEREF_ALWAYS Aliases are always dereferenced.
++ *</PRE>
++ * By default, the value of this option is
++ * <CODE>DEREF_NEVER</CODE>.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv2.SIZELIMIT</CODE></TD>
++ * <TD><CODE>Integer</CODE></TD>
++ * <TD>Specifies the maximum number of search results to return.
++ * If this option is set to 0, there is no maximum limit.
++ * By default, the value of this option is 1000.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv2.TIMELIMIT</CODE></TD>
++ * <TD><CODE>Integer</CODE></TD>
++ * <TD>Specifies the maximum number of milliseconds to wait for results
++ * before timing out. If this option is set to 0, there is no maximum
++ * time limit.
++ * By default, the value of this option is 0.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv2.REFERRALS</CODE></TD>
++ * <TD><CODE>Boolean</CODE></TD>
++ * <TD>Specifies whether or not your client follows referrals automatically.
++ * If <CODE>true</CODE>, your client follows referrals automatically.
++ * If <CODE>false</CODE>, an <CODE>LDAPReferralException</CODE> is raised
++ * when referral is detected.
++ * By default, the value of this option is <CODE>false</CODE>.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv2.REFERRALS_REBIND_PROC</CODE></TD>
++ * <TD><CODE>LDAPRebind</CODE></TD>
++ * <TD>Specifies an object with a class that implements the
++ * <CODE>LDAPRebind</CODE> interface. You must define this class and
++ * the <CODE>getRebindAuthentication</CODE> method that will be used to
++ * get the distinguished name and password to use for authentication.
++ * Modifying this option sets the <CODE>LDAPv2.BIND</CODE> option to null.
++ * By default, the value of this option is <CODE>null</CODE>.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv2.BIND</CODE></TD>
++ * <TD><CODE>LDAPBind</CODE></TD>
++ * <TD>Specifies an object with a class that implements the
++ * <CODE>LDAPBind</CODE>
++ * interface. You must define this class and the
++ * <CODE>bind</CODE> method that will be used to authenticate
++ * to the server on referrals. Modifying this option sets the 
++ * <CODE>LDAPv2.REFERRALS_REBIND_PROC</CODE> to null.
++ * By default, the value of this option is <CODE>null</CODE>.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv2.REFERRALS_HOP_LIMIT</CODE></TD>
++ * <TD><CODE>Integer</CODE></TD>
++ * <TD>Specifies the maximum number of referrals in a sequence that
++ * your client will follow. (For example, if REFERRALS_HOP_LIMIT is 5,
++ * your client will follow no more than 5 referrals in a row when resolving
++ * a single LDAP request.)
++ * By default, the value of this option is 10.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv2.BATCHSIZE</CODE></TD>
++ * <TD><CODE>Integer</CODE></TD>
++ * <TD>Specifies the number of search results to return at a time.
++ * (For example, if BATCHSIZE is 1, results are returned one at a time.)
++ * By default, the value of this option is 1.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv3.CLIENTCONTROLS</CODE></TD>
++ * <TD><CODE>LDAPControl[]</CODE></TD>
++ * <TD>Specifies the client controls that may affect the handling of LDAP
++ * operations in the LDAP classes. These controls are used by the client
++ * and are not passed to the LDAP server. At this time, no client controls
++ * are defined for clients built with the Netscape LDAP classes. </TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv3.SERVERCONTROLS</CODE></TD>
++ * <TD><CODE>LDAPControl[]</CODE></TD>
++ * <TD>Specifies the server controls that are passed to the LDAP
++ * server on each LDAP operation. Not all servers support server
++ * controls; a particular server may or may not support a given
++ * server control.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>MAXBACKLOG</CODE></TD>
++ * <TD><CODE>Integer</CODE></TD>
++ * <TD>Specifies the maximum number of search results to accumulate in an
++ * LDAPSearchResults before suspending the reading of input from the server.
++ * By default, the value of this option is 100. The value 0 means there
++ * is no limit.</TD></TR>
++ * </TABLE>
++ * @return the value for the option wrapped in an object. (You
++ * need to cast the returned value as its appropriate type. For
++ * example, when getting the SIZELIMIT option, cast the returned
++ * value as an <CODE>Integer</CODE>.)
++ * @exception LDAPException Failed to get the specified option.
++ * @see netscape.ldap.LDAPRebind
++ * @see netscape.ldap.LDAPConstraints
++ * @see netscape.ldap.LDAPSearchConstraints
++ * @see netscape.ldap.LDAPReferralException
++ * @see netscape.ldap.LDAPControl
++ * @see netscape.ldap.LDAPConnection#getSearchConstraints
++ * @see netscape.ldap.LDAPConnection#search(java.lang.String, int, java.lang.String, java.lang.String[], boolean, netscape.ldap.LDAPSearchConstraints)
++ */
++ public Object getOption( int option ) throws LDAPException {
++ if (option == LDAPv2.PROTOCOL_VERSION) {
++ return new Integer(m_protocolVersion);
++ }
++
++ return getOption(option, m_defaultConstraints);
++ }
++
++ private static Object getOption( int option, LDAPSearchConstraints cons )
++ throws LDAPException {
++ switch (option) {
++ case LDAPv2.DEREF:
++ return new Integer (cons.getDereference());
++ case LDAPv2.SIZELIMIT:
++ return new Integer (cons.getMaxResults());
++ case LDAPv2.TIMELIMIT:
++ return new Integer (cons.getServerTimeLimit());
++ case LDAPv2.REFERRALS:
++ return new Boolean (cons.getReferrals());
++ case LDAPv2.REFERRALS_REBIND_PROC:
++ return cons.getRebindProc();
++ case LDAPv2.BIND:
++ return cons.getBindProc();
++ case LDAPv2.REFERRALS_HOP_LIMIT:
++ return new Integer (cons.getHopLimit());
++ case LDAPv2.BATCHSIZE:
++ return new Integer (cons.getBatchSize());
++ case LDAPv3.CLIENTCONTROLS:
++ return cons.getClientControls();
++ case LDAPv3.SERVERCONTROLS:
++ return cons.getServerControls();
++ case MAXBACKLOG:
++ return new Integer (cons.getMaxBacklog());
++ default:
++ throw new LDAPException ( "invalid option",
++ LDAPException.PARAM_ERROR );
++ }
++ }
++ 
++ /**
++ * Sets the value of the specified option for this
++ * <CODE>LDAPConnection</CODE> object. 
++ *
++ * These options represent the constraints for the current
++ * connection.
++ * To get all constraints for the current connection, call the
++ * <CODE>getSearchConstraints</CODE> method. 
++ * 
++ *
++ * By default, the option that you set applies to all subsequent
++ * operations performed through the current connection. If you want to
++ * set a constraint only for a particular operation, create an
++ * <CODE>LDAPConstraints</CODE> object (or a 
++ * <CODE>LDAPSearchConstraints</CODE> object for a search or find operation)
++ * with your new constraints
++ * and pass it to the <CODE>LDAPConnection</CODE> method that performs the
++ * operation.
++ * 
++ *
++ * For example, the following section of code changes the constraint for
++ * the maximum number of search results that are returned for searches
++ * performed through this connection. (This applies to all searches
++ * unless a different set of search constraints is specified in an
++ * <CODE>LDAPSearchConstraints</CODE> object.)
++ * 
++ *
++ * <PRE>
++ * LDAPConnection ld = new LDAPConnection();
++ * Integer newLimit = new Integer( 20 );
++ * ld.setOption( LDAPv2.SIZELIMIT, newLimit );
++ * System.out.println( "Changed the maximum number of results to " + newLimit.intValue() );
++ * </PRE>
++ *
++ * @param option you can specify one of the following options:
++ * <TABLE CELLPADDING=5>
++ * <TR VALIGN=BASELINE ALIGN=LEFT>
++ * <TH>Option</TH><TH>Data Type</TH><TH>Description</TH></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv2.PROTOCOL_VERSION</CODE></TD>
++ * <TD><CODE>Integer</CODE></TD>
++ * <TD>Specifies the version of the LDAP protocol used by the
++ * client.
++ * By default, the value of this option is 2. If you want
++ * to use LDAP v3 features (such as extended operations or
++ * controls), you need to set this value to 3. </TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv2.DEREF</CODE></TD>
++ * <TD><CODE>Integer</CODE></TD>
++ * <TD>Specifies when your client dereferences aliases.
++ *<PRE>
++ * Legal values for this option are:
++ *
++ * DEREF_NEVER Aliases are never dereferenced.
++ *
++ * DEREF_FINDING Aliases are dereferenced when find-
++ * ing the starting point for the
++ * search (but not when searching
++ * under that starting entry).
++ *
++ * DEREF_SEARCHING Aliases are dereferenced when
++ * searching the entries beneath the
++ * starting point of the search (but
++ * not when finding the starting
++ * entry).
++ *
++ * DEREF_ALWAYS Aliases are always dereferenced.
++ *</PRE>
++ * By default, the value of this option is
++ * <CODE>DEREF_NEVER</CODE>.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv2.SIZELIMIT</CODE></TD>
++ * <TD><CODE>Integer</CODE></TD>
++ * <TD>Specifies the maximum number of search results to return.
++ * If this option is set to 0, there is no maximum limit.
++ * By default, the value of this option is 1000.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv2.TIMELIMIT</CODE></TD>
++ * <TD><CODE>Integer</CODE></TD>
++ * <TD>Specifies the maximum number of milliseconds to wait for results
++ * before timing out. If this option is set to 0, there is no maximum
++ * time limit.
++ * By default, the value of this option is 0.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv2.REFERRALS</CODE></TD>
++ * <TD><CODE>Boolean</CODE></TD>
++ * <TD>Specifies whether or not your client follows referrals automatically.
++ * If <CODE>true</CODE>, your client follows referrals automatically.
++ * If <CODE>false</CODE>, an <CODE>LDAPReferralException</CODE> is
++ * raised when a referral is detected.
++ * By default, the value of this option is <CODE>false</CODE>.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv2.REFERRALS_REBIND_PROC</CODE></TD>
++ * <TD><CODE>LDAPRebind</CODE></TD>
++ * <TD>Specifies an object with a class that implements the
++ * <CODE>LDAPRebind</CODE>
++ * interface. You must define this class and the
++ * <CODE>getRebindAuthentication</CODE> method that will be used to get
++ * the distinguished name and password to use for authentication. 
++ * Modifying this option sets the <CODE>LDAPv2.BIND</CODE> option to null.
++ * By default, the value of this option is <CODE>null</CODE>.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv2.BIND</CODE></TD>
++ * <TD><CODE>LDAPBind</CODE></TD>
++ * <TD>Specifies an object with a class that implements the
++ * <CODE>LDAPBind</CODE>
++ * interface. You must define this class and the
++ * <CODE>bind</CODE> method that will be used to autheniticate
++ * to the server on referrals. Modifying this option sets the 
++ * <CODE>LDAPv2.REFERRALS_REBIND_PROC</CODE> to null.
++ * By default, the value of this option is <CODE>null</CODE>.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv2.REFERRALS_HOP_LIMIT</CODE></TD>
++ * <TD><CODE>Integer</CODE></TD>
++ * <TD>Specifies the maximum number of referrals in a sequence that
++ * your client will follow. (For example, if REFERRALS_HOP_LIMIT is 5,
++ * your client will follow no more than 5 referrals in a row when resolving
++ * a single LDAP request.)
++ * By default, the value of this option is 10.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv2.BATCHSIZE</CODE></TD>
++ * <TD><CODE>Integer</CODE></TD>
++ * <TD>Specifies the number of search results to return at a time.
++ * (For example, if BATCHSIZE is 1, results are returned one at a time.)
++ * By default, the value of this option is 1.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv3.CLIENTCONTROLS</CODE></TD>
++ * <TD><CODE>LDAPControl[]</CODE></TD>
++ * <TD>Specifies the client controls that may affect handling of LDAP
++ * operations in the LDAP classes. These controls are used by the client
++ * and are not passed to the server. At this time, no client controls
++ * are defined for clients built with the Netscape LDAP classes. </TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>LDAPv3.SERVERCONTROLS</CODE></TD>
++ * <TD><CODE>LDAPControl[]</CODE></TD>
++ * <TD>Specifies the server controls that are passed to the LDAP
++ * server on each LDAP operation. Not all servers support server
++ * controls; a particular server may or may not support a particular
++ * control.</TD></TR>
++ * <TR VALIGN=BASELINE><TD>
++ * <CODE>MAXBACKLOG</CODE></TD>
++ * <TD><CODE>Integer</CODE></TD>
++ * <TD>Specifies the maximum number of search results to accumulate in an
++ * LDAPSearchResults before suspending the reading of input from the server.
++ * By default, the value of this option is 100. The value 0 means there
++ * is no limit.</TD></TR>
++ * </TABLE>
++ * @param value the value to assign to the option. The value must be
++ * the java.lang object wrapper for the appropriate parameter
++ * (e.g. boolean->Boolean,
++ * integer->Integer)
++ * @exception LDAPException Failed to set the specified option.
++ * @see netscape.ldap.LDAPRebind
++ * @see netscape.ldap.LDAPConstraints
++ * @see netscape.ldap.LDAPSearchConstraints
++ * @see netscape.ldap.LDAPReferralException
++ * @see netscape.ldap.LDAPControl
++ * @see netscape.ldap.LDAPConnection#getSearchConstraints
++ * @see netscape.ldap.LDAPConnection#search(java.lang.String, int, java.lang.String, java.lang.String[], boolean, netscape.ldap.LDAPSearchConstraints)
++ */
++ public void setOption( int option, Object value ) throws LDAPException {
++ if (option == LDAPv2.PROTOCOL_VERSION) {
++ setProtocolVersion(((Integer)value).intValue());
++ return;
++ }
++ setOption(option, value, m_defaultConstraints);
++ }
++
++ private static void setOption( int option, Object value, LDAPSearchConstraints cons ) throws LDAPException {
++ try {
++ switch (option) {
++ case LDAPv2.DEREF:
++ cons.setDereference(((Integer)value).intValue());
++ return;
++ case LDAPv2.SIZELIMIT:
++ cons.setMaxResults(((Integer)value).intValue());
++ return;
++ case LDAPv2.TIMELIMIT:
++ cons.setTimeLimit(((Integer)value).intValue());
++ return;
++ case LDAPv2.SERVER_TIMELIMIT:
++ cons.setServerTimeLimit(((Integer)value).intValue());
++ return;
++ case LDAPv2.REFERRALS:
++ cons.setReferrals(((Boolean)value).booleanValue());
++ return;
++ case LDAPv2.BIND:
++ cons.setBindProc((LDAPBind)value);
++ return;
++ case LDAPv2.REFERRALS_REBIND_PROC:
++ cons.setRebindProc((LDAPRebind)value);
++ return;
++ case LDAPv2.REFERRALS_HOP_LIMIT:
++ cons.setHopLimit(((Integer)value).intValue());
++ return;
++ case LDAPv2.BATCHSIZE:
++ cons.setBatchSize(((Integer)value).intValue());
++ return;
++ case LDAPv3.CLIENTCONTROLS:
++ if ( value == null )
++ cons.setClientControls( (LDAPControl[]) null );
++ else if ( value instanceof LDAPControl )
++ cons.setClientControls( (LDAPControl) value );
++ else if ( value instanceof LDAPControl[] )
++ cons.setClientControls( (LDAPControl[])value );
++ else
++ throw new LDAPException ( "invalid LDAPControl",
++ LDAPException.PARAM_ERROR );
++ return;
++ case LDAPv3.SERVERCONTROLS:
++ if ( value == null )
++ cons.setServerControls( (LDAPControl[]) null );
++ else if ( value instanceof LDAPControl )
++ cons.setServerControls( (LDAPControl) value );
++ else if ( value instanceof LDAPControl[] )
++ cons.setServerControls( (LDAPControl[])value );
++ else
++ throw new LDAPException ( "invalid LDAPControl",
++ LDAPException.PARAM_ERROR );
++ return;
++ case MAXBACKLOG:
++ cons.setMaxBacklog(((Integer)value).intValue());
++ return;
++ default:
++ throw new LDAPException ("invalid option",
++ LDAPException.PARAM_ERROR );
++ }
++ } catch (ClassCastException cc) {
++ throw new LDAPException ("invalid option value",
++ LDAPException.PARAM_ERROR );
++ }
++ }
++
++ /**
++ * Returns an array of the latest controls (if any) from server.
++ * 
++ * To retrieve the controls from a search result, call the 
++ * <CODE>getResponseControls</CODE> method from the <CODE>LDAPSearchResults
++ * </CODE> object returned with the result.
++ * @return an array of the controls returned by an operation, or
++ * null if none.
++ * @see netscape.ldap.LDAPControl
++ * @see netscape.ldap.LDAPSearchResults#getResponseControls
++ */
++ public LDAPControl[] getResponseControls() {
++ LDAPControl[] controls = null;
++ Thread caller = Thread.currentThread();
++ 
++ /* Get the latest controls for the caller thread */
++ synchronized(m_responseControlTable) {
++ ResponseControls rspCtrls =
++ (ResponseControls) m_responseControlTable.get(caller);
++
++ if (rspCtrls != null) {
++ Vector v = rspCtrls.ctrls;
++ controls = (LDAPControl[]) v.elementAt(0);
++ v.removeElementAt(0);
++ if (v.size() == 0) {
++ m_responseControlTable.remove(caller);
++ }
++ }
++ }
++ 
++ return controls;
++ }
++
++ /**
++ * Returns an array of the latest controls associated with the 
++ * particular request. Used internally by LDAPSearchResults to
++ * get response controls returned for a search request.
++ * 
++ * @param msdid Message ID
++ */
++ LDAPControl[] getResponseControls(int msgID) {
++ LDAPControl[] controls = null;
++
++ synchronized(m_responseControlTable) { 
++ Enumeration itr = m_responseControlTable.keys(); 
++ while (itr.hasMoreElements()) {
++ Object client = itr.nextElement();
++ ResponseControls rspCtrls = (ResponseControls)m_responseControlTable.get(client);
++
++ if (msgID == rspCtrls.msgID) {
++ Vector v = rspCtrls.ctrls;
++ controls = (LDAPControl[]) v.elementAt(0);
++ v.removeElementAt(0);
++ if (v.size() == 0) {
++ m_responseControlTable.remove(client);
++ }
++ break;
++ }
++ }
++ }
++ 
++ return controls;
++ }
++ 
++ /**
++ * Returns the set of constraints that apply to all operations
++ * performed through this connection (unless you specify a different
++ * set of constraints when calling a method). 
++ * 
++ *
++ * Note that if you want to get individual constraints (rather than
++ * getting the
++ * entire set of constraints), call the <CODE>getOption</CODE> method.
++ * 
++ *
++ * Typically, you might call the <CODE>getConstraints</CODE> method
++ * to create a slightly different set of constraints for a particular 
++ * operation.
++ * 
++ *
++ * For example, the following section of code changes the timeout
++ * to 3000 milliseconds for a specific rename. Rather than construct a new
++ * set of constraints from scratch, the example gets the current
++ * settings for the connections and just changes the setting for the
++ * timeout.
++ * 
++ *
++ * Note that this change only applies to the searches performed with this
++ * custom set of constraints. All other searches performed through this
++ * connection use the original set of search constraints.
++ * 
++ *
++ * <PRE>
++ * ...
++ * LDAPConstraints myOptions = ld.getConstraints();
++ * myOptions.setTimeout( 3000 );
++ * ld.search( "cn=William Jensen, ou=Accounting, o=Ace Industry,c=US",
++ * "cn=Will Jensen",
++ * null,
++ * false,
++ * myOptions );
++ * ...
++ * </PRE>
++ *
++ * @return a copy of the <CODE>LDAPConstraints</CODE> object representing the
++ * set of constraints that apply (by default) to all operations
++ * performed through this connection.
++ * @see netscape.ldap.LDAPConstraints
++ * @see netscape.ldap.LDAPConnection#getOption
++ */
++ public LDAPConstraints getConstraints () {
++ return (LDAPConstraints)getSearchConstraints();
++ }
++ 
++ /**
++ * Returns the set of search constraints that apply to all searches
++ * performed through this connection (unless you specify a different
++ * set of search constraints when calling the <CODE>search</CODE>
++ * method). 
++ * 
++ *
++ * Note that if you want to get individual constraints (rather than
++ * getting the
++ * entire set of constraints), call the <CODE>getOption</CODE> method.
++ * 
++ *
++ * Typically, you might call the <CODE>getSearchConstraints</CODE> method
++ * to create a slightly different set of search constraints
++ * to apply to a particular search.
++ * 
++ *
++ * For example, the following section of code changes the maximum number
++ * of results to 10 for a specific search. Rather than construct a new
++ * set of search constraints from scratch, the example gets the current
++ * settings for the connections and just changes the setting for the
++ * maximum results.
++ * 
++ *
++ * Note that this change only applies to the searches performed with this
++ * custom set of constraints. All other searches performed through this
++ * connection use the original set of search constraints.
++ * 
++ *
++ * <PRE>
++ * ...
++ * LDAPSearchConstraints myOptions = ld.getSearchConstraints();
++ * myOptions.setMaxResults( 10 );
++ * String[] myAttrs = { "objectclass" };
++ * LDAPSearchResults myResults = ld.search( "o=Ace Industry,c=US",
++ * LDAPv2.SCOPE_SUB,
++ * "(objectclass=*)",
++ * myAttrs,
++ * false,
++ * myOptions );
++ * ...
++ * </PRE>
++ *
++ * @return a copy of the <CODE>LDAPSearchConstraints</CODE> object 
++ * representing the set of search constraints that apply (by default) to 
++ * all searches performed through this connection.
++ * @see netscape.ldap.LDAPSearchConstraints
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#search(java.lang.String, int, java.lang.String, java.lang.String[], boolean, netscape.ldap.LDAPSearchConstraints) 
++ */
++ public LDAPSearchConstraints getSearchConstraints () {
++ return (LDAPSearchConstraints)m_defaultConstraints.clone();
++ }
++
++
++ /**
++ * Set the default constraint set for all operations. 
++ * @param cons <CODE>LDAPConstraints</CODE> object to use as the default
++ * constraint set
++ * @see netscape.ldap.LDAPConnection#getConstraints
++ * @see netscape.ldap.LDAPConstraints
++ */
++ public void setConstraints(LDAPConstraints cons) {
++ m_defaultConstraints.setHopLimit(cons.getHopLimit());
++ m_defaultConstraints.setReferrals(cons.getReferrals());
++ m_defaultConstraints.setTimeLimit(cons.getTimeLimit());
++ m_defaultConstraints.setBindProc(cons.getBindProc());
++ m_defaultConstraints.setRebindProc(cons.getRebindProc());
++
++ LDAPControl[] tClientControls = cons.getClientControls();
++ LDAPControl[] oClientControls = null;
++
++ if ( (tClientControls != null) &&
++ (tClientControls.length > 0) ) {
++ oClientControls = new LDAPControl[tClientControls.length]; 
++ for( int i = 0; i < tClientControls.length; i++ ) {
++ oClientControls[i] = (LDAPControl)tClientControls[i].clone();
++ }
++ } 
++ m_defaultConstraints.setClientControls(oClientControls);
++ 
++ LDAPControl[] tServerControls = cons.getServerControls();
++ LDAPControl[] oServerControls = null;
++
++ if ( (tServerControls != null) && 
++ (tServerControls.length > 0) ) {
++ oServerControls = new LDAPControl[tServerControls.length];
++ for( int i = 0; i < tServerControls.length; i++ ) {
++ oServerControls[i] = (LDAPControl)tServerControls[i].clone();
++ }
++ }
++ m_defaultConstraints.setServerControls(oServerControls);
++ }
++ 
++ /**
++ * Set the default constraint set for all search operations. 
++ * @param cons <CODE>LDAPSearchConstraints</CODE> object to use as the
++ * default constraint set
++ * @see netscape.ldap.LDAPConnection#getSearchConstraints
++ * @see netscape.ldap.LDAPSearchConstraints
++ */
++ public void setSearchConstraints(LDAPSearchConstraints cons) {
++ m_defaultConstraints = (LDAPSearchConstraints)cons.clone();
++ }
++
++ /**
++ * Gets the stream for reading from the listener socket
++ *
++ * @return the stream for reading from the listener socket, or
++ * <CODE>null</CODE> if there is none
++ */
++ public InputStream getInputStream() {
++ return (m_thread != null) ? m_thread.getInputStream() : null;
++ }
++
++ /**
++ * Sets the stream for reading from the listener socket if
++ * there is one
++ *
++ * @param is the stream for reading from the listener socket
++ */
++ public void setInputStream( InputStream is ) {
++ if ( m_thread != null ) {
++ m_thread.setInputStream( is );
++ }
++ }
++
++ /**
++ * Gets the stream for writing to the socket
++ *
++ * @return the stream for writing to the socket, or
++ * <CODE>null</CODE> if there is none
++ */
++ public OutputStream getOutputStream() {
++ return (m_thread != null) ? m_thread.getOutputStream() : null;
++ }
++
++ /**
++ * Sets the stream for writing to the socket
++ *
++ * @param os the stream for writing to the socket, if there is one
++ */
++ public void setOutputStream( OutputStream os ) {
++ if ( m_thread != null ) {
++ m_thread.setOutputStream( os );
++ }
++ }
++
++ /**
++ * Get a new listening agent from the internal buffer of available agents.
++ * These objects are used to make the asynchronous LDAP operations
++ * synchronous.
++ * @return response listener object
++ */
++ synchronized LDAPResponseListener getResponseListener () {
++ if (m_responseListeners == null) {
++ m_responseListeners = new Vector (5);
++ }
++
++ LDAPResponseListener l;
++ if ( m_responseListeners.size() < 1 ) {
++ l = new LDAPResponseListener ( /*asynchOp=*/false );
++ }
++ else {
++ l = (LDAPResponseListener)m_responseListeners.elementAt (0);
++ m_responseListeners.removeElementAt (0);
++ }
++ return l;
++ }
++
++ /**
++ * Get a new search listening agent from the internal buffer of available
++ * agents. These objects are used to make the asynchronous LDAP operations
++ * synchronous.
++ * @return a search response listener object
++ */
++ private synchronized LDAPSearchListener getSearchListener (
++ LDAPSearchConstraints cons ) {
++ if (m_searchListeners == null) {
++ m_searchListeners = new Vector (5);
++ }
++
++ LDAPSearchListener l;
++ if ( m_searchListeners.size() < 1 ) {
++ l = new LDAPSearchListener ( /*asynchOp=*/false, cons );
++ }
++ else {
++ l = (LDAPSearchListener)m_searchListeners.elementAt (0);
++ m_searchListeners.removeElementAt (0);
++ l.setSearchConstraints(cons);
++ }
++ return l;
++ }
++
++ /**
++ * Put a listening agent into the internal buffer of available agents.
++ * These objects are used to make the asynchronous LDAP operations
++ * synchronous.
++ * @param l listener to buffer
++ */
++ synchronized void releaseResponseListener (LDAPResponseListener l) {
++ if (m_responseListeners == null) {
++ m_responseListeners = new Vector (5);
++ }
++
++ l.reset ();
++ m_responseListeners.addElement (l);
++ }
++
++ /**
++ * Put a search listening agent into the internal buffer of available
++ * agents. These objects are used to make the asynchronous LDAP
++ * operations synchronous.
++ * @param l listener to buffer
++ */
++ synchronized void releaseSearchListener (LDAPSearchListener l) {
++
++ if (l.isAsynchOp()) { // persistent search 
++ return;
++ }
++
++ if (m_searchListeners == null) {
++ m_searchListeners = new Vector (5);
++ }
++
++ l.reset ();
++ m_searchListeners.addElement (l);
++ }
++
++ /**
++ * Checks the message (assumed to be a return value). If the resultCode
++ * is anything other than SUCCESS, it throws an LDAPException describing
++ * the server's (error) response.
++ * Extract response controls from the message, if any avaialble.
++ * @param m server response to validate
++ * @exception LDAPException failed to check message
++ */
++ void checkMsg (LDAPMessage m) throws LDAPException {
++
++ // Check for response controls
++ LDAPControl[] ctrls = m.getControls();
++ if (ctrls != null) {
++ int msgID = m.getMessageID();
++ setResponseControls(Thread.currentThread(), msgID, ctrls);
++ }
++ 
++ if (m.getProtocolOp() instanceof JDAPResult) {
++ JDAPResult response = (JDAPResult)(m.getProtocolOp());
++ int resultCode = response.getResultCode ();
++
++ if (resultCode == JDAPResult.SUCCESS) {
++ return;
++ }
++
++ if (resultCode == JDAPResult.REFERRAL) {
++ throw new LDAPReferralException ("referral", resultCode,
++ response.getReferrals());
++ }
++
++ if (resultCode == JDAPResult.LDAP_PARTIAL_RESULTS) {
++ throw new LDAPReferralException ("referral", resultCode,
++ response.getErrorMessage());
++ } else {
++ throw new LDAPException ("error result", resultCode,
++ response.getErrorMessage(),
++ response.getMatchedDN());
++ }
++
++ } else if (m.getProtocolOp() instanceof JDAPSearchResultReference) {
++ String[] referrals =
++ ((JDAPSearchResultReference)m.getProtocolOp()).getUrls();
++ throw new LDAPReferralException ("referral",
++ JDAPResult.SUCCESS, referrals);
++ } else {
++ return;
++ }
++ }
++
++ /**
++ * Set response controls for the current connection for a particular 
++ * thread. Get the oldest returned controls and remove them from the 
++ * queue. If the connection is executing a persistent search, there may
++ * be more than one set of controls in the queue. For any other 
++ * operation, there will only ever be at most one set of controls 
++ * (controls from any earlier operation are replaced by controls 
++ * received on the latest operation on this connection by this thread).
++ * @param current the target thread
++ * @param con the server response controls
++ */
++ void setResponseControls( Thread client, int msgID, LDAPControl[] ctrls ) {
++ synchronized(m_responseControlTable) {
++ ResponseControls rspCtrls = (ResponseControls)m_responseControlTable.get(client);
++
++ if (rspCtrls == null || rspCtrls.msgID != msgID) {
++ rspCtrls = new ResponseControls(msgID, ctrls);
++
++ m_responseControlTable.put(client, rspCtrls);
++ }
++ else {
++ rspCtrls.addControls(ctrls);
++ }
++ }
++ }
++
++ /**
++ * Set up connection for referral.
++ * @param u referral URL
++ * @param cons search constraints
++ * @return new LDAPConnection, already connected and authenticated
++ */
++ private LDAPConnection referralConnect( LDAPUrl[] refList,
++ LDAPConstraints cons )
++ throws LDAPException {
++ LDAPConnection connection = new LDAPConnection (getSocketFactory());
++ 
++ // Set the same connection setup failover policy as for this connection
++ connection.setConnSetupDelay(getConnSetupDelay());
++ 
++ connection.setOption(REFERRALS, new Boolean(true));
++ connection.setOption(REFERRALS_REBIND_PROC, cons.getRebindProc());
++ connection.setOption(BIND, cons.getBindProc());
++ 
++ Object traceOut = getProperty(TRACE_PROPERTY);
++ if (traceOut != null) {
++ connection.setProperty(TRACE_PROPERTY, traceOut);
++ }
++ 
++ // need to set the protocol version which gets passed to connection
++ connection.setOption(PROTOCOL_VERSION,
++ new Integer(m_protocolVersion));
++
++ connection.setOption(REFERRALS_HOP_LIMIT,
++ new Integer(cons.getHopLimit()-1));
++
++ try { 
++ connection.connect (refList);
++ }
++ catch (LDAPException e) {
++ throw new LDAPException("Referral connect failed: " + e.getMessage(),
++ e.getLDAPResultCode());
++ }
++ return connection;
++ }
++
++ private void referralRebind(LDAPConnection ldc, LDAPConstraints cons)
++ throws LDAPException{
++ try {
++ if (cons.getRebindProc() == null && cons.getBindProc() == null) {
++ ldc.authenticate (m_protocolVersion, null, null);
++ } else if (cons.getBindProc() == null) {
++ LDAPRebindAuth auth =
++ cons.getRebindProc().getRebindAuthentication(ldc.getHost(),
++ ldc.getPort());
++ ldc.authenticate(m_protocolVersion, auth.getDN(), auth.getPassword());
++ } else {
++ cons.getBindProc().bind(ldc);
++ }
++ }
++ catch (LDAPException e) {
++ throw new LDAPException("Referral bind failed: " + e.getMessage(),
++ e.getLDAPResultCode());
++ } 
++ }
++
++ /**
++ * Check for "ldap(s):///" referrals (no host:port) and replace them with
++ * "ldap(s)://currentHost:currentPort".
++ */
++ private void adjustReferrals(LDAPUrl[] urls) {
++ String host = null;
++ int port =0;
++ 
++ for (int i=0; urls != null && i < urls.length; i++) {
++ host = urls[i].getHost();
++ port = urls[i].getPort();
++ if ( (host == null) || (host.length() < 1) ) {
++ // If no host:port was specified, use the latest (hop-wise) parameters
++ host = getHost();
++ port = getPort();
++ urls[i] = new LDAPUrl (host, port,
++ urls[i].getDN(),
++ urls[i].getAttributeArray(),
++ urls[i].getScope(),
++ urls[i].getFilter(),
++ urls[i].isSecure()); 
++ }
++ }
++ }
++
++ /**
++ * Establish the LDAPConnection to the referred server. This one is used
++ * for bind operation only since we need to keep this new connection for
++ * the subsequent operations. This new connection will be destroyed in
++ * two circumstances: disconnect gets called or the client binds as
++ * someone else.
++ * @return the new LDAPConnection to the referred server
++ */
++ LDAPConnection createReferralConnection(LDAPReferralException e,
++ LDAPConstraints cons) throws LDAPException {
++ if (cons.getHopLimit() <= 0) {
++ throw new LDAPException("exceed hop limit",
++ e.getLDAPResultCode(), e.getLDAPErrorMessage());
++ }
++ if (!cons.getReferrals()) {
++ throw e;
++ }
++
++ LDAPUrl[] refList = e.getURLs();
++ 
++ // If there are no referrals (because the server isn't set up for
++ // them), give up here
++ if (refList == null) {
++ throw new LDAPException("No target URL in referral",
++ LDAPException.NO_RESULTS_RETURNED);
++ }
++ adjustReferrals(refList);
++ 
++ LDAPConnection connection = referralConnect(refList, cons);
++
++ // which one did we connect to...
++ LDAPUrl refURL = connection.m_connMgr.getLDAPUrl();
++
++ String refDN = refURL.getDN();
++ if ((refDN == null) || (refDN.equals(""))) {
++ refDN = m_boundDN;
++ }
++
++ try {
++ connection.authenticate(m_protocolVersion, refDN, m_boundPasswd);
++ }
++ catch (LDAPException authEx) {
++ // Disconnect needed to terminate the LDAPConnThread
++ try { 
++ connection.disconnect();
++ }
++ catch (LDAPException ignore) {}
++ throw authEx;
++ }
++ return connection;
++ }
++
++ /**
++ * Follows a referral.
++ * @param e referral exception
++ * @param cons search constraints
++ */
++ void performReferrals(LDAPReferralException e,
++ LDAPConstraints cons, int ops,
++ /* unions of different operation parameters */
++ String dn, int scope, String filter, String types[],
++ boolean attrsOnly, LDAPModification mods[],
++ LDAPEntry entry,
++ LDAPAttribute attr,
++ /* result */
++ Vector results
++ ) throws LDAPException {
++
++ LDAPUrl refURL = null;
++ LDAPConnection connection = null;
++ 
++ try { 
++
++ if (cons.getHopLimit() <= 0) {
++ throw new LDAPException("exceed hop limit",
++ e.getLDAPResultCode(),
++ e.getLDAPErrorMessage());
++ }
++ if (!cons.getReferrals()) {
++ if (ops == JDAPProtocolOp.SEARCH_REQUEST) {
++ LDAPSearchResults res = new LDAPSearchResults();
++ res.add(e);
++ results.addElement(res);
++ return;
++ } else {
++ throw e;
++ }
++ }
++
++ LDAPUrl urls[] = e.getURLs();
++ // If there are no referrals (because the server isn't configured to
++ // return one), give up here
++ if ( urls == null || urls.length == 0) {
++ return;
++ }
++ adjustReferrals(urls);
++ 
++ // Check if we can use m_referralConnection to follow this referral 
++ if (m_referralConnection != null && m_referralConnection.isConnected()) {
++ String refHost = m_referralConnection.getHost();
++ int refPort = m_referralConnection.getPort();
++ try {
++ // Compare ipAddr:port for each referral with the m_referralConnection
++ String refAddr = InetAddress.getByName(refHost).getHostAddress(); 
++ for (int i = 0; i < urls.length; i++) {
++ String urlHost = urls[i].getHost();
++ int urlPort = urls[i].getPort();
++ String urlAddr = InetAddress.getByName(urlHost).getHostAddress();
++ if (refAddr == urlAddr && refPort == urlPort) {
++ refURL = urls[i];
++ break;
++ }
++ }
++ }
++ catch (UnknownHostException ex) {
++ // Compare host names rather than ip addr
++ for (int i = 0; i < urls.length; i++) {
++ if (refHost == urls[i].getHost() &&
++ refPort == urls[i].getPort()) {
++ refURL = urls[i];
++ break;
++ }
++ }
++ }
++ }
++
++ if (refURL != null) {
++ connection = m_referralConnection;
++ }
++ else {
++ connection = referralConnect( urls, cons );
++ 
++ // which one did we connect to...
++ refURL = connection.m_connMgr.getLDAPUrl();
++ 
++ // Authenticate
++ referralRebind(connection, cons);
++ }
++
++ String newDN = refURL.getDN();
++ String DN = null;
++ if ((newDN == null) || (newDN.equals(""))) {
++ DN = dn;
++ } else {
++ DN = newDN;
++ }
++ // If this was a one-level search, and a direct subordinate
++ // has a referral, there will be a "?base" in the URL, and
++ // we have to rewrite the scope from one to base
++ if ( refURL.getUrl().indexOf("?base") > -1 ) {
++ scope = SCOPE_BASE;
++ }
++
++ LDAPSearchConstraints newcons = (LDAPSearchConstraints)cons.clone();
++ newcons.setHopLimit( cons.getHopLimit()-1 );
++
++ referralOperation(connection, newcons, ops, DN, scope, filter,
++ types, attrsOnly, mods, entry, attr, results);
++
++ }
++ catch (LDAPException ex) {
++ if (refURL != null) {
++ ex.setExtraMessage("Failed to follow referral to " + refURL);
++ }
++ else {
++ ex.setExtraMessage("Failed to follow referral");
++ }
++ throw ex;
++ }
++ }
++
++ void referralOperation(LDAPConnection connection, 
++ LDAPConstraints cons, int ops, String dn, int scope,
++ String filter, String types[], boolean attrsOnly,
++ LDAPModification mods[], LDAPEntry entry,
++ LDAPAttribute attr,
++ Vector results) throws LDAPException {
++ 
++ LDAPSearchResults res = null;
++ try {
++ switch (ops) {
++ case JDAPProtocolOp.SEARCH_REQUEST:
++
++ res = connection.search(dn, scope, filter,
++ types, attrsOnly, 
++ (LDAPSearchConstraints)cons);
++ if (res != null) {
++ res.closeOnCompletion(connection);
++ results.addElement(res);
++ } else {
++ if ((m_referralConnection == null) ||
++ (!connection.equals(m_referralConnection)))
++ connection.disconnect();
++ }
++ break;
++ case JDAPProtocolOp.MODIFY_REQUEST:
++ connection.modify(dn, mods, cons);
++ break;
++ case JDAPProtocolOp.ADD_REQUEST:
++ if ((dn != null) && (!dn.equals("")))
++ entry.setDN(dn);
++ connection.add(entry, cons);
++ break;
++ case JDAPProtocolOp.DEL_REQUEST:
++ connection.delete(dn, cons);
++ break;
++ case JDAPProtocolOp.MODIFY_RDN_REQUEST:
++ connection.rename(dn, filter /* newRDN */, 
++ attrsOnly /* deleteOld */, cons);
++ break;
++ case JDAPProtocolOp.COMPARE_REQUEST:
++ boolean bool = connection.compare(dn, attr, cons);
++ results.addElement(new Boolean(bool));
++ break;
++ default:
++ /* impossible */
++ break;
++ }
++ } catch (LDAPException ee) {
++ throw ee;
++ } finally {
++ if ((connection != null) && 
++ ((ops != JDAPProtocolOp.SEARCH_REQUEST) || (res == null)) &&
++ ((m_referralConnection == null) || 
++ (!connection.equals(m_referralConnection)))) {
++ connection.disconnect();
++ }
++ }
++ }
++
++ /**
++ * Follows a referral for an extended operation.
++ * @param e referral exception
++ * @param cons search constraints
++ */
++ private LDAPExtendedOperation performExtendedReferrals(
++ LDAPReferralException e,
++ LDAPConstraints cons, LDAPExtendedOperation op )
++ throws LDAPException {
++
++ if (cons.getHopLimit() <= 0) {
++ throw new LDAPException("exceed hop limit",
++ e.getLDAPResultCode(),
++ e.getLDAPErrorMessage());
++ }
++ if (!cons.getReferrals()) {
++ throw e;
++ }
++
++ LDAPUrl u[] = e.getURLs();
++ // If there are no referrals (because the server isn't configured to
++ // return one), give up here
++ if ( u == null || u.length == 0) {
++ return null;
++ }
++ adjustReferrals(u);
++ 
++ LDAPConnection connection = referralConnect( u, cons);
++ referralRebind(connection, cons);
++ LDAPExtendedOperation results =
++ connection.extendedOperation( op );
++ connection.disconnect();
++ return results; /* return right away if operation is successful */
++ 
++ }
++
++ /**
++ * Returns a new <CODE>LDAPConnection</CODE> object that shares
++ * the physical connection to the LDAP server but has its own state.
++ * 
++ * The returned <CODE>LDAPConnection</CODE> object contains the same
++ * state as the current connection, including:
++ * <UL>
++ * <LI>the default search constraints
++ * <LI>host name and port number of the LDAP server
++ * <LI>the DN and password used to authenticate to the LDAP server
++ * <LI>the cache
++ * </UL>
++ * 
++ * @return the <CODE>LDAPconnection</CODE> object representing the
++ * new object.
++ */
++ public synchronized Object clone() {
++
++ LDAPConnection c = null; 
++ 
++ try {
++ if (m_thread != null) {
++ checkConnection(/*rebind=*/true);
++ }
++ }
++ catch (LDAPException ignore) {}
++ 
++ try {
++ c = (LDAPConnection)super.clone();
++ c.m_defaultConstraints =
++ (LDAPSearchConstraints)m_defaultConstraints.clone();
++ c.m_responseListeners = null;
++ c.m_searchListeners = null; 
++ c.m_properties = (Hashtable)m_properties.clone();
++ c.m_responseControlTable = new Hashtable();
++
++ if (c.m_cache != null) {
++ c.m_cache.addReference();
++ }
++
++ if (isConnected()) {
++ /* share current connection thread */
++ c.m_thread.register(c);
++ }
++ else {
++ c.m_thread = null;
++ c.m_connMgr = null;
++ }
++
++ } catch (Exception ignore) {}
++
++ return c;
++ }
++
++ /**
++ * Sets up basic connection privileges for Communicator.
++ * @return true if in Communicator and connections okay.
++ */
++ private static boolean checkCommunicator() {
++ try {
++ java.lang.reflect.Method m = LDAPCheckComm.getMethod(
++ "netscape.security.PrivilegeManager", "enablePrivilege");
++ if (m == null) {
++ printDebug("Method is null");
++ return false;
++ }
++
++ Object[] args = new Object[1];
++ args[0] = new String("UniversalConnect");
++ m.invoke( null, args);
++ printDebug( "UniversalConnect enabled" );
++ args[0] = new String("UniversalPropertyRead");
++ m.invoke( null, args);
++ printDebug( "UniversalPropertyRead enabled" );
++ return true;
++ } catch (LDAPException e) {
++ printDebug("Exception: "+e.toString());
++ } catch (Exception ie) {
++ printDebug("Exception on invoking " + "enablePrivilege: "+ie.toString());
++ }
++ return false;
++ }
++
++ /**
++ * Reports if the class is running in a Netscape browser.
++ * @return <CODE>true</CODE> if the class is running in a Netscape browser.
++ */
++ public static boolean isNetscape() {
++ return isCommunicator;
++ }
++
++ static void printDebug( String msg ) {
++ if ( debug ) {
++ System.out.println( msg );
++ }
++ }
++
++ /**
++ * Returns the string representation for this <CODE>LDAPConnection</CODE>.
++ * 
++ * For example:
++ *
++ * <PRE>LDAPConnection {ldap://dilly:389 (2) ldapVersion:3 bindDN:"uid=admin,o=iplanet.com"}</PRE>
++ * 
++ * For cloned connections, the number of LDAPConnection instances sharing the 
++ * same physical connection is shown in parenthesis following the ldap url. 
++ * If a LDAPConnection is not cloned, this number is omitted from the string
++ * representation.
++ *
++ * @return string representation of the connection.
++ * @see netscape.ldap.LDAPConnection#clone
++ */ 
++ public String toString() {
++ int cloneCnt = (m_thread == null) ? 0 : m_thread.getClientCount();
++ StringBuffer sb = new StringBuffer("LDAPConnection {");
++ //url
++ if (m_connMgr != null) {
++ sb.append(m_connMgr.getLDAPUrl().getServerUrl());
++ }
++ // clone count
++ if (cloneCnt > 1) {
++ sb.append(" (");
++ sb.append(cloneCnt);
++ sb.append(")");
++ }
++ // ldap version
++ sb.append(" ldapVersion:");
++ sb.append(m_protocolVersion);
++ // bind DN
++ sb.append(" bindDN:\"");
++ if (getAuthenticationDN() != null) {
++ sb.append(getAuthenticationDN());
++ }
++ sb.append("\"}");
++ 
++ return sb.toString();
++ }
++
++ /** 
++ * A helper class for collecting response controls. Used as a value 
++ * in m_responseControlTable
++ */
++ class ResponseControls {
++ int msgID;
++ Vector ctrls;
++ 
++ public ResponseControls(int msgID, LDAPControl[] ctrls) {
++ this.msgID = msgID;
++ this.ctrls = new Vector();
++ this.ctrls.addElement(ctrls);
++ }
++
++ void addControls(LDAPControl[] ctrls) {
++ this.ctrls.addElement(ctrls);
++ }
++ }
++
++ 
++ /**
++ * Prints out the LDAP Java SDK version and the highest LDAP
++ * protocol version supported by the SDK. To view this
++ * information, open a terminal window, and enter:
++ * <PRE>java netscape.ldap.LDAPConnection
++ * </PRE>
++ * @param args not currently used
++ */
++ public static void main(String[] args) {
++ System.out.println("LDAP SDK Version is "+SdkVersion);
++ System.out.println("LDAP Protocol Version is "+ProtocolVersion);
++ }
++
++ /**
++ * Option specifying the maximum number of unread entries to be cached in any
++ * LDAPSearchResults without suspending reading from the server.
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#setOption
++ */
++ public static final int MAXBACKLOG = 30;
++
++ private static boolean isCommunicator = checkCommunicator();
++ private static boolean debug = false;
++}
+--- /dev/null
++++ ldapjdk-4.18/mozilla/directory/java-sdk/src/netscape/ldap/LDAPSyntaxSchema.java
+@@ -0,0 +1,193 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
++ *
++ * ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org code.
++ *
++ * The Initial Developer of the Original Code is
++ * Netscape Communications Corporation.
++ * Portions created by the Initial Developer are Copyright (C) 2000
++ * the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++package netscape.ldap;
++
++import java.util.*;
++
++/**
++ * The definition of a syntax type in the schema.
++ * <A HREF="http://www.ietf.org/rfc/rfc2252.txt"
++ * TARGET="_blank">RFC 2252, Lightweight Directory Access Protocol (v3):
++ * LDAP Subschema Attribute</A> covers the types of information
++ * to specify when defining a syntax.
++ * The description of a syntax can include the following:
++ * 
++ *
++ * <UL>
++ * <LI>an OID identifying the syntax
++ * <LI>a description of the attribute type
++ * </UL>
++ * 
++ *
++ * When you construct an <CODE>LDAPSyntaxSchema</CODE> object, you can
++ * specify these types of information as arguments to the constructor or
++ * in the ldapSyntaxes format specified in RFC 2252.
++ * When an LDAP client searches an LDAP server for the schema, the server
++ * returns schema information as an object with attribute values in this
++ * format.
++ * 
++ * RFC 2252 defines SyntaxDescription as follows:
++ * 
++ * <PRE>
++ * SyntaxDescription = "(" whsp
++ * numericoid whsp
++ * [ "DESC" qdstring ]
++ * whsp ")"
++ * </PRE>
++ *
++ * Syntax definitions do not have a name, so the <CODE>getName</CODE>
++ * method inherited from <CODE>LDAPSchemaElement</CODE> returns "".
++ * To get the OID and description of this syntax type
++ * definition, use the <CODE>getOID</CODE> and
++ * <CODE>getDescription</CODE> methods inherited from the abstract class
++ * <CODE>LDAPSchemaElement</CODE>.
++ * 
++ *
++ * To add or remove this syntax type definition from the
++ * schema, use the <CODE>add</CODE> and <CODE>remove</CODE>
++ * methods, which this class inherits from the <CODE>LDAPSchemaElement</CODE>
++ * abstract class.
++ *
++ * @version 1.0
++ * @see netscape.ldap.LDAPSchemaElement
++ **/
++
++public class LDAPSyntaxSchema extends LDAPSchemaElement {
++
++ static final long serialVersionUID = 3590667117475688132L;
++
++ /**
++ * Constructs a blank element.
++ */
++ protected LDAPSyntaxSchema() {
++ super();
++ }
++
++ /**
++ * Constructs a syntax type definition, using the specified
++ * information.
++ * @param oid object identifier (OID) of the syntax type
++ * in dotted-string format (for example, "1.2.3.4")
++ * @param description description of syntax type
++ */
++ public LDAPSyntaxSchema( String oid, String description ) {
++ super( "", oid, description );
++ attrName = "ldapSyntaxes";
++ syntaxElement.syntax = syntaxElement.syntaxCheck( oid );
++ syntaxElement.syntaxString = oid;
++ }
++
++ /**
++ * Constructs a syntax type definition based on a description in
++ * the ldapSyntaxes format. For information on this format,
++ * (see <A HREF="http://www.ietf.org/rfc/rfc2252.txt"
++ * TARGET="_blank">RFC 2252, Lightweight Directory Access Protocol (v3):
++ * LDAP Subschema Attribute</A>. This is the format that LDAP servers
++ * and clients use to exchange schema information. (For example, when
++ * you search an LDAP server for its schema, the server returns an entry
++ * with the syntaxs "objectclasses" and "ldapSyntaxes". The
++ * values of "ldapSyntaxes" are syntax type descriptions
++ * in this format.)
++ * 
++ *
++ * @param raw definition of the syntax type in the
++ * ldapSyntaxes format
++ */
++ public LDAPSyntaxSchema( String raw ) {
++ attrName = "ldapSyntaxes";
++ parseValue( raw );
++ }
++
++ /**
++ * Gets the syntax of the schema element
++ * @return one of the following values:
++ * <UL>
++ * <LI><CODE>cis</CODE> (case-insensitive string)
++ * <LI><CODE>ces</CODE> (case-exact string)
++ * <LI><CODE>binary</CODE> (binary data)
++ * <LI><CODE>int</CODE> (integer)
++ * <LI><CODE>telephone</CODE> (telephone number -- identical to cis,
++ * but blanks and dashes are ignored during comparisons)
++ * <LI><CODE>dn</CODE> (distinguished name)
++ * <LI><CODE>unknown</CODE> (not a known syntax)
++ * </UL>
++ */
++ public int getSyntax() {
++ return syntaxElement.syntax;
++ }
++
++ /**
++ * Gets the syntax of the syntax type in dotted-decimal format,
++ * for example "1.2.3.4.5"
++ * @return The syntax syntax in dotted-decimal format.
++ */
++ public String getSyntaxString() {
++ return syntaxElement.syntaxString;
++ }
++
++ /**
++ * Prepares a value in RFC 2252 format for submission to a server
++ *
++ * @return a String ready for submission to an LDAP server.
++ */
++ public String getValue() {
++ String s = getValuePrefix();
++ String val = getCustomValues();
++ if ( val.length() > 0 ) {
++ s += val + ' ';
++ }
++ s += ')';
++ return s;
++ }
++
++ /**
++ * Gets the definition of the syntax type in a user friendly format.
++ * This is the format that the syntax type definition uses when
++ * printing the syntax type or the schema.
++ * @return definition of the syntax type in a user friendly format.
++ */
++ public String toString() {
++ String s = "OID: " + oid;
++ s += "; Description: " + description;
++ s += getQualifierString( null );
++ return s;
++ }
++
++ protected LDAPSyntaxSchemaElement syntaxElement =
++ new LDAPSyntaxSchemaElement();
++}
+--- /dev/null
++++ ldapjdk-4.18/mozilla/directory/java-sdk/src/netscape/ldap/LDAPSchema.java
+@@ -0,0 +1,953 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
++ *
++ * ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org code.
++ *
++ * The Initial Developer of the Original Code is
++ * Netscape Communications Corporation.
++ * Portions created by the Initial Developer are Copyright (C) 1999
++ * the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++package netscape.ldap;
++
++import java.util.*;
++
++/**
++ * This object represents the schema of an LDAP v3 server.
++ * You can use the <CODE>fetchSchema</CODE> method to retrieve
++ * the schema used by a server. (The server must support LDAP v3
++ * and the capability to retrieve the schema over the LDAP protocol.)
++ * 
++ *
++ * After you retrieve the schema, you can use this object to get
++ * the object class, attribute type, and matching rule descriptions
++ * in the schema. You can also add your own object classes,
++ * attribute types, and matching rules to the schema.
++ * 
++ *
++ * To remove any object classes, attribute types, and matching rules
++ * that you added, call the <CODE>remove</CODE> methods of the
++ * <CODE>LDAPObjectClassSchema</CODE>, <CODE>LDAPAttributeSchema</CODE>,
++ * and <CODE>LDAPMatchingRuleSchema</CODE> classes. (This method is
++ * inherited from the <CODE>LDAPSchemaElement</CODE> class.)
++ * 
++ *
++ * The following class is an example of an LDAP client that can
++ * fetch the schema, get and print object class descriptions and
++ * attribute type descriptions, and add object classes and attribute
++ * types to the schema over the LDAP protocol.
++ * 
++ *
++ * <PRE>
++ * import netscape.ldap.*;
++ * public class TestSchema {
++ * public static void main( String[] args ) {
++ * String HOSTNAME = "ldap.netscape.com";
++ * int PORT_NUMBER = DEFAULT_PORT;
++ * String ROOT_DN = "cn=Directory Manager";
++ * String ROOT_PASSWORD = "23skidoo";
++ *
++ * LDAPConnection ld = new LDAPConnection();
++ *
++ * // Construct a new <CODE>LDAPSchema</CODE> object to get the schema.
++ * LDAPSchema dirSchema = new LDAPSchema();
++ *
++ * try {
++ * // Connect to the server.
++ * ld.connect( HOSTNAME, PORT_NUMBER );
++ *
++ * // Get the schema from the directory.
++ * dirSchema.fetchSchema( ld );
++ *
++ * // Get and print the inetOrgPerson object class description.
++ * LDAPObjectClassSchema objClass = dirSchema.getObjectClass(
++ * "inetOrgPerson" );
++ * if ( objClass != null ) {
++ * System.out.println("inetOrgPerson := "+objClass.toString());
++ * }
++ *
++ * // Get and print the definition of the userPassword attribute.
++ * LDAPAttributeSchema attrType = dirSchema.getAttribute(
++ * "userpassword" );
++ * if ( attrType != null ) {
++ * System.out.println("userPassword := " + attrType.toString());
++ * }
++ *
++ * // Create a new object class definition.
++ * String[] requiredAttrs = {"cn", "mail"};
++ * String[] optionalAttrs = {"sn", "phoneNumber"};
++ * LDAPObjectClassSchema newObjClass =
++ * new LDAPObjectClassSchema( "newInetOrgPerson",
++ * "1.2.3.4.5.6.7",
++ * "top",
++ * "Experiment",
++ * requiredAttrs,
++ * optionalAttrs );
++ *
++ * // Authenticate as root DN to get permissions to edit the schema.
++ * ld.authenticate( ROOT_DN, ROOT_PASSWORD );
++ *
++ * // Add the new object class to the schema.
++ * newObjClass.add( ld );
++ *
++ * // Create a new attribute type "hairColor".
++ * LDAPAttributeSchema newAttrType =
++ * new LDAPAttributeSchema( "hairColor",
++ * "1.2.3.4.5.4.3.2.1",
++ * "Blonde, red, etc",
++ * LDAPAttributeSchema.cis,
++ * false );
++ * // Add a custom qualifier
++ * newObjClass.setQualifier( "X-OWNER", "John Jacobson" );
++ *
++ * // Add the new attribute type to the schema.
++ * newAttrType.add( ld );
++ *
++ * // Fetch the schema again to verify that changes were made.
++ * dirSchema.fetchSchema( ld );
++ *
++ * // Get and print the new attribute type.
++ * newAttrType = dirSchema.getAttribute( "hairColor" );
++ * if ( newAttrType != null ) {
++ * System.out.println("hairColor := " + newAttrType.toString());
++ * }
++ *
++ * // Get and print the new object class.
++ * newObjClass = dirSchema.getObjectClass( "newInetOrgPerson" );
++ * if ( newObjClass != null ) {
++ * System.out.println("newInetOrgPerson := " +newObjClass.toString());
++ * }
++ *
++ * ld.disconnect();
++ *
++ * } catch ( Exception e ) {
++ * System.err.println( e.toString() );
++ * System.exit( 1 );
++ * }
++ *
++ * System.exit( 0 );
++ * }
++ * }
++ * </PRE>
++ *
++ * If you are using the Netscape Directory Server 3.0, you can also
++ * verify that the class and attribute type have been added through
++ * the directory server manager (go to Schema | Edit or View Attributes
++ * or Schema | Edit or View Object Classes).
++ * 
++ *
++ * To remove the classes and attribute types added by the example,
++ * see the examples under the <CODE>LDAPSchemaElement</CODE> class.
++ * 
++ *
++ * @see netscape.ldap.LDAPAttributeSchema
++ * @see netscape.ldap.LDAPObjectClassSchema
++ * @see netscape.ldap.LDAPMatchingRuleSchema
++ * @see netscape.ldap.LDAPSchemaElement
++ * @version 1.0
++ * @author Rob Weltman
++ **/
++public class LDAPSchema implements java.io.Serializable {
++
++ static final long serialVersionUID = -3911737419783579398L;
++
++ /**
++ * Constructs a new <CODE>LDAPSchema</CODE> object.
++ * Once you construct the object, you can get
++ * the schema by calling <CODE>fetchSchema</CODE>.
++ * 
++ *
++ * You can also print out the schema by using the
++ * <CODE>main</CODE> method. For example, you can enter
++ * the following command:
++ * <PRE>
++ * java netscape.ldap.LDAPSchema myhost.mydomain.com 389
++ * </PRE>
++ *
++ * Note that you need to call <CODE>fetchSchema</CODE>
++ * to get the schema from the server. Constructing the
++ * object does not fetch the schema.
++ * 
++ *
++ * @see netscape.ldap.LDAPSchema#fetchSchema
++ * @see netscape.ldap.LDAPSchema#main
++ */
++ public LDAPSchema() {
++ }
++
++ public LDAPSchema( LDAPEntry entry ) {
++ initialize( entry );
++ }
++
++ /**
++ * Adds an object class schema definition to the current schema.
++ * You can also add object class schema definitions by calling the
++ * <CODE>add</CODE> method of your newly constructed
++ * <CODE>LDAPObjectClassSchema</CODE> object.
++ * 
++ *
++ * To remove an object class schema definition that you have added,
++ * call the <CODE>getObjectClass</CODE> method to get the
++ * <CODE>LDAPObjectClassSchema</CODE> object representing your
++ * object class and call the <CODE>remove</CODE> method.
++ * 
++ *
++ * NOTE: For information on the <CODE>add</CODE> and
++ * <CODE>remove</CODE> methods of <CODE>LDAPObjectClassSchema</CODE>,
++ * see the documentation for <CODE>LDAPSchemaElement</CODE>.
++ * (These methods are inherited from <CODE>LDAPSchemaElement</CODE>.)
++ * 
++ *
++ * @param objectSchema <CODE>LDAPObjectClassSchema</CODE> object
++ * representing the object class schema definition to add
++ * @see netscape.ldap.LDAPObjectClassSchema
++ * @see netscape.ldap.LDAPSchemaElement#add
++ * @see netscape.ldap.LDAPSchemaElement#remove
++ */
++ public void addObjectClass( LDAPObjectClassSchema objectSchema ) {
++ objectClasses.put( objectSchema.getName().toLowerCase(),
++ objectSchema );
++ }
++
++ /**
++ * Add an attribute type schema definition to the current schema.
++ * You can also add attribute type schema definitions by calling the
++ * <CODE>add</CODE> method of your newly constructed
++ * <CODE>LDAPAttributeSchema</CODE> object.
++ * 
++ *
++ * To remove an attribute type schema definition that you have added,
++ * call the <CODE>getAttribute</CODE> method to get the
++ * <CODE>LDAPAttributeSchema</CODE> object representing your
++ * attribute type and call the <CODE>remove</CODE> method.
++ * 
++ *
++ * NOTE: For information on the <CODE>add</CODE> and
++ * <CODE>remove</CODE> methods of <CODE>LDAPAttributeSchema</CODE>,
++ * see the documentation for <CODE>LDAPSchemaElement</CODE>.
++ * (These methods are inherited from <CODE>LDAPSchemaElement</CODE>.)
++ * 
++ *
++ * @param attrSchema <CODE>LDAPAttributeSchema</CODE> object
++ * representing the attribute type schema definition to add
++ * @see netscape.ldap.LDAPAttributeSchema
++ * @see netscape.ldap.LDAPSchemaElement#add
++ * @see netscape.ldap.LDAPSchemaElement#remove
++ */
++ public void addAttribute( LDAPAttributeSchema attrSchema ) {
++ attributes.put( attrSchema.getName().toLowerCase(), attrSchema );
++ }
++
++ /**
++ * Add a matching rule schema definition to the current schema.
++ * You can also add matching rule schema definitions by calling the
++ * <CODE>add</CODE> method of your newly constructed
++ * <CODE>LDAPMatchingRuleSchema</CODE> object.
++ * 
++ *
++ * To remove an attribute type schema definition that you have added,
++ * call the <CODE>getMatchingRule</CODE> method to get the
++ * <CODE>LDAPMatchingRuleSchema</CODE> object representing your
++ * matching rule and call the <CODE>remove</CODE> method.
++ * 
++ *
++ * NOTE: For information on the <CODE>add</CODE> and
++ * <CODE>remove</CODE> methods of <CODE>LDAPMatchingRuleSchema</CODE>,
++ * see the documentation for <CODE>LDAPSchemaElement</CODE>.
++ * (These methods are inherited from <CODE>LDAPSchemaElement</CODE>.)
++ * 
++ *
++ * @param matchSchema <CODE>LDAPMatchingRuleSchema</CODE> object
++ * representing the matching rule schema definition to add
++ * @see netscape.ldap.LDAPMatchingRuleSchema
++ * @see netscape.ldap.LDAPSchemaElement#add
++ * @see netscape.ldap.LDAPSchemaElement#remove
++ */
++ public void addMatchingRule( LDAPMatchingRuleSchema matchSchema ) {
++ matchingRules.put( matchSchema.getName().toLowerCase(), matchSchema );
++ }
++
++ /**
++ * Add a syntax schema definition to the current schema.
++ * You can also add syntax schema definitions by calling the
++ * <CODE>add</CODE> method of your newly constructed
++ * <CODE>LDAPSyntaxSchema</CODE> object.
++ * 
++ *
++ * To remove a syntax schema definition that you have added,
++ * call the <CODE>getSyntax</CODE> method to get the
++ * <CODE>LDAPSyntaxSchema</CODE> object representing your
++ * syntax type and call the <CODE>remove</CODE> method.
++ * 
++ *
++ * NOTE: For information on the <CODE>add</CODE> and
++ * <CODE>remove</CODE> methods of <CODE>LDAPSyntaxSchema</CODE>,
++ * see the documentation for <CODE>LDAPSchemaElement</CODE>.
++ * (These methods are inherited from <CODE>LDAPSchemaElement</CODE>.)
++ * 
++ *
++ * @param syntaxSchema <CODE>LDAPSyntaxSchema</CODE> object
++ * representing the syntax schema definition to add
++ * @see netscape.ldap.LDAPSyntaxSchema
++ * @see netscape.ldap.LDAPSchemaElement#add
++ * @see netscape.ldap.LDAPSchemaElement#remove
++ */
++ public void addSyntax( LDAPSyntaxSchema syntaxSchema ) {
++ String name = syntaxSchema.getName().toLowerCase();
++ if ( name.length() < 1 ) {
++ name = syntaxSchema.getOID();
++ }
++ syntaxes.put( name, syntaxSchema );
++ }
++
++ /**
++ * Add a structure rule definition to the current schema.
++ * You can also add structure rule definitions by calling the
++ * <CODE>add</CODE> method of your newly constructed
++ * <CODE>LDAPDITStructureRuleSchema</CODE> object.
++ * 
++ *
++ * To remove a structure rule definition that you have added,
++ * call the <CODE>getDITStructureRule</CODE> method to get the
++ * <CODE>LDAPDITStructureRuleSchema</CODE> object representing your
++ * rule and call the <CODE>remove</CODE> method.
++ * 
++ *
++ * NOTE: For information on the <CODE>add</CODE> and
++ * <CODE>remove</CODE> methods of <CODE>LDAPSyntaxSchema</CODE>,
++ * see the documentation for <CODE>LDAPSchemaElement</CODE>.
++ * (These methods are inherited from <CODE>LDAPSchemaElement</CODE>.)
++ * 
++ *
++ * @param rule <CODE>LDAPDITStructureRuleSchema</CODE> object
++ * representing the structure rule definition to add
++ * @see netscape.ldap.LDAPDITStructureRuleSchema
++ * @see netscape.ldap.LDAPSchemaElement#add
++ * @see netscape.ldap.LDAPSchemaElement#remove
++ */
++ public void addDITStructureRule( LDAPDITStructureRuleSchema rule ) {
++ String name = rule.getName().toLowerCase();
++ structureRulesByName.put( name, rule );
++ structureRulesById.put( new Integer( rule.getRuleID() ), rule );
++ }
++
++ /**
++ * Add a content rule definition to the current schema.
++ * You can also add content rule definitions by calling the
++ * <CODE>add</CODE> method of your newly constructed
++ * <CODE>LDAPDITContentRuleSchema</CODE> object.
++ * 
++ *
++ * To remove a content rule definition that you have added,
++ * call the <CODE>getDITContentRule</CODE> method to get the
++ * <CODE>LDAPDITContentRuleSchema</CODE> object representing your
++ * rule and call the <CODE>remove</CODE> method.
++ * 
++ *
++ * NOTE: For information on the <CODE>add</CODE> and
++ * <CODE>remove</CODE> methods of <CODE>LDAPSyntaxSchema</CODE>,
++ * see the documentation for <CODE>LDAPSchemaElement</CODE>.
++ * (These methods are inherited from <CODE>LDAPSchemaElement</CODE>.)
++ * 
++ *
++ * @param rule <CODE>LDAPDITContentRuleSchema</CODE> object
++ * representing the content rule definition to add
++ * @see netscape.ldap.LDAPDITContentRuleSchema
++ * @see netscape.ldap.LDAPSchemaElement#add
++ * @see netscape.ldap.LDAPSchemaElement#remove
++ */
++ public void addDITContentRule( LDAPDITContentRuleSchema rule ) {
++ String name = rule.getName().toLowerCase();
++ contentRules.put( name, rule );
++ }
++
++ /**
++ * Add a name form definition to the current schema.
++ * You can also add name form definitions by calling the
++ * <CODE>add</CODE> method of your newly constructed
++ * <CODE>LDAPNameFormSchema</CODE> object.
++ * 
++ *
++ * To remove a name form definition that you have added,
++ * call the <CODE>getNameForm</CODE> method to get the
++ * <CODE>LDAPNameFormSchema</CODE> object representing your
++ * nameForm type and call the <CODE>remove</CODE> method.
++ * 
++ *
++ * NOTE: For information on the <CODE>add</CODE> and
++ * <CODE>remove</CODE> methods of <CODE>LDAPNameFormSchema</CODE>,
++ * see the documentation for <CODE>LDAPSchemaElement</CODE>.
++ * (These methods are inherited from <CODE>LDAPSchemaElement</CODE>.)
++ * 
++ *
++ * @param nameForm <CODE>LDAPNameFormSchema</CODE> object
++ * representing the name form definition to add
++ * @see netscape.ldap.LDAPNameFormSchema
++ * @see netscape.ldap.LDAPSchemaElement#add
++ * @see netscape.ldap.LDAPSchemaElement#remove
++ */
++ public void addNameForm( LDAPNameFormSchema nameForm ) {
++ String name = nameForm.getName().toLowerCase();
++ nameForms.put( name, nameForm );
++ }
++
++ /**
++ * Gets an enumeration ofthe object class definitions in this schema.
++ * @return an enumeration of object class definitions.
++ */
++ public Enumeration getObjectClasses() {
++ return objectClasses.elements();
++ }
++
++ /**
++ * Gets an enumeration ofthe attribute type definitions in this schema.
++ * @return an enumeration of attribute type definitions.
++ */
++ public Enumeration getAttributes() {
++ return attributes.elements();
++ }
++
++ /**
++ * Gets an enumeration ofthe matching rule definitions in this schema.
++ * @return an enumeration of matching rule definitions.
++ */
++ public Enumeration getMatchingRules() {
++ return matchingRules.elements();
++ }
++
++ /**
++ * Get an enumeration of the syntaxes in this schema.
++ * @return an enumeration of syntax objects
++ */
++ public Enumeration getSyntaxes() {
++ return syntaxes.elements();
++ }
++
++ /**
++ * Get an enumeration of the structure rules in this schema.
++ * @return an enumeration of structure rule objects
++ */
++ public Enumeration getDITStructureRules() {
++ return structureRulesByName.elements();
++ }
++
++ /**
++ * Get an enumeration of the content rules in this schema.
++ * @return an enumeration of content rule objects
++ */
++ public Enumeration getDITContentRules() {
++ return contentRules.elements();
++ }
++
++ /**
++ * Get an enumeration of the name forms in this schema.
++ * @return an enumeration of name form objects
++ */
++ public Enumeration getNameForms() {
++ return nameForms.elements();
++ }
++
++ /**
++ * Gets the definition of the object class with the specified name.
++ * @param name name of the object class to find
++ * @return an <CODE>LDAPObjectClassSchema</CODE> object representing
++ * the object class definition, or <CODE>null</CODE> if not found.
++ */
++ public LDAPObjectClassSchema getObjectClass( String name ) {
++ return (LDAPObjectClassSchema)objectClasses.get( name.toLowerCase() );
++ }
++
++ /**
++ * Gets the definition of the attribute type with the specified name.
++ * @param name name of the attribute type to find
++ * @return an <CODE>LDAPAttributeSchema</CODE> object representing
++ * the attribute type definition, or <CODE>null</CODE> if not found.
++ */
++ public LDAPAttributeSchema getAttribute( String name ) {
++ return (LDAPAttributeSchema)attributes.get( name.toLowerCase() );
++ }
++
++ /**
++ * Gets the definition of a matching rule with the specified name.
++ * @param name name of the matching rule to find
++ * @return an <CODE>LDAPMatchingRuleSchema</CODE> object representing
++ * the matching rule definition, or <CODE>null</CODE> if not found.
++ */
++ public LDAPMatchingRuleSchema getMatchingRule( String name ) {
++ return (LDAPMatchingRuleSchema)matchingRules.get( name.toLowerCase() );
++ }
++
++ /**
++ * Gets the definition of a syntax with the specified name.
++ * @param name name of the syntax to find
++ * @return an <CODE>LDAPSyntaxSchema</CODE> object representing
++ * the syntax definition, or <CODE>null</CODE> if not found.
++ */
++ public LDAPSyntaxSchema getSyntax( String name ) {
++ return (LDAPSyntaxSchema)syntaxes.get( name.toLowerCase() );
++ }
++
++ /**
++ * Gets the definition of a structure rule with the specified name.
++ * @param name name of the rule to find
++ * @return an <CODE>LDAPDITStructureRuleSchema</CODE> object representing
++ * the rule, or <CODE>null</CODE> if not found.
++ */
++ public LDAPDITStructureRuleSchema getDITStructureRule( String name ) {
++ return (LDAPDITStructureRuleSchema)structureRulesByName.get(
++ name.toLowerCase() );
++ }
++
++ /**
++ * Gets the definition of a structure rule with the specified name.
++ * @param ID ID of the rule to find
++ * @return an <CODE>LDAPDITStructureRuleSchema</CODE> object representing
++ * the rule, or <CODE>null</CODE> if not found.
++ */
++ public LDAPDITStructureRuleSchema getDITStructureRule( int ID ) {
++ return (LDAPDITStructureRuleSchema)structureRulesById.get(
++ new Integer( ID ) );
++ }
++
++ /**
++ * Gets the definition of a content rule with the specified name.
++ * @param name name of the rule to find
++ * @return an <CODE>LDAPDITContentRuleSchema</CODE> object representing
++ * the rule, or <CODE>null</CODE> if not found.
++ */
++ public LDAPDITContentRuleSchema getDITContentRule( String name ) {
++ return (LDAPDITContentRuleSchema)contentRules.get(
++ name.toLowerCase() );
++ }
++
++ /**
++ * Gets the definition of a name form with the specified name.
++ * @param name name of the name form to find
++ * @return an <CODE>LDAPNameFormSchema</CODE> object representing
++ * the syntax definition, or <CODE>null</CODE> if not found.
++ */
++ public LDAPNameFormSchema getNameForm( String name ) {
++ return (LDAPNameFormSchema)nameForms.get( name.toLowerCase() );
++ }
++
++ /**
++ * Get an enumeration of the names of the object classes in this schema.
++ * @return an enumeration of object class names (all lower-case).
++ */
++ public Enumeration getObjectClassNames() {
++ return objectClasses.keys();
++ }
++
++ /**
++ * Get an enumeration of the names of the attribute types in this schema.
++ * @return an enumeration of attribute names (all lower-case).
++ */
++ public Enumeration getAttributeNames() {
++ return attributes.keys();
++ }
++
++ /**
++ * Get an enumeration of the names of the matching rules in this schema.
++ * @return an enumeration of matching rule names (all lower-case).
++ */
++ public Enumeration getMatchingRuleNames() {
++ return matchingRules.keys();
++ }
++
++ /**
++ * Get an enumeration of the names of the syntaxes in this schema.
++ * @return an enumeration of syntax names (all lower-case).
++ */
++ public Enumeration getSyntaxNames() {
++ return syntaxes.keys();
++ }
++
++ /**
++ * Get an enumeration of the names of the structure rules in this schema.
++ * @return an enumeration of names of the structure rule objects
++ */
++ public Enumeration getDITStructureRuleNames() {
++ return structureRulesByName.keys();
++ }
++
++ /**
++ * Get an enumeration of the names of the content rules in this schema.
++ * @return an enumeration of names of the content rule objects
++ */
++ public Enumeration getDITContentRuleNames() {
++ return contentRules.keys();
++ }
++
++ /**
++ * Get an enumeration of the names of the name forms in this schema.
++ * @return an enumeration of names of name form objects
++ */
++ public Enumeration getNameFormNames() {
++ return nameForms.keys();
++ }
++
++ /**
++ * Retrieve the schema for a specific entry.
++ * @param ld an active connection to a Directory Server
++ * @param dn the entry for which to fetch schema
++ * @exception LDAPException on failure.
++ */
++ public void fetchSchema( LDAPConnection ld, String dn )
++ throws LDAPException {
++ /* Find the subschemasubentry value for this DN */
++ String entryName = getSchemaDN( ld, dn );
++ Enumeration en;
++
++ /* Get the entire schema definition entry */
++ LDAPEntry entry = readSchema( ld, entryName );
++ initialize( entry );
++ }
++
++ /**
++ * Extract all schema elements from subschema entry
++ *
++ * @param entry entry containing schema definitions
++ */
++ protected void initialize( LDAPEntry entry ) {
++ /* Get all object class definitions */
++ LDAPAttribute attr = entry.getAttribute( "objectclasses" );
++ Enumeration en;
++ if ( attr != null ) {
++ en = attr.getStringValues();
++ while( en.hasMoreElements() ) {
++ LDAPObjectClassSchema sch =
++ new LDAPObjectClassSchema( (String)en.nextElement() );
++ addObjectClass( sch );
++ }
++ }
++
++ /* Get all attribute definitions */
++ attr = entry.getAttribute( "attributetypes" );
++ if ( attr != null ) {
++ en = attr.getStringValues();
++ while( en.hasMoreElements() ) {
++ LDAPAttributeSchema sch =
++ new LDAPAttributeSchema( (String)en.nextElement() );
++ addAttribute( sch );
++ }
++ }
++
++ /* Get all syntax definitions */
++ attr = entry.getAttribute( "ldapsyntaxes" );
++ if ( attr != null ) {
++ en = attr.getStringValues();
++ while( en.hasMoreElements() ) {
++ LDAPSyntaxSchema sch =
++ new LDAPSyntaxSchema( (String)en.nextElement() );
++ addSyntax( sch );
++ }
++ }
++
++ /* Get all structure rule definitions */
++ attr = entry.getAttribute( "ldapditstructurerules" );
++ if ( attr != null ) {
++ en = attr.getStringValues();
++ while( en.hasMoreElements() ) {
++ LDAPDITStructureRuleSchema sch =
++ new LDAPDITStructureRuleSchema(
++ (String)en.nextElement() );
++ addDITStructureRule( sch );
++ }
++ }
++
++ /* Get all content rule definitions */
++ attr = entry.getAttribute( "ldapditcontentrules" );
++ if ( attr != null ) {
++ en = attr.getStringValues();
++ while( en.hasMoreElements() ) {
++ LDAPDITContentRuleSchema sch =
++ new LDAPDITContentRuleSchema(
++ (String)en.nextElement() );
++ addDITContentRule( sch );
++ }
++ }
++
++ /* Get all name form definitions */
++ attr = entry.getAttribute( "nameforms" );
++ if ( attr != null ) {
++ en = attr.getStringValues();
++ while( en.hasMoreElements() ) {
++ LDAPNameFormSchema sch =
++ new LDAPNameFormSchema(
++ (String)en.nextElement() );
++ addNameForm( sch );
++ }
++ }
++
++ /* Matching rules are tricky, because we have to match up a
++ rule with its use. First get all the uses. */
++ Hashtable h = new Hashtable();
++ attr = entry.getAttribute( "matchingruleuse" );
++ if ( attr != null ) {
++ en = attr.getStringValues();
++ while( en.hasMoreElements() ) {
++ String use = (String)en.nextElement();
++ LDAPMatchingRuleSchema sch =
++ new LDAPMatchingRuleSchema( null, use );
++ h.put( sch.getOID(), use );
++ }
++ }
++ /* Now get the rules, and assign uses to them */
++ attr = entry.getAttribute( "matchingrules" );
++ if ( attr != null ) {
++ en = attr.getStringValues();
++ while( en.hasMoreElements() ) {
++ String raw = (String)en.nextElement();
++ LDAPMatchingRuleSchema sch =
++ new LDAPMatchingRuleSchema( raw, null );
++ String use = (String)h.get( sch.getOID() );
++ if ( use != null )
++ sch = new LDAPMatchingRuleSchema( raw, use );
++ addMatchingRule( sch );
++ }
++ }
++ }
++
++ /**
++ * Retrieve the entire schema from the root of a Directory Server.
++ * @param ld an active connection to a Directory Server
++ * @exception LDAPException on failure.
++ */
++ public void fetchSchema( LDAPConnection ld ) throws LDAPException {
++ fetchSchema( ld, "" );
++ }
++
++ /**
++ * Read one attribute definition from a server to determine if
++ * attribute syntaxes are quoted (a bug, present in Netscape
++ * and Novell servers).
++ * @param ld an active connection to a Directory Server
++ * @return <CODE>true</CODE> if standards-compliant.
++ * @exception LDAPException on failure.
++ */
++ static boolean isAttributeSyntaxStandardsCompliant( LDAPConnection ld )
++ throws LDAPException {
++
++ /* Check if this has already been investigated */
++ String schemaBug = (String)ld.getProperty( ld.SCHEMA_BUG_PROPERTY );
++ if ( schemaBug != null ) {
++ return schemaBug.equalsIgnoreCase( "standard" );
++ }
++
++ boolean compliant = true;
++ /* Get the schema definitions for attributes */
++ String entryName = getSchemaDN( ld, "" );
++ String[] attrs = { "attributetypes" };
++ LDAPEntry entry = ld.read( entryName, attrs );
++ /* Get all attribute definitions, and check the first one */
++ LDAPAttribute attr = entry.getAttribute( "attributetypes" );
++ if ( attr != null ) {
++ Enumeration en = attr.getStringValues();
++ if( en.hasMoreElements() ) {
++ compliant = !isSyntaxQuoted( (String)en.nextElement() );
++ }
++ }
++ ld.setProperty( ld.SCHEMA_BUG_PROPERTY, compliant ? "standard" :
++ "NetscapeBug" );
++ return compliant;
++ }
++
++ /**
++ * Parses an attribute schema definition to see if the SYNTAX value
++ * is quoted. It shouldn't be (according to RFC 2252), but it is for
++ * some LDAP servers. It will either be: 
++ * <CODE>SYNTAX 1.3.6.1.4.1.1466.115.121.1.15</CODE> or 
++ * <CODE>SYNTAX '1.3.6.1.4.1.1466.115.121.1.15'</CODE>
++ * @param raw Definition of the attribute type in the
++ * AttributeTypeDescription format.
++ */
++ static boolean isSyntaxQuoted( String raw ) {
++ int ind = raw.indexOf( " SYNTAX " );
++ if ( ind >= 0 ) {
++ ind += 8;
++ int l = raw.length() - ind;
++ // Extract characters
++ char[] ch = new char[l];
++ raw.getChars( ind, raw.length(), ch, 0 );
++ ind = 0;
++ // Skip to ' or start of syntax value
++ while( (ind < ch.length) && (ch[ind] == ' ') ) {
++ ind++;
++ }
++ if ( ind < ch.length ) {
++ return ( ch[ind] == '\'' );
++ }
++ }
++ return false;
++ }
++
++ /**
++ * Displays the schema (including the descriptions of its object
++ * classes, attribute types, and matching rules) in an easily
++ * readable format (not the same as the format expected by
++ * an LDAP server).
++ * @return a string containing the schema in printable format.
++ */
++ public String toString() {
++ String s = "Object classes:\n";
++ Enumeration en = getObjectClasses();
++ while( en.hasMoreElements() ) {
++ s += en.nextElement().toString();
++ s += '\n';
++ }
++ s += "Attributes:\n";
++ en = getAttributes();
++ while( en.hasMoreElements() ) {
++ s += en.nextElement().toString();
++ s += '\n';
++ }
++ s += "Matching rules:\n";
++ en = getMatchingRules();
++ while( en.hasMoreElements() ) {
++ s += en.nextElement().toString();
++ s += '\n';
++ }
++ s += "Syntaxes:\n";
++ en = getSyntaxes();
++ while( en.hasMoreElements() ) {
++ s += en.nextElement().toString();
++ s += '\n';
++ }
++ return s;
++ }
++
++ /**
++ * Retrieve the DN of the schema definitions for a specific entry.
++ * @param ld an active connection to a Directory Server
++ * @param dn the entry for which to fetch schema
++ * @exception LDAPException on failure.
++ */
++ static String getSchemaDN( LDAPConnection ld, String dn )
++ throws LDAPException {
++ if ( (ld == null) || !ld.isConnected() ) {
++ throw new LDAPException( "No connection", LDAPException.OTHER );
++ }
++ String[] attrs = { "subschemasubentry" };
++ LDAPEntry entry = ld.read( dn, attrs );
++ if ( entry == null ) {
++ throw new LDAPException( "", LDAPException.NO_SUCH_OBJECT );
++ }
++ LDAPAttribute attr = entry.getAttribute( attrs[0] );
++ String entryName = "cn=schema";
++ if ( attr != null ) {
++ Enumeration en = attr.getStringValues();
++ if ( en.hasMoreElements() ) {
++ entryName = (String)en.nextElement();
++ }
++ }
++ return entryName;
++ }
++
++ private static LDAPEntry readSchema( LDAPConnection ld, String dn,
++ String[] attrs )
++ throws LDAPException {
++ LDAPSearchResults results = ld.search (dn, ld.SCOPE_BASE,
++ "objectclass=subschema",
++ attrs, false);
++ if ( !results.hasMoreElements() ) {
++ throw new LDAPException( "Cannot read schema",
++ LDAPException.INSUFFICIENT_ACCESS_RIGHTS );
++ }
++ return results.next ();
++ }
++
++ private static LDAPEntry readSchema( LDAPConnection ld, String dn )
++ throws LDAPException {
++ return readSchema( ld, dn, new String[] { "*", "ldapSyntaxes",
++ "matchingRules", "attributeTypes", "objectClasses" } ); 
++ }
++
++ /**
++ * Helper for "main" to print out schema elements.
++ * @param en enumeration of schema elements
++ */
++ private static void printEnum( Enumeration en ) {
++ while( en.hasMoreElements() ) {
++ LDAPSchemaElement s = (LDAPSchemaElement)en.nextElement();
++ System.out.println( " " + s );
++// System.out.println( " " + s.getValue() );
++ }
++ }
++
++ /**
++ * Fetch the schema from the LDAP server at the specified
++ * host and port, and print out the schema (including descriptions
++ * of its object classes, attribute types, and matching rules).
++ * The schema is printed in an easily readable format (not the
++ * same as the format expected by an LDAP server). For example,
++ * you can enter the following command to print the schema:
++ * <PRE>
++ * java netscape.ldap.LDAPSchema myhost.mydomain.com 389
++ * </PRE>
++ *
++ * @param args the host name and the port number of the LDAP server
++ * (for example, <CODE>netscape.ldap.LDAPSchema directory.netscape.com
++ * 389</CODE>)
++ */
++ public static void main( String[] args ) {
++ if ( args.length < 2 ) {
++ System.err.println( "Usage: netscape.ldap.LDAPSchema HOST PORT" );
++ System.exit(1 );
++ }
++ int port = Integer.parseInt( args[1] );
++ LDAPConnection ld = new LDAPConnection();
++ try {
++ ld.connect( args[0], port );
++ LDAPSchema schema = new LDAPSchema();
++ schema.fetchSchema( ld );
++ ld.disconnect();
++ System.out.println( "Object classes: " );
++ printEnum( schema.getObjectClasses() );
++ System.out.println( "\nAttributes: " );
++ printEnum( schema.getAttributes() );
++ System.out.println( "\nMatching rules: " );
++ printEnum( schema.getMatchingRules() );
++ System.out.println( "\nSyntaxes: " );
++ printEnum( schema.getSyntaxes() );
++ System.exit( 0 );
++ } catch ( LDAPException e ) {
++ System.err.println( e );
++ }
++ }
++
++ private Hashtable objectClasses = new Hashtable();
++ private Hashtable attributes = new Hashtable();
++ private Hashtable matchingRules = new Hashtable();
++ private Hashtable syntaxes = new Hashtable();
++ private Hashtable structureRulesByName = new Hashtable();
++ private Hashtable structureRulesById = new Hashtable();
++ private Hashtable contentRules = new Hashtable();
++ private Hashtable nameForms = new Hashtable();
++}
+--- /dev/null
++++ ldapjdk-4.18/mozilla/directory/java-sdk/src/netscape/ldap/LDAPv3.java
+@@ -0,0 +1,213 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
++ *
++ * ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org code.
++ *
++ * The Initial Developer of the Original Code is
++ * Netscape Communications Corporation.
++ * Portions created by the Initial Developer are Copyright (C) 1999
++ * the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++package netscape.ldap;
++
++import java.util.*;
++import netscape.ldap.client.*;
++import netscape.ldap.client.opers.*;
++import java.io.*;
++
++/**
++ * Specifies additional features available in version 3 of the
++ * LDAP protocol. (To view preliminary information on this work
++ * in progress, see the LDAP v3 internet draft. You can find the
++ * latest version of this document listed under the Internet-Drafts
++ * section of the
++ * <A HREF="http://www.ietf.cnri.reston.va.us/html.charters/asid-charter.html"
++ * TARGET=_blank">ASID home page</A>.)
++ *
++ * @version 1.0
++ */
++public interface LDAPv3 extends LDAPv2 {
++
++ /**
++ * Connects and authenticates to the LDAP server using the specified version of the
++ * LDAP protocol.
++ * @param version requested version of the LDAP protocol: currently 2 or 3
++ * @param host hostname of the LDAP server
++ * @param port port number of the LDAP server. To specify the
++ * default port, use <CODE>DEFAULT_PORT</CODE>.
++ * @param dn distinguished name to use for authentication
++ * @param passwd password for authentication
++ * @exception LDAPException Failed to connect and authenticate to the server.
++ */
++ public void connect(int version, String host, int port, String dn,
++ String passwd) throws LDAPException;
++
++ /**
++ * Authenticates to the LDAP server (to which the object is currently
++ * connected) using the specified name, password, and version
++ * of the LDAP protocol. If the server does not support the requested 
++ * protocol version, an exception is thrown. If the object has been 
++ * disconnected from an LDAP server, this method attempts to reconnect 
++ * to the server. If the object had already authenticated, the old 
++ * authentication is discarded.
++ * @param version requested LDAP protocol version: currently 2 or 3.
++ * @param dn if non-null and non-empty, specifies that the
++ * connection and all operations through it should
++ * authenticate with dn as the distinguished name
++ * @param passwd if non-null and non-empty, specifies that the
++ * connection and all operations through it should
++ * authenticated with passwd as password
++ * @exception LDAPException Failed to authenticate to the LDAP server.
++ */
++ public void authenticate(int version,
++ String dn,
++ String passwd)
++ throws LDAPException;
++
++ /**
++ * Authenticates to the LDAP server (to which the object is currently
++ * connected) using the specified name, password, and version of the
++ * LDAP protocol. If the server does not support the requested
++ * version of the protocol, an exception is thrown. If the
++ * object has been disconnected from an LDAP server, this method
++ * attempts to reconnect to the server. If the object had already
++ * authenticated, the old authentication is discarded.
++ * @param version requested LDAP protocol version: currently 2 or 3.
++ * @param dn if non-null and non-empty, specifies that the
++ * connection and all operations through it should authenticate
++ * with dn as the distinguished name
++ * @param passwd if non-null and non-empty, specifies that the
++ * connection and all operations through it should authenticate
++ * with passwd as password
++ * @exception LDAPException Failed to authenticate to the LDAP server.
++ */
++ public void bind(int version,
++ String dn,
++ String passwd)
++ throws LDAPException;
++ 
++ /**
++ * Performs an extended operation on the directory. Extended operations
++ * are part of version 3 of the LDAP protocol.
++ * 
++ *
++ * @param op LDAPExtendedOperation object specifying the OID of the
++ * extended operation and the data to use in the operation
++ * @exception LDAPException Failed to execute the operation
++ * @return LDAPExtendedOperation object representing the extended response
++ * returned by the server.
++ * @see LDAPExtendedOperation
++ */
++ public LDAPExtendedOperation extendedOperation( LDAPExtendedOperation op )
++ throws LDAPException;
++
++ /**
++ * Renames and moves an entry in the directory.
++ * @param DN original distinguished name (DN) for the entry
++ * @param newRDN new relative distinguished name (RDN) for the entry
++ * @param newParentDN distinguished name of the new parent entry of the
++ * specified entry
++ * @param deleteOldRDN specifies whether or not to remove the old RDN
++ * when renaming and moving the entry. If <code>true</code>, the old RDN will be deleted.
++ * @exception LDAPException Failed to rename the specified entry.
++ */
++ public void rename( String DN, String newRDN, String newParentDN,
++ boolean deleteOldRDN ) throws LDAPException;
++
++ /**
++ * Renames and moves an entry in the directory.
++ * @param DN original distinguished name (DN) for the entry
++ * @param newRDN new relative distinguished name (RDN) for the entry
++ * @param newParentDN distinguished name of the new parent entry of the
++ * specified entry
++ * @param deleteOldRDN specifies whether or not to remove the old RDN
++ * when renaming and moving the entry. If <code>true</code>, the old RDN will be deleted.
++ * @param cons the constraints set for the rename operation
++ * @exception LDAPException Failed to rename the specified entry.
++ */
++ public void rename( String DN, String newRDN, String newParentDN,
++ boolean deleteOldRDN, LDAPConstraints cons ) throws LDAPException;
++
++ /**
++ * Returns an array of the latest controls (if any) from the server.
++ * @return an array of the controls returned by an operation,
++ * or <CODE>null</CODE> if none.
++ * @see netscape.ldap.LDAPControl
++ */
++ public LDAPControl[] getResponseControls();
++
++ /**
++ * Option specifying client controls for LDAP operations. These
++ * controls are interpreted by the client and are not passed
++ * to the LDAP server.
++ * @see netscape.ldap.LDAPControl
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#setOption
++ */
++ public static final int CLIENTCONTROLS = 11;
++
++ /**
++ * Option specifying server controls for LDAP operations. These
++ * controls are passed to the LDAP server. They may also be returned by
++ * the server.
++ * @see netscape.ldap.LDAPControl
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#setOption
++ */
++ public static final int SERVERCONTROLS = 12;
++
++ /**
++ * Attribute type that you can specify in the LDAPConnection
++ * search method if you don't want to retrieve any of the
++ * attribute types for entries found by the search.
++ * @see netscape.ldap.LDAPConnection#search
++ */
++ public static final String NO_ATTRS = "1.1";
++
++ /**
++ * Attribute type that you can specify in the LDAPConnection
++ * search method if you want to retrieve all attribute types.
++ * You can use this if you want to retrieve all attributes in
++ * addition to an operational attribute. For example:
++ * 
++ *
++ * <PRE>
++ * ...
++ * String [] MY_ATTRS = { LDAPv3.ALL_USER_ATTRS, "modifiersName",
++ * "modifyTimestamp" };
++ * LDAPSearchResults res = ld.search( MY_SEARCHBASE,
++ * LDAPConnection.SCOPE_SUB, MY_FILTER, MY_ATTRS, false, cons );
++ * ...
++ * </PRE>
++ * @see netscape.ldap.LDAPConnection#search
++ */
++ public static final String ALL_USER_ATTRS = "*";
++
++}
+--- /dev/null
++++ ldapjdk-4.18/mozilla/directory/java-sdk/src/netscape/ldap/LDAPControl.java
+@@ -0,0 +1,529 @@
++/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
++ *
++ * ***** BEGIN LICENSE BLOCK *****
++ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
++ *
++ * The contents of this file are subject to the Mozilla Public License Version
++ * 1.1 (the "License"); you may not use this file except in compliance with
++ * the License. You may obtain a copy of the License at
++ * http://www.mozilla.org/MPL/
++ *
++ * Software distributed under the License is distributed on an "AS IS" basis,
++ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
++ * for the specific language governing rights and limitations under the
++ * License.
++ *
++ * The Original Code is mozilla.org code.
++ *
++ * The Initial Developer of the Original Code is
++ * Netscape Communications Corporation.
++ * Portions created by the Initial Developer are Copyright (C) 1999
++ * the Initial Developer. All Rights Reserved.
++ *
++ * Contributor(s):
++ *
++ * Alternatively, the contents of this file may be used under the terms of
++ * either the GNU General Public License Version 2 or later (the "GPL"), or
++ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
++ * in which case the provisions of the GPL or the LGPL are applicable instead
++ * of those above. If you wish to allow use of your version of this file only
++ * under the terms of either the GPL or the LGPL, and not to allow others to
++ * use your version of this file under the terms of the MPL, indicate your
++ * decision by deleting the provisions above and replace them with the notice
++ * and other provisions required by the GPL or the LGPL. If you do not delete
++ * the provisions above, a recipient may use your version of this file under
++ * the terms of any one of the MPL, the GPL or the LGPL.
++ *
++ * ***** END LICENSE BLOCK ***** */
++package netscape.ldap;
++
++import java.io.*;
++import java.util.*;
++import java.lang.reflect.*;
++import netscape.ldap.ber.stream.*;
++import netscape.ldap.client.*;
++import netscape.ldap.util.*;
++import netscape.ldap.controls.*;
++
++/**
++ * Represents arbitrary control data that can be used with a
++ * a particular LDAP operation. LDAP controls are part of version 3
++ * of the LDAP protocol.
++ * 
++ *
++ * LDAP controls allow you to extend the functionality of
++ * an LDAP operation. For example, you can use an LDAP control
++ * for the search operation to sort search results on an LDAP server.
++ * 
++ *
++ * An LDAP control can be either a server control or
++ * a client control:
++ * 
++ * <UL>
++ * <LI>Server controls can be sent to the LDAP server or returned
++ * by the server on any operation.
++ * <LI>Client controls are intended to affect only the client side
++ * of the operation.
++ * </UL>
++ * 
++ *
++ * An LDAP control consists of the following information:
++ * 
++ * <UL>
++ * <LI>A unique object ID (OID) that identifies the control.
++ * <LI>A &quot;criticality&quot; field, which indicates whether or
++ * not the control is critical to the operation. (If the control is
++ * critical to the operation and the server does not support the control,
++ * the server should not execute the operation.)
++ * <LI>Data pertaining to the control.
++ * </UL>
++ * 
++ *
++ * To determine which server controls are supported by a particular server,
++ * you need to search for the root DSE (DSA-specific entry, where DSA is
++ * another term for &quot;LDAP server&quot;) and find the values of the
++ * <CODE>supportedControl</CODE> attribute. This attribute contains the
++ * object IDs (OIDs) of the controls supported by this server.
++ * 
++ *
++ * The following section of code demonstrates how to get the list
++ * of the server controls supported by an LDAP server.
++ * 
++ *
++ * <PRE>
++ * public static void main( String[] args )
++ * {
++ * LDAPConnection ld = new LDAPConnection();
++ * try {
++ * String MY_HOST = "localhost";
++ * int MY_PORT = 389;
++ * ld.connect( MY_HOST, MY_PORT );
++ * try {
++ * ld.authenticate( 3, "cn=Directory Manager", "23skidoo" );
++ * } catch( LDAPException e ) {
++ * System.out.println( "LDAP server does not support v3." );
++ * ld.disconnect();
++ * System.exit(1);
++ * }
++ *
++ * String MY_FILT = "(objectclass=*)";
++ * String MY_BASE = "";
++ * String getAttrs[] = { "supportedControl" };
++ * LDAPSearchResults res = ld.search( MY_BASE,
++ * LDAPConnection.SCOPE_BASE, MY_FILT, getAttrs, false );
++ *
++ * while ( res.hasMoreElements() ) {
++ * LDAPEntry findEntry = (LDAPEntry)res.nextElement();
++ * LDAPAttributeSet findAttrs = findEntry.getAttributeSet();
++ * Enumeration enumAttrs = findAttrs.getAttributes();
++ *
++ * while ( enumAttrs.hasMoreElements() ) {
++ * LDAPAttribute anAttr = (LDAPAttribute)enumAttrs.nextElement();
++ * String attrName = anAttr.getName();
++ * System.out.println( attrName );
++ * Enumeration enumVals = anAttr.getStringValues();
++ *
++ * while ( enumVals.hasMoreElements() ) {
++ * String aVal = ( String )enumVals.nextElement();
++ * System.out.println( "\t" + aVal );
++ * }
++ * }
++ * }
++ * }
++ * catch( LDAPException e ) {
++ * System.out.println( "Error: " + e.toString() );
++ * }
++ * try {
++ * ld.disconnect();
++ * }
++ * catch( LDAPException e ) {
++ * System.exit(1);
++ * }
++ * System.exit(0);
++ * }
++ * </PRE>
++ * 
++ *
++ * If you compile and run this example against an LDAP server that
++ * supports v3 of the protocol, you might receive the following results:
++ * 
++ *
++ * <PRE>
++ * supportedcontrol
++ * 2.16.840.1.113730.3.4.2
++ * 2.16.840.1.113730.3.4.3
++ * 2.16.840.1.113730.3.4.4
++ * 2.16.840.1.113730.3.4.5
++ * 1.2.840.113556.1.4.473
++ * </PRE>
++ * 
++ *
++ * For more information on LDAP controls, see the Internet-Draft on
++ * the LDAP v3 protocol. (Note that this internet draft is still a
++ * work in progress. You can find the latest draft at the <A
++ * HREF="http://www.ietf.cnri.reston.va.us/html.charters/asid-charter.html"
++ * TARGET="_blank">ASID home page</A>.
++ * 
++ *
++ * @version 1.0
++ * @see netscape.ldap.LDAPv3#CLIENTCONTROLS
++ * @see netscape.ldap.LDAPv3#SERVERCONTROLS
++ * @see netscape.ldap.LDAPConnection#search(java.lang.String, int, java.lang.String, java.lang.String[], boolean)
++ * @see netscape.ldap.LDAPConnection#getOption
++ * @see netscape.ldap.LDAPConnection#setOption
++ * @see netscape.ldap.LDAPConnection#getResponseControls
++ * @see netscape.ldap.LDAPConstraints#getClientControls
++ * @see netscape.ldap.LDAPConstraints#getServerControls
++ * @see netscape.ldap.LDAPConstraints#setClientControls
++ * @see netscape.ldap.LDAPConstraints#setServerControls
++ */
++public class LDAPControl implements Cloneable, java.io.Serializable {
++ static final long serialVersionUID = 5149887553272603753L;
++ public final static String MANAGEDSAIT = "2.16.840.1.113730.3.4.2";
++ /* Password information sent back to client */
++ public final static String PWEXPIRED = "2.16.840.1.113730.3.4.4";
++ public final static String PWEXPIRING = "2.16.840.1.113730.3.4.5";
++
++ /**
++ * Default constructor for the <CODE>LDAPControl</CODE> class.
++ */
++ public LDAPControl()
++ {
++ }
++
++ /**
++ * Constructs a new <CODE>LDAPControl</CODE> object using the
++ * specified object ID (OID), &quot;criticality&quot; field, and
++ * data to be used by the control.
++ * 
++ *
++ * @param id the object ID (OID) identifying the control
++ * @param critical <CODE>true</CODE> if the LDAP operation should be
++ * cancelled when the server does not support this control (in other
++ * words, this control is critical to the LDAP operation)
++ * @param vals control-specific data
++ * @see netscape.ldap.LDAPConstraints#setClientControls
++ * @see netscape.ldap.LDAPConstraints#setServerControls
++ */
++ public LDAPControl(String id,
++ boolean critical,
++ byte vals[]) {
++ m_oid = id;
++ m_critical = critical;
++ m_value = vals;
++ }
++ 
++ /**
++ * Gets the object ID (OID) of the control.
++ * @return object ID (OID) of the control.
++ */
++ public String getID() {
++ return m_oid;
++ }
++
++ /**
++ * Specifies whether or not the control is critical to the LDAP operation.
++ * @return <CODE>true</CODE> if the LDAP operation should be cancelled when
++ * the server does not support this control.
++ */
++ public boolean isCritical() {
++ return m_critical;
++ }
++
++ /**
++ * Gets the data in the control.
++ * @return the data in the control as a byte array.
++ */
++ public byte[] getValue() {
++ return m_value;
++ }
++
++ /**
++ * Gets the ber representation of control.
++ * @return ber representation of control.
++ */
++ BERElement getBERElement() {
++ BERSequence seq = new BERSequence();
++ seq.addElement(new BEROctetString (m_oid));
++ seq.addElement(new BERBoolean (m_critical));
++ if ( (m_value == null) || (m_value.length < 1) )
++ seq.addElement(new BEROctetString ((byte[])null));
++ else {
++ seq.addElement(new BEROctetString (m_value, 0, m_value.length));
++ }
++ return seq;
++ }
++ 
++ /** 
++ * Associates a class with an oid. This class must be an extension of 
++ * <CODE>LDAPControl</CODE>, and should implement the <CODE>LDAPControl(
++ * String oid, boolean critical, byte[] value)</CODE> constructor to 
++ * instantiate the control. 
++ * @param oid the string representation of the oid
++ * @param controlClass the class that instantatiates the control associated
++ * with oid
++ * @exception netscape.ldap.LDAPException If the class parameter is not
++ * a subclass of <CODE>LDAPControl</CODE> or the class parameter does not
++ * implement the <CODE>LDAPControl(String oid, boolean critical, byte[] value)
++ * </CODE> constructor.
++ */
++ public static void register(String oid, Class controlClass) throws 
++ LDAPException {
++
++ if (controlClass == null) {
++	 return;
++ }
++
++	// 1. make sure controlClass is a subclass of LDAPControl
++	Class superClass = controlClass;
++	while (superClass != LDAPControl.class && superClass != null) {
++	 superClass = superClass.getSuperclass();
++	}
++
++	if (superClass == null) 
++	 throw new LDAPException("controlClass must be a subclass of " +
++				 "LDAPControl", LDAPException.PARAM_ERROR);
++
++	// 2. make sure controlClass has the proper constructor
++	Class[] cparams = { String.class, boolean.class, byte[].class };
++	try {
++	 controlClass.getConstructor(cparams);
++	} catch (NoSuchMethodException e) {
++	 throw new LDAPException("controlClass does not implement the " +
++				 "correct contstructor", 
++				 LDAPException.PARAM_ERROR);
++	}
++
++ // 3. check if the hash table exists
++ if (m_controlClassHash == null) {
++ m_controlClassHash = new Hashtable();
++	}
++
++	// 4. add the controlClass
++ m_controlClassHash.put(oid, controlClass);
++ }
++
++ /**
++ * Returns the <CODE>Class</CODE> that has been registered to oid.
++ * @param oid a String that associates the control class to a control
++ * @return a <CODE>Class</CODE> that can instantiate a control of the
++ * type specified by oid.
++ * @see netscape.ldap.LDAPControl#register
++ *
++ */
++ protected static Class lookupControlClass(String oid) {
++ if (m_controlClassHash == null) {
++	 return null;
++ }
++ 
++	return (Class)m_controlClassHash.get(oid);
++ }
++ 
++ /**
++ * Returns a <CODE>LDAPControl</CODE> object instantiated by the Class
++ * associated by <CODE>LDAPControl.register</CODE> to the oid. If
++ * no Class is found for the given control, or an exception occurs when 
++ * attempting to instantiate the control, a basic <CODE>LDAPControl</CODE>
++ * is instantiated using the parameters. 
++ * @param oid the oid of the control to instantiate
++ * @param critical <CODE>true</CODE> if this is a critical control
++ * @param value the byte value for the control
++ * @return a newly instantiated <CODE>LDAPControl</CODE>.
++ * @see netscape.ldap.LDAPControl#register
++ */ 
++ protected static LDAPControl createControl(String oid, boolean critical,
++ byte[] value) {
++ 
++	Class controlClass = lookupControlClass(oid);
++	
++	if (controlClass == null) {
++	 return new LDAPControl(oid, critical, value);
++	}
++
++	Class[] cparams = { String.class, boolean.class, byte[].class };
++	Constructor creator = null;
++	try {
++	 creator = controlClass.getConstructor(cparams);
++	} catch (NoSuchMethodException e) {
++	 //shouldn't happen, but...
++	 System.err.println("Caught java.lang.NoSuchMethodException while" +
++			 " attempting to instantiate a control of type " +
++			 oid);
++	 return new LDAPControl(oid, critical, value);
++	}
++	
++	Object[] oparams = { oid, new Boolean(critical), value } ;
++	LDAPControl returnControl = null;
++	try {
++	 returnControl = (LDAPControl)creator.newInstance(oparams);
++	} catch (Exception e) {
++	 String eString = null;
++	 if (e instanceof InvocationTargetException) {
++	 eString = ((InvocationTargetException)
++		 e).getTargetException().toString();
++	 } else {
++	 eString = e.toString();
++	 }
++	
++	 System.err.println("Caught " + eString + " while attempting to" +
++			 " instantiate a control of type " +
++			 oid);
++	 returnControl = new LDAPControl(oid, critical, value);
++ 	}
++
++	return returnControl;
++ }
++
++ /**
++ * Returns a <CODE>LDAPControl</CODE> object instantiated by the Class
++ * associated by <CODE>LDAPControl.register</CODE> to the oid. If
++ * no Class is found for the given control, or an exception occurs when 
++ * attempting to instantiate the control, a basic <CODE>LDAPControl</CODE>
++ * is instantiated using the parameters.
++ * @param el the <CODE>BERElement</CODE> containing the control
++ * @return a newly instantiated <CODE>LDAPControl</CODE>.
++ * @see netscape.ldap.LPAPControl#register
++ * 
++ * Note:
++ * This code was extracted from <CODE>JDAPControl(BERElement el)</CODE>
++ * constructor.
++ */ 
++ static LDAPControl parseControl(BERElement el) {
++ BERSequence s = (BERSequence)el;
++ String oid = null;
++ boolean critical = false;
++ byte[] value = null;
++ try{
++ oid = new String(((BEROctetString)s.elementAt(0)).getValue(), "UTF8");
++ } catch(Throwable x) {}
++ 
++ Object obj = s.elementAt(1);
++ if (obj instanceof BERBoolean) {
++ critical = ((BERBoolean)obj).getValue();
++ } 
++ else {
++ value = ((BEROctetString)obj).getValue();
++ } 
++
++ if (s.size() >= 3) {
++ value = ((BEROctetString)s.elementAt(2)).getValue();
++ }
++ 
++ return createControl(oid, critical, value);
++ }
++ 
++
++ /**
++ * Instantiates all of the controls contained within the LDAP message 
++ * fragment specified by data and returns them in an <CODE>LDAPControl</CODE>
++ * array. This fragment can be either the entire LDAP message or just the 
++ * control section of the message.
++ * 
++ * If an exception occurs when instantiating a control, that control is 
++ * returned as a basic <CODE>LDAPControl</CODE>.
++ * @param data the LDAP message fragment in raw BER format
++ * @return an <CODE>LDAPControl</CODE> array containing all of the controls
++ * from the message fragment.
++ * @exception java.lang.IOException If the data passed to this method
++ * is not a valid LDAP message fragment.
++ * @see netscape.ldap.LDAPControl#register
++ */
++ public static LDAPControl[] newInstance(byte[] data) throws IOException {
++ 
++ int[] bread = { 0 };
++	
++ 	BERElement el = BERElement.getElement(new JDAPBERTagDecoder(), 
++ new ByteArrayInputStream(data),
++ bread);
++
++	LDAPControl[] jc = null;
++	try {
++	 // see if data is a LDAP message
++	 LDAPMessage msg = LDAPMessage.parseMessage(el);
++	 return msg.getControls();
++	} catch (IOException e) {
++ 	 // that didn't work; let's see if its just the controls 
++	 BERTag tag = (BERTag)el;
++	 if ( tag.getTag() == (BERTag.CONSTRUCTED|BERTag.CONTEXT|0) ) {
++	 BERSequence controls = (BERSequence)tag.getValue();
++		jc = new LDAPControl[controls.size()];
++		for (int i = 0; i < controls.size(); i++) {
++		 jc[i] = parseControl(controls.elementAt(i));
++		}
++	 }
++	}
++	
++	return jc;
++	 
++ }
++
++ /**
++ * Creates a copy of the control.
++ * @return copy of the control.
++ */
++ public Object clone() {
++ byte[] vals = null;
++ if ( m_value != null ) {
++ vals = new byte[m_value.length];
++ for( int i = 0; i < m_value.length; i++ )
++ vals[i] = m_value[i];
++ }
++ LDAPControl control = new LDAPControl( m_oid, m_critical, vals );
++
++ return control;
++ }
++
++ /**
++ * Create a "flattened" BER encoding from a BER,
++ * and return it as a byte array.
++ * @param ber a BER encoded sequence
++ * @return the byte array of encoded data.
++ */
++ protected byte[] flattenBER( BERSequence ber ) {
++ /* Suck out the data and return it */
++ ByteArrayOutputStream outStream = new ByteArrayOutputStream();
++ try {
++ ber.write( outStream );
++ } catch ( IOException e ) {
++ return null;
++ }
++ return outStream.toByteArray();
++ }
++
++ /**
++ * Return a string representation of the control for debugging
++ *
++ * @return a string representation of the control.

debian.changelog Added

@@ -0,0 +1,45 @@
+ldapjdk (4.18-5) unstable; urgency=low
+
+ * control: Change the VCS header to point to the git repository.
+
+ -- Timo Aaltonen <tjaalton@ubuntu.com> Thu, 06 Oct 2011 13:42:09 +0300
+
+ldapjdk (4.18-4) unstable; urgency=low
+
+ * Update my email address
+
+ -- Michele Baldessari <michele@acksyn.org> Sun, 17 Oct 2010 23:44:49 +0200
+
+ldapjdk (4.18-3) unstable; urgency=low
+
+ * Switch to 3.0 quilt format
+ * Bump policy to 3.9.1
+
+ -- Michele Baldessari <michele@pupazzo.org> Sat, 04 Sep 2010 23:49:35 +0200
+
+ldapjdk (4.18-2) unstable; urgency=low
+
+ * Added VCS-* fields
+ * debian/control:
+ - Build-Depend on default-jdk-builddep instead of java-gcj-compat-dev
+ * Move all build-deps to Build-Depends-Indep
+ * Change section to java
+ * Update policy to 3.8.1 (no changes necessary)
+ * Add ${misc:Depends} since we depend on debhelper
+ * Update policy to 3.8.3
+
+ -- Michele Baldessari <michele@pupazzo.org> Sun, 24 Jan 2010 23:40:27 +0100
+
+ldapjdk (4.18-1) unstable; urgency=low
+
+ * New upstream
+ * Removed watch file (upstream does not release updated tarballs ATM)
+ * Updated Standards (3.8.0)
+
+ -- Michele Baldessari <michele@pupazzo.org> Tue, 30 Sep 2008 20:00:35 +0200
+
+ldapjdk (4.17-1) unstable; urgency=low
+
+ * Initial release (Closes: #474490)
+
+ -- Michele Baldessari <michele@pupazzo.org> Wed, 09 Apr 2008 16:09:59 +0200

debian.control Added

@@ -0,0 +1,21 @@
+Source: ldapjdk
+Section: java
+Maintainer: Debian Java Maintainers <pkg-java-maintainers@lists.alioth.debian.org>
+Uploaders: Michele Baldessari <michele@acksyn.org>
+Priority: optional
+Build-Depends: debhelper (>> 5)
+Build-Depends-Indep: liboro-java, ant, libjss-java, default-jdk-builddep
+Standards-Version: 3.9.1
+Vcs-Svn: git://git.debian.org/git/pkg-fedora-ds/ldapjdk.git
+Vcs-Browser: http://anonscm.debian.org/gitweb/?p=pkg-fedora-ds/ldapjdk.git
+Homepage: http://www.mozilla.org/directory/javasdk.html
+
+Package: libldap-java
+Architecture: all
+Depends: java-gcj-compat-headless | java2-runtime-headless, ${misc:Depends}
+Description: Netscape Directory SDK for Java
+ The Netscape Directory SDK for Java includes the LDAP Java classes, 
+ which you use to build LDAP clients. The LDAP Java classes allow you 
+ to write applets and applications that can connect to LDAP servers 
+ and perform standard LDAP operations (for example, you can search 
+ for entries or add, update, or delete entries).

debian.rules Added

@@ -0,0 +1,99 @@
+#!/usr/bin/make -f
+
+# These are used for cross-compiling and for saving the configure script
+# from having to guess our platform (since we know it already)
+DEB_HOST_GNU_TYPE   ?= $(shell dpkg-architecture -qDEB_HOST_GNU_TYPE)
+DEB_BUILD_GNU_TYPE  ?= $(shell dpkg-architecture -qDEB_BUILD_GNU_TYPE)
+DEB_BUILD_ARCH  ?= $(shell dpkg-architecture -qDEB_BUILD_ARCH)
+
+UPSTREAM_VERSION := $(shell dpkg-parsechangelog | sed -n 's/^Version: *$.*$-.*$$/\1/ p' | sed -e 's/~.*//')
+MOD_MAJOR_VERSION := $(word 1, $(subst ., ,$(UPSTREAM_VERSION)))
+MOD_MINOR_VERSION := $(word 2, $(subst ., ,$(UPSTREAM_VERSION)))
+MOD_PATCH_VERSION := $(word 3, $(subst ., ,$(UPSTREAM_VERSION)))
+
+export USE_64 := $(shell echo "int main(void) { int assert[(sizeof(long) == 8) ? 1 : -1]; return 0; }" | gcc -o /dev/null -x c - 2> /dev/null && echo --enable-64bit)
+
+CFLAGS := -Wall -pipe
+
+ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS)))
+	CFLAGS += -O0
+else
+	CFLAGS += -O2 -fno-strict-aliasing
+endif
+
+CFLAGS += -g
+# Enable compiler optimizations and disable debugging code
+BUILD_OPT=1
+export BUILD_OPT
+export XCFLAGS="-g"
+BASEDIR := $(CURDIR)/mozilla/security/
+export PKG_CONFIG_ALLOW_SYSTEM_LIBS=1
+export PKG_CONFIG_ALLOW_SYSTEM_CFLAGS=1
+export NSPR_INCLUDE_DIR=`/usr/bin/pkg-config --cflags-only-I nspr | sed 's/-I//'`
+export NSPR_LIB_DIR=`/usr/bin/pkg-config --libs-only-L nspr | sed 's/-L//'`
+export NSS_INCLUDE_DIR=`/usr/bin/pkg-config --cflags-only-I nss | sed 's/-I//'`
+export NSS_LIB_DIR=`/usr/bin/pkg-config --libs-only-L nss | sed 's/-L//'`
+
+export JAVA_HOME=/usr/lib/jvm/java-gcj
+
+configure: configure-stamp
+configure-stamp: $(QUILT_STAMPFN)
+	touch configure-stamp
+
+
+build: build-stamp
+build-stamp: configure
+	dh_testdir
+	install -m 644 $(CURDIR)/debian/ldapsdk-build.xml $(CURDIR)/mozilla/directory/java-sdk/build.xml
+	mkdir -p $(CURDIR)/mozilla/directory/java-sdk/src
+	-cp -pfr $(CURDIR)/mozilla/directory/java-sdk/ldapbeans/netscape \
+		$(CURDIR)/mozilla/directory/java-sdk/ldapfilter/netscape \
+		$(CURDIR)/mozilla/directory/java-sdk/ldapjdk/netscape \
+		$(CURDIR)/mozilla/directory/java-sdk/ldapsp/com \
+		$(CURDIR)/mozilla/directory/java-sdk/src
+	find . -name "*.java" -exec perl -p -i -e 's|com.oroinc|org.apache.oro|g;' {} \;
+	#-(cd $(CURDIR)/mozilla/directory/java-sdk/ && ant)
+	ant -buildfile $(CURDIR)/mozilla/directory/java-sdk/build.xml 
+	touch build-stamp
+
+clean:
+	dh_testdir
+	dh_testroot
+	rm -rf $(CURDIR)/mozilla/directory/java-sdk/src/build
+	rm -rf $(CURDIR)/mozilla/directory/java-sdk/build
+	rm -rf $(CURDIR)/debian/libldapjdk-java
+
+	dh_clean build-stamp install-stamp 
+
+install: install-stamp
+install-stamp:
+	dh_testdir
+	dh_testroot
+	dh_clean -k
+	dh_installdirs
+	mkdir -p $(CURDIR)/debian/libldap-java/usr/share/java/
+	install -m 644 $(CURDIR)/mozilla/directory/java-sdk/build/lib/ldapsdk.jar $(CURDIR)/debian/libldap-java/usr/share/java/ldapsdk-$(UPSTREAM_VERSION).jar
+
+	touch install-stamp
+
+binary-indep: install
+	dh_testdir
+	dh_testroot
+	dh_installchangelogs -i
+	dh_installdocs -i
+	dh_install
+	dh_link -i
+	dh_strip -i 
+	dh_compress -i
+	dh_fixperms -i
+	dh_installdeb -i
+	dh_shlibdeps -i
+	dh_gencontrol -i
+	dh_md5sums -i
+	dh_builddeb -i
+
+binary-arch: 
+
+binary: binary-arch binary-indep
+
+.PHONY: clean install build clean-patched binary-indep binary-arch binary

debian.series Added

debian.tar.gz Added

jss4.jar Added

ldapjdk-4.18.tar.gz Added

ldapjdk.dsc Added

Build Results
RPM Lint

Refresh

Comments for request 25 0

Request History

vanmeeuwen created request about 11 years ago

Add to Kolab:Development

vanmeeuwen accepted request about 11 years ago