CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-com-unboundid--unboundid-ldapsdk

Comprehensive Java LDAP SDK providing full LDAPv3 protocol support, connection pooling, schema handling, and persistence framework for LDAP directory operations.

—

Pending
Overview
Eval results
Files

data-types.mddocs/

Data Types and Manipulation

Core LDAP data types for representing directory entries, attributes, distinguished names, and related manipulation utilities.

Capabilities

Entry Representation

Entry

Core class representing an LDAP directory entry.

/**
 * Represents an LDAP directory entry with DN and attributes
 */
public class Entry implements Serializable {
    // Constructors
    public Entry(String dn);
    public Entry(String dn, Attribute... attributes);
    public Entry(String dn, Collection<Attribute> attributes);
    public Entry(DN dn);
    public Entry(DN dn, Attribute... attributes);
    public Entry(DN dn, Collection<Attribute> attributes);
    
    // DN access
    public String getDN();
    public DN getParsedDN() throws LDAPException;
    
    // Attribute access
    public Attribute getAttribute(String attributeName);
    public String getAttributeValue(String attributeName);
    public byte[] getAttributeValueBytes(String attributeName);
    public String[] getAttributeValues(String attributeName);
    public byte[][] getAttributeValueByteArrays(String attributeName);
    public Collection<Attribute> getAttributes();
    public int getNumAttributes();
    public boolean hasAttribute(String attributeName);
    public boolean hasAttributeValue(String attributeName, String attributeValue);
    
    // Entry modification
    public void addAttribute(Attribute attribute);
    public void addAttribute(String attributeName, String attributeValue);
    public void addAttribute(String attributeName, byte[] attributeValue);
    public boolean removeAttribute(String attributeName);
    public boolean removeAttributeValue(String attributeName, String attributeValue);
    public void setAttribute(Attribute attribute);
    public void setAttribute(String attributeName, String attributeValue);
    
    // Utility methods
    public Entry duplicate();
    public String toLDIFString();
    public String toLDIFString(int wrapColumn);
}

Attribute Handling

Attribute

Class representing an LDAP attribute with one or more values.

/**
 * Represents an LDAP attribute with one or more values
 */
public class Attribute implements Serializable {
    // Constructors
    public Attribute(String name);
    public Attribute(String name, String value);
    public Attribute(String name, byte[] value);
    public Attribute(String name, String... values);
    public Attribute(String name, byte[]... values);
    public Attribute(String name, Collection<String> values);
    
    // Name access
    public String getName();
    public String getBaseName();
    public String[] getOptions();
    public boolean hasOption(String option);
    
    // Value access
    public String getValue();
    public byte[] getValueByteArray();
    public String[] getValues();
    public byte[][] getValueByteArrays();
    public int size();
    public boolean hasValue();
    public boolean hasValue(String value);
    public boolean hasValue(byte[] value);
    
    // Value manipulation
    public Attribute addValue(String value);
    public Attribute addValue(byte[] value);
    public Attribute removeValue(String value);
    public Attribute removeValue(byte[] value);
    
    // Utility methods
    public Attribute duplicate();
    public String toString();
    public int hashCode();
    public boolean equals(Object obj);
}

Distinguished Name Processing

DN (Distinguished Name)

Class for parsing, manipulating, and validating LDAP distinguished names.

/**
 * Represents and manipulates LDAP distinguished names
 */
public class DN implements Comparable<DN>, Serializable {
    // Constructors
    public DN(String dnString) throws LDAPException;
    public DN(RDN... rdns);
    public DN(List<RDN> rdns);
    
    // DN structure access
    public RDN[] getRDNs();
    public RDN getRDN();
    public RDN getRDN(int index);
    public int getRDNCount();
    public DN getParent();
    public DN getParent(int count);
    
    // DN relationships
    public boolean isAncestorOf(DN dn, boolean strict);
    public boolean isDescendantOf(DN dn, boolean strict);
    public boolean isWithinSubtree(DN baseDN, boolean strict);
    
