Back to index...

	/*
	* Copyright (c) 1999, 2002, 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.ldap;

	import javax.naming.*;
	import java.net.MalformedURLException;
	import java.io.UnsupportedEncodingException;
	import java.util.StringTokenizer;
	import com.sun.jndi.toolkit.url.Uri;
	import com.sun.jndi.toolkit.url.UrlUtil;

	/*
	* Extract components of an LDAP URL.
	*
	* The format of an LDAP URL is defined in RFC 2255 as follows:
	*
	* ldapurl = scheme "://" [hostport] ["/"
	* [dn ["?" [attributes] ["?" [scope]
	* ["?" [filter] ["?" extensions]]]]]]
	* scheme = "ldap"
	* attributes = attrdesc *("," attrdesc)
	* scope = "base" / "one" / "sub"
	* dn = distinguishedName from Section 3 of [1]
	* hostport = hostport from Section 5 of RFC 1738 [5]
	* attrdesc = AttributeDescription from Section 4.1.5 of [2]
	* filter = filter from Section 4 of [4]
	* extensions = extension *("," extension)
	* extension = ["!"] extype ["=" exvalue]
	* extype = token / xtoken
	* exvalue = LDAPString from section 4.1.2 of [2]
	* token = oid from section 4.1 of [3]
	* xtoken = ("X-" / "x-") token
	*
	* For example,
	*
	* ldap://ldap.itd.umich.edu/o=University%20of%20Michigan,c=US
	* ldap://host.com:6666/o=IMC,c=US??sub?(cn=Babs%20Jensen)
	*
	* This class also supports ldaps URLs.
	*/

	final public class LdapURL extends Uri {

	private boolean useSsl = false;
	private String DN = null;
	private String attributes = null;
	private String scope = null;
	private String filter = null;
	private String extensions = null;

	/**
	* Creates an LdapURL object from an LDAP URL string.
	*/
	public LdapURL(String url) throws NamingException {

	super();

	try {
	init(url); // scheme, host, port, path, query
	useSsl = scheme.equalsIgnoreCase("ldaps");

	if (! (scheme.equalsIgnoreCase("ldap") \|\| useSsl)) {
	throw new MalformedURLException("Not an LDAP URL: " + url);
	}

	parsePathAndQuery(); // DN, attributes, scope, filter, extensions

	} catch (MalformedURLException e) {
	NamingException ne = new NamingException("Cannot parse url: " + url);
	ne.setRootCause(e);
	throw ne;
	} catch (UnsupportedEncodingException e) {
	NamingException ne = new NamingException("Cannot parse url: " + url);
	ne.setRootCause(e);
	throw ne;
	}
	}

	/**
	* Returns true if the URL is an LDAPS URL.
	*/
	public boolean useSsl() {
	return useSsl;
	}

	/**
	* Returns the LDAP URL's distinguished name.
	*/
	public String getDN() {
	return DN;
	}

	/**
	* Returns the LDAP URL's attributes.
	*/
	public String getAttributes() {
	return attributes;
	}

	/**
	* Returns the LDAP URL's scope.
	*/
	public String getScope() {
	return scope;
	}

	/**
	* Returns the LDAP URL's filter.
	*/
	public String getFilter() {
	return filter;
	}

	/**
	* Returns the LDAP URL's extensions.
	*/
	public String getExtensions() {
	return extensions;
	}

	/**
	* Given a space-separated list of LDAP URLs, returns an array of strings.
	*/
	public static String[] fromList(String urlList) throws NamingException {

	String[] urls = new String[(urlList.length() + 1) / 2];
	int i = 0; // next available index in urls
	StringTokenizer st = new StringTokenizer(urlList, " ");

	while (st.hasMoreTokens()) {
	urls[i++] = st.nextToken();
	}
	String[] trimmed = new String[i];
	System.arraycopy(urls, 0, trimmed, 0, i);
	return trimmed;
	}

	/**
	* Derermines whether an LDAP URL has query components.
	*/
	public static boolean hasQueryComponents(String url) {
	return (url.lastIndexOf('?') != -1);
	}

	/*
	* Assembles an LDAP or LDAPS URL string from its components.
	* If "host" is an IPv6 literal, it may optionally include delimiting
	* brackets.
	*/
	static String toUrlString(String host, int port, String dn, boolean useSsl)
	{

	try {
	String h = (host != null) ? host : "";
	if ((h.indexOf(':') != -1) && (h.charAt(0) != '[')) {
	h = "[" + h + "]"; // IPv6 literal
	}
	String p = (port != -1) ? (":" + port) : "";
	String d = (dn != null) ? ("/" + UrlUtil.encode(dn, "UTF8")) : "";

	return useSsl ? "ldaps://" + h + p + d : "ldap://" + h + p + d;
	} catch (UnsupportedEncodingException e) {
	// UTF8 should always be supported
	throw new IllegalStateException("UTF-8 encoding unavailable");
	}
	}

	/*
	* Parses the path and query components of an URL and sets this
	* object's fields accordingly.
	*/
	private void parsePathAndQuery() throws MalformedURLException,
	UnsupportedEncodingException {

	// path begins with a '/' or is empty

	if (path.equals("")) {
	return;
	}

	DN = path.startsWith("/") ? path.substring(1) : path;
	if (DN.length() > 0) {
	DN = UrlUtil.decode(DN, "UTF8");
	}

	// query begins with a '?' or is null

	if (query == null \|\| query.length() < 2) {
	return;
	}

	int currentIndex = 1;
	int nextQmark;
	int endIndex;

	// attributes:
	nextQmark = query.indexOf('?', currentIndex);
	endIndex = nextQmark == -1 ? query.length() : nextQmark;
	if (endIndex - currentIndex > 0) {
	attributes = query.substring(currentIndex, endIndex);
	}
	currentIndex = endIndex + 1;
	if (currentIndex >= query.length()) {
	return;
	}

	// scope:
	nextQmark = query.indexOf('?', currentIndex);
	endIndex = nextQmark == -1 ? query.length() : nextQmark;
	if (endIndex - currentIndex > 0) {
	scope = query.substring(currentIndex, endIndex);
	}
	currentIndex = endIndex + 1;
	if (currentIndex >= query.length()) {
	return;
	}

	// filter:
	nextQmark = query.indexOf('?', currentIndex);
	endIndex = nextQmark == -1 ? query.length() : nextQmark;
	if (endIndex - currentIndex > 0) {
	filter = query.substring(currentIndex, endIndex);
	filter = UrlUtil.decode(filter, "UTF8");
	}
	currentIndex = endIndex + 1;
	if (currentIndex >= query.length()) {
	return;
	}

	// extensions:
	if (query.length() - currentIndex > 0) {
	extensions = query.substring(currentIndex);
	extensions = UrlUtil.decode(extensions, "UTF8");
	}
	}

	/*
	public static void main(String[] args) throws Exception {

	LdapURL url = new LdapURL(args[0]);

	System.out.println("Example LDAP URL: " + url.toString());
	System.out.println(" scheme: " + url.getScheme());
	System.out.println(" host: " + url.getHost());
	System.out.println(" port: " + url.getPort());
	System.out.println(" DN: " + url.getDN());
	System.out.println(" attrs: " + url.getAttributes());
	System.out.println(" scope: " + url.getScope());
	System.out.println(" filter: " + url.getFilter());
	System.out.println(" extens: " + url.getExtensions());
	System.out.println("");
	}
	*/
	}

Back to index...