/ - Diff - Metacat - Ecoinformatics Redmine

« Previous | Next »

Revision 730

Added by bojilova about 23 years ago

Changes related to running LDAP servers referred each other in one tree modeling the KNB tree.
Currently there are running LDAP server on dev that holds the KNB root and the NCEAS' s subtree.
It also refers to a subtree modeling the LTER's tree which is held by another LDAP server runnig on alpha .

     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 java.util.Iterator;
     import java.util.HashMap;
     import java.util.Hashtable;
     import java.util.Enumeration;
     import java.util.Set;
     import java.util.Vector;
-...
         this.util = new MetaCatUtil();
         this.ldapUrl = util.getOption("ldapurl");
         this.ldapBase = util.getOption("ldapbase");
+      }
       /**
-...
       public boolean authenticate(String user, String password)
                         throws ConnectException
+      {
         String distName = null;
         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.PROVIDER_URL, ldapUrl + ldapBase);
     //    env.put(Context.SECURITY_AUTHENTICATION, "simple");
     //    env.put(Context.SECURITY_PRINCIPAL, user);
         try {
           // Get the dn for this uid or cn
           String identifier = getIdentifyingName(user);
           if (identifier != null) {
             distName = identifier + "," + ldapBase;
             // Now that we have the dn, we can authenticate, so
             // authenticate this time when opening the DirContext
             env.put(Context.SECURITY_AUTHENTICATION, "simple");
             env.put(Context.SECURITY_PRINCIPAL, distName);
             env.put(Context.SECURITY_CREDENTIALS, password);
             // If our auth credentials are invalid, an exception will be thrown
             DirContext ctx = new InitialDirContext(env);
           /*
            * 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 no exception is thrown then authentication succeeded
             authenticated = true;
             if (identifier != null) {
               // 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("NOT FOUND HERE");
+            }
           } /* while ( enum.hasMore() ) */
             // Close the context when we're done
             ctx.close();
           } else {
             util.debugMessage("User not found!");
+          }
         } catch (AuthenticationException ae) {
           util.debugMessage("Error authenticating in AuthLdap.authenticate: " + ae);
           throw new ConnectException(
           "Error authenticating in AuthLdap.authenticate: " + ae);
         } 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)
-...
         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);
           //// 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);
-...
             // Close the context when we're done
             ctx.close();
           } else {
             util.debugMessage("User not found!");
+          }
           //} else {
           //  util.debugMessage("User not found!");
           //}
         } catch (NamingException e) {
           System.err.println("Problem getting users in AuthLdap.getUsers:" + e);
-...
         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);
           //// 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);
-...
             // Close the context when we're done
             ctx.close();
           } else {
             util.debugMessage("User not found!");
+          }
           //} else {
           //  util.debugMessage("User not found!");
           //}
         } catch (NamingException e) {
           System.err.println("Problem getting users for a group in AuthLdap.getUsers:" + e);
-...
         } catch (NamingException ne) {
           System.err.println("Problem getting userID by \"dn\" in AuthLdap.getUserID:" + ne);
           throw ne;
           //throw new ConnectException(
           //"Problem getting userID searching by \"dn\" in AuthLdap.getUserID:" + e);
           //return null;
+        }
         if ( users.length > 0 ) {
-...
         } catch (NamingException ne) {
           System.err.println("Problem getting groupID by \"dn\" in AuthLdap.getGroupID:" + ne);
           throw ne;
           //throw new ConnectException(
           //"Problem getting groupID searching by \"dn\" in AuthLdap.getGroupID:" + e);
           //return null;
+        }
         if ( groups.length > 0 ) {
-...
         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);
           //// 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);
-...
             // Close the context when we're done
             ctx.close();
           } else {
             util.debugMessage("User not found!");
+          }
           //} else {
           //  util.debugMessage("User not found!");
           //}
         } catch (NamingException e) {
           System.err.println("Problem getting groups in AuthLdap.getGroups:" + e);
-...
         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);
           //// 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);