    // DN manipulation
    public DN child(RDN rdn);
    public DN child(String rdnString) throws LDAPException;
    public DN parent();
    public DN parent(int count);
    
    // String representations
    public String toString();
    public String toNormalizedString();
    public String toMinimallyEncodedString();
    
    // Validation and normalization
    public static boolean isValidDN(String dnString);
    public static DN normalize(DN dn);
    public byte[] getNormalizedByteArray();
    
    // Comparison
    public int compareTo(DN dn);
    public boolean equals(Object obj);
    public boolean equals(DN dn);
    public int hashCode();
}

RDN (Relative Distinguished Name)

Class representing individual components of a distinguished name.

/**
 * Represents a relative distinguished name (single DN component)
 */
public class RDN implements Comparable<RDN>, Serializable {
    // Constructors
    public RDN(String rdnString) throws LDAPException;
    public RDN(String attributeName, String attributeValue);
    public RDN(String attributeName, byte[] attributeValue);
    public RDN(String[] attributeNames, String[] attributeValues);
    public RDN(String[] attributeNames, byte[][] attributeValues);
    
    // Component access
    public String[] getAttributeNames();
    public String[] getAttributeValues();
    public byte[][] getAttributeValueBytes();
    public int getValueCount();
    public boolean hasAttribute(String attributeName);
    public String getAttributeValue(String attributeName);
    public byte[] getAttributeValueBytes(String attributeName);
    
    // String representations
    public String toString();
    public String toNormalizedString();
    public String toMinimallyEncodedString();
    
    // Validation and normalization
    public static boolean isValidRDN(String rdnString);
    public byte[] getNormalizedByteArray();
    
    // Comparison
    public int compareTo(RDN rdn);
    public boolean equals(Object obj);
    public int hashCode();
}

Filter Construction

Filter

Class for constructing and parsing LDAP search filters.

/**
 * Represents and constructs LDAP search filters
 */
public class Filter implements Serializable {
    // Filter creation from string
    public static Filter create(String filterString) throws LDAPException;
    
    // Basic filter types
    public static Filter createEqualityFilter(String attributeName, String assertionValue);
    public static Filter createEqualityFilter(String attributeName, byte[] assertionValue);
    public static Filter createSubstringFilter(String attributeName, String subInitial, String[] subAny, String subFinal);
    public static Filter createSubInitialFilter(String attributeName, String subInitial);
    public static Filter createSubAnyFilter(String attributeName, String... subAnyValues);
    public static Filter createSubFinalFilter(String attributeName, String subFinal);
    public static Filter createGreaterOrEqualFilter(String attributeName, String assertionValue);
    public static Filter createLessOrEqualFilter(String attributeName, String assertionValue);
    public static Filter createPresenceFilter(String attributeName);
    public static Filter createApproximateMatchFilter(String attributeName, String assertionValue);
    
    // Logical combinations
    public static Filter createANDFilter(Filter... filters);
    public static Filter createANDFilter(Collection<Filter> filters);
    public static Filter createORFilter(Filter... filters);
    public static Filter createORFilter(Collection<Filter> filters);
    public static Filter createNOTFilter(Filter filter);
    
    // Extensible match filters
    public static Filter createExtensibleMatchFilter(String attributeName, String matchingRuleID, boolean dnAttributes, String assertionValue);
    public static Filter createExtensibleMatchFilter(String attributeName, String matchingRuleID, boolean dnAttributes, byte[] assertionValue);
    
    // Filter properties
    public FilterType getFilterType();
    public String getAttributeName();
    public String getAssertionValue();
    public byte[] getAssertionValueBytes();
    public Filter[] getComponents();
    public Filter getNOTComponent();
    
    // String representation
    public String toString();
    public String toNormalizedString();
    
    // Validation
    public static boolean isValidFilter(String filterString);
    
    // Comparison
    public boolean equals(Object obj);
    public int hashCode();
}

/**
 * Enumeration of filter types
 */
