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: sgarg $'

 *     '$Date: 2006-07-19 08:56:59 -0700 (Wed, 19 Jul 2006) $'

 * '$Revision: 3023 $'

 *

 * 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.NamingEnumeration;

import javax.naming.NamingException;

import javax.naming.SizeLimitExceededException;

import javax.naming.directory.InvalidSearchFilterException;

import javax.naming.directory.Attribute;

import javax.naming.directory.Attributes;

import javax.naming.directory.DirContext;

import javax.naming.directory.InitialDirContext;

import javax.naming.directory.SearchResult;

import javax.naming.directory.SearchControls;

import javax.naming.ReferralException;

import javax.naming.ldap.InitialLdapContext;

import javax.naming.ldap.LdapContext;

import javax.naming.ldap.StartTlsRequest;

import javax.naming.ldap.StartTlsResponse;

import javax.net.ssl.SSLSession;

import org.apache.log4j.Logger;

import java.net.URLDecoder;

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, Runnable {

  private MetaCatUtil util = new MetaCatUtil();

  private String ldapUrl;

  private String ldapsUrl;

  private String ldapBase;

  private String referral;

  private Context referralContext;

  Hashtable env = new Hashtable(11);

  private Context rContext;

  private String userName;

  private String userPassword;

  ReferralException refExc;

  private static Logger logMetacat = Logger.getLogger(AuthLdap.class);

  /**

   * Construct an AuthLdap

   */

  public AuthLdap() {

    // Read LDAP URI for directory service information

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

    this.ldapsUrl = MetaCatUtil.getOption("ldapsurl");

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

    this.referral = MetaCatUtil.getOption("referral");

  }

  /**

   * 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 ldapsUrl = this.ldapsUrl;

    String ldapBase = this.ldapBase;

    boolean authenticated = false;

    String identifier = user;

    //get uid here.

    String uid=user.substring(0, user.indexOf(","));

    user = user.substring(user.indexOf(","), user.length());

    logMetacat.debug("identifier: " + identifier);

    logMetacat.debug("uid: " + uid);

    logMetacat.debug("user: " + user);

    try {

    	// Check the usename as passed in

        logMetacat.info("Calling ldapAuthenticate");

        logMetacat.info("with user as identifier: " + identifier);

        authenticated = ldapAuthenticate(identifier, password, 

        		(new Boolean(MetaCatUtil.getOption("onlySecureLDAPConnection"))).booleanValue());

        // if not found, try looking up a valid DN then auth again

        if (!authenticated) {

        	logMetacat.info("Not Authenticated");

        	logMetacat.info("Looking up DN for: " + identifier);

        	identifier = getIdentifyingName(identifier, ldapUrl, ldapBase);

        	if(identifier == null){

        		logMetacat.info("No DN found from getIdentifyingName");

        		return authenticated;

        	}

           	logMetacat.info("DN found from getIdentifyingName: " + identifier);

        	String decoded = URLDecoder.decode(identifier);

        	logMetacat.info("DN decoded: " + decoded);

        	identifier = decoded;

        	String refUrl = "";

        	String refBase = "";

        	if (identifier.startsWith("ldap")) {

        		logMetacat.debug("identifier starts with ldap");

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

        		int position = identifier.indexOf(",");

        		int position2 = identifier.indexOf(",", position + 1);

        		refBase = identifier.substring(position2 + 1);

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

        		logMetacat.info("Calling ldapAuthenticate");

        		logMetacat.info("with user as identifier: " + identifier);

        		logMetacat.info("and refUrl as: " + refUrl);

        		logMetacat.info("and refBase as: " + refBase);

        		authenticated = ldapAuthenticate(identifier, password, refUrl, refBase,

                		(new Boolean(MetaCatUtil.getOption("onlySecureLDAPReferalsConnection")))

                			.booleanValue());

        	} else {

        		logMetacat.info("identifier doesnt start with ldap");

        		identifier = identifier + "," + ldapBase;

        		logMetacat.info("Calling ldapAuthenticate");

        		logMetacat.info("with user as identifier: " + identifier);

        		authenticated = ldapAuthenticate(identifier, password,

            		(new Boolean(MetaCatUtil.getOption("onlySecureLDAPConnection"))).booleanValue());

        	}

        }

    }

    catch (NullPointerException e) {

    	logMetacat.error("NullPointerException while authenticating in " +

                        "AuthLdap.authenticate: " + e);

    	e.printStackTrace();

    	throw new ConnectException(

          "NullPointerException while authenticating in " +

          "AuthLdap.authenticate: " + e);

    } catch (NamingException e) {

    	logMetacat.error("Naming exception while authenticating in " +

                        "AuthLdap.authenticate: " + e);

    	e.printStackTrace();

    } catch (Exception e) {

    	logMetacat.error(e.getMessage());

    }

    return authenticated;

  }

  /**

   * Connect to the LDAP directory and do the authentication using the

   * username and password as passed into the routine.

   *

   * @param identifier the distinguished name to check against LDAP

   * @param password the password for authentication

   */

  private boolean ldapAuthenticate(String identifier, String password, 

		  boolean secureConnectionOnly) throws ConnectException, NamingException, 

		  NullPointerException {

    return ldapAuthenticate(identifier, password,

                            this.ldapsUrl, this.ldapBase, secureConnectionOnly);

  }

  /**

   * Connect to the LDAP directory and do the authentication using the

   * username and password as passed into the routine.

   *

   * @param identifier the distinguished name to check against LDAP

   * @param password the password for authentication

   */

  private boolean ldapAuthenticate(String dn, String password, String rootServer, 

		  String rootBase, boolean secureConnectionOnly){

	  boolean authenticated = false;

	  String server = "";

	  String userDN = "";

	  logMetacat.info("dn is: " + dn);

	  int position = dn.lastIndexOf("/");

      logMetacat.debug("position is: " + position);

	  if (position == -1) {

		  server = rootServer;

		  if(dn.indexOf(userDN) < 0){

			  userDN = dn + "," + rootBase;

		  } else {

			  userDN = dn;

		  }

		  logMetacat.info("userDN is: " + userDN);

       } else {

		  server = dn.substring(0, position+1);

		  userDN = dn.substring(position+1);

		  logMetacat.info("server is: " + server);

		  logMetacat.info("userDN is: " + userDN);

	   }

	   logMetacat.warn("Trying to authenticate: " + userDN);

	   logMetacat.warn("          Using server: " + server);

	   LdapContext ctx = null;

	   double startTime;

	   double stopTime;

	   try {

		   Hashtable env = new Hashtable();

		   env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");

		   env.put(Context.PROVIDER_URL, server);

		   env.put(Context.REFERRAL, "throw");

		   try {

			   startTime = System.currentTimeMillis();

			   ctx = new InitialLdapContext(env, null);

			   // Start up TLS here so that we don't pass our jewels in cleartext

		       StartTlsResponse tls =

		              (StartTlsResponse)ctx.extendedOperation(new StartTlsRequest());

		       //tls.setHostnameVerifier(new SampleVerifier());

		       SSLSession sess = tls.negotiate();

		       ctx.addToEnvironment(Context.SECURITY_AUTHENTICATION, "simple");

			   ctx.addToEnvironment(Context.SECURITY_PRINCIPAL, userDN);

			   ctx.addToEnvironment(Context.SECURITY_CREDENTIALS, password);

			   ctx.reconnect(null);

			   stopTime = System.currentTimeMillis();

			   logMetacat.info("Connection time thru " + ldapsUrl + " was: " +

                       	(stopTime - startTime) / 1000 + " seconds.");

			   authenticated = true;

		   } catch (java.io.IOException ioe) {

			   logMetacat.warn("Caught IOException in login while negotiating TLS: "

	                                 + ioe.getMessage());

			   if(secureConnectionOnly){

				   return authenticated;

			   } else {

				   logMetacat.info("Trying to authenticate without TLS");

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

				   env.put(Context.SECURITY_PRINCIPAL, userDN);

				   env.put(Context.SECURITY_CREDENTIALS, password);

				   startTime = System.currentTimeMillis();

				   ctx = new InitialLdapContext(env, null);				

				   stopTime = System.currentTimeMillis();

				   logMetacat.info("Connection time thru " + ldapsUrl + " was: " +

	                       	(stopTime - startTime) / 1000 + " seconds.");

				   authenticated = true;

			   }

		   }

	   } catch (AuthenticationException ae) {

		   authenticated = false;

	   } catch (javax.naming.InvalidNameException ine) {

	        logMetacat.error("An invalid DN was provided!");

	   } catch (NamingException e) {

		   logMetacat.warn("Caught NamingException in login: " + e.getClass().getName());

		   logMetacat.info(e.toString() + "  " + e.getRootCause());

       }

       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;

      Hashtable env = new Hashtable();

      env.put(Context.INITIAL_CONTEXT_FACTORY,

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

      env.put(Context.REFERRAL, "throw");

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

      try {

    	  int position = user.indexOf(",");

          String uid = user.substring(user.indexOf("=") + 1, position);

          logMetacat.info("uid is: " + uid);

          String org = user.substring(user.indexOf("=", position + 1) + 1,

                                        user.indexOf(",", position + 1));

          logMetacat.info("org is: " + org);

          DirContext sctx = new InitialDirContext(env);

          SearchControls ctls = new SearchControls();

          ctls.setSearchScope(SearchControls.SUBTREE_SCOPE);

          String filter = "(&(uid=" + uid + ")(o=" + org + "))";

          logMetacat.warn("Searching for DNs with following filter: " + filter);

          for (boolean moreReferrals = true; moreReferrals;) {

              try {

                  // Perform the search

                  NamingEnumeration answer = 

                      sctx.search("", filter, ctls);

                  // Return the answer

                  while (answer.hasMore()) {

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

                      identifier = sr.getName();

                      return identifier;

                  }

                  // The search completes with no more referrals

                  moreReferrals = false;

              } catch (ReferralException e) {

            	  logMetacat.info("Got referral: " + e.getReferralInfo());

            	  // Point to the new context from the referral

                  if (moreReferrals) {

                      sctx = (DirContext) e.getReferralContext();

                  }

              }

          }

      } catch (NamingException e) {

    	     logMetacat.error("Naming exception while getting dn: " + e);

    	      throw new NamingException(

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

    	      }

      return identifier;

  }

  /**

   * Get all users from the authentication service

   *

   * @param user the user for authenticating against the service

   * @param password the password for authenticating against the service

   * @returns string array of all of the user names

   */

  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.REFERRAL, referral);

    env.put(Context.PROVIDER_URL, ldapUrl);

    try {

      // Create the initial directory context

      DirContext ctx = new InitialDirContext(env);

      // Specify the attributes to match.

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

      SearchControls ctls = new SearchControls();

      String[] attrIDs = {

          "dn", "cn", "o", "ou", "mail"};

      ctls.setReturningAttributes(attrIDs);

      ctls.setSearchScope(SearchControls.SUBTREE_SCOPE);

      //ctls.setCountLimit(1000);

      String filter = "(objectClass=inetOrgPerson)";

      NamingEnumeration namingEnum = ctx.search(ldapBase, filter, ctls);

      // Store the users in a vector

      Vector uvec = new Vector();

      Vector uname = new Vector();

      Vector uorg = new Vector();

      Vector uou = new Vector();

      Vector umail = new Vector();

      Attributes tempAttr = null;

      try {

        while (namingEnum.hasMore()) {

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

          tempAttr = sr.getAttributes();

          if ( (tempAttr.get("cn") + "").startsWith("cn: ")) {

            uname.add( (tempAttr.get("cn") + "").substring(4));

          }

          else {

            uname.add(tempAttr.get("cn") + "");

          }

          if ( (tempAttr.get("o") + "").startsWith("o: ")) {

            uorg.add( (tempAttr.get("o") + "").substring(3));

          }

          else {

            uorg.add(tempAttr.get("o") + "");

          }

          if ( (tempAttr.get("ou") + "").startsWith("ou: ")) {

            uou.add( (tempAttr.get("ou") + "").substring(4));

          }

          else {

            uou.add(tempAttr.get("ou") + "");

          }

          if ( (tempAttr.get("mail") + "").startsWith("mail: ")) {

            umail.add( (tempAttr.get("mail") + "").substring(6));

          }

          else {

            umail.add(tempAttr.get("mail") + "");

          }

          uvec.add(sr.getName() + "," + ldapBase);

        }

      }

      catch (SizeLimitExceededException slee) {

        logMetacat.error("LDAP Server size limit exceeded. " +

                          "Returning incomplete record set.");

      }

      // initialize users[]; fill users[]

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

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

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

        users[i][1] = (String) uname.elementAt(i);

        users[i][2] = (String) uorg.elementAt(i);

        users[i][3] = (String) uorg.elementAt(i);

        users[i][4] = (String) umail.elementAt(i);

      }

      // Close the context when we're done

      ctx.close();

    }

    catch (NamingException e) {

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

      //e.printStackTrace(System.err);

      throw new ConnectException(

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

    }

    return users;

  }

  /**

   * Get all users from the authentication service

   *

   * @param user the user for authenticating against the service

   * @param password the password for authenticating against the service

   * @returns string array of all of the user names

   */

  public String[] getUserInfo(String user, String password) throws

      ConnectException {

    String[] userinfo = new String[3];

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

    env.put(Context.INITIAL_CONTEXT_FACTORY,

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

    env.put(Context.REFERRAL, referral);

    env.put(Context.PROVIDER_URL, ldapUrl);

    try {

      // Create the initial directory context

      DirContext ctx = new InitialDirContext(env);

      // Specify the attributes to match.

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

      SearchControls ctls = new SearchControls();

      String[] attrIDs = {

          "cn", "o", "mail"};

      ctls.setReturningAttributes(attrIDs);

      ctls.setSearchScope(SearchControls.SUBTREE_SCOPE);

      //ctls.setCountLimit(1000);

      // create the filter based on the uid

      String filter = null;

      if(user.indexOf("o=")>0){

    	  String tempStr = user.substring(user.indexOf("o="));

    	  filter = "(&(" + user.substring(0, user.indexOf(",")) 

			+ ")(" + tempStr.substring(0, tempStr.indexOf(",")) 

			+ "))";      

      } else{

    	  filter = "(&(" + user.substring(0, user.indexOf(",")) 

			+ "))";          		  

      }

   	  filter = "(&(" + user.substring(0, user.indexOf(",")) 

		+ "))";          		  

      NamingEnumeration namingEnum = ctx.search(user, filter, ctls);

      Attributes tempAttr = null;

      try {

        while (namingEnum.hasMore()) {

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

          tempAttr = sr.getAttributes();

          if ( (tempAttr.get("cn") + "").startsWith("cn: ")) {

        	  userinfo[0] = (tempAttr.get("cn") + "").substring(4);

          }

          else {

        	  userinfo[0] = (tempAttr.get("cn") + "");

          }

          if ( (tempAttr.get("o") + "").startsWith("o: ")) {

        	  userinfo[1] = (tempAttr.get("o") + "").substring(3);

          }

          else {

        	  userinfo[1] = (tempAttr.get("o") + "");

          }

          if ( (tempAttr.get("mail") + "").startsWith("mail: ")) {

        	  userinfo[2] =  (tempAttr.get("mail") + "").substring(6);

          }

          else {

        	  userinfo[2] = (tempAttr.get("mail") + "");

          }

        }

      }

      catch (SizeLimitExceededException slee) {

        logMetacat.error("LDAP Server size limit exceeded. " +

                          "Returning incomplete record set.");

      }

      // Close the context when we're done

      ctx.close();

    }

    catch (NamingException e) {

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

      //e.printStackTrace(System.err);

      throw new ConnectException(

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

    }

    return userinfo;

  }

  /**

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

   *

   * @param user the user for authenticating against the service

   * @param password the password for authenticating against the service

   * @param group the group whose user list should be returned

   * @returns string array of the user names belonging to the group

   */

  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.REFERRAL, referral);

    env.put(Context.PROVIDER_URL, ldapUrl);

    try {

      // Create the initial directory context

      DirContext ctx = new InitialDirContext(env);

      // Specify the ids of the attributes to return

      String[] attrIDs = {

          "uniqueMember"};

      Attributes answer = ctx.getAttributes(group, attrIDs);

      Vector uvec = new Vector();

      try {

        for (NamingEnumeration ae = answer.getAll(); ae.hasMore(); ) {

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

          for (NamingEnumeration e = attr.getAll();

               e.hasMore();

               uvec.add(e.next())

               ) {

            ;

          }

        }

      }

      catch (SizeLimitExceededException slee) {

        logMetacat.error("LDAP Server size limit exceeded. " +

                          "Returning incomplete record set.");

      }

      // 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 e) {

      logMetacat.error("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 all groups from the authentication service

   *

   * @param user the user for authenticating against the service

   * @param password the password for authenticating against the service

   * @returns string array of the group names

   */

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

      ConnectException {

    return getGroups(user, password, null);

  }

  /**

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

   *

   * @param user the user for authenticating against the service

   * @param password the password for authenticating against the service

   * @param foruser the user whose group list should be returned

   * @returns string array of the group names

   */

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

      ConnectException {

    Vector gvec = new Vector();

    Vector desc = new Vector();

    Attributes tempAttr = null;

    //Pass the username and password to run() method

    userName = user;

    userPassword = password;

    // Identify service provider to use

    env.put(Context.INITIAL_CONTEXT_FACTORY,

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

    env.put(Context.REFERRAL, "throw");

    env.put(Context.PROVIDER_URL, ldapUrl);

    try {

      // Create the initial directory context

      DirContext ctx = new InitialDirContext(env);

      // Specify the ids of the attributes to return

      String[] attrIDs = {

          "cn", "o", "description"};

      // Specify the attributes to match.

      // Groups are objects with attribute objectclass=groupofuniquenames.

      // and have attribute uniquemember: uid=foruser,ldapbase.

      SearchControls ctls = new SearchControls();

      ctls.setReturningAttributes(attrIDs);

      ctls.setSearchScope(SearchControls.SUBTREE_SCOPE);

      String filter = null;

      String gfilter = "(objectClass=groupOfUniqueNames)";

      if (null == foruser) {

        filter = gfilter;

      }

      else {

        filter = "(& " + gfilter + "(uniqueMember=" + foruser + "))";

      }

      logMetacat.info("searching for groups: " + filter);

      NamingEnumeration namingEnum = ctx.search(ldapBase, filter, ctls);

      // Print the groups

      logMetacat.info("getting group results.");

      while (namingEnum.hasMore()) {

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

        tempAttr = sr.getAttributes();

        if ( (tempAttr.get("description") + "").startsWith("description: ")) {

          desc.add( (tempAttr.get("description") + "").substring(13));

        }

        else {

          desc.add(tempAttr.get("description") + "");

        }

        gvec.add(sr.getName() + "," + ldapBase);

        logMetacat.info("group " + sr.getName() +

                                 " added to Group vector");

      }

      // Close the context when we're done

      ctx.close();

    }

    catch (ReferralException re) {

      refExc = re;

      Thread t = new Thread(new GetGroup());

      logMetacat.info("Starting thread...");

      t.start();

      logMetacat.info("sleeping for 5 seconds.");

      try {

        Thread.sleep(5000);

      }

      catch (InterruptedException ie) {

        logMetacat.error("main thread interrupted: " + ie.getMessage());

      }

      //this is a manual override of jndi's hideously long time

      //out period.

      logMetacat.info("Awake after 5 seconds.");

      if (referralContext == null) {

        logMetacat.info("thread timed out...returning groups: " +

                          gvec.toString());

        String groups[][] = new String[gvec.size()][2];

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

          groups[i][0] = (String) gvec.elementAt(i);

          groups[i][1] = (String) desc.elementAt(i);

        }

        t.interrupt();

        return groups;

      }

      DirContext dc = (DirContext) referralContext;

      String[] attrIDs = {

          "cn", "o", "description"};

      // Specify the attributes to match.

      // Groups are objects with attribute objectclass=groupofuniquenames.

      // and have attribute uniquemember: uid=foruser,ldapbase.

      SearchControls ctls = new SearchControls();

      ctls.setReturningAttributes(attrIDs);

      ctls.setSearchScope(SearchControls.SUBTREE_SCOPE);

      String filter = null;

      String gfilter = "(objectClass=groupOfUniqueNames)";

      if (null == foruser) {

        filter = gfilter;

      }

      else {

        filter = "(& " + gfilter + "(uniqueMember=" + foruser + "))";

      }

      try {

        NamingEnumeration namingEnum = dc.search(ldapBase, filter, ctls);

        // Print the groups

        while (namingEnum.hasMore()) {

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

          tempAttr = sr.getAttributes();

          if ( (tempAttr.get("description") + "").startsWith("description: ")) {

            desc.add( (tempAttr.get("description") + "").substring(13));

          }

          else {

            desc.add(tempAttr.get("description") + "");

          }

          gvec.add(sr.getName() + "," + ldapBase);

        }

        referralContext.close();

        dc.close();

      }

      catch (NamingException ne) {

        logMetacat.info("Naming Exception in AuthLdap.getGroups for referals" +

                                 ne.getExplanation() + ne.getMessage());

      }

    }

    catch (NamingException e) {

      e.printStackTrace(System.err);

      String groups[][] = new String[gvec.size()][2];

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

        groups[i][0] = (String) gvec.elementAt(i);

        groups[i][1] = (String) desc.elementAt(i);

      }

      return groups;

      /*throw new ConnectException(

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

    }

    logMetacat.warn("The user is in the following groups: " +

                             gvec.toString());

    String groups[][] = new String[gvec.size()][2];

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

      groups[i][0] = (String) gvec.elementAt(i);

      groups[i][1] = (String) desc.elementAt(i);

    }

    return groups;

  }

  /**

   * Get attributes describing a user or group

   *

   * @param foruser 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);

  }