Metacat

  public boolean authenticate(String user, String password)

                    throws ConnectException

  {

    String ldapUrl = this.ldapUrl;

    String ldapsUrl = this.ldapsUrl;

    String ldapBase = this.ldapBase;

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

        if (!authenticated) {

            identifier = getIdentifyingName(identifier,ldapUrl,ldapBase);

            authenticated = ldapAuthenticate(identifier+","+ldapBase, password);

        }

  private boolean ldapAuthenticate(String identifier, String password)

            throws ConnectException, NamingException, NullPointerException

  {

    boolean authenticated = false;

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

        env.put(Context.INITIAL_CONTEXT_FACTORY, 

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

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

        // authenticate this time when opening the DirContext

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

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

        if ( !ldapsUrl.equals(ldapUrl) ) {

          // ldap is set on default port 389

        }

        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;

//          StartTlsResponse tls =

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

//          tls.negotiate();

          double stopTime = System.currentTimeMillis();

          System.out.println("Connection time thru " + ldapsUrl + " was: " +

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

        } catch (javax.naming.InvalidNameException ine) {

            System.out.println("An invalid DN was provided!");

        } catch(javax.naming.ReferralException re) {

            try

            {

              /*

               Matt, I think this is right but I'm not sure...please check me to make

               sure I didn't do something wrong here.

              */

              Context refctx = re.getReferralContext(env);

              authenticated = true;

            }

            catch(Exception e)

            {

            }

	}

    } else { 

        util.debugMessage("User not found");

    }

    return authenticated;

  }

    util.debugMessage("setting referrals to: " + referral);

    env.put(Context.REFERRAL, referral);

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

    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

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

      NamingEnumeration answer;

          return identifier;

        }

      } catch (InvalidSearchFilterException e) {}

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

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

      if (answer.hasMore()) {

      throw new NamingException(

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

    }

    return identifier;

  }

    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"};

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

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

    env.put(Context.REFERRAL, referral);

    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"};

        // Specify the attributes to match.

        // Groups are objects with attribute objectclass=groupofuniquenames.

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

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

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

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

        // Search for objects in the current context

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

        // Print the users

        Vector uvec = new Vector();

        while (enum.hasMore()) {

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

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

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

            if ( enum1.hasMore() ) {

              attr = (Attribute)enum1.next();

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

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

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

                trees.put(ldapBase,

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

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

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

              }

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

                trees.put(ldapBase, ldapUrl);

            } else {              

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

            }

          }

        }

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

    }

    return trees;

  }

   * Construct an AuthSession

   */

  public AuthSession() throws Exception {

    // Determine our session authentication method and

    // create an instance of the auth class

    MetaCatUtil util = new MetaCatUtil();

    this.authClass = util.getOption("authclass");

    this.authService = (AuthInterface)createObject(authClass);

  }

  /** 

   * @param password the password entered when login

   */

  public boolean authenticate(HttpServletRequest request, 

    String message = null;

    try { 

      if ( authService.authenticate(username, password) ) {

        String[] groups = authService.getGroups(username,password,username);

      out.println(e.getMessage());

      return;

    }

    boolean isValid = sess.authenticate(request, un, pw);

    // format and transform the output

    if (qformat.equals("xml")) {

      response.setContentType("text/xml");