Metacat

/**

 *  '$RCSfile$'

 *    Purpose: An implementation of the AuthInterface interface that

 *             allows Metacat to use the LDAP protocol for

 *             directory services

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones

 *    Release: @release@

 *

 *   '$Author: bojilova $'

 *     '$Date: 2001-05-09 13:49:39 -0700 (Wed, 09 May 2001) $'

 * '$Revision: 740 $'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program 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 for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat;

import java.net.ConnectException;

import javax.naming.AuthenticationException;

import javax.naming.Context;

import javax.naming.InitialContext;

import javax.naming.directory.Attribute;

import javax.naming.directory.Attributes;

import javax.naming.directory.BasicAttribute;

import javax.naming.directory.BasicAttributes;

import javax.naming.directory.DirContext;

import javax.naming.directory.InitialDirContext;

import javax.naming.directory.SearchResult;

import javax.naming.directory.SearchControls;

import javax.naming.NamingEnumeration;

import javax.naming.NamingException;

import java.util.Iterator;

import java.util.HashMap;

import java.util.Hashtable;

import java.util.Enumeration;

import java.util.Set;

import java.util.Vector;

/**

 * An implementation of the AuthInterface interface that

 * allows Metacat to use the LDAP protocol for directory services.

 * The LDAP authentication service is used to determine if a user 

 * is authenticated, and whether they are a member of a particular group.

 */

public class AuthLdap implements AuthInterface {

  private MetaCatUtil util;

  private String ldapUrl;

  private String ldapBase;

  /** 

   * Construct an AuthLdap

   */

  public AuthLdap() {

    // Read LDAP URI for directory service information

    this.util = new MetaCatUtil();

    this.ldapUrl = util.getOption("ldapurl");

    this.ldapBase = util.getOption("ldapbase");

  }

  /**

   * Determine if a user/password are valid according to the authentication

   * service.

   *

   * @param user the name of the principal to authenticate

   * @param password the password to use for authentication

   * @returns boolean true if authentication successful, false otherwise

   */

  public boolean authenticate(String user, String password)

                    throws ConnectException

  {

    String ldapUrl = this.ldapUrl;

    String ldapBase = this.ldapBase;

    boolean authenticated = false;

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

    env.put(Context.INITIAL_CONTEXT_FACTORY, 

            "com.sun.jndi.ldap.LdapCtxFactory");

//    env.put(Context.SECURITY_AUTHENTICATION, "simple");

//    env.put(Context.SECURITY_PRINCIPAL, user);

    try {

      /*

       * get all subtrees first in the current dir context 

       * and then the dn for this uid or cn

       */

      Hashtable subtrees = getSubtrees(user,password,ldapUrl,ldapBase);

      Enumeration enum = subtrees.keys();

      while ( enum.hasMoreElements() ) {

        ldapBase = (String)enum.nextElement();

        ldapUrl = (String)subtrees.get(ldapBase);

System.out.println(ldapUrl + ldapBase); 

        String identifier = getIdentifyingName(user,ldapUrl,ldapBase);

        if (identifier != null && !password.equals("")) {

          // Now that we have the dn, we can authenticate, so

          // authenticate this time when opening the DirContext

          env.put(Context.PROVIDER_URL, ldapUrl + ldapBase);

          //env.put(Context.SECURITY_PROTOCOL, "ssl");

          env.put(Context.SECURITY_AUTHENTICATION, "simple");

          env.put(Context.SECURITY_PRINCIPAL, identifier + "," + ldapBase);

          env.put(Context.SECURITY_CREDENTIALS, password);

          // If our auth credentials are invalid, an exception will be thrown

          DirContext ctx = null;

          try {

            ctx = new InitialDirContext(env);

            authenticated = true;

            ctx.close();

            this.ldapUrl = ldapUrl;

            this.ldapBase = ldapBase;

            break;

          } catch (AuthenticationException ae) {

            authenticated = false;

            if ( ctx != null ) {

              ctx.close();

            }

          }

        } else { 

          util.debugMessage("User not found");

//System.out.println("User NOT FOUND");

        }

      } /* while ( enum.hasMore() ) */

    } catch (NullPointerException e) {

      util.debugMessage("NullPointerException b' password is null");

      util.debugMessage("NullPointerException while authenticating in " + 

                        "AuthLdap.authenticate: " + e);

      throw new ConnectException(

      "NullPointerException while authenticating in " + 

                        "AuthLdap.authenticate: " + e);

    } catch (NamingException e) {

      util.debugMessage("Naming exception while authenticating in " + 

                        "AuthLdap.authenticate: " + e);

      throw new ConnectException(

      "Naming exception while authenticating in " + 

                        "AuthLdap.authenticate: " + e);

    } catch (Exception e) {

      System.out.println(e.getMessage());

    }

    return authenticated;

  }

