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

 *     '$Date$'

 * '$Revision$'

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

import javax.naming.directory.Attributes;

import javax.naming.directory.BasicAttributes;

import javax.naming.directory.DirContext;

import javax.naming.directory.InitialDirContext;

import javax.naming.directory.SearchResult;

import java.util.HashMap;

import java.util.Hashtable;

import java.util.Vector;

/**

 * An implementation of the AuthInterface interface that

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

 */

    implements AuthInterface, Runnable {

  private Context rContext;

  private String userPassword;

   */

  public AuthLdap() {

    // Read LDAP URI for directory service information

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

    this.ldapBase = MetaCatUtil.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

   */

      ConnectException {

      authenticated = ldapAuthenticate(identifier, password);

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

      if (!authenticated) {

        String refUrl = "";

        String refBase = "";

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

          refUrl = identifier.substring(0,

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

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

          refBase = identifier.substring(position2 + 1);

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

                                           refUrl, refBase);

          identifier = identifier + "," + ldapBase;

        }

        //authenticated = ldapAuthenticate(identifier, password);

      }

    catch (NullPointerException e) {

      MetaCatUtil.logMetacat.info("NullPointerException while authenticating in " +

                        "AuthLdap.authenticate: " + e);

          "AuthLdap.authenticate: " + e);

    }

    catch (NamingException e) {

                        "AuthLdap.authenticate: " + e);

    catch (Exception e) {

    return authenticated;

  }

  /**

   * username and password as passed into the routine.

   *

   * @param identifier the distinguished name to check against LDAP

   * @param password the password for authentication

   */

      ConnectException, NamingException, NullPointerException {

    return ldapAuthenticate(identifier, password,

                            this.ldapsUrl, this.ldapBase);

  /**

   * 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,

      ConnectException, NamingException, NullPointerException {

      userName = identifier;

      userPassword = password;

      // Identify service provider to use

      Hashtable env = new Hashtable(11);

      env.put(Context.INITIAL_CONTEXT_FACTORY,

      env.put(Context.PROVIDER_URL, directoryUrl + searchBase);

        // ldap is set on default port 389

        // ldaps is set on second port - 636 by default

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

      }

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

      env.put(Context.SECURITY_PRINCIPAL, identifier);

      env.put(Context.SECURITY_CREDENTIALS, password);

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

      DirContext ctx = null;

      try {

        double startTime = System.currentTimeMillis();

        //Here to check the authorization

        ctx = new InitialDirContext(env);

        double stopTime = System.currentTimeMillis();

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

        //tls.close();

        ctx.close();

        this.ldapUrl = ldapUrl;

        this.ldapBase = ldapBase;

        //break;

      }

      catch (AuthenticationException ae) {

        authenticated = false;

        if (ctx != null) {

          ctx.close();

      catch (javax.naming.InvalidNameException ine) {

      catch (javax.naming.ReferralException re) {

        MetaCatUtil.logMetacat.info("Referral information: " + re.getReferralInfo());

          t.start();

          Thread.sleep(5000); //this is a manual override of ldap's

          //hideously long time out period.

            t.interrupt();

          }

            authenticated = true;

          }

          authenticated = false;

        }

      }

                      (totStopTime - totStartTime) / 1000 + " seconds");

  }

  /**

   * 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

   */

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

    env.put(Context.INITIAL_CONTEXT_FACTORY,

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

      // 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);

      // they have a ridiculous amount of redundancy

      // This assumes a dn like "uid=x,o=y,dc=someinst,dc=org"

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

      String comp1 = user.substring(0, position);

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

      String filter = "(&(" + comp1 + ")(" + comp2 + "))";

      MetaCatUtil.logMetacat.info("Provider URL is: " + ldapUrl + ldapBase);

      try {

        }

      // That failed, so check if it is just a username

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

      try {

        if (answer.hasMore()) {

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

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

          }

        }

      catch (InvalidSearchFilterException e) {}

      // Maybe its a user id (uid)

          this.ldapUrl = identifier.substring(0,

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

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

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

        }

      else {

        // maybe its just a common name

        if (answer2.hasMore()) {

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

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

          }

        else {

          // ok, last resort, is it a surname?

          if (answer3.hasMore()) {

                                                  1);

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

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

            }

        }

      }

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

      ctx.close();

    catch (NamingException e) {

  }

  /**

   * @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

      ConnectException {

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

      DirContext ctx = new InitialDirContext(env);

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

      SearchControls ctls = new SearchControls();

      String[] attrIDs = {

      ctls.setSearchScope(SearchControls.SUBTREE_SCOPE);

      //ctls.setCountLimit(1000);

      String filter = "(objectClass=inetOrgPerson)";

      Vector uvec = new Vector();

      Vector uname = new Vector();

      Vector uorg = new Vector();

      Attributes tempAttr = null;

      try {

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

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

          }

          else {

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

          }

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

          }

          else {

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

          }

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

          }

          else {

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

          }

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

          }

          else {

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

          }

      catch (SizeLimitExceededException slee) {

                          "Returning incomplete record set.");

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

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

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

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

      ctx.close();

    catch (NamingException e) {

    return users;

  /**

   * 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

      ConnectException {

    // Identify service provider to use

    Hashtable env = new Hashtable(11);

    try {

      DirContext ctx = new InitialDirContext(env);

      String[] attrIDs = {

          "uniqueMember"};

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

                          "Returning incomplete record set.");

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

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

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

      }

      ctx.close();

    catch (NamingException e) {

                        "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

      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

      ConnectException {

    Attributes tempAttr = null;

    userPassword = password;

      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 gfilter = "(objectClass=groupOfUniqueNames)";

      if (null == foruser) {

        filter = gfilter;

      }

      else {

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

      }