public enum FilterType {
    AND((byte) 0xA0),
    OR((byte) 0xA1),
    NOT((byte) 0xA2),
    EQUALITY((byte) 0xA3),
    SUBSTRING((byte) 0xA4),
    GREATER_OR_EQUAL((byte) 0xA5),
    LESS_OR_EQUAL((byte) 0xA6),
    PRESENT((byte) 0x87),
    APPROXIMATE_MATCH((byte) 0xA8),
    EXTENSIBLE_MATCH((byte) 0xA9);
}

Modification Framework

Modification

Class representing modifications to LDAP entries.

/**
 * Represents a modification to be applied to an LDAP entry
 */
public class Modification implements Serializable {
    // Constructors
    public Modification(ModificationType modificationType, String attributeName);
    public Modification(ModificationType modificationType, String attributeName, String attributeValue);
    public Modification(ModificationType modificationType, String attributeName, byte[] attributeValue);
    public Modification(ModificationType modificationType, String attributeName, String... attributeValues);
    public Modification(ModificationType modificationType, String attributeName, byte[]... attributeValues);
    public Modification(ModificationType modificationType, Attribute attribute);
    
    // Access methods
    public ModificationType getModificationType();
    public String getAttributeName();
    public String[] getValues();
    public byte[][] getValueByteArrays();
    public Attribute getAttribute();
    
    // Utility methods
    public String toString();
    public boolean equals(Object obj);
    public int hashCode();
}

/**
 * Types of modifications that can be applied to entries
 */
public enum ModificationType {
    ADD(0),
    DELETE(1),
    REPLACE(2),
    INCREMENT(3);
    
    public int intValue();
    public static ModificationType valueOf(int intValue);
}

Utility Classes

Control

Base class for LDAP controls.

/**
 * Base class for LDAP controls
 */
public class Control implements Serializable {
    // Constructors
    public Control(String oid);
    public Control(String oid, boolean isCritical);
    public Control(String oid, boolean isCritical, ASN1OctetString value);
    
    // Access methods
    public String getOID();
    public boolean isCritical();
    public ASN1OctetString getValue();
    
    // Utility methods
    public String toString();
    public boolean equals(Object obj);
    public int hashCode();
}

ASN.1 Support

Basic ASN.1 BER encoding support for LDAP protocol elements.

/**
 * Base class for ASN.1 BER elements
 */
public class ASN1Element implements Serializable {
    public byte getType();
    public int getValueLength();
    public byte[] getValue();
    public byte[] encode();
    
    public static ASN1Element decode(byte[] elementBytes) throws ASN1Exception;
    public static ASN1Element decode(InputStream inputStream) throws ASN1Exception;
}

/**
 * ASN.1 BER octet string element
 */
public class ASN1OctetString extends ASN1Element {
    public ASN1OctetString(String stringValue);
    public ASN1OctetString(byte[] value);
    
    public String stringValue();
    public byte[] getValue();
}

/**
 * ASN.1 BER sequence element
 */
public class ASN1Sequence extends ASN1Element {
    public ASN1Sequence(ASN1Element... elements);
    public ASN1Sequence(List<ASN1Element> elements);
    
    public ASN1Element[] getElements();
    public int size();
}

Usage Examples

Working with Entries

import com.unboundid.ldap.sdk.*;

// Create a new entry
Entry entry = new Entry(
    "cn=John Doe,ou=people,dc=example,dc=com",
    new Attribute("objectClass", "inetOrgPerson"),
    new Attribute("cn", "John Doe"),
    new Attribute("sn", "Doe"),
    new Attribute("givenName", "John"),
    new Attribute("mail", "john.doe@example.com"),
    new Attribute("telephoneNumber", "+1-555-0123", "+1-555-0124")
);

// Access entry properties
System.out.println("DN: " + entry.getDN());
System.out.println("CN: " + entry.getAttributeValue("cn"));
System.out.println("Mail: " + entry.getAttributeValue("mail"));

// Check for attributes
if (entry.hasAttribute("telephoneNumber")) {
    String[] phones = entry.getAttributeValues("telephoneNumber");
    System.out.println("Phone numbers: " + Arrays.toString(phones));
}