  /**

   * Get the identifying name for a given userid or name.  This is the name

   * that is used in conjunction withthe LDAP BaseDN to create a

   * distinguished name (dn) for the record

   *

   * @param user the user for which the identifying name is requested

   * @returns String the identifying name for the user, 

   *          or null if not found

   */

  private String getIdentifyingName(String user, String ldapUrl, String ldapBase) 

         throws NamingException

  {

    String identifier = null;

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

    env.put(Context.INITIAL_CONTEXT_FACTORY,

            "com.sun.jndi.ldap.LdapCtxFactory");

    env.put(Context.PROVIDER_URL, ldapUrl + ldapBase);

//    env.put(Context.SECURITY_AUTHENTICATION, "EXTERNAL");

//    env.put(Context.SECURITY_PROTOCOL, "ssl");

    try {

      // Bind to the LDAP server, in order to search for the right

      // distinguished name (dn) based on userid (uid) or common name (cn)

      DirContext ctx = new InitialDirContext(env);

      SearchControls ctls = new SearchControls();

      ctls.setSearchScope(SearchControls.SUBTREE_SCOPE);

      // Search for the user id or name using the uid, then cn and sn attributes

      // If we find a record, determine the dn for the record

      util.debugMessage("\nStarting search phase...\n");

      String filter = "(uid=" + user + ")";

      NamingEnumeration answer = ctx.search("", filter, ctls);

      if (answer.hasMore()) {

        SearchResult sr = (SearchResult)answer.next();

        identifier = sr.getName();

        if ( !sr.isRelative() ) { 

          this.ldapUrl = identifier.substring(0,identifier.lastIndexOf("/")+1);

          this.ldapBase = identifier.substring(identifier.indexOf(",")+1);

          identifier = identifier.substring(identifier.lastIndexOf("/")+1,

                                            identifier.indexOf(","));

        }

        util.debugMessage("Found: " + identifier);

      } else {

        //Attributes matchAttrs2 = new BasicAttributes(true);

        //matchAttrs2.put(new BasicAttribute("cn", user));

        //NamingEnumeration answer2 = ctx.search("", matchAttrs2);

        filter = "(cn=" + user + ")";

        NamingEnumeration answer2 = ctx.search("", filter, ctls);

        if (answer2.hasMore()) {

          SearchResult sr = (SearchResult)answer2.next();

          identifier = sr.getName();

          if ( !sr.isRelative() ) { 

            this.ldapUrl = identifier.substring(0,identifier.lastIndexOf("/")+1);

            this.ldapBase = identifier.substring(identifier.indexOf(",")+1);

            identifier = identifier.substring(identifier.lastIndexOf("/")+1,

                                              identifier.indexOf(","));

          }

          util.debugMessage("Found: " + identifier);

        } else {

          //Attributes matchAttrs3 = new BasicAttributes(true);

          //matchAttrs3.put(new BasicAttribute("sn", user));

          //NamingEnumeration answer3 = ctx.search("", matchAttrs3);

          filter = "(sn=" + user + ")";

          NamingEnumeration answer3 = ctx.search("", filter, ctls);

          if (answer3.hasMore()) {

            SearchResult sr = (SearchResult)answer3.next();

            identifier = sr.getName();

            if ( !sr.isRelative() ) { 

              this.ldapUrl = identifier.substring(0,identifier.lastIndexOf("/")+1);

              this.ldapBase = identifier.substring(identifier.indexOf(",")+1);

              identifier = identifier.substring(identifier.lastIndexOf("/")+1,

                                                identifier.indexOf(","));

            }

            util.debugMessage("Found: " + identifier);

          }

        }

      }

      // Close the context when we're done the initial search

      ctx.close();

    } catch (NamingException e) {

      util.debugMessage("Naming exception while getting dn: " + e);

      throw new NamingException(

      "Naming exception in AuthLdap.getIdentifyingName: " + e);

    }

//System.out.println("context: " + identifier);

    return identifier;

  }

