/*
 * Copyright (c) 1999, 2003, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package com.sun.jndi.cosnaming;

import javax.naming.*;
import java.util.Properties;
import java.util.Vector;
import java.util.Enumeration;

import org.omg.CosNaming.NameComponent;

Parsing routines for NameParser as well as COS Naming stringified names. This is used by CNCtx to create a NameComponent[] object and vice versa. It follows Section 4.5 of Interoperable Naming Service (INS) 98-10-11. In summary, the stringified form is a left-to-right, forward-slash separated name. id and kinds are separated by '.'. backslash is the escape character.
Author:Rosanna Lee
/** * Parsing routines for NameParser as well as COS Naming stringified names. * This is used by CNCtx to create a NameComponent[] object and vice versa. * It follows Section 4.5 of Interoperable Naming Service (INS) 98-10-11. * In summary, the stringified form is a left-to-right, forward-slash * separated name. id and kinds are separated by '.'. backslash is the * escape character. * * @author Rosanna Lee */
final public class CNNameParser implements NameParser { private static final Properties mySyntax = new Properties(); private static final char kindSeparator = '.'; private static final char compSeparator = '/'; private static final char escapeChar = '\\'; static { mySyntax.put("jndi.syntax.direction", "left_to_right"); mySyntax.put("jndi.syntax.separator", ""+compSeparator); mySyntax.put("jndi.syntax.escape", ""+escapeChar); };
Constructs a new name parser for parsing names in INS syntax.
/** * Constructs a new name parser for parsing names in INS syntax. */
public CNNameParser() { }
Returns a CompoundName given a string in INS syntax.
Params:
  • name – The non-null string representation of the name.
Returns:a non-null CompoundName
/** * Returns a CompoundName given a string in INS syntax. * @param name The non-null string representation of the name. * @return a non-null CompoundName */
public Name parse(String name) throws NamingException { Vector comps = insStringToStringifiedComps(name); return new CNCompoundName(comps.elements()); }
Creates a NameComponent[] from a Name structure. Used by CNCtx to convert the input Name arg into a NameComponent[].
Params:
  • a – CompoundName or a CompositeName; each component must be the stringified form of a NameComponent.
/** * Creates a NameComponent[] from a Name structure. * Used by CNCtx to convert the input Name arg into a NameComponent[]. * @param a CompoundName or a CompositeName; * each component must be the stringified form of a NameComponent. */
static NameComponent[] nameToCosName(Name name) throws InvalidNameException { int len = name.size(); if (len == 0) { return new NameComponent[0]; } NameComponent[] answer = new NameComponent[len]; for (int i = 0; i < len; i++) { answer[i] = parseComponent(name.get(i)); } return answer; }
Returns the INS stringified form of a NameComponent[]. Used by CNCtx.getNameInNamespace(), CNCompoundName.toString().
/** * Returns the INS stringified form of a NameComponent[]. * Used by CNCtx.getNameInNamespace(), CNCompoundName.toString(). */
static String cosNameToInsString(NameComponent[] cname) { StringBuffer str = new StringBuffer(); for ( int i = 0; i < cname.length; i++) { if ( i > 0) { str.append(compSeparator); } str.append(stringifyComponent(cname[i])); } return str.toString(); }
Creates a CompositeName from a NameComponent[]. Used by ExceptionMapper and CNBindingEnumeration to convert a NameComponent[] into a composite name.
/** * Creates a CompositeName from a NameComponent[]. * Used by ExceptionMapper and CNBindingEnumeration to convert * a NameComponent[] into a composite name. */
static Name cosNameToName(NameComponent[] cname) { Name nm = new CompositeName(); for ( int i = 0; cname != null && i < cname.length; i++) { try { nm.add(stringifyComponent(cname[i])); } catch (InvalidNameException e) { // ignore } } return nm; }
Converts an INS-syntax string name into a Vector in which each element of the vector contains a stringified form of a NameComponent.
/** * Converts an INS-syntax string name into a Vector in which * each element of the vector contains a stringified form of * a NameComponent. */
private static Vector insStringToStringifiedComps(String str) throws InvalidNameException { int len = str.length(); Vector components = new Vector(10); char[] id = new char[len]; char[] kind = new char[len]; int idCount, kindCount; boolean idMode; for (int i = 0; i < len; ) { idCount = kindCount = 0; // reset for new component idMode = true; // always start off parsing id while (i < len) { if (str.charAt(i) == compSeparator) { break; } else if (str.charAt(i) == escapeChar) { if (i + 1 >= len) { throw new InvalidNameException(str + ": unescaped \\ at end of component"); } else if (isMeta(str.charAt(i+1))) { ++i; // skip escape and let meta through if (idMode) { id[idCount++] = str.charAt(i++); } else { kind[kindCount++] = str.charAt(i++); } } else { throw new InvalidNameException(str + ": invalid character being escaped"); } } else if (idMode && str.charAt(i) == kindSeparator) { // just look for the first kindSeparator ++i; // skip kind separator idMode = false; } else { if (idMode) { id[idCount++] = str.charAt(i++); } else { kind[kindCount++] = str.charAt(i++); } } } components.addElement(stringifyComponent( new NameComponent(new String(id, 0, idCount), new String(kind, 0, kindCount)))); if (i < len) { ++i; // skip separator } } return components; }
Return a NameComponent given its stringified form.
/** * Return a NameComponent given its stringified form. */
private static NameComponent parseComponent(String compStr) throws InvalidNameException { NameComponent comp = new NameComponent(); int kindSep = -1; int len = compStr.length(); int j = 0; char[] newStr = new char[len]; boolean escaped = false; // Find the kind separator for (int i = 0; i < len && kindSep < 0; i++) { if (escaped) { newStr[j++] = compStr.charAt(i); escaped = false; } else if (compStr.charAt(i) == escapeChar) { if (i + 1 >= len) { throw new InvalidNameException(compStr + ": unescaped \\ at end of component"); } else if (isMeta(compStr.charAt(i+1))) { escaped = true; } else { throw new InvalidNameException(compStr + ": invalid character being escaped"); } } else if (compStr.charAt(i) == kindSeparator) { kindSep = i; } else { newStr[j++] = compStr.charAt(i); } } // Set id comp.id = new String(newStr, 0, j); // Set kind if (kindSep < 0) { comp.kind = ""; // no kind separator } else { // unescape kind j = 0; escaped = false; for (int i = kindSep+1; i < len; i++) { if (escaped) { newStr[j++] = compStr.charAt(i); escaped = false; } else if (compStr.charAt(i) == escapeChar) { if (i + 1 >= len) { throw new InvalidNameException(compStr + ": unescaped \\ at end of component"); } else if (isMeta(compStr.charAt(i+1))) { escaped = true; } else { throw new InvalidNameException(compStr + ": invalid character being escaped"); } } else { newStr[j++] = compStr.charAt(i); } } comp.kind = new String(newStr, 0, j); } return comp; } private static String stringifyComponent(NameComponent comp) { StringBuffer one = new StringBuffer(escape(comp.id)); if (comp.kind != null && !comp.kind.equals("")) { one.append(kindSeparator + escape(comp.kind)); } if (one.length() == 0) { return ""+kindSeparator; // if neither id nor kind specified } else { return one.toString(); } }
Returns a string with '.', '\', '/' escaped. Used when stringifying the name into its INS stringified form.
/** * Returns a string with '.', '\', '/' escaped. Used when * stringifying the name into its INS stringified form. */
private static String escape(String str) { if (str.indexOf(kindSeparator) < 0 && str.indexOf(compSeparator) < 0 && str.indexOf(escapeChar) < 0) { return str; // no meta characters to escape } else { int len = str.length(); int j = 0; char[] newStr = new char[len+len]; for (int i = 0; i < len; i++) { if (isMeta(str.charAt(i))) { newStr[j++] = escapeChar; // escape meta character } newStr[j++] = str.charAt(i); } return new String(newStr, 0, j); } }
In INS, there are three meta characters: '.', '/' and '\'.
/** * In INS, there are three meta characters: '.', '/' and '\'. */
private static boolean isMeta(char ch) { switch (ch) { case kindSeparator: case compSeparator: case escapeChar: return true; } return false; }
An implementation of CompoundName that bypasses the parsing and stringifying code of the default CompoundName.
/** * An implementation of CompoundName that bypasses the parsing * and stringifying code of the default CompoundName. */
static final class CNCompoundName extends CompoundName { CNCompoundName(Enumeration enum_) { super(enum_, CNNameParser.mySyntax); } public Object clone() { return new CNCompoundName(getAll()); } public Name getPrefix(int posn) { Enumeration comps = super.getPrefix(posn).getAll(); return new CNCompoundName(comps); } public Name getSuffix(int posn) { Enumeration comps = super.getSuffix(posn).getAll(); return new CNCompoundName(comps); } public String toString() { try { // Convert Name to NameComponent[] then stringify return cosNameToInsString(nameToCosName(this)); } catch (InvalidNameException e) { return super.toString(); } } private static final long serialVersionUID = -6599252802678482317L; } // for testing only /* private static void print(String input) { try { System.out.println("\n >>>>>> input: " + input); System.out.println("--Compound Name: "); NameParser parser = new CNNameParser(); Name name = parser.parse(input); for (int i = 0; i < name.size(); i++) { System.out.println("\t" + i + ": " + name.get(i)); NameComponent cp = parseComponent(name.get(i)); System.out.println("\t\t" + "id: " + cp.id + ";kind: " + cp.kind); } System.out.println("\t" + name.toString()); System.out.println("--Composite Name: "); Name composite = new CompositeName(input); for (int i = 0; i < composite.size(); i++) { System.out.println("\t" + i+": " + composite.get(i)); } System.out.println("\t" + composite.toString()); System.out.println("--Composite To NameComponent"); NameComponent[] names = nameToCosName(composite); for (int i = 0; i < composite.size(); i++) { System.out.println("\t" + i+": id: " + names[i].id + "; kind: " + names[i].kind); } System.out.println("\t" + cosNameToInsString(names)); } catch (NamingException e) { System.out.println(e); } } private static void checkName(Name name, String[] comps) throws Exception { if (name.size() != comps.length) { throw new Exception( "test failed; incorrect component count in " + name + "; " + "expecting " + comps.length + " got " + name.size()); } for (int i = 0; i < name.size(); i++) { if (!comps[i].equals(name.get(i))) { throw new Exception ( "test failed; invalid component in " + name + "; " + "expecting '" + comps[i] + "' got '" + name.get(i) + "'"); } } } private static void checkCompound(NameParser parser, String input, String[] comps) throws Exception { checkName(parser.parse(input), comps); } private static void checkComposite(String input, String[] comps) throws Exception { checkName(new CompositeName(input), comps); } private static String[] compounds = { "a/b/c", "a.b/c.d", "a", ".", "a.", "c.d", ".e", "a/x\\/y\\/z/b", "a\\.b.c\\.d/e.f", "a/b\\\\/c", "x\\\\.y", "x\\.y", "x.\\\\y", "x.y\\\\", "\\\\x.y", "a.b\\.c/d" }; private static String[][] compoundComps = { {"a", "b", "c"}, {"a.b", "c.d"}, {"a"}, {"."}, {"a"}, {"c.d"}, {".e"}, {"a", "x\\/y\\/z", "b"}, {"a\\.b.c\\.d", "e.f"}, {"a", "b\\\\", "c"}, {"x\\\\.y"}, {"x\\.y"}, {"x.\\\\y"}, {"x.y\\\\"}, {"\\\\x.y"}, {"a.b\\.c", "d"}, }; private static String[] composites = { "a/b/c", "a.b/c.d", "a", ".", "a.", "c.d", ".e", "a/x\\\\\\/y\\\\\\/z/b", "a\\\\.b.c\\\\.d/e.f", "a/b\\\\\\\\/c", "x\\\\\\.y", "x\\\\.y", "x.\\\\\\\\y", "x.y\\\\\\\\", "\\\\\\\\x.y" }; private static String[][] compositeComps = { {"a", "b", "c"}, {"a.b", "c.d"}, {"a"}, {"."}, {"a."}, // unlike compound, kind sep is not consumed {"c.d"}, {".e"}, {"a", "x\\/y\\/z", "b"}, {"a\\.b.c\\.d", "e.f"}, {"a", "b\\\\", "c"}, {"x\\\\.y"}, {"x\\.y"}, {"x.\\\\y"}, {"x.y\\\\"}, {"\\\\x.y"} }; public static void main(String[] args) throws Exception { if (args.length > 0) { for (int i = 0; i < args.length; i++) { print(args[0]); } } else { print("x\\\\.y"); print("x\\.y"); print("x.\\\\y"); print("x.y\\\\"); print("\\\\x.y"); } NameParser parser = new com.sun.jndi.cosnaming.CNNameParser(); for (int i = 0; i < compounds.length; i++) { checkCompound(parser, compounds[i], compoundComps[i]); } for (int i = 0; i < composites.length; i++) { checkComposite(composites[i], compositeComps[i]); } System.out.println("hardwire"); NameComponent[] foo = new NameComponent[1]; foo[0] = new NameComponent("foo\\", "bar"); System.out.println(cosNameToInsString(foo)); System.out.println(cosNameToName(foo)); } */ }