-...
             // Close the context when we're done
             ctx.close();
           } else {
             util.debugMessage("User not found!");
+          }
           //} else {
           //  util.debugMessage("User not found!");
           //}
         } catch (NamingException e) {
           System.err.println("Problem getting groups in AuthLdap.getGroups:" + e);
-...
         try {
           if ((user != null) && (password != null)) {
             String identifier = getIdentifyingName(user);
             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);
-...
           DirContext ctx = new InitialDirContext(env);
           // Find out the identifying attribute for the user
           String userident = getIdentifyingName(foruser);
           String userident = getIdentifyingName(foruser,this.ldapUrl,this.ldapBase);
           // Ask for all attributes of the user
           Attributes attrs = ctx.getAttributes(userident);
-...
+      }
       /**
        * 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
        * 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 String getIdentifyingName(String user)
              throws NamingException
       private Hashtable getSubtrees(String user, String password,
                                     String ldapUrl, String ldapBase)
                     throws ConnectException
+      {
         String identifier = null;
         Hashtable trees = new Hashtable();
         // Identify service provider to use
         Hashtable env = new Hashtable(11);
         env.put(Context.INITIAL_CONTEXT_FACTORY,
         env.put(Context.INITIAL_CONTEXT_FACTORY,
                 "com.sun.jndi.ldap.LdapCtxFactory");
         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);
           //if ( this.authenticate(user, password) ) {
           // 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");
           Attributes matchAttrs = new BasicAttributes(true);
           matchAttrs.put(new BasicAttribute("uid", user));
           NamingEnumeration answer = ctx.search("", matchAttrs);
           if (answer.hasMore()) {
             SearchResult sr = (SearchResult)answer.next();
             identifier = sr.getName();
             util.debugMessage("Found: " + identifier);
           } else {
             Attributes matchAttrs2 = new BasicAttributes(true);
             matchAttrs2.put(new BasicAttribute("cn", user));
             NamingEnumeration answer2 = ctx.search("", matchAttrs2);
             if (answer2.hasMore()) {
               SearchResult sr = (SearchResult)answer2.next();
               identifier = sr.getName();
               util.debugMessage("Found: " + identifier);
             } else {
               Attributes matchAttrs3 = new BasicAttributes(true);
               matchAttrs3.put(new BasicAttribute("sn", user));
               NamingEnumeration answer3 = ctx.search("", matchAttrs3);
               if (answer3.hasMore()) {
                 SearchResult sr = (SearchResult)answer3.next();
                 identifier = sr.getName();
                 util.debugMessage("Found: " + identifier);
             // 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 the initial search
           ctx.close();
             // Close the context when we're done
             ctx.close();
           //} else {
           //  System.out.println("Not authenticated user: " + user + "@" + ldapUrl + ldapBase);
           //}
         } catch (NamingException e) {
           util.debugMessage("Naming exception while getting dn: " + e);
           System.out.println("Naming exception in AuthLdap.getIdentifyingName");
           throw new NamingException(
           "Naming exception in AuthLdap.getIdentifyingName: " + e);
           System.err.println("Problem getting subtrees in AuthLdap.getSubtrees:" + e);
           throw new ConnectException(
           "Problem getting subtrees in AuthLdap.getSubtrees:" + e);
+        }
         return identifier;
     //System.out.println("number of subtrees:" + trees.size());
         return trees;
+      }
       /**
        * Get list of all groups and users from authentication scheme.
        * 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
        */
       private String getPrincipals(String user, String password)
       public String getPrincipals(String user, String password)
                     throws ConnectException
+      {
         StringBuffer out = new StringBuffer();
         String[] groups = getGroups(user, password);
         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 authSystemURI=\"" + ldapUrl + ldapBase + "\">\n");
         out.append("<principals>\n");
         // for the groups and users that belong to them
         if ( groups.length > 0 ) {
           for (int i=0; i < groups.length; i++ ) {
             out.append("  <group>\n");
             out.append("    <groupname>" + groups[i] + "<groupname>\n");
             String[] usersForGroup = getUsers(user,password,groups[i]);
             for (int j=0; j < usersForGroup.length; j++ ) {
               usersIn.addElement(usersForGroup[j]);
         /*
          * 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 ) {
             for (int i=0; i < groups.length; i++ ) {
               out.append("    <group>\n");
               out.append("      <groupname>" + groups[i] + "<groupname>\n");
               String[] usersForGroup = getUsers(user,password,groups[i]);
               for (int j=0; j < usersForGroup.length; j++ ) {
                 usersIn.addElement(usersForGroup[j]);
                 out.append("      <user>\n");
                 out.append("        <username>" + usersForGroup[j] + "<username>\n");
                 out.append("      </user>\n");
+              }
               out.append("    </group>\n");
+            }
+          }
           // for the users not belonging to any group
           String[] users = getUsers(user, password);
           for (int j=0; j < users.length; j++ ) {
             if ( !usersIn.contains(users[j]) ) {
               out.append("    <user>\n");
               out.append("      <username>" + usersForGroup[j] + "<username>\n");
               out.append("      <username>" + users[j] + "<username>\n");
               out.append("    </user>\n");
+            }
             out.append("  </group>\n");
+          }
+        }
         // for the users not belonging to any group
         String[] users = getUsers(user, password);
         for (int j=0; j < users.length; j++ ) {
           if ( !usersIn.contains(users[j]) ) {
             out.append("  <user>\n");
             out.append("    <username>" + users[j] + "<username>\n");
             out.append("  </user>\n");
           out.append("  </authSystem>\n");
           if ( !usersIn.isEmpty() ) {
             usersIn.removeAllElements();
             usersIn.trimToSize();
+          }
+        }
         out.append("</principals>");
         return out.toString();
+      }
-...
               Iterator attvalues = values.iterator();
               while (attvalues.hasNext()) {
                 String value = (String)attvalues.next();
                 System.out.println(att + ": " + value);
               //  System.out.println(att + ": " + value);
+              }
+            }
-...
     */
           // get the whole list groups and users in XML format
           if (isValid) {
             authservice = new AuthLdap();
             String out = authservice.getPrincipals(user, password);
             java.io.File f = new java.io.File("principals.txt");
             java.io.FileWriter fw = new java.io.FileWriter(f);
-...
+          }
         } catch (ConnectException ce) {
           System.err.println("Error connecting to LDAP server in authldap.main");
           System.err.println(ce.getMessage());
         } catch (java.io.IOException ioe) {
           System.err.println("I/O Error writing to file principals.txt");
+        }

       private String authClass = null;
       private HttpSession session = null;
       private AuthInterface authService = null;
       private String ldapUrl;
       private String ldapBase;
       private String statusMessage = null;
       /**
-...
         MetaCatUtil util = new MetaCatUtil();
         this.authClass = util.getOption("authclass");
         this.authService = (AuthInterface)createObject(authClass);
         this.ldapUrl = util.getOption("ldapurl");
         this.ldapBase = util.getOption("ldapbase");
+      }
-...
+      }
       /**
        * Get list of all groups and users from authentication scheme.
        * 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();
         String[] groups = authService.getGroups(user, password);
         out.append("<?xml version=\"1.0\"?>\n");
         out.append("<principals authSystemURI=\"" + ldapUrl + ldapBase + "\">\n");
         // for the groups and users that belong to them
         if ( groups.length > 0 ) {
           for (int i=0; i < groups.length; i++ ) {
             out.append("  <group>\n");
             out.append("    <groupname>" + groups[i] + "<groupname>\n");
             String[] usersForGroup = authService.getUsers(user,password,groups[i]);
             for (int j=0; j < usersForGroup.length; j++ ) {
               out.append("    <user>\n");
               out.append("      <username>" + usersForGroup[j] + "<username>\n");
               out.append("    </user>\n");
+            }
             out.append("</group>\n");
+          }
         // for the users only when there are no any groups defined
         } else {
           String[] users = authService.getUsers(user, password);
           for (int j=0; j < users.length; j++ ) {
             out.append("  <user>\n");
             out.append("    <username>" + users[j] + "<username>\n");
             out.append("  </user>\n");
+          }
+        }
         out.append("</principals>");
         return out.toString();
         return authService.getPrincipals(user, password);
+      }
       /*

+      }
       /**
        * 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
+      {
         // NOT IMPLEMENTED YET
         return null;
+      }
       /**
        * Test method for the class
        */
       public static void main(String[] args) {

        */
       public HashMap getAttributes(String user, String password, String foruser)
              throws ConnectException;
       /**
        * Get all groups and users from authentication service.
        * 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;
+    }

Also available in: Unified diff

Project

General

Profile

Metacat

Revision 730

Added by bojilova about 23 years ago