  /**

   * Get all users from the authentication service

   */

  public String[] getUsers(String user, String password) 

         throws ConnectException

  {

    String[] users = null;

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

    env.put(Context.INITIAL_CONTEXT_FACTORY, 

            "com.sun.jndi.ldap.LdapCtxFactory");

    env.put(Context.PROVIDER_URL, ldapUrl + ldapBase);

    try {

      //// Get the dn for this uid or cn 

      //String identifier = getIdentifyingName(user);

      //if (identifier != null) {

      //  env.put(Context.SECURITY_AUTHENTICATION, "simple");

      //  env.put(Context.SECURITY_PRINCIPAL, identifier + "," + ldapBase);

      //  env.put(Context.SECURITY_CREDENTIALS, password);

        // Create the initial directory context

        DirContext ctx = new InitialDirContext(env);

        // Specify the ids of the attributes to return

        String[] attrIDs = {"uid"};

        // Specify the attributes to match.

        // Users are objects that have the attribute objectclass=InetOrgPerson.

        Attributes matchAttrs = new BasicAttributes(true); // ignore case

        matchAttrs.put(new BasicAttribute("objectclass", "inetOrgPerson"));

        // Search for objects in the current context

        NamingEnumeration enum = ctx.search("", matchAttrs, attrIDs);

        // Print the users

        Vector uvec = new Vector();

        while (enum.hasMore()) {

          SearchResult sr = (SearchResult)enum.next();

          Attributes attrs = sr.getAttributes();

          NamingEnumeration enum1 = attrs.getAll(); // only "uid" attr

          while (enum1.hasMore()) {

            Attribute attr = (Attribute)enum1.next();

            uvec.add(attr.get());

          }

        }

        // initialize users[]; fill users[]

        users = new String[uvec.size()];

        for (int i=0; i < uvec.size(); i++) {

          users[i] = (String)uvec.elementAt(i); 

        }

        // Close the context when we're done

        ctx.close();

      //} else {

      //  util.debugMessage("User not found!");

      //}

    } catch (NamingException e) {

      System.err.println("Problem getting users in AuthLdap.getUsers:" + e);

      throw new ConnectException(

      "Problem getting users in AuthLdap.getUsers:" + e);

    }

    return users;

  }

  /**

   * Get the users for a particular group from the authentication service

   */

  public String[] getUsers(String user, String password, String group) 

         throws ConnectException