// Modify entry
entry.addAttribute("description", "Software Engineer");
entry.setAttribute("mail", "j.doe@example.com");  // Replace existing value
entry.removeAttributeValue("telephoneNumber", "+1-555-0124");

// Convert to LDIF
System.out.println(entry.toLDIFString());

Working with Distinguished Names

import com.unboundid.ldap.sdk.*;

try {
    // Parse DN
    DN userDN = new DN("cn=John Doe,ou=people,dc=example,dc=com");
    
    // Access DN components
    System.out.println("Full DN: " + userDN.toString());
    System.out.println("RDN: " + userDN.getRDN().toString());
    System.out.println("Parent: " + userDN.getParent().toString());
    
    // Work with RDNs
    RDN[] rdns = userDN.getRDNs();
    for (RDN rdn : rdns) {
        System.out.println("RDN: " + rdn.toString());
        String[] attrNames = rdn.getAttributeNames();
        for (String name : attrNames) {
            System.out.println("  " + name + "=" + rdn.getAttributeValue(name));
        }
    }
    
    // DN relationships
    DN baseDN = new DN("dc=example,dc=com");
    DN peopleDN = new DN("ou=people,dc=example,dc=com");
    
    System.out.println("User is descendant of base: " + userDN.isDescendantOf(baseDN, false));
    System.out.println("People is ancestor of user: " + peopleDN.isAncestorOf(userDN, false));
    
    // Construct new DNs
    DN newUserDN = peopleDN.child("cn=Jane Smith");
    System.out.println("New user DN: " + newUserDN.toString());
    
} catch (LDAPException e) {
    System.err.println("Invalid DN: " + e.getMessage());
}

Working with Filters

import com.unboundid.ldap.sdk.*;

// Simple filters
Filter equalityFilter = Filter.createEqualityFilter("cn", "John Doe");
Filter presenceFilter = Filter.createPresenceFilter("mail");
Filter substringFilter = Filter.createSubstringFilter("cn", "John", null, null);

// Complex filters with logical operators
Filter userFilter = Filter.createANDFilter(
    Filter.createEqualityFilter("objectClass", "inetOrgPerson"),
    Filter.createPresenceFilter("mail"),
    Filter.createORFilter(
        Filter.createSubstringFilter("cn", "John", null, null),
        Filter.createSubstringFilter("cn", "Jane", null, null)
    )
);

System.out.println("Filter: " + userFilter.toString());
// Output: (&(objectClass=inetOrgPerson)(mail=*)(|(cn=John*)(cn=Jane*)))

// Parse filter from string
try {
    Filter parsedFilter = Filter.create("(&(objectClass=person)(|(cn=John*)(mail=*@example.com)))");
    System.out.println("Parsed filter type: " + parsedFilter.getFilterType());
    
    // Access filter components
    if (parsedFilter.getFilterType() == FilterType.AND) {
        Filter[] components = parsedFilter.getComponents();
        for (Filter component : components) {
            System.out.println("Component: " + component.toString());
        }
    }
    
} catch (LDAPException e) {
    System.err.println("Invalid filter: " + e.getMessage());
}

Working with Attributes

import com.unboundid.ldap.sdk.*;

// Create attributes
Attribute singleValueAttr = new Attribute("cn", "John Doe");
Attribute multiValueAttr = new Attribute("telephoneNumber", "+1-555-0123", "+1-555-0124", "+1-555-0125");
Attribute binaryAttr = new Attribute("userCertificate", certificateBytes);

// Access attribute properties
System.out.println("Attribute name: " + singleValueAttr.getName());
System.out.println("Single value: " + singleValueAttr.getValue());
System.out.println("All values: " + Arrays.toString(multiValueAttr.getValues()));

// Check for values
if (multiValueAttr.hasValue("+1-555-0123")) {
    System.out.println("Found phone number");
}

// Modify attributes
Attribute modifiedAttr = multiValueAttr.addValue("+1-555-0126");
modifiedAttr = modifiedAttr.removeValue("+1-555-0125");

System.out.println("Modified values: " + Arrays.toString(modifiedAttr.getValues()));

