1 /*
2 * Copyright 1999-2002 Sun Microsystems, Inc. All Rights Reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Sun designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Sun in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22 * CA 95054 USA or visit www.sun.com if you need additional information or
23 * have any questions.
24 */
25
26 package javax.naming;
27
28 import java.util.Vector;
29 import java.util.Enumeration;
30 import java.util.Properties;
31 import java.util.NoSuchElementException;
32
33 /**
34 * The implementation class for CompoundName and CompositeName.
35 * This class is package private.
36 *
37 * @author Rosanna Lee
38 * @author Scott Seligman
39 * @author Aravindan Ranganathan
40 * @since 1.3
41 */
42
43 class NameImpl {
44 private static final byte LEFT_TO_RIGHT = 1;
45 private static final byte RIGHT_TO_LEFT = 2;
46 private static final byte FLAT = 0;
47
48 private Vector components;
49
50 private byte syntaxDirection = LEFT_TO_RIGHT;
51 private String syntaxSeparator = "/";
52 private String syntaxSeparator2 = null;
53 private boolean syntaxCaseInsensitive = false;
54 private boolean syntaxTrimBlanks = false;
55 private String syntaxEscape = "\\";
56 private String syntaxBeginQuote1 = "\"";
57 private String syntaxEndQuote1 = "\"";
58 private String syntaxBeginQuote2 = "'";
59 private String syntaxEndQuote2 = "'";
60 private String syntaxAvaSeparator = null;
61 private String syntaxTypevalSeparator = null;
62
63 // escapingStyle gives the method used at creation time for
64 // quoting or escaping characters in the name. It is set to the
65 // first style of quote or escape encountered if and when the name
66 // is parsed.
67 private static final int STYLE_NONE = 0;
68 private static final int STYLE_QUOTE1 = 1;
69 private static final int STYLE_QUOTE2 = 2;
70 private static final int STYLE_ESCAPE = 3;
71 private int escapingStyle = STYLE_NONE;
72
73 // Returns true if "match" is not null, and n contains "match" at
74 // position i.
75 private final boolean isA(String n, int i, String match) {
76 return (match != null && n.startsWith(match, i));
77 }
78
79 private final boolean isMeta(String n, int i) {
80 return (isA(n, i, syntaxEscape) ||
81 isA(n, i, syntaxBeginQuote1) ||
82 isA(n, i, syntaxBeginQuote2) ||
83 isSeparator(n, i));
84 }
85
86 private final boolean isSeparator(String n, int i) {
87 return (isA(n, i, syntaxSeparator) ||
88 isA(n, i, syntaxSeparator2));
89 }
90
91 private final int skipSeparator(String name, int i) {
92 if (isA(name, i, syntaxSeparator)) {
93 i += syntaxSeparator.length();
94 } else if (isA(name, i, syntaxSeparator2)) {
95 i += syntaxSeparator2.length();
96 }
97 return (i);
98 }
99
100 private final int extractComp(String name, int i, int len, Vector comps)
101 throws InvalidNameException {
102 String beginQuote;
103 String endQuote;
104 boolean start = true;
105 boolean one = false;
106 StringBuffer answer = new StringBuffer(len);
107
108 while (i < len) {
109 // handle quoted strings
110 if (start && ((one = isA(name, i, syntaxBeginQuote1)) ||
111 isA(name, i, syntaxBeginQuote2))) {
112
113 // record choice of quote chars being used
114 beginQuote = one ? syntaxBeginQuote1 : syntaxBeginQuote2;
115 endQuote = one ? syntaxEndQuote1 : syntaxEndQuote2;
116 if (escapingStyle == STYLE_NONE) {
117 escapingStyle = one ? STYLE_QUOTE1 : STYLE_QUOTE2;
118 }
119
120 // consume string until matching quote
121 for (i += beginQuote.length();
122 ((i < len) && !name.startsWith(endQuote, i));
123 i++) {
124 // skip escape character if it is escaping ending quote
125 // otherwise leave as is.
126 if (isA(name, i, syntaxEscape) &&
127 isA(name, i + syntaxEscape.length(), endQuote)) {
128 i += syntaxEscape.length();
129 }
130 answer.append(name.charAt(i)); // copy char
131 }
132
133 // no ending quote found
134 if (i >= len)
135 throw
136 new InvalidNameException(name + ": no close quote");
137 // new Exception("no close quote");
138
139 i += endQuote.length();
140
141 // verify that end-quote occurs at separator or end of string
142 if (i == len || isSeparator(name, i)) {
143 break;
144 }
145 // throw (new Exception(
146 throw (new InvalidNameException(name +
147 ": close quote appears before end of component"));
148
149 } else if (isSeparator(name, i)) {
150 break;
151
152 } else if (isA(name, i, syntaxEscape)) {
153 if (isMeta(name, i + syntaxEscape.length())) {
154 // if escape precedes meta, consume escape and let
155 // meta through
156 i += syntaxEscape.length();
157 if (escapingStyle == STYLE_NONE) {
158 escapingStyle = STYLE_ESCAPE;
159 }
160 } else if (i + syntaxEscape.length() >= len) {
161 throw (new InvalidNameException(name +
162 ": unescaped " + syntaxEscape + " at end of component"));
163 }
164 } else if (isA(name, i, syntaxTypevalSeparator) &&
165 ((one = isA(name, i+syntaxTypevalSeparator.length(), syntaxBeginQuote1)) ||
166 isA(name, i+syntaxTypevalSeparator.length(), syntaxBeginQuote2))) {
167 // Handle quote occurring after typeval separator
168 beginQuote = one ? syntaxBeginQuote1 : syntaxBeginQuote2;
169 endQuote = one ? syntaxEndQuote1 : syntaxEndQuote2;
170
171 i += syntaxTypevalSeparator.length();
172 answer.append(syntaxTypevalSeparator+beginQuote); // add back
173
174 // consume string until matching quote
175 for (i += beginQuote.length();
176 ((i < len) && !name.startsWith(endQuote, i));
177 i++) {
178 // skip escape character if it is escaping ending quote
179 // otherwise leave as is.
180 if (isA(name, i, syntaxEscape) &&
181 isA(name, i + syntaxEscape.length(), endQuote)) {
182 i += syntaxEscape.length();
183 }
184 answer.append(name.charAt(i)); // copy char
185 }
186
187 // no ending quote found
188 if (i >= len)
189 throw
190 new InvalidNameException(name + ": typeval no close quote");
191
192 i += endQuote.length();
193 answer.append(endQuote); // add back
194
195 // verify that end-quote occurs at separator or end of string
196 if (i == len || isSeparator(name, i)) {
197 break;
198 }
199 throw (new InvalidNameException(name.substring(i) +
200 ": typeval close quote appears before end of component"));
201 }
202
203 answer.append(name.charAt(i++));
204 start = false;
205 }
206
207 if (syntaxDirection == RIGHT_TO_LEFT)
208 comps.insertElementAt(answer.toString(), 0);
209 else
210 comps.addElement(answer.toString());
211 return i;
212 }
213
214 private static boolean getBoolean(Properties p, String name) {
215 return toBoolean(p.getProperty(name));
216 }
217
218 private static boolean toBoolean(String name) {
219 return ((name != null) && name.toLowerCase().equals("true"));
220 }
221
222 private final void recordNamingConvention(Properties p) {
223 String syntaxDirectionStr =
224 p.getProperty("jndi.syntax.direction", "flat");
225 if (syntaxDirectionStr.equals("left_to_right")) {
226 syntaxDirection = LEFT_TO_RIGHT;
227 } else if (syntaxDirectionStr.equals("right_to_left")) {
228 syntaxDirection = RIGHT_TO_LEFT;
229 } else if (syntaxDirectionStr.equals("flat")) {
230 syntaxDirection = FLAT;
231 } else {
232 throw new IllegalArgumentException(syntaxDirectionStr +
233 "is not a valid value for the jndi.syntax.direction property");
234 }
235
236 if (syntaxDirection != FLAT) {
237 syntaxSeparator = p.getProperty("jndi.syntax.separator");
238 syntaxSeparator2 = p.getProperty("jndi.syntax.separator2");
239 if (syntaxSeparator == null) {
240 throw new IllegalArgumentException(
241 "jndi.syntax.separator property required for non-flat syntax");
242 }
243 } else {
244 syntaxSeparator = null;
245 }
246 syntaxEscape = p.getProperty("jndi.syntax.escape");
247
248 syntaxCaseInsensitive = getBoolean(p, "jndi.syntax.ignorecase");
249 syntaxTrimBlanks = getBoolean(p, "jndi.syntax.trimblanks");
250
251 syntaxBeginQuote1 = p.getProperty("jndi.syntax.beginquote");
252 syntaxEndQuote1 = p.getProperty("jndi.syntax.endquote");
253 if (syntaxEndQuote1 == null && syntaxBeginQuote1 != null)
254 syntaxEndQuote1 = syntaxBeginQuote1;
255 else if (syntaxBeginQuote1 == null && syntaxEndQuote1 != null)
256 syntaxBeginQuote1 = syntaxEndQuote1;
257 syntaxBeginQuote2 = p.getProperty("jndi.syntax.beginquote2");
258 syntaxEndQuote2 = p.getProperty("jndi.syntax.endquote2");
259 if (syntaxEndQuote2 == null && syntaxBeginQuote2 != null)
260 syntaxEndQuote2 = syntaxBeginQuote2;
261 else if (syntaxBeginQuote2 == null && syntaxEndQuote2 != null)
262 syntaxBeginQuote2 = syntaxEndQuote2;
263
264 syntaxAvaSeparator = p.getProperty("jndi.syntax.separator.ava");
265 syntaxTypevalSeparator =
266 p.getProperty("jndi.syntax.separator.typeval");
267 }
268
269 NameImpl(Properties syntax) {
270 if (syntax != null) {
271 recordNamingConvention(syntax);
272 }
273 components = new Vector();
274 }
275
276 NameImpl(Properties syntax, String n) throws InvalidNameException {
277 this(syntax);
278
279 boolean rToL = (syntaxDirection == RIGHT_TO_LEFT);
280 boolean compsAllEmpty = true;
281 int len = n.length();
282
283 for (int i = 0; i < len; ) {
284 i = extractComp(n, i, len, components);
285
286 String comp = rToL
287 ? (String)components.firstElement()
288 : (String)components.lastElement();
289 if (comp.length() >= 1) {
290 compsAllEmpty = false;
291 }
292
293 if (i < len) {
294 i = skipSeparator(n, i);
295 if ((i == len) && !compsAllEmpty) {
296 // Trailing separator found. Add an empty component.
297 if (rToL) {
298 components.insertElementAt("", 0);
299 } else {
300 components.addElement("");
301 }
302 }
303 }
304 }
305 }
306
307 NameImpl(Properties syntax, Enumeration comps) {
308 this(syntax);
309
310 // %% comps could shrink in the middle.
311 while (comps.hasMoreElements())
312 components.addElement(comps.nextElement());
313 }
314 /*
315 // Determines whether this component needs any escaping.
316 private final boolean escapingNeeded(String comp) {
317 int len = comp.length();
318 for (int i = 0; i < len; i++) {
319 if (i == 0) {
320 if (isA(comp, 0, syntaxBeginQuote1) ||
321 isA(comp, 0, syntaxBeginQuote2)) {
322 return (true);
323 }
324 }
325 if (isSeparator(comp, i)) {
326 return (true);
327 }
328 if (isA(comp, i, syntaxEscape)) {
329 i += syntaxEscape.length();
330 if (i >= len || isMeta(comp, i)) {
331 return (true);
332 }
333 }
334 }
335 return (false);
336 }
337 */
338 private final String stringifyComp(String comp) {
339 int len = comp.length();
340 boolean escapeSeparator = false, escapeSeparator2 = false;
341 String beginQuote = null, endQuote = null;
342 StringBuffer strbuf = new StringBuffer(len);
343
344 // determine whether there are any separators; if so escape
345 // or quote them
346 if (syntaxSeparator != null &&
347 comp.indexOf(syntaxSeparator) >= 0) {
348 if (syntaxBeginQuote1 != null) {
349 beginQuote = syntaxBeginQuote1;
350 endQuote = syntaxEndQuote1;
351 } else if (syntaxBeginQuote2 != null) {
352 beginQuote = syntaxBeginQuote2;
353 endQuote = syntaxEndQuote2;
354 } else if (syntaxEscape != null)
355 escapeSeparator = true;
356 }
357 if (syntaxSeparator2 != null &&
358 comp.indexOf(syntaxSeparator2) >= 0) {
359 if (syntaxBeginQuote1 != null) {
360 if (beginQuote == null) {
361 beginQuote = syntaxBeginQuote1;
362 endQuote = syntaxEndQuote1;
363 }
364 } else if (syntaxBeginQuote2 != null) {
365 if (beginQuote == null) {
366 beginQuote = syntaxBeginQuote2;
367 endQuote = syntaxEndQuote2;
368 }
369 } else if (syntaxEscape != null)
370 escapeSeparator2 = true;
371 }
372
373 // if quoting component,
374 if (beginQuote != null) {
375
376 // start string off with opening quote
377 strbuf = strbuf.append(beginQuote);
378
379 // component is being quoted, so we only need to worry about
380 // escaping end quotes that occur in component
381 for (int i = 0; i < len; ) {
382 if (comp.startsWith(endQuote, i)) {
383 // end-quotes must be escaped when inside a quoted string
384 strbuf.append(syntaxEscape).append(endQuote);
385 i += endQuote.length();
386 } else {
387 // no special treatment required
388 strbuf.append(comp.charAt(i++));
389 }
390 }
391
392 // end with closing quote
393 strbuf.append(endQuote);
394
395 } else {
396
397 // When component is not quoted, add escape for:
398 // 1. leading quote
399 // 2. an escape preceding any meta char
400 // 3. an escape at the end of a component
401 // 4. separator
402
403 // go through characters in component and escape where necessary
404 boolean start = true;
405 for (int i = 0; i < len; ) {
406 // leading quote must be escaped
407 if (start && isA(comp, i, syntaxBeginQuote1)) {
408 strbuf.append(syntaxEscape).append(syntaxBeginQuote1);
409 i += syntaxBeginQuote1.length();
410 } else if (start && isA(comp, i, syntaxBeginQuote2)) {
411 strbuf.append(syntaxEscape).append(syntaxBeginQuote2);
412 i += syntaxBeginQuote2.length();
413 } else
414
415 // Escape an escape preceding meta characters, or at end.
416 // Other escapes pass through.
417 if (isA(comp, i, syntaxEscape)) {
418 if (i + syntaxEscape.length() >= len) {
419 // escape an ending escape
420 strbuf.append(syntaxEscape);
421 } else if (isMeta(comp, i + syntaxEscape.length())) {
422 // escape meta strings
423 strbuf.append(syntaxEscape);
424 }
425 strbuf.append(syntaxEscape);
426 i += syntaxEscape.length();
427 } else
428
429 // escape unescaped separator
430 if (escapeSeparator && comp.startsWith(syntaxSeparator, i)) {
431 // escape separator
432 strbuf.append(syntaxEscape).append(syntaxSeparator);
433 i += syntaxSeparator.length();
434 } else if (escapeSeparator2 &&
435 comp.startsWith(syntaxSeparator2, i)) {
436 // escape separator2
437 strbuf.append(syntaxEscape).append(syntaxSeparator2);
438 i += syntaxSeparator2.length();
439 } else {
440 // no special treatment required
441 strbuf.append(comp.charAt(i++));
442 }
443 start = false;
444 }
445 }
446 return (strbuf.toString());
447 }
448
449 public String toString() {
450 StringBuffer answer = new StringBuffer();
451 String comp;
452 boolean compsAllEmpty = true;
453 int size = components.size();
454
455 for (int i = 0; i < size; i++) {
456 if (syntaxDirection == RIGHT_TO_LEFT) {
457 comp =
458 stringifyComp((String) components.elementAt(size - 1 - i));
459 } else {
460 comp = stringifyComp((String) components.elementAt(i));
461 }
462 if ((i != 0) && (syntaxSeparator != null))
463 answer.append(syntaxSeparator);
464 if (comp.length() >= 1)
465 compsAllEmpty = false;
466 answer = answer.append(comp);
467 }
468 if (compsAllEmpty && (size >= 1) && (syntaxSeparator != null))
469 answer = answer.append(syntaxSeparator);
470 return (answer.toString());
471 }
472
473 public boolean equals(Object obj) {
474 if ((obj != null) && (obj instanceof NameImpl)) {
475 NameImpl target = (NameImpl)obj;
476 if (target.size() == this.size()) {
477 Enumeration mycomps = getAll();
478 Enumeration comps = target.getAll();
479 while (mycomps.hasMoreElements()) {
480 // %% comps could shrink in the middle.
481 String my = (String)mycomps.nextElement();
482 String his = (String)comps.nextElement();
483 if (syntaxTrimBlanks) {
484 my = my.trim();
485 his = his.trim();
486 }
487 if (syntaxCaseInsensitive) {
488 if (!(my.equalsIgnoreCase(his)))
489 return false;
490 } else {
491 if (!(my.equals(his)))
492 return false;
493 }
494 }
495 return true;
496 }
497 }
498 return false;
499 }
500
501 /**
502 * Compares obj to this NameImpl to determine ordering.
503 * Takes into account syntactic properties such as
504 * elimination of blanks, case-ignore, etc, if relevant.
505 *
506 * Note: using syntax of this NameImpl and ignoring
507 * that of comparison target.
508 */
509 public int compareTo(NameImpl obj) {
510 if (this == obj) {
511 return 0;
512 }
513
514 int len1 = size();
515 int len2 = obj.size();
516 int n = Math.min(len1, len2);
517
518 int index1 = 0, index2 = 0;
519
520 while (n-- != 0) {
521 String comp1 = get(index1++);
522 String comp2 = obj.get(index2++);
523
524 // normalize according to syntax
525 if (syntaxTrimBlanks) {
526 comp1 = comp1.trim();
527 comp2 = comp2.trim();
528 }
529 if (syntaxCaseInsensitive) {
530 comp1 = comp1.toLowerCase();
531 comp2 = comp2.toLowerCase();
532 }
533 int local = comp1.compareTo(comp2);
534 if (local != 0) {
535 return local;
536 }
537 }
538
539 return len1 - len2;
540 }
541
542 public int size() {
543 return (components.size());
544 }
545
546 public Enumeration getAll() {
547 return components.elements();
548 }
549
550 public String get(int posn) {
551 return ((String) components.elementAt(posn));
552 }
553
554 public Enumeration getPrefix(int posn) {
555 if (posn < 0 || posn > size()) {
556 throw new ArrayIndexOutOfBoundsException(posn);
557 }
558 return new NameImplEnumerator(components, 0, posn);
559 }
560
561 public Enumeration getSuffix(int posn) {
562 int cnt = size();
563 if (posn < 0 || posn > cnt) {
564 throw new ArrayIndexOutOfBoundsException(posn);
565 }
566 return new NameImplEnumerator(components, posn, cnt);
567 }
568
569 public boolean isEmpty() {
570 return (components.isEmpty());
571 }
572
573 public boolean startsWith(int posn, Enumeration prefix) {
574 if (posn < 0 || posn > size()) {
575 return false;
576 }
577 try {
578 Enumeration mycomps = getPrefix(posn);
579 while (mycomps.hasMoreElements()) {
580 String my = (String)mycomps.nextElement();
581 String his = (String)prefix.nextElement();
582 if (syntaxTrimBlanks) {
583 my = my.trim();
584 his = his.trim();
585 }
586 if (syntaxCaseInsensitive) {
587 if (!(my.equalsIgnoreCase(his)))
588 return false;
589 } else {
590 if (!(my.equals(his)))
591 return false;
592 }
593 }
594 } catch (NoSuchElementException e) {
595 return false;
596 }
597 return true;
598 }
599
600 public boolean endsWith(int posn, Enumeration suffix) {
601 // posn is number of elements in suffix
602 // startIndex is the starting position in this name
603 // at which to start the comparison. It is calculated by
604 // subtracting 'posn' from size()
605 int startIndex = size() - posn;
606 if (startIndex < 0 || startIndex > size()) {
607 return false;
608 }
609 try {
610 Enumeration mycomps = getSuffix(startIndex);
611 while (mycomps.hasMoreElements()) {
612 String my = (String)mycomps.nextElement();
613 String his = (String)suffix.nextElement();
614 if (syntaxTrimBlanks) {
615 my = my.trim();
616 his = his.trim();
617 }
618 if (syntaxCaseInsensitive) {
619 if (!(my.equalsIgnoreCase(his)))
620 return false;
621 } else {
622 if (!(my.equals(his)))
623 return false;
624 }
625 }
626 } catch (NoSuchElementException e) {
627 return false;
628 }
629 return true;
630 }
631
632 public boolean addAll(Enumeration comps) throws InvalidNameException {
633 boolean added = false;
634 while (comps.hasMoreElements()) {
635 try {
636 Object comp = comps.nextElement();
637 if (size() > 0 && syntaxDirection == FLAT) {
638 throw new InvalidNameException(
639 "A flat name can only have a single component");
640 }
641 components.addElement(comp);
642 added = true;
643 } catch (NoSuchElementException e) {
644 break; // "comps" has shrunk.
645 }
646 }
647 return added;
648 }
649
650 public boolean addAll(int posn, Enumeration comps)
651 throws InvalidNameException {
652 boolean added = false;
653 for (int i = posn; comps.hasMoreElements(); i++) {
654 try {
655 Object comp = comps.nextElement();
656 if (size() > 0 && syntaxDirection == FLAT) {
657 throw new InvalidNameException(
658 "A flat name can only have a single component");
659 }
660 components.insertElementAt(comp, i);
661 added = true;
662 } catch (NoSuchElementException e) {
663 break; // "comps" has shrunk.
664 }
665 }
666 return added;
667 }
668
669 public void add(String comp) throws InvalidNameException {
670 if (size() > 0 && syntaxDirection == FLAT) {
671 throw new InvalidNameException(
672 "A flat name can only have a single component");
673 }
674 components.addElement(comp);
675 }
676
677 public void add(int posn, String comp) throws InvalidNameException {
678 if (size() > 0 && syntaxDirection == FLAT) {
679 throw new InvalidNameException(
680 "A flat name can only zero or one component");
681 }
682 components.insertElementAt(comp, posn);
683 }
684
685 public Object remove(int posn) {
686 Object r = components.elementAt(posn);
687 components.removeElementAt(posn);
688 return r;
689 }
690
691 public int hashCode() {
692 int hash = 0;
693 for (Enumeration e = getAll(); e.hasMoreElements();) {
694 String comp = (String)e.nextElement();
695 if (syntaxTrimBlanks) {
696 comp = comp.trim();
697 }
698 if (syntaxCaseInsensitive) {
699 comp = comp.toLowerCase();
700 }
701
702 hash += comp.hashCode();
703 }
704 return hash;
705 }
706 }
707
708 final
709 class NameImplEnumerator implements Enumeration {
710 Vector vector;
711 int count;
712 int limit;
713
714 NameImplEnumerator(Vector v, int start, int lim) {
715 vector = v;
716 count = start;
717 limit = lim;
718 }
719
720 public boolean hasMoreElements() {
721 return count < limit;
722 }
723
724 public Object nextElement() {
725 if (count < limit) {
726 return vector.elementAt(count++);
727 }
728 throw new NoSuchElementException("NameImplEnumerator");
729 }
730 }
Save This Page