  {

    String[] users = null;

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

    env.put(Context.INITIAL_CONTEXT_FACTORY, 

            "com.sun.jndi.ldap.LdapCtxFactory");

    env.put(Context.PROVIDER_URL, ldapUrl + ldapBase);

    try {

      //// Get the dn for this uid or cn 

      //String identifier = getIdentifyingName(user);

      //if (identifier != null) {

      //  env.put(Context.SECURITY_AUTHENTICATION, "simple");

      //  env.put(Context.SECURITY_PRINCIPAL, identifier + "," + ldapBase);

      //  env.put(Context.SECURITY_CREDENTIALS, password);

        // Create the initial directory context

        DirContext ctx = new InitialDirContext(env);

        // Specify the ids of the attributes to return

        String[] attrIDs = {"uniquemember"};

        // Specify the attributes to match.

        // Groups are objects with attribute objectclass=groupofuniquenames.

        Attributes matchAttrs = new BasicAttributes(true); // ignore case

        matchAttrs.put(new BasicAttribute("objectclass", "groupofuniquenames"));

        matchAttrs.put(new BasicAttribute("cn", group));

        // Search for objects in the current context

        NamingEnumeration enum = ctx.search("", matchAttrs, attrIDs);

        // Print the users

        Vector uvec = new Vector();

        while (enum.hasMore()) {

          SearchResult sr = (SearchResult)enum.next();

          Attributes attrs = sr.getAttributes();

          // return all attributes (only "uniquemember" attr)

          NamingEnumeration enum1 = attrs.getAll();

          while (enum1.hasMore()) {

            Attribute attr = (Attribute)enum1.next();

            // return all values of that attribute

            NamingEnumeration enum2 = attr.getAll();

            while (enum2.hasMore()) {

              // get DN of a member

              String memberDN = (String)enum2.next();

              try {

                // we actually need RDN of the member

                // try to get RDN (UID) of the member in case of a user

                String memberID = getUserID(memberDN);

                if ( memberID != null ) {

                  uvec.add(memberID);

                // CURRENTLY WE DON'T SUPPORT SUBGROUPING, THUS

                // IGNORE SUBGROUPS AS MEMBERS OF THE GROUP

                // // this is a group, not user

                // // try to get RDN (CN) of the group

                // } else {

                //   memberID = getGroupID(memberDN);

                //   uvec.add(memberID);

                }

              } catch (NamingException ne) {}

            }

          }

        }

        // initialize users[]; fill users[]

        users = new String[uvec.size()];

        for (int i=0; i < uvec.size(); i++) {

          users[i] = (String)uvec.elementAt(i); 

        }

        // Close the context when we're done

        ctx.close();

      //} else {

      //  util.debugMessage("User not found!");

      //}

    } catch (NamingException e) {

      System.err.println("Problem getting users for a group in AuthLdap.getUsers:" + e);

      throw new ConnectException(

      "Problem getting users for a group in AuthLdap.getUsers:" + e);

    }

    return users;

  }

  /**

   * Get UID by DN of a member

   */

  private String getUserID(String dn) 

         throws NamingException

  {

    String[] users = null;

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

    env.put(Context.INITIAL_CONTEXT_FACTORY, 

            "com.sun.jndi.ldap.LdapCtxFactory");

    env.put(Context.PROVIDER_URL, ldapUrl); // + ldapBase);

    try {

        // Create the initial directory context

        DirContext ctx = new InitialDirContext(env);

        // Specify the ids of the attributes to return

        String[] attrIDs = {"uid"};

        // Ask for "uid" attributes of the user 

        Attributes attrs = ctx.getAttributes(dn, attrIDs);

        // Print all of the attributes (only "uid" attr)

        Vector uvec = new Vector();

        NamingEnumeration en = attrs.getAll();

        while (en.hasMore()) {

          Attribute att = (Attribute)en.next();

          Vector values = new Vector();

          String attName = att.getID();

          NamingEnumeration attvalues = att.getAll();

          while (attvalues.hasMore()) {

            String value = (String)attvalues.next();

            values.add(value);

          }

          uvec.add(values.elementAt(0));

        }

        // initialize users[]; fill users[]

        users = new String[uvec.size()];

        for (int i=0; i < uvec.size(); i++) {

          users[i] = (String)uvec.elementAt(i); 

        }

        // Close the context when we're done

        ctx.close();

    } catch (NamingException ne) {

      System.err.println("Problem getting userID by \"dn\" in AuthLdap.getUserID:" + ne);

      throw ne;

    }

    if ( users.length > 0 ) {

      return users[0];

    }

    return null;

  }

  /**

   * Get CN by DN of a member

   */

  private String getGroupID(String dn) 

         throws NamingException

  {

    String[] groups = null;

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

    env.put(Context.INITIAL_CONTEXT_FACTORY, 

            "com.sun.jndi.ldap.LdapCtxFactory");

    env.put(Context.PROVIDER_URL, ldapUrl); // + ldapBase);

    try {

        // Create the initial directory context

        DirContext ctx = new InitialDirContext(env);

        // Specify the ids of the attributes to return

        String[] attrIDs = {"cn"};

        // Ask for "uid" attributes of the user 

        Attributes attrs = ctx.getAttributes(dn, attrIDs);

        // Print all of the attributes (only "cn" attr)

        Vector uvec = new Vector();

        NamingEnumeration en = attrs.getAll();

        while (en.hasMore()) {

          Attribute att = (Attribute)en.next();

          Vector values = new Vector();

          String attName = att.getID();

          NamingEnumeration attvalues = att.getAll();

          while (attvalues.hasMore()) {

            String value = (String)attvalues.next();

            values.add(value);

          }

          uvec.add(values.elementAt(0));

        }

        // initialize users[]; fill users[]

        groups = new String[uvec.size()];

        for (int i=0; i < uvec.size(); i++) {

          groups[i] = (String)uvec.elementAt(i); 

        }

        // Close the context when we're done

        ctx.close();

    } catch (NamingException ne) {

      System.err.println("Problem getting groupID by \"dn\" in AuthLdap.getGroupID:" + ne);

      throw ne;

    }

    if ( groups.length > 0 ) {

      return groups[0];

    }

    return null;

  }