// Work with attribute options
Attribute langAttr = new Attribute("description;lang-en", "English description");
System.out.println("Base name: " + langAttr.getBaseName());  // "description"
System.out.println("Options: " + Arrays.toString(langAttr.getOptions()));  // ["lang-en"]

Working with Modifications

import com.unboundid.ldap.sdk.*;

// Create modifications
Modification addMod = new Modification(
    ModificationType.ADD,
    "description",
    "Software Engineer"
);

Modification replaceMod = new Modification(
    ModificationType.REPLACE,
    "mail",
    "j.doe@example.com"
);

Modification deleteMod = new Modification(
    ModificationType.DELETE,
    "telephoneNumber",
    "+1-555-0124"
);

Modification deleteAllMod = new Modification(
    ModificationType.DELETE,
    "faxNumber"  // Delete all values
);

// Apply modifications to connection
LDAPConnection connection = new LDAPConnection("ldap.example.com", 389);
try {
    connection.bind("cn=admin,dc=example,dc=com", "password");
    
    LDAPResult result = connection.modify(
        "cn=John Doe,ou=people,dc=example,dc=com",
        addMod, replaceMod, deleteMod, deleteAllMod
    );
    
    if (result.getResultCode() == ResultCode.SUCCESS) {
        System.out.println("Modifications applied successfully");
    }
    
} finally {
    connection.close();
}

Entry Validation and Manipulation

import com.unboundid.ldap.sdk.*;

// Create entry with validation
try {
    Entry entry = new Entry("cn=Test User,ou=people,dc=example,dc=com");
    
    // Add required attributes
    entry.addAttribute("objectClass", "inetOrgPerson");
    entry.addAttribute("cn", "Test User");
    entry.addAttribute("sn", "User");
    
    // Validate DN parsing
    DN entryDN = entry.getParsedDN();
    System.out.println("Valid DN: " + entryDN.toString());
    
    // Clone entry for modifications
    Entry modifiedEntry = entry.duplicate();
    modifiedEntry.addAttribute("mail", "test.user@example.com");
    
    // Compare entries
    if (!entry.equals(modifiedEntry)) {
        System.out.println("Entries are different");
    }
    
    // Generate LDIF representation
    System.out.println("Entry LDIF:");
    System.out.println(entry.toLDIFString(80));  // Wrap at 80 characters
    
} catch (LDAPException e) {
    System.err.println("Invalid entry: " + e.getMessage());
}

LDAP URL Handling

LDAPURL

LDAP URL parsing and construction utilities.

/**
 * LDAP URL representation and manipulation
 */
public class LDAPURL {
    // Constructors
    public LDAPURL(String url) throws LDAPException;
    public LDAPURL(String scheme, String host, int port, DN baseDN, String[] attributes, SearchScope scope, Filter filter);
    
    // URL components
    public String getScheme();
    public String getHost();
    public int getPort();
    public DN getBaseDN();
    public String[] getAttributes();
    public SearchScope getScope();
    public Filter getFilter();
    
    // URL manipulation
    public String toString();
    public static boolean isValidLDAPURL(String url);
    public static LDAPURL[] parseURLList(String urlList) throws LDAPException;
}

Utility Classes

ResultCode

LDAP result codes and status information.

/**
 * LDAP operation result codes
 */
