/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at * trunk/opends/resource/legal-notices/OpenDS.LICENSE * or https://OpenDS.dev.java.net/OpenDS.LICENSE. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable, * add the following below this CDDL HEADER, with the fields enclosed * by brackets "[]" replaced with your own identifying * information: * Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END * * * Portions Copyright 2006 Sun Microsystems, Inc. */ package org.opends.server.schema; import org.opends.server.api.ApproximateMatchingRule; import org.opends.server.api.AttributeSyntax; import org.opends.server.api.AttributeValueDecoder; import org.opends.server.api.EqualityMatchingRule; import org.opends.server.api.OrderingMatchingRule; import org.opends.server.api.SubstringMatchingRule; import org.opends.server.config.ConfigEntry; import org.opends.server.config.ConfigException; import org.opends.server.core.DirectoryServer; import org.opends.server.types.AttributeValue; import org.opends.server.types.ByteString; import org.opends.server.types.DirectoryException; import org.opends.server.types.DN; import org.opends.server.types.ErrorLogCategory; import org.opends.server.types.ErrorLogSeverity; import static org.opends.server.loggers.Debug.*; import static org.opends.server.loggers.Error.*; import static org.opends.server.messages.MessageHandler.*; import static org.opends.server.messages.SchemaMessages.*; import static org.opends.server.schema.SchemaConstants.*; /** * This class defines the distinguished name attribute syntax, which is used for * attributes that hold distinguished names (DNs). Equality and substring * matching will be allowed by default. */ public class DistinguishedNameSyntax extends AttributeSyntax { /** * The fully-qualified name of this class for debugging purposes. */ private static final String CLASS_NAME = "org.opends.server.schema.DistinguishedNameSyntax"; // The default equality matching rule for this syntax. private EqualityMatchingRule defaultEqualityMatchingRule; // The default substring matching rule for this syntax. private SubstringMatchingRule defaultSubstringMatchingRule; /** * A {@link DN} attribute value decoder for this syntax. */ public static final AttributeValueDecoder DECODER = new AttributeValueDecoder() { /** * {@inheritDoc} */ public DN decode(AttributeValue value) throws DirectoryException { return DN.decode(value.getStringValue()); } }; /** * Creates a new instance of this syntax. Note that the only thing that * should be done here is to invoke the default constructor for the * superclass. All initialization should be performed in the * initializeSyntax method. */ public DistinguishedNameSyntax() { super(); assert debugConstructor(CLASS_NAME); } /** * Initializes this attribute syntax based on the information in the provided * configuration entry. * * @param configEntry The configuration entry that contains the information * to use to initialize this attribute syntax. * * @throws ConfigException If an unrecoverable problem arises in the * process of performing the initialization. */ public void initializeSyntax(ConfigEntry configEntry) throws ConfigException { assert debugEnter(CLASS_NAME, "initializeSyntax", String.valueOf(configEntry)); defaultEqualityMatchingRule = DirectoryServer.getEqualityMatchingRule(EMR_DN_OID); if (defaultEqualityMatchingRule == null) { logError(ErrorLogCategory.SCHEMA, ErrorLogSeverity.SEVERE_ERROR, MSGID_ATTR_SYNTAX_UNKNOWN_EQUALITY_MATCHING_RULE, EMR_DN_OID, SYNTAX_DN_NAME); } defaultSubstringMatchingRule = DirectoryServer.getSubstringMatchingRule(SMR_CASE_IGNORE_OID); if (defaultSubstringMatchingRule == null) { logError(ErrorLogCategory.SCHEMA, ErrorLogSeverity.SEVERE_ERROR, MSGID_ATTR_SYNTAX_UNKNOWN_SUBSTRING_MATCHING_RULE, SMR_CASE_IGNORE_OID, SYNTAX_DN_NAME); } } /** * Retrieves the common name for this attribute syntax. * * @return The common name for this attribute syntax. */ public String getSyntaxName() { assert debugEnter(CLASS_NAME, "getSyntaxName"); return SYNTAX_DN_NAME; } /** * Retrieves the OID for this attribute syntax. * * @return The OID for this attribute syntax. */ public String getOID() { assert debugEnter(CLASS_NAME, "getOID"); return SYNTAX_DN_OID; } /** * Retrieves a description for this attribute syntax. * * @return A description for this attribute syntax. */ public String getDescription() { assert debugEnter(CLASS_NAME, "getDescription"); return SYNTAX_DN_DESCRIPTION; } /** * Retrieves the default equality matching rule that will be used for * attributes with this syntax. * * @return The default equality matching rule that will be used for * attributes with this syntax, or null if equality * matches will not be allowed for this type by default. */ public EqualityMatchingRule getEqualityMatchingRule() { assert debugEnter(CLASS_NAME, "getEqualityMatchingRule"); return defaultEqualityMatchingRule; } /** * Retrieves the default ordering matching rule that will be used for * attributes with this syntax. * * @return The default ordering matching rule that will be used for * attributes with this syntax, or null if ordering * matches will not be allowed for this type by default. */ public OrderingMatchingRule getOrderingMatchingRule() { assert debugEnter(CLASS_NAME, "getOrderingMatchingRule"); // There is no ordering matching rule by default. return null; } /** * Retrieves the default substring matching rule that will be used for * attributes with this syntax. * * @return The default substring matching rule that will be used for * attributes with this syntax, or null if substring * matches will not be allowed for this type by default. */ public SubstringMatchingRule getSubstringMatchingRule() { assert debugEnter(CLASS_NAME, "getSubstringMatchingRule"); return defaultSubstringMatchingRule; } /** * Retrieves the default approximate matching rule that will be used for * attributes with this syntax. * * @return The default approximate matching rule that will be used for * attributes with this syntax, or null if approximate * matches will not be allowed for this type by default. */ public ApproximateMatchingRule getApproximateMatchingRule() { assert debugEnter(CLASS_NAME, "getApproximateMatchingRule"); // There is no approximate matching rule by default. return null; } /** * Indicates whether the provided value is acceptable for use in an attribute * with this syntax. If it is not, then the reason may be appended to the * provided buffer. * * @param value The value for which to make the determination. * @param invalidReason The buffer to which the invalid reason should be * appended. * * @return true if the provided value is acceptable for use with * this syntax, or false if not. */ public boolean valueIsAcceptable(ByteString value, StringBuilder invalidReason) { assert debugEnter(CLASS_NAME, "valueIsAcceptable", String.valueOf(value), "java.lang.StringBuilder"); // Use the DN code to make this determination. try { DN.decode(value.stringValue()); return true; } catch (DirectoryException de) { assert debugException(CLASS_NAME, "valueIsAcceptable", de); invalidReason.append(de.getErrorMessage()); return false; } catch (Exception e) { assert debugException(CLASS_NAME, "valueIsAcceptable", e); int msgID = MSGID_ATTR_SYNTAX_DN_INVALID; invalidReason.append(getMessage(msgID, value.stringValue(), String.valueOf(e))); return false; } } }