  /**

   * Get all groups from the authentication service

   */

  public String[] getGroups(String user, String password) 

         throws ConnectException

  {

    String[] groups = null;

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

    env.put(Context.INITIAL_CONTEXT_FACTORY, 

            "com.sun.jndi.ldap.LdapCtxFactory");

    env.put(Context.PROVIDER_URL, ldapUrl + ldapBase);

    try {

      //// Get the dn for this uid or cn 

      //String identifier = getIdentifyingName(user);

      //if (identifier != null) {

      //  env.put(Context.SECURITY_AUTHENTICATION, "simple");

      //  env.put(Context.SECURITY_PRINCIPAL, identifier + "," + ldapBase);

      //  env.put(Context.SECURITY_CREDENTIALS, password);

        // Create the initial directory context

        DirContext ctx = new InitialDirContext(env);

        // Specify the ids of the attributes to return

        String[] attrIDs = {"cn"};

        // Specify the attributes to match.

        // Groups are objects with attribute objectclass=groupofuniquenames.

        Attributes matchAttrs = new BasicAttributes(true); // ignore case

        matchAttrs.put(new BasicAttribute("objectclass", "groupofuniquenames"));

        // Search for objects in the current context

        NamingEnumeration enum = ctx.search("", matchAttrs, attrIDs);

        // Print the users

        Vector uvec = new Vector();

        while (enum.hasMore()) {

          SearchResult sr = (SearchResult)enum.next();

          Attributes attrs = sr.getAttributes();

          NamingEnumeration enum1 = attrs.getAll(); // only "cn" attr

          while (enum1.hasMore()) {

            Attribute attr = (Attribute)enum1.next();

            uvec.add(attr.get());

          }

        }

        // initialize groups[] and fill it

        groups = new String[uvec.size()];

        for (int i=0; i < uvec.size(); i++) {

          groups[i] = (String)uvec.elementAt(i); 

        }

        // Close the context when we're done

        ctx.close();

      //} else {

      //  util.debugMessage("User not found!");

      //}

    } catch (NamingException e) {

      System.err.println("Problem getting groups in AuthLdap.getGroups:" + e);

      throw new ConnectException(

      "Problem getting groups in AuthLdap.getGroups:" + e);

    }

    return groups;

  }

  /**

   * Get the groups for a particular user from the authentication service

   */

  public String[] getGroups(String user, String password, String foruser) 

         throws ConnectException