public class ResultCode {
    // Standard result codes
    public static final ResultCode SUCCESS;
    public static final ResultCode OPERATIONS_ERROR;
    public static final ResultCode PROTOCOL_ERROR;
    public static final ResultCode TIME_LIMIT_EXCEEDED;
    public static final ResultCode SIZE_LIMIT_EXCEEDED;
    public static final ResultCode COMPARE_FALSE;
    public static final ResultCode COMPARE_TRUE;
    public static final ResultCode AUTH_METHOD_NOT_SUPPORTED;
    public static final ResultCode STRONG_AUTH_REQUIRED;
    public static final ResultCode REFERRAL;
    public static final ResultCode ADMIN_LIMIT_EXCEEDED;
    public static final ResultCode UNAVAILABLE_CRITICAL_EXTENSION;
    public static final ResultCode CONFIDENTIALITY_REQUIRED;
    public static final ResultCode SASL_BIND_IN_PROGRESS;
    public static final ResultCode NO_SUCH_ATTRIBUTE;
    public static final ResultCode UNDEFINED_ATTRIBUTE_TYPE;
    public static final ResultCode INAPPROPRIATE_MATCHING;
    public static final ResultCode CONSTRAINT_VIOLATION;
    public static final ResultCode ATTRIBUTE_OR_VALUE_EXISTS;
    public static final ResultCode INVALID_ATTRIBUTE_SYNTAX;
    public static final ResultCode NO_SUCH_OBJECT;
    public static final ResultCode ALIAS_PROBLEM;
    public static final ResultCode INVALID_DN_SYNTAX;
    public static final ResultCode ALIAS_DEREFERENCING_PROBLEM;
    public static final ResultCode INAPPROPRIATE_AUTHENTICATION;
    public static final ResultCode INVALID_CREDENTIALS;
    public static final ResultCode INSUFFICIENT_ACCESS_RIGHTS;
    public static final ResultCode BUSY;
    public static final ResultCode UNAVAILABLE;
    public static final ResultCode UNWILLING_TO_PERFORM;
    public static final ResultCode LOOP_DETECT;
    public static final ResultCode NAMING_VIOLATION;
    public static final ResultCode OBJECT_CLASS_VIOLATION;
    public static final ResultCode NOT_ALLOWED_ON_NONLEAF;
    public static final ResultCode NOT_ALLOWED_ON_RDN;
    public static final ResultCode ENTRY_ALREADY_EXISTS;
    public static final ResultCode OBJECT_CLASS_MODS_PROHIBITED;
    public static final ResultCode AFFECTS_MULTIPLE_DSAS;
    public static final ResultCode OTHER;
    
    // Methods
    public int intValue();
    public String getName();
    public String toString();
    public boolean isConnectionUsable();
    public static ResultCode valueOf(int intValue);
}

LDAPConnectionStatistics

Connection usage statistics and monitoring.

/**
 * Statistics for LDAP connection usage
 */
public class LDAPConnectionStatistics {
    public long getNumConnects();
    public long getNumDisconnects();
    public long getNumAbandonRequests();
    public long getNumAddRequests();
    public long getNumAddResponses();
    public long getNumBindRequests();
    public long getNumBindResponses();
    public long getNumCompareRequests();
    public long getNumCompareResponses();
    public long getNumDeleteRequests();
    public long getNumDeleteResponses();
    public long getNumExtendedRequests();
    public long getNumExtendedResponses();
    public long getNumModifyRequests();
    public long getNumModifyResponses();
    public long getNumModifyDNRequests();
    public long getNumModifyDNResponses();
    public long getNumSearchRequests();
    public long getNumSearchEntryResponses();
    public long getNumSearchReferenceResponses();
    public long getNumSearchDoneResponses();
    public long getNumUnbindRequests();
}

LDAPConnectionPoolStatistics

Connection pool usage statistics and health monitoring.

/**
 * Statistics for LDAP connection pool usage
 */
public class LDAPConnectionPoolStatistics {
    public int getNumSuccessfulConnectionAttempts();
    public int getNumFailedConnectionAttempts();
    public int getNumConnectionsClosedDefunct();
    public int getNumConnectionsClosedExpired();
    public int getNumConnectionsClosedUnneeded();
    public int getNumSuccessfulCheckouts();
    public int getNumSuccessfulCheckoutsWithoutWaiting();
    public int getNumSuccessfulCheckoutsAfterWaiting();
    public int getNumFailedCheckouts();
    public int getNumReleasedValid();
    public long getMaximumWaitTimeMillis();
    public long getAverageWaitTimeMillis();
    
    public void reset();
    public String toString();
}

Install with Tessl CLI

npx tessl i tessl/maven-com-unboundid--unboundid-ldapsdk

docs

authentication.md

controls-extensions.md

core-operations.md

data-types.md

index.md

ldif.md

persistence.md

schema.md

search.md

tile.json