1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one
3 * or more contributor license agreements. See the NOTICE file
4 * distributed with this work for additional information
5 * regarding copyright ownership. The ASF licenses this file
6 * to you under the Apache License, Version 2.0 (the
7 * "License"); you may not use this file except in compliance
8 * with the License. You may obtain a copy of the License at
9 *
10 * https://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing,
13 * software distributed under the License is distributed on an
14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 * KIND, either express or implied. See the License for the
16 * specific language governing permissions and limitations
17 * under the License.
18 *
19 */
20 package org.apache.directory.api.ldap.model.schema.syntaxCheckers;
21
22
23 import org.apache.directory.api.i18n.I18n;
24 import org.apache.directory.api.ldap.model.constants.SchemaConstants;
25 import org.apache.directory.api.ldap.model.name.Dn;
26 import org.apache.directory.api.ldap.model.name.Rdn;
27 import org.apache.directory.api.ldap.model.schema.SyntaxChecker;
28 import org.apache.directory.api.util.Strings;
29
30
31 /**
32 * A SyntaxChecker which verifies that a value is a valid Name and Optional UID.
33 * <p>
34 * This element is a composition of two parts, a {@link Dn} and an optional UID :
35 * <pre>
36 * NameAndOptionalUID = distinguishedName [ SHARP BitString ]
37 * </pre>
38 * Both part already have their syntax checkers, so we will just call them
39 * after having split the element in two ( if necessary)
40 * <p>
41 * We just check that the {@link Dn} is valid, we don't need to verify each of the {@link Rdn}
42 * syntax.
43 *
44 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
45 */
46 @SuppressWarnings("serial")
47 public final class NameAndOptionalUIDSyntaxChecker extends SyntaxChecker
48 {
49 /**
50 * A static instance of NameAndOptionalUIDSyntaxChecker
51 */
52 public static final NameAndOptionalUIDSyntaxChecker INSTANCE =
53 new NameAndOptionalUIDSyntaxChecker( SchemaConstants.NAME_AND_OPTIONAL_UID_SYNTAX );
54
55 /**
56 * A static Builder for this class
57 */
58 public static final class Builder extends SCBuilder<NameAndOptionalUIDSyntaxChecker>
59 {
60 /**
61 * The Builder constructor
62 */
63 private Builder()
64 {
65 super( SchemaConstants.NAME_AND_OPTIONAL_UID_SYNTAX );
66 }
67
68
69 /**
70 * Create a new instance of NameAndOptionalUIDSyntaxChecker
71 * @return A new instance of NameAndOptionalUIDSyntaxChecker
72 */
73 @Override
74 public NameAndOptionalUIDSyntaxChecker build()
75 {
76 return new NameAndOptionalUIDSyntaxChecker( oid );
77 }
78 }
79
80
81 /**
82 * Creates a new instance of NameAndOptionalUIDSyntaxChecker.
83 *
84 * @param oid The OID to use for this SyntaxChecker
85 */
86 private NameAndOptionalUIDSyntaxChecker( String oid )
87 {
88 super( oid );
89 }
90
91
92 /**
93 * @return An instance of the Builder for this class
94 */
95 public static Builder builder()
96 {
97 return new Builder();
98 }
99
100
101 /**
102 * {@inheritDoc}
103 */
104 @Override
105 public boolean isValidSyntax( Object value )
106 {
107 String strValue;
108
109 if ( value == null )
110 {
111 if ( LOG.isDebugEnabled() )
112 {
113 LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, "null" ) );
114 }
115
116 return false;
117 }
118
119 if ( value instanceof String )
120 {
121 strValue = ( String ) value;
122 }
123 else if ( value instanceof byte[] )
124 {
125 strValue = Strings.utf8ToString( ( byte[] ) value );
126 }
127 else
128 {
129 strValue = value.toString();
130 }
131
132 if ( strValue.length() == 0 )
133 {
134 if ( LOG.isDebugEnabled() )
135 {
136 LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, value ) );
137 }
138
139 return false;
140 }
141
142 // Let's see if we have an UID part
143 int sharpPos = strValue.lastIndexOf( '#' );
144
145 if ( sharpPos != -1 )
146 {
147 // Now, check that we don't have another '#'
148 if ( strValue.indexOf( '#' ) != sharpPos )
149 {
150 // Yes, we have one : this is not allowed, it should have been
151 // escaped.
152 if ( LOG.isDebugEnabled() )
153 {
154 LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, value ) );
155 }
156
157 return false;
158 }
159
160 // This is an UID if the '#' is immediately
161 // followed by a BitString, except if the '#' is
162 // on the last position
163 if ( BitStringSyntaxChecker.isValid( strValue.substring( sharpPos + 1 ) )
164 && ( sharpPos < strValue.length() ) )
165 {
166 // Ok, we have a BitString, now check the Dn,
167 // except if the '#' is in first position
168 if ( sharpPos > 0 )
169 {
170 boolean result = Dn.isValid( strValue.substring( 0, sharpPos ) );
171
172 if ( LOG.isDebugEnabled() )
173 {
174 if ( result )
175 {
176 LOG.debug( I18n.msg( I18n.MSG_13701_SYNTAX_VALID, value ) );
177 }
178 else
179 {
180 LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, value ) );
181 }
182 }
183
184 return result;
185
186 }
187 else
188 {
189 // The Dn must not be null ?
190 if ( LOG.isDebugEnabled() )
191 {
192 LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, value ) );
193 }
194
195 return false;
196 }
197 }
198 else
199 {
200 // We have found a '#' but no UID part.
201 if ( LOG.isDebugEnabled() )
202 {
203 LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, value ) );
204 }
205
206 return false;
207 }
208 }
209 else
210 {
211 // No UID, the strValue is a Dn
212 // Check that the value is a valid Dn
213 boolean result = Dn.isValid( strValue );
214
215 if ( LOG.isDebugEnabled() )
216 {
217 if ( result )
218 {
219 LOG.debug( I18n.msg( I18n.MSG_13701_SYNTAX_VALID, value ) );
220 }
221 else
222 {
223 LOG.debug( I18n.err( I18n.ERR_13210_SYNTAX_INVALID, value ) );
224 }
225 }
226
227 return result;
228 }
229 }
230 }