  {

    String[] groups = null;

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

    env.put(Context.INITIAL_CONTEXT_FACTORY, 

            "com.sun.jndi.ldap.LdapCtxFactory");

    env.put(Context.PROVIDER_URL, ldapUrl + ldapBase);

    try {

      //// Get the dn for this uid or cn 

      //String identifier = getIdentifyingName(user);

      //if (identifier != null) {

      //  env.put(Context.SECURITY_AUTHENTICATION, "simple");

      //  env.put(Context.SECURITY_PRINCIPAL, identifier + "," + ldapBase);

      //  env.put(Context.SECURITY_CREDENTIALS, password);

        // Create the initial directory context

        DirContext ctx = new InitialDirContext(env);

        // Specify the ids of the attributes to return

        String[] attrIDs = {"cn"};

        // Specify the attributes to match.

        // Groups are objects with attribute objectclass=groupofuniquenames.

        // and have attribute uniquemember=foruser,ldapbase.

        Attributes matchAttrs = new BasicAttributes(true); // ignore case

        matchAttrs.put(new BasicAttribute("objectclass", "groupofuniquenames"));

        matchAttrs.put(new BasicAttribute("uniquemember",foruser+","+ldapBase));

        // Search for objects in the current context

        NamingEnumeration enum = ctx.search("", matchAttrs, attrIDs);

        // Print the users

        Vector uvec = new Vector();

        while (enum.hasMore()) {

          SearchResult sr = (SearchResult)enum.next();

          Attributes attrs = sr.getAttributes();

          NamingEnumeration enum1 = attrs.getAll(); // only "cn" attr

          while (enum1.hasMore()) {

            Attribute attr = (Attribute)enum1.next();

            uvec.add(attr.get());

          }

        }

        // initialize groups[] and fill it

        groups = new String[uvec.size()];

        for (int i=0; i < uvec.size(); i++) {

          groups[i] = (String)uvec.elementAt(i); 

        }

        // Close the context when we're done

        ctx.close();

      //} else {

      //  util.debugMessage("User not found!");

      //}

    } catch (NamingException e) {

      System.err.println("Problem getting groups in AuthLdap.getGroups:" + e);

      throw new ConnectException(

      "Problem getting groups for a user in AuthLdap.getGroups:" + e);

    }

    return groups;

  }

  /**

   * Get attributes describing a user or group

   *

   * @param user the user for which the attribute list is requested

   * @returns HashMap a map of attribute name to a Vector of values

   */

  public HashMap getAttributes(String foruser) 

         throws ConnectException

  {

    return getAttributes(null, null, foruser);

  }

  /**

   * Get attributes describing a user or group

   *

   * @param user the user for which the attribute list is requested

   * @param authuser the user for authenticating against the service

   * @param password the password for authenticating against the service

   * @returns HashMap a map of attribute name to a Vector of values

   */

  public HashMap getAttributes(String user, String password, String foruser) 

         throws ConnectException

  {

    HashMap attributes = new HashMap();

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

    env.put(Context.INITIAL_CONTEXT_FACTORY, 

        "com.sun.jndi.ldap.LdapCtxFactory");

    env.put(Context.PROVIDER_URL, ldapUrl + ldapBase);

    // Authentication information

    try {

      if ((user != null) && (password != null)) {

        String identifier = getIdentifyingName(user,this.ldapUrl,this.ldapBase);

        env.put(Context.SECURITY_AUTHENTICATION, "simple");

        env.put(Context.SECURITY_PRINCIPAL, identifier + "," + ldapBase);

        env.put(Context.SECURITY_CREDENTIALS, password);

      }

      // Create the initial directory context

      DirContext ctx = new InitialDirContext(env);

      // Find out the identifying attribute for the user

      String userident = getIdentifyingName(foruser,this.ldapUrl,this.ldapBase);

      // Ask for all attributes of the user 

      Attributes attrs = ctx.getAttributes(userident);

      // Print all of the attributes

      NamingEnumeration en = attrs.getAll();

      while (en.hasMore()) {

        Attribute att = (Attribute)en.next();

        Vector values = new Vector();

        String attName = att.getID();

        NamingEnumeration attvalues = att.getAll();

        while (attvalues.hasMore()) {

          String value = (String)attvalues.next();

          values.add(value);

        }

        attributes.put(attName, values);

      }

      // Close the context when we're done

      ctx.close();

    } catch (NamingException e) {

      System.err.println("Problem getting attributes in AuthLdap.getAttributes:" 

                          + e);

      throw new ConnectException(

      "Problem getting attributes in AuthLdap.getAttributes:" + e);

    }

    return attributes;

  }

  /**

   * Get list of all subtrees holding Metacat's groups and users

   * starting from the Metacat LDAP root, 

   * i.e. ldap://dev.nceas.ucsb.edu/dc=ecoinformatics,dc=org

   */

  private Hashtable getSubtrees(String user, String password,

                                String ldapUrl, String ldapBase)

                throws ConnectException

