001    /*
002     * Copyright 2008-2016 UnboundID Corp.
003     * All Rights Reserved.
004     */
005    /*
006     * Copyright (C) 2008-2016 UnboundID Corp.
007     *
008     * This program is free software; you can redistribute it and/or modify
009     * it under the terms of the GNU General Public License (GPLv2 only)
010     * or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
011     * as published by the Free Software Foundation.
012     *
013     * This program is distributed in the hope that it will be useful,
014     * but WITHOUT ANY WARRANTY; without even the implied warranty of
015     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
016     * GNU General Public License for more details.
017     *
018     * You should have received a copy of the GNU General Public License
019     * along with this program; if not, see <http://www.gnu.org/licenses>.
020     */
021    package com.unboundid.ldap.matchingrules;
022    
023    
024    
025    import com.unboundid.asn1.ASN1OctetString;
026    import com.unboundid.ldap.sdk.DN;
027    import com.unboundid.ldap.sdk.LDAPException;
028    import com.unboundid.ldap.sdk.ResultCode;
029    import com.unboundid.util.ThreadSafety;
030    import com.unboundid.util.ThreadSafetyLevel;
031    
032    import static com.unboundid.ldap.matchingrules.MatchingRuleMessages.*;
033    import static com.unboundid.util.Debug.*;
034    import static com.unboundid.util.StaticUtils.*;
035    
036    
037    
038    /**
039     * This class provides an implementation of a matching rule that performs
040     * equality comparisons against values that should be distinguished names.
041     * Substring and ordering matching are not supported.
042     */
043    @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
044    public final class DistinguishedNameMatchingRule
045           extends MatchingRule
046    {
047      /**
048       * The singleton instance that will be returned from the {@code getInstance}
049       * method.
050       */
051      private static final DistinguishedNameMatchingRule INSTANCE =
052           new DistinguishedNameMatchingRule();
053    
054    
055    
056      /**
057       * The name for the distinguishedNameMatch equality matching rule.
058       */
059      public static final String EQUALITY_RULE_NAME = "distinguishedNameMatch";
060    
061    
062    
063      /**
064       * The name for the distinguishedNameMatch equality matching rule, formatted
065       * in all lowercase characters.
066       */
067      static final String LOWER_EQUALITY_RULE_NAME =
068           toLowerCase(EQUALITY_RULE_NAME);
069    
070    
071    
072      /**
073       * The OID for the distinguishedNameMatch equality matching rule.
074       */
075      public static final String EQUALITY_RULE_OID = "2.5.13.1";
076    
077    
078    
079      /**
080       * The serial version UID for this serializable class.
081       */
082      private static final long serialVersionUID = -2617356571703597868L;
083    
084    
085    
086      /**
087       * Creates a new instance of this distinguished name matching rule.
088       */
089      public DistinguishedNameMatchingRule()
090      {
091        // No implementation is required.
092      }
093    
094    
095    
096      /**
097       * Retrieves a singleton instance of this matching rule.
098       *
099       * @return  A singleton instance of this matching rule.
100       */
101      public static DistinguishedNameMatchingRule getInstance()
102      {
103        return INSTANCE;
104      }
105    
106    
107    
108      /**
109       * {@inheritDoc}
110       */
111      @Override()
112      public String getEqualityMatchingRuleName()
113      {
114        return EQUALITY_RULE_NAME;
115      }
116    
117    
118    
119      /**
120       * {@inheritDoc}
121       */
122      @Override()
123      public String getEqualityMatchingRuleOID()
124      {
125        return EQUALITY_RULE_OID;
126      }
127    
128    
129    
130      /**
131       * {@inheritDoc}
132       */
133      @Override()
134      public String getOrderingMatchingRuleName()
135      {
136        return null;
137      }
138    
139    
140    
141      /**
142       * {@inheritDoc}
143       */
144      @Override()
145      public String getOrderingMatchingRuleOID()
146      {
147        return null;
148      }
149    
150    
151    
152      /**
153       * {@inheritDoc}
154       */
155      @Override()
156      public String getSubstringMatchingRuleName()
157      {
158        return null;
159      }
160    
161    
162    
163      /**
164       * {@inheritDoc}
165       */
166      @Override()
167      public String getSubstringMatchingRuleOID()
168      {
169        return null;
170      }
171    
172    
173    
174      /**
175       * {@inheritDoc}
176       */
177      @Override()
178      public boolean valuesMatch(final ASN1OctetString value1,
179                                 final ASN1OctetString value2)
180             throws LDAPException
181      {
182        final DN dn1;
183        try
184        {
185          dn1 = new DN(value1.stringValue());
186        }
187        catch (LDAPException le)
188        {
189          debugException(le);
190          throw new LDAPException(ResultCode.INVALID_ATTRIBUTE_SYNTAX,
191                                  le.getMessage(), le);
192        }
193    
194        final DN dn2;
195        try
196        {
197          dn2 = new DN(value2.stringValue());
198        }
199        catch (LDAPException le)
200        {
201          debugException(le);
202          throw new LDAPException(ResultCode.INVALID_ATTRIBUTE_SYNTAX,
203                                  le.getMessage(), le);
204        }
205    
206        return dn1.equals(dn2);
207      }
208    
209    
210    
211      /**
212       * {@inheritDoc}
213       */
214      @Override()
215      public boolean matchesSubstring(final ASN1OctetString value,
216                                      final ASN1OctetString subInitial,
217                                      final ASN1OctetString[] subAny,
218                                      final ASN1OctetString subFinal)
219             throws LDAPException
220      {
221        throw new LDAPException(ResultCode.INAPPROPRIATE_MATCHING,
222                                ERR_DN_SUBSTRING_MATCHING_NOT_SUPPORTED.get());
223      }
224    
225    
226    
227      /**
228       * {@inheritDoc}
229       */
230      @Override()
231      public int compareValues(final ASN1OctetString value1,
232                               final ASN1OctetString value2)
233             throws LDAPException
234      {
235        throw new LDAPException(ResultCode.INAPPROPRIATE_MATCHING,
236                                ERR_DN_ORDERING_MATCHING_NOT_SUPPORTED.get());
237      }
238    
239    
240    
241      /**
242       * {@inheritDoc}
243       */
244      @Override()
245      public ASN1OctetString normalize(final ASN1OctetString value)
246             throws LDAPException
247      {
248        try
249        {
250          final DN dn = new DN(value.stringValue());
251          return new ASN1OctetString(dn.toNormalizedString());
252        }
253        catch (LDAPException le)
254        {
255          debugException(le);
256          throw new LDAPException(ResultCode.INVALID_ATTRIBUTE_SYNTAX,
257                                  le.getMessage(), le);
258        }
259      }
260    
261    
262    
263      /**
264       * {@inheritDoc}
265       */
266      @Override()
267      public ASN1OctetString normalizeSubstring(final ASN1OctetString value,
268                                                final byte substringType)
269             throws LDAPException
270      {
271        throw new LDAPException(ResultCode.INAPPROPRIATE_MATCHING,
272                                ERR_DN_SUBSTRING_MATCHING_NOT_SUPPORTED.get());
273      }
274    }