  {

    Hashtable trees = new Hashtable();

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

    env.put(Context.INITIAL_CONTEXT_FACTORY, 

            "com.sun.jndi.ldap.LdapCtxFactory");

    env.put(Context.PROVIDER_URL, ldapUrl + ldapBase);

    try {

      //if ( this.authenticate(user, password) ) {

        // Create the initial directory context

        DirContext ctx = new InitialDirContext(env);

        // Specify the ids of the attributes to return

        String[] attrIDs = {"o","ref"};

        SearchControls ctls = new SearchControls();

        ctls.setReturningAttributes(attrIDs);

        ctls.setSearchScope(SearchControls.SUBTREE_SCOPE);

        // Specify the attributes to match.

        // Subtrees from the main server are found as objects with attribute

        // objectclass=organization or objectclass=referral to the subtree

        // resided on other server.

        String filter = "(|(objectclass=organization)(objectclass=referral))";

        // Search for objects in the current context

        NamingEnumeration enum = ctx.search("", filter, ctls);

        // Print the subtrees' <ldapURL, baseDN>

        while (enum.hasMore()) {

          SearchResult sr = (SearchResult)enum.next();

          Attributes attrs = sr.getAttributes();

          NamingEnumeration enum1 = attrs.getAll(); // "dc" and "ref" attrs

          if (enum1.hasMore()) {

            Attribute attr = (Attribute)enum1.next();

            String attrValue = (String)attr.get();

            String attrName = (String)attr.getID();

 //System.out.println(attrName + "=" + attrValue);

            if ( enum1.hasMore() ) {

              attr = (Attribute)enum1.next();

              String refValue = (String)attr.get();

              String refName = (String)attr.getID();

 //System.out.println(refName + "=" + refValue);

              if ( ldapBase.startsWith(refName + "=" + refValue) ) {

                trees.put(ldapBase,

                          attrValue.substring(0,attrValue.lastIndexOf("/")+1) );

              } else {

                trees.put(refName + "=" + refValue + "," + ldapBase,

                          attrValue.substring(0,attrValue.lastIndexOf("/")+1) );

              }

 //System.out.println("REFERRAL:" + attrValue);

            } else if ( ldapBase.startsWith(attrName + "=" + attrValue) ) {

                trees.put(ldapBase, ldapUrl);

            } else {              

                trees.put(attrName + "=" + attrValue + "," + ldapBase, ldapUrl);

 //System.out.println(ldapUrl + attrName + "=" + attrValue + "," + ldapBase);

            }

          }

        }

        // Close the context when we're done

        ctx.close();

      //} else {

      //  System.out.println("Not authenticated user: " + user + "@" + ldapUrl + ldapBase);

      //}

    } catch (NamingException e) {

      System.err.println("Problem getting subtrees in AuthLdap.getSubtrees:" + e);

      throw new ConnectException(

      "Problem getting subtrees in AuthLdap.getSubtrees:" + e);

    }

//System.out.println("number of subtrees:" + trees.size());

    return trees;

  }

  /**

   * Get all groups and users from authentication scheme.

   * The output is formatted in XML.

   * @param user the user which requests the information

   * @param password the user's password

   */

  public String getPrincipals(String user, String password)

                throws ConnectException

  {

    StringBuffer out = new StringBuffer();

    Vector usersIn = new Vector();

    //String ldapUrl = "ldap://dev.nceas.ucsb.edu/";

    //String ldapBase = "dc=ecoinformatics,dc=org";

    //String ldapUrl = "ldap://ldap.nceas.ucsb.edu/";

    //String ldapBase = "o=NCEAS,c=US";

    out.append("<?xml version=\"1.0\"?>\n");

    out.append("<principals>\n");

    /*

     * get all subtrees first in the current dir context 

     * and then the Metacat users under them

     */

    Hashtable subtrees = getSubtrees(user,password,this.ldapUrl,this.ldapBase);

    Enumeration enum = subtrees.keys();

    while ( enum.hasMoreElements() ) {

      this.ldapBase = (String)enum.nextElement();

      this.ldapUrl = (String)subtrees.get(ldapBase);

      out.append("  <authSystem URI=\"" + 

                 this.ldapUrl + this.ldapBase + "\">\n");

      // get all groups for directory context

      String[] groups = getGroups(user, password);

      // for the groups and users that belong to them

      if ( groups.length > 0 ) {