Datei "FileRegistrySample.java"

Dieser Abschnitt enthält eine Beispieldatei FileRegistrySample.java.

Die für dieses Beispiel erforderlichen Benutzer- und Gruppeninformationen sind in den Dateien Datei users.props und Datei groups.props enthalten.

Achtung: Die bereitgestellten Beispiele sind sehr einfach aufgebaut und sollen Sie mit dieser Funktion vertraut machen. Verwenden Sie diese Beispiele nicht in einer realen Produktionsumgebung.
Es folgt der Inhalt der Datei FileRegistrySample.java:
//
//  5639-D57, 5630-A36, 5630-A37, 5724-D18 
// (C) COPYRIGHT International Business Machines Corp. 1997, 2005
//  Alle Rechte vorbehalten. Lizenziertes Material - Eigentum der IBM.
//

//----------------------------------------------------------------------
// Dieses Programm darf für Entwicklungs-, Nutzungs-, Marketing- und
// Vertriebszwecke gebührenfrei genutzt, ausgeführt, kopiert, geändert und
// vertrieben werden.
//----------------------------------------------------------------------
// 

// Dieses Beispiel ist für angepasste Registrys in WebSphere Application Server bestimmt.

import java.util.*;
import java.io.*;
import java.security.cert.X509Certificate;
import com.ibm.websphere.security.*;

/**
 *  Hauptsächlich soll dieses Beispiel die Verwendung des Features
 *  für angepasste Benutzerregistrys von WebSphere Application Server
 *  veranschaulichen. Das Beispiel ist eine dateibasierte Registry,
 *  in der die Benutzer- und Gruppeninformationen in Dateien
 *  aufgelistet sind (users.props und groups.props). Im Vordergrund
 *  steht hier die Einfachheit und nicht die Leistung. Das Beispiel
 *  dient nur dazu, sich mit dem Feature vertraut zu machen. Für eine
 *  echte Registry müssen verschiedene Faktoren wie Leistung,
 *  Skalierbarkeit, Threadsicherheit usw. berücksichtigt werden.
 **/
public class FileRegistrySample implements UserRegistry {

   private static String USERFILENAME = null;        
   private static String GROUPFILENAME = null;

   /** Standardkonstruktor **/
   public FileRegistrySample() throws java.rmi.RemoteException {
   }

  /**
   * Initialisiert die Registry. Diese Methode wird beim Erstellen
   * der Registry aufgerufen.
   *
   * @param      props   Die registrysspezifischen Eigenschaften, mit denen die
   *                     angepasste Registry initialisiert werden sollen.
   * @exception: CustomRegistryException auslösen, wenn ein Registry-spezifischer Fehler auftritt.
   **/
  public void initialize(java.util.Properties props)
         throws CustomRegistryException {
      try  {    
    
         /* Versuchen, den USERFILENAME und den GROUPFILENAME anhand der
          * (z. B. von der Administrationskonsole) übergebenen Eigenschaften
          * abzurufen. Definieren Sie diese Werte in der
          * Administrationskonsole in der Anzeige 'Authentifizierung'.
          * Sie finden diese Einstellungen in dem Abschnitt
          * für angepasste Benutzerregistrys.
          * Beispiel: 
          * usersFile   c:/temp/users.props
          * groupsFile  c:/temp/groups.props
          */
          if (props != null) {
             USERFILENAME = props.getProperty("usersFile");
             GROUPFILENAME = props.getProperty("groupsFile");
          }

      } catch (Exception ex) {
         throw new CustomRegistryException(ex.getMessage(),ex);
      }

      if (USERFILENAME == null || GROUPFILENAME == null) {
         throw new CustomRegistryException("users/groups information missing");
      }

   }

  /**
   * Prüft das Kennwort des Benutzers. Diese Methode wird aufgerufen,
   * um einen Benutzer zu authentifizieren, wenn Benutzername und
   * Kennwort angegeben werden.
   *
   * @param userSecurityName: Der Name des Benutzers 
   * @param password: Das Kennwort des Benutzers
   * @return Einen gültigen userSecurityName. Normalerweise ist das 
   *         der Name desselben Benutzers, dessen Kennwort zuvor geprüft wurde,
   *         wurde, aber wenn die Implementierung einen anderen gültigen
   *         Benutzernamen in der Registry zurückgeben möchte, ist das möglich.
   * @exception CheckPasswordFailedException, wenn die
   *            Kombination von userSecurityName und Kennwort
   *            nicht in der Registry enthalten ist.
   * @exception: CustomRegistryException bei Auftreten eines Registry-spezifischen
   *             Fehlers auslösen.
   **/
   public String checkPassword(String userSecurityName, String passwd) 
      throws PasswordCheckFailedException,
             CustomRegistryException {
      String s,userName = null;
      BufferedReader in = null;
    
      try  {    
         in = fileOpen(USERFILENAME);
         while ((s=in.readLine())!=null)
         {
            if (!(s.startsWith("#") || s.trim().length() <=0 )) {
               int index = s.indexOf(":");
               int index1 = s.indexOf(":",index+1);
               // Prüfen, ob die Kombination userSecurityName:passwd vorhanden ist
               if ((s.substring(0,index)).equals(userSecurityName) && 
                       s.substring(index+1,index1).equals(passwd)) {
                  // Authentifizierung erfolgreich, Benutzer-ID zurückgeben.
                  userName = userSecurityName;
                  break;
               }
            }
         }
      } catch (Exception ex) {
         throw new CustomRegistryException(ex.getMessage(),ex);
      } finally {
         fileClose(in);
      }
       

      if (userName == null) {
         throw new PasswordCheckFailedException("Password check failed for user: " + userSecurityName);
            } 

      return userName;
   }

  /**
   * Ordnet ein X.509-Zertifikat einem gültigen Benutzer in der Registry zu.
   * Es wird verwendet, um den Namen im Zertifikat, der von einem Browser angegeben 
   * wird, einem gültigen Benutzernamen in der Registry zuzuordnen.
   *
   * @param cert: die X509-Zertifikatskette
   * @return      Der zugeordnete Name des userSecurityName des Benutzers.
   * @exception:  CertificateMapNotSupportedException auslösen, wenn ein bestimmtes
   *              Zertifikat nicht unterstützt wird.
   * @exception:  CertificateMapFailedException auslösen, wenn die Zuordnung des
   *              Zertifikats fehlschlägt.
   * @exception: CustomRegistryException bei Auftreten eines Registry-spezifischen
   *             Fehlers
   **/
   public String mapCertificate(X509Certificate[] cert)
      throws CertificateMapNotSupportedException,
             CertificateMapFailedException,
             CustomRegistryException {
      String name=null;
      X509Certificate cert1 = cert[0];
      try  {    
         // Den SubjectDN im Zertifikat einer Benutzer-ID zuordnen
         name = cert1.getSubjectDN().getName();
      } catch (Exception ex) {
         throw new CertificateMapNotSupportedException(ex.getMessage(),ex);
      }

      if(!isValidUser(name)) {
         throw new CertificateMapFailedException("user: " + name + " is not valid");
            }
      return name;
   }

  /**
   * Gibt den Realm der Registry zurück.
   *
   * @return:   Der Realm. Eine registry-spezifische Zeichenfolge, die den Realm oder
   * die Domäne angibt, für den bzw. die diese Registry gültig
   * ist. Unter OS/400 oder AIX ist dies beispielsweise der Hostname des
   * Systems, dessen Benutzerregistry dieses Objekt darstellt. Wenn diese Methode null
   * zurückgibt, wird als Realm standardmäßig der Wert "customRealm" verwendet.
   * Es wird empfohlen, einen eigenen Wert für den Realm festzulegen.
   * 
   * @exception: CustomRegistryException bei Auftreten eines Registry-spezifischen
   * Fehlers
   **/
   public String getRealm()       
      throws CustomRegistryException {
      String name = "customRealm";
      return name;
   }

  /**
   * Ruft eine Liste der Benutzer ab, die einem Muster in der Registry entsprechen.
   * Die Maximalanzahl der zurückgegebenen Benutzer wird vom Parameter limit
   * definiert.
   * Diese Methode wird von der Administrationskonsole und Scripts (Befehlszeile
   * aufgerufen, um die Benutzer in der Registry so vorzubereiten, dass sie
   * (die Benutzer) Rollen zugeordnet werden können.
   *
   * @param pattern  Das Muster, mit dem eine Übereinstimmung erzielt werden
   *                 muss. (Mit a* stimmen beispielsweise alle userSecurityNames
   *                 überein, die mit a beginnen.)
      * @param limit    Die Maximalanzahl der zurückzugebenden Benutzer.
   *                 Die Verwendung dieses Parameters empfiehlt sich,
   *                 wenn Tausende von Benutzern in der Registry vorhanden
   *                 sind und das Abrufen aller Benutzer nicht sinnvoll ist. Der
   *                 Standardwert ist 100. Der Wert 0 bedeutet, dass alle Benutzer abgerufen werden
   *                  sollen, und muss daher mit Vorsicht verwendet werden.
      * @return:     Ein Result-Objekt, das die Liste der angeforderten Benutzer
   *                 enthält. Ein Flag zeigt an, ob weitere Benutzer vorhanden sind.
   * @exception: CustomRegistryException bei Auftreten eines Registry-spezifischen
*             Fehlers auslösen.
   **/
   public Result getUsers(String pattern, int limit)      throws CustomRegistryException {
      String s;
      BufferedReader in = null;
      List allUsers = new ArrayList();
      Result result = new Result();
      int count = 0;
      int newLimit = limit+1;
      try  {    
         in = fileOpen(USERFILENAME);
         while ((s=in.readLine())!=null)
         {
            if (!(s.startsWith("#") || s.trim().length() <=0 )) {
               int index = s.indexOf(":");
               String user = s.substring(0,index);
               if (match(user,pattern)) {
                  allUsers.add(user);
                  if (limit !=0 && ++count == newLimit) {
                     allUsers.remove(user);
                     result.setHasMore();
                     break;
                  }
               }
            }
         }
      } catch (Exception ex) {
         throw new CustomRegistryException(ex.getMessage(),ex);
      } finally {
         fileClose(in);
      }

      result.setList(allUsers);
      return result;
   }

  /**
   * Gibt den Anzeigenamen des mit userSecurityName angegebenen
   * Benutzers zurück.
   *
   * Diese Methode kann nur aufgerufen werden, wenn die Benutzerdaten
   * angezeigt (z. B. nur zu Informationszwecken in der Administrationskonsole)
   * und deshalb nicht für die eigentliche Authentifizierung oder Berechtigung
   * verwendet werden. Falls keine Anzeigenamen in der Registry vorhanden sind,
   * null oder eine leere Zeichenfolge zurückgeben.
   *
   * Wenn Sie in der angepassten Registry von WebSphere Application Server
   * einen Anzeigenamen für den Benutzer festgelegt haben und dieser vom
   * Sicherheitsnamen abgewichen ist, wurde bei der
   * EJB-Methode getCallerPrincipal() und den Servlet-Methoden
   * getUserPrincipal() und getRemoteUser() der Anzeigename
   * zurückgegeben.
   * In Version 5.x und höher wird für dieselben Methoden
   * standardmäßig der Sicherheitsname zurückgegeben.
   * Dies ist die empfohlene Verfahrensweise, weil der Anzeigename
   * nicht eindeutig ist und ansonsten Sicherheitslücken auftreten
   * könnten. Wenn aus Gründen der Abwärtskompatibilität jedoch
   * der Anzeigename zurückgegeben werden muss, setzen Sie die Eigenschaft
   * WAS_UseDisplayName auf true.
   *
   * Nähere Informationen finden Sie im Information Center.
   *
   * @param      userSecurityName - Der Name des Benutzers.
   * @return: Der Anzeigename des Benutzers. Der Anzeigename ist eine
   *          Registry-spezifische Zeichenfolge, die einen beschreibenden,
   *          nicht unbedingt eindeutigen Namen für einen Benutzer angibt.
   *          Ist kein Anzeigename vorhanden, wird null oder eine leere
   *          Zeichenfolge zurückgegeben.
   * @exception: EntryNotFoundException auslösen, wenn der Benutzername
   *             nicht vorhanden ist.
   * @exception: CustomRegistryException bei Auftreten eines Registry-spezifischen
   *             Fehlers
   **/
   public String getUserDisplayName(String userSecurityName)
      throws CustomRegistryException,
             EntryNotFoundException {

      String s,displayName = null;
      BufferedReader in = null;

      if(!isValidUser(userSecurityName)) {
         EntryNotFoundException nsee = new EntryNotFoundException("user: " + userSecurityName + " is not valid");
                  throw nsee;
      }

      try  {    
         in = fileOpen(USERFILENAME);
         while ((s=in.readLine())!=null)
         {
            if (!(s.startsWith("#") || s.trim().length() <=0 )) {
               int index = s.indexOf(":");
               int index1 = s.lastIndexOf(":");
               if ((s.substring(0,index)).equals(userSecurityName)) {
                  displayName = s.substring(index1+1);
                  break;
               }
            }
         }
      } catch (Exception ex) {
         throw new CustomRegistryException(ex.getMessage(), ex);
      } finally {
         fileClose(in);
      }

      return displayName;
   }

  /**
   * Gibt die eindeutige ID für einen Benutzernamen zurück. Diese Methode wird
   * aufgerufen, wenn ein Berechtigungsnachweis für einen Benutzer erstellt wird.
   *
   * @param      userSecurityName - Der Name des Benutzers.
   * @return: Die eindeutige ID des Benutzers. Die eindeutige
   *          eines Benutzers ist eine Zeichenfolge, die sich
   *          aus eindeutigen, Registry-spezifischen Daten für
   *          die Darstellung des Benutzers zusammensetzt. Für
   *          die UNIX-Benutzerregistry kann die eindeutige ID
   *          für einen Benutzer beispielsweise die UID sein.
   * @exception: EntryNotFoundException auslösen, wenn der Benutzername
   *             nicht vorhanden ist.
   * @exception: CustomRegistryException bei Auftreten eines Registry-spezifischen
   *             Fehlers auslösen.
   **/
   public String getUniqueUserId(String userSecurityName)       
      throws CustomRegistryException,
             EntryNotFoundException {

      String s,uniqueUsrId = null;
      BufferedReader in = null;
      try  {    
         in = fileOpen(USERFILENAME);
         while ((s=in.readLine())!=null)
         {
            if (!(s.startsWith("#") || s.trim().length() <=0 )) {
               int index = s.indexOf(":");
               int index1 = s.indexOf(":", index+1);
               if ((s.substring(0,index)).equals(userSecurityName)) {
                  int index2 = s.indexOf(":", index1+1);
                  uniqueUsrId = s.substring(index1+1,index2);
                  break;
               }
            }
         }
      } catch (Exception ex) {
         throw new CustomRegistryException(ex.getMessage(),ex);
      } finally {
         fileClose(in);
      }

      if (uniqueUsrId == null) {
         EntryNotFoundException nsee = new EntryNotFoundException("Cannot obtain uniqueId for user: " + userSecurityName);
                  throw nsee;
      }

      return uniqueUsrId;
   }

  /**
   * Gibt den Namen eines Benutzers zurück, wenn dessen eindeutige ID angegeben wurde.
   *
   * @param      uniqueUserId  Die eindeutige ID des Benutzers.
   * @return     Den userSecurityName des Benutzers.
   * @exception: EntryNotFoundException auslösen, wenn keine eindeutige Benutzer-ID vorhanden ist.
   * @exception:  CustomRegistryException bei Auftreten eines Registry-spezifischen
   *               Fehlers
   **/
   public String getUserSecurityName(String uniqueUserId)
      throws CustomRegistryException,
             EntryNotFoundException {
      String s,usrSecName = null;
      BufferedReader in = null;
      try  {    
         in = fileOpen(USERFILENAME);
         while ((s=in.readLine())!=null)
         {
            if (!(s.startsWith("#") || s.trim().length() <=0 )) {
               int index = s.indexOf(":");
               int index1 = s.indexOf(":", index+1);
               int index2 = s.indexOf(":", index1+1);
               if ((s.substring(index1+1,index2)).equals(uniqueUserId)) {
                  usrSecName = s.substring(0,index);
                  break;
               }
            }
         }
      } catch (Exception ex) {
         throw new CustomRegistryException(ex.getMessage(), ex);
      } finally {
         fileClose(in);
      }

      if (usrSecName == null) {
         EntryNotFoundException ex = 
            new EntryNotFoundException("Cannot obtain the user securityName for " + uniqueUserId);
                  throw ex;
      }

      return usrSecName;

   }

  /**
   * Ermittelt, ob der userSecurityName in der Registry vorhanden ist.
   *
   * @param      userSecurityName - Der Name des Benutzers.
   * @return    True, wenn der Benutzer gültig ist, andernfalls false.
   * @exception: CustomRegistryException bei Auftreten eines Registry-spezifischen
   *             Fehlers auslösen.
   * @exception RemoteException bei Erweiterung der Schnittstelle java.rmi.Remote
   **/
   public boolean isValidUser(String userSecurityName)
      throws CustomRegistryException {
      String s;
      boolean isValid = false;
      BufferedReader in = null;
      try  {    
         in = fileOpen(USERFILENAME);
         while ((s=in.readLine())!=null)
         {
            if (!(s.startsWith("#") || s.trim().length() <=0 )) {
               int index = s.indexOf(":");
               if ((s.substring(0,index)).equals(userSecurityName)) {
                  isValid=true;
                  break;
               }
            }
         }
      } catch (Exception ex) {
         throw new CustomRegistryException(ex.getMessage(), ex);
      } finally {
         fileClose(in);
      }

      return isValid;
   }


  /**
   * Ruft eine Liste der Gruppen ab, die einem Muster in der Registry entsprechen.
   * Die maximale Anzahl zurückgegebener Gruppen wird mit dem Argument limit
   * definiert. Diese Methode wird von der Administrationskonsole und Scripts
   * (Befehlszeile) aufgerufen, um die Gruppen in der Registry so vorzubereiten,
   * dass sie (die Gruppen) Rollen zugeordnet werden können.
   *
   * @param pattern  Das Muster, mit dem eine Übereinstimmung erzielt werden
   *                 muss. (Beispiel: Mit a* werden alle groupSecurityNames
   *                 gesucht, die mit a beginnen.)
   * @param limit:   Die Maximalanzahl der Gruppen, die zurückgegeben werden sollen.
   *                 Die Verwendung dieses Parameters empfiehlt sich, wenn Tausende
   *                 von Gruppen in der Registry vorhanden sind und das Abrufen aller
   *                 Gruppen nicht sinnvoll ist. Der Standardwert ist 100.
   *                 Der Wert 0 bedeutet, dass alle Gruppen abgerufen werden sollen,
   *                 und muss daher mit Vorsicht verwendet werden.
   * @return         Ein Result-Objekt, das die Liste der angeforderten Gruppen und
   *                 ein Flag enthält, das anzeigt, ob weitere Gruppen vorhanden sind.
   * @exception:  CustomRegistryException bei Auftreten eines Registry-spezifischen
   *               Fehlers
   **/
   public Result getGroups(String pattern, int limit)
      throws CustomRegistryException {
      String s;
      BufferedReader in = null;
      List allGroups = new ArrayList();
      Result result = new Result();
      int count = 0;
      int newLimit = limit+1;
      try  {    
         in = fileOpen(GROUPFILENAME);
         while ((s=in.readLine())!=null)
         {
            if (!(s.startsWith("#") || s.trim().length() <=0 )) {
               int index = s.indexOf(":");
               String group = s.substring(0,index);
               if (match(group,pattern)) {
                  allGroups.add(group);
                  if (limit !=0 && ++count == newLimit) {
                     allGroups.remove(group);
                     result.setHasMore();
                     break;
                  }
               }
            }
         }
      } catch (Exception ex) {
         throw new CustomRegistryException(ex.getMessage(),ex);
      } finally {
         fileClose(in);
      }
  
      result.setList(allGroups);
      return result;
   }

  /**
   * Gibt den Anzeigenamen für die durch den Gruppennamen angegebene Gruppe zurück.
   * In dieser Version von WebSphere Application Server wird diese Methode von den
   * Clients (Administrationskonsole und Scripting) nur verwendet, um einen
   * beschreibenden Namen für den Benutzer anzuzeigen, sofern ein solcher vorhanden ist.
   *
   * @param     groupSecurityName - Der Name der Gruppe.
   * @return: Der Anzeigename für die Gruppe. Der Anzeigename ist eine
   *            Registry-spezifische Zeichenfolge, die einen beschreibenden,
   *            nicht unbedingt eindeutigen Namen für eine Gruppe angibt.
      *            Ist kein Anzeigename vorhanden, wird null oder eine leere
   *            Zeichenfolge zurückgegeben.
   * @exception:  EntryNotFoundException auslösen, wenn der Gruppenname
   *              nicht vorhanden ist.
   * @exception: CustomRegistryException bei Auftreten eines Registry-spezifischen
   *             Fehlers
   **/
   public String getGroupDisplayName(String groupSecurityName)
      throws CustomRegistryException,
             EntryNotFoundException {
      String s,displayName = null;
      BufferedReader in = null;

      if(!isValidGroup(groupSecurityName)) {
         EntryNotFoundException nsee = new EntryNotFoundException("group: " + groupSecurityName + " is not valid");
                  throw nsee;
      }
      
      try  {    
         in = fileOpen(GROUPFILENAME);
         while ((s=in.readLine())!=null)
         {
            if (!(s.startsWith("#") || s.trim().length() <=0 )) {
               int index = s.indexOf(":");
               int index1 = s.lastIndexOf(":");
               if ((s.substring(0,index)).equals(groupSecurityName)) {
                  displayName = s.substring(index1+1);
                  break;
               }
            }
         }
      } catch (Exception ex) {
         throw new CustomRegistryException(ex.getMessage(),ex);
      } finally {
         fileClose(in);
      }
   
      return displayName;
   }

  /**
   * Gibt die eindeutige ID für eine Gruppe zurück.

   * @param     groupSecurityName - Der Name der Gruppe.
   * @return    Die eindeutige ID der Gruppe. Die eindeutige ID für eine Gruppe ist
   *            eine Zeichenfolge, die sich aus eindeutigen, Registry-spezifischen
   *            Daten zur Angabe der Gruppe zusammensetzt. Für die
   *            UNIX-Benutzerregistry kann die eindeutige ID beispielsweise
   *            die GID sein.
   * @exception:  EntryNotFoundException auslösen, wenn der Gruppenname
   *              nicht vorhanden ist.
   * @exception: CustomRegistryException bei Auftreten eines Registry-spezifischen
   *             Fehlers auslösen.
   * @exception RemoteException bei Erweiterung von java.rmi.Remote
   **/
   public String getUniqueGroupId(String groupSecurityName)
      throws CustomRegistryException,
             EntryNotFoundException {
      String s,uniqueGrpId = null;
      BufferedReader in = null;
      try  {    
         in = fileOpen(GROUPFILENAME);
         while ((s=in.readLine())!=null)
         {
            if (!(s.startsWith("#") || s.trim().length() <=0 )) {
               int index = s.indexOf(":");
               int index1 = s.indexOf(":", index+1);
               if ((s.substring(0,index)).equals(groupSecurityName)) {
                  uniqueGrpId = s.substring(index+1,index1);
                  break;
               }
            }
         }
      } catch (Exception ex) {
         throw new CustomRegistryException(ex.getMessage(),ex);
      } finally {
         fileClose(in);
      }

      if (uniqueGrpId == null) {
         EntryNotFoundException nsee = new EntryNotFoundException("Cannot obtain the uniqueId for group: " + groupSecurityName);
                  throw nsee;
      }
      
      return uniqueGrpId;
   }

  /**
   * Gibt die eindeutigen IDs aller Gruppen zurück, die die eindeutige ID eines
   * Benutzers enthalten. Wird bei der Erstellung einer Benutzerberechtigung aufgerufen.
   *
   * @param      uniqueUserId  Die eindeutige ID des Benutzers.
   * @return     Eine Liste alle eindeutigen Gruppen-IDs, zu denen die eindeutige
   *             Benutzer-ID gehört. Die eindeutige ID eines Eintrags ist
   *             eine Zeichenfolge, die sich aus eindeutigen, Registry-spezifischen
   *             Daten für die Darstellung des Eintrags zusammensetzt. Für
   *             die UNIX-Benutzerregistry kann die eindeutige ID
   *            für eine Gruppe beispielsweise die GID und die eindeutige ID
   *            für den Benutzer die UID sein.
      * @exception EntryNotFoundException, wenn die eindeutige Benutzer-ID nicht vorhanden ist.
   * @exception:  CustomRegistryException bei Auftreten eines Registry-spezifischen
   *               Fehlers
   **/
   public List getUniqueGroupIds(String uniqueUserId)
      throws CustomRegistryException,
             EntryNotFoundException {
      String s,uniqueGrpId = null;
      BufferedReader in = null;
      List uniqueGrpIds=new ArrayList();
      try  {    
         in = fileOpen(USERFILENAME);
         while ((s=in.readLine())!=null)
         {
            if (!(s.startsWith("#") || s.trim().length() <=0 )) {
               int index = s.indexOf(":");
               int index1 = s.indexOf(":", index+1);
               int index2 = s.indexOf(":", index1+1);
               if ((s.substring(index1+1,index2)).equals(uniqueUserId)) {
                  int lastIndex = s.lastIndexOf(":");
                  String subs = s.substring(index2+1,lastIndex);
                  StringTokenizer st1 = new StringTokenizer(subs, ",");
                  while (st1.hasMoreTokens()) 
                     uniqueGrpIds.add(st1.nextToken());
                  break;
               }
            }
         }
      } catch (Exception ex) {
         throw new CustomRegistryException(ex.getMessage(),ex);
      } finally {
         fileClose(in);
      }

      return uniqueGrpIds;
   }

  /**
   * Gibt den Namen einer Gruppe zurück, wenn deren eindeutige ID angegeben wurde.
   *
   * @param     uniqueGroupId Die eindeutige ID der Gruppe.
   * @return:   Der Name der Gruppe.
   * @exception:  EntryNotFoundException, wenn die eindeutige Gruppen-ID nicht vorhanden ist.
   * @exception: CustomRegistryException bei Auftreten eines Registry-spezifischen
   *             Fehlers auslösen.
   **/
   public String getGroupSecurityName(String uniqueGroupId)
      throws CustomRegistryException,
             EntryNotFoundException {
      String s,grpSecName = null;
      BufferedReader in = null;
      try  {    
         in = fileOpen(GROUPFILENAME);
         while ((s=in.readLine())!=null)
         {
            if (!(s.startsWith("#") || s.trim().length() <=0 )) {
               int index = s.indexOf(":");
               int index1 = s.indexOf(":", index+1);
               if ((s.substring(index+1,index1)).equals(uniqueGroupId)) {
                  grpSecName = s.substring(0,index);
                  break;
               }
            }
         }
      } catch (Exception ex) {
         throw new CustomRegistryException(ex.getMessage(),ex);
      } finally {
         fileClose(in);
      }

      if (grpSecName == null) {
         EntryNotFoundException ex = 
            new EntryNotFoundException("Cannot obtain the group security name for: " + uniqueGroupId);
                  throw ex;
      }

      return grpSecName;

   }

  /**
   * Ermittelt, ob der Gruppenname in der Registry vorhanden ist.
   *
   * @param       groupSecurityName - Der Name der Gruppe.
   * @return      True, wenn die Gruppe vorhanden ist, andernfalls false.
   * @exception: CustomRegistryException bei Auftreten eines Registry-spezifischen
   *             Fehlers auslösen.
   **/
   public boolean isValidGroup(String groupSecurityName)
      throws CustomRegistryException {
      String s;
      boolean isValid = false;
      BufferedReader in = null;
      try  {    
         in = fileOpen(GROUPFILENAME);
         while ((s=in.readLine())!=null)
         {
            if (!(s.startsWith("#") || s.trim().length() <=0 )) {
               int index = s.indexOf(":");
               if ((s.substring(0,index)).equals(groupSecurityName)) {
                  isValid=true;
                  break;
               }
            }
         }
      } catch (Exception ex) {
         throw new CustomRegistryException(ex.getMessage(),ex);
      } finally {
         fileClose(in);
      }

      return isValid;
   }

  /**
   * Gibt die securityNames aller Gruppen zurück, die den Benutzer enthalten.
   *
   * Diese Methode wird von der Administrationskonsole und Scripts (Befehlszeile)
   * aufgerufen, um sicherzustellen, dass der Benutzer, der für die
   * RunAsRole-Zuordnung eingegeben wurde, zur angegebenen Rolle
   * gehört. Am Anfang wird die Prüfung durchgeführt, um festzustellen,
   * ob die Rolle den Benutzer enthält. Wenn die Rolle
   * den Benutzer nicht explizit enthält, wird diese Methode aufgerufen,
   * um die Gruppen, zu denen dieser Benutzer gehört, abzurufen. Auf diese
   * Weise können die Gruppen geprüft werden, die die Rolle enthält.
   *
   * @param      userSecurityName - Der Name des Benutzers.
   * @return     Eine Liste aller Gruppen-securityNames, zu denen der Benutzer
   *             gehört.
      * @exception: EntryNotFoundException auslösen, wenn der Benutzer nicht vorhanden ist.
   * @exception: CustomRegistryException bei Auftreten eines Registry-spezifischen
   *             Fehlers auslösen.
      * @exception: RemoteException bei Erweiterung von java.rmi.Remote auslösen.
   **/
   public List getGroupsForUser(String userName)
      throws CustomRegistryException,
             EntryNotFoundException {
      String s;
      List grpsForUser = new ArrayList();
      BufferedReader in = null;
      try  {    
         in = fileOpen(GROUPFILENAME);
         while ((s=in.readLine())!=null)
         {
            if (!(s.startsWith("#") || s.trim().length() <=0 )) {
               StringTokenizer st = new StringTokenizer(s, ":");
               for (int i=0; i<2; i++)
                  st.nextToken();
               String subs = st.nextToken();
               StringTokenizer st1 = new StringTokenizer(subs, ",");
               while (st1.hasMoreTokens()) {
                  if((st1.nextToken()).equals(userName)) {
                     int index = s.indexOf(":");
                     grpsForUser.add(s.substring(0,index));
                  }
               }
            }
         }
      } catch (Exception ex) {
         if (!isValidUser(userName)) {
            throw new EntryNotFoundException("user: " + userName  + " is not valid");
                  }
         throw new CustomRegistryException(ex.getMessage(),ex);
      } finally {
         fileClose(in);
      }

      return grpsForUser;
   }

  /**
   * Ruft eine Liste der Benutzer in einer Gruppe ab.
   *
   * Die maximale Anzahl zurückgegebener Benutzer wird mit dem Argument limit
   * definiert.
   *
   * Diese Methode wird von WebSphere Application Server
   * Enterprise Process Choreographer (Enterprise) verwendet,
   * wenn Personalzuordnungen mit Gruppen modelliert werden.
   *
   * Wenn Sie in seltenen Fällen mit einer Registry arbeiten, bei der sich das
   * Abrufen aller Benutzer aus einer Ihrer Gruppen nicht empfiehlt (z. B.
   * bei einer großen Anzahl von Benutzern), können Sie die Ausnahme
   * NotImplementedException für diese bestimmte Gruppe auslösen. Stellen
   * Sie sicher, dass die Staff-Zuordnungen nicht mit diesen Gruppen modelliert
   * werden, wenn Process Choreographer installiert ist (oder später installiert
   * wird).    Sollten keine Bedenken hinsichtlich der Rückgabe der Benutzer aus
   * Gruppen in der Registry bestehen, wird empfohlen, diese Methode zu
   * implementieren, ohne die Ausnahme NotImplemented auzulösen.
   * @param       groupSecurityName - Der Name der Gruppe.
   * @param Limits    Die Maximalanzahl der zurückzugebenden Benutzer.
   *                  Die Verwendung dieses Parameters empfiehlt sich,
   *                  wenn sehr viele Benutzer in der Registry vorhanden
   *                  sind und das Abrufen aller Benutzer nicht sinnvoll ist.
   *                  Der Wert 0 bedeutet, dass alle Benutzer abgerufen werden
   *                  sollen, und muss daher mit Vorsicht verwendet werden.
      * @return:         Ein Result-Objekt, das die Liste der angeforderten Benutzer
   *                  enthält. Ein Flag zeigt an, ob weitere Benutzer vorhanden sind.
   * @deprecated:  Diese Methode wird in Zukunft nicht mehr unterstützt.
   * @exception:   NotImplementedException. Diese Ausnahme nur auslösen,
   *               wenn es sich nicht empfiehlt, die Informationen für
   *               eine dieser Gruppen aus der Registry abzurufen.
   * @exception:   EntryNotFoundException auslösen, wenn die Gruppe nicht in der Registry
   *               vorhanden ist.
   * @exception:  CustomRegistryException bei Auftreten eines Registry-spezifischen
   *               Fehlers
   **/
   public Result getUsersForGroup(String groupSecurityName, int limit)
      throws NotImplementedException,
             EntryNotFoundException,
             CustomRegistryException {
      String s, user;
      BufferedReader in = null;
      List usrsForGroup = new ArrayList();
      int count = 0;
      int newLimit = limit+1;
      Result result = new Result();

      try  {    
         in = fileOpen(GROUPFILENAME);
         while ((s=in.readLine())!=null)
         {
            if (!(s.startsWith("#") || s.trim().length() <=0 )) {
               int index = s.indexOf(":");
               if ((s.substring(0,index)).equals(groupSecurityName))
               {
                  StringTokenizer st = new StringTokenizer(s, ":");
                  for (int i=0; i<2; i++)
                     st.nextToken();
                  String subs = st.nextToken();
                  StringTokenizer st1 = new StringTokenizer(subs, ",");
                  while (st1.hasMoreTokens()) {
                     user = st1.nextToken();
                     usrsForGroup.add(user);
                     if (limit !=0 && ++count == newLimit) {
                        usrsForGroup.remove(user);
                        result.setHasMore();
                        break;
                     }
                  }
               }
            }
         }
      } catch (Exception ex) {
         if (!isValidGroup(groupSecurityName)) {
            throw new EntryNotFoundException("group: " + groupSecurityName + " is not valid");
                  }
         throw new CustomRegistryException(ex.getMessage(),ex);
      } finally {
         fileClose(in);
      }

      result.setList(usrsForGroup);
      return result;
   }

  /**
   * Diese Methoe wird in diesem Release intern vom Code von WebSphere Application Server
   * implementiert. Diese Methode wird in diesem Release für
   * angepasste Registry-Implementierungen nicht aufgerufen.
   * In der Implementierung einen Nullwert zurückgeben.
   *
   **/
   public com.ibm.websphere.security.cred.WSCredential 
         createCredential(String userSecurityName)
         throws CustomRegistryException,
                NotImplementedException,
                EntryNotFoundException {

      // Diese Methode wird nicht aufgerufen.
      return null;
   }

   // private Methoden
   private BufferedReader fileOpen(String fileName)
      throws FileNotFoundException {
      try  {    
         return new BufferedReader(new FileReader(fileName));
      } catch(FileNotFoundException e) {
         throw e;
      }
   }

   private void fileClose(BufferedReader in) {
      try  {    
         if (in != null) in.close();
      } catch (Exception e)  {
         System.out.println("Error closing file" + e);
      }
   }

   private boolean match(String name, String pattern) {
      RegExpSample regexp = new RegExpSample(pattern);
      boolean matches = false;
      if(regexp.match(name))
          matches = true;
      return matches;
   }
}


//----------------------------------------------------------------------
// Das Programm stellt die Implementierung regulärer Ausdrücke, die im
// Beispiel für die angepasste Benutzerregistry (FileRegistrySample)
// verwendet wird, bereit. Das Programm wird verwendet, um Übereinstimmungen
// mit dem Muster (für Benutzer und Gruppen) zu suchen.
//----------------------------------------------------------------------

class RegExpSample
{

    private boolean match(String s, int i, int j, int k)
    {
        for(; k < expr.length; k++)
label0:
            {
                Object obj = expr[k];
                if(obj == STAR)
                {
                    if(++k >= expr.length)
                        return true;
                    if(expr[k] instanceof String)
                    {
                        String s1 = (String)expr[k++];
                        int l = s1.length();
                        for(; (i = s.indexOf(s1, i)) >= 0; i++)
                            if(match(s, i + l, j, k))
                                return true;

                        return false;
                    }
                    for(; i < j; i++)
                        if(match(s, i, j, k))
                            return true;

                    return false;
                }
                if(obj == ANY)
                {
                    if(++i > j)
                        return false;
                    break label0;
                }
                if(obj instanceof char[][])
                {
                    if(i >= j)
                        return false;
                    char c = s.charAt(i++);
                    char ac[][] = (char[][])obj;
                    if(ac[0] == NOT)
                    {
                        for(int j1 = 1; j1 < ac.length; j1++)
                            if(ac[j1][0] <= c && c <= ac[j1][1])
                                return false;

                        break label0;
                    }
                    for(int k1 = 0; k1 < ac.length; k1++)
                        if(ac[k1][0] <= c && c <= ac[k1][1])
                            break label0;

                    return false;
                }
                if(obj instanceof String)
                {
                    String s2 = (String)obj;
                    int i1 = s2.length();
                    if(!s.regionMatches(i, s2, 0, i1))
                        return false;
                    i += i1;
                }
            }

        return i == j;
    }

    public boolean match(String s)
    {
        return match(s, 0, s.length(), 0);
    }

    public boolean match(String s, int i, int j)
    {
        return match(s, i, j, 0);
    }

    public RegExpSample(String s)
    {
        Vector vector = new Vector();
        int i = s.length();
        StringBuffer stringbuffer = null;
        Object obj = null;
        for(int j = 0; j < i; j++)
        {
            char c = s.charAt(j);
            switch(c)
            {
            case 63: /* '?' */
                obj = ANY;
                break;

            case 42: /* '*' */
                obj = STAR;
                break;

            case 91: /* '[' */
                int k = ++j;
                Vector vector1 = new Vector();
                for(; j < i; j++)
                {
                    c = s.charAt(j);
                    if(j == k && c == '^')
                    {
                        vector1.addElement(NOT);
                        continue;
                    }
                    if(c == '\\')
                    {
                        if(j + 1 < i)
                            c = s.charAt(++j);
                    }
                    else 
                    if(c == ']')
                        break;
                    char c1 = c;
                    if(j + 2 < i && s.charAt(j + 1) == '-')
                        c1 = s.charAt(j += 2);
                    char ac1[] = {
                        c, c1
                    };
                    vector1.addElement(ac1);
                }

                char ac[][] = new char[vector1.size()][];
                vector1.copyInto(ac);
                obj = ac;
                break;

            case 92: /* '\\' */
                if(j + 1 < i)
                    c = s.charAt(++j);
                break;

            }
            if(obj != null)
            {
                if(stringbuffer != null)
                {
                    vector.addElement(stringbuffer.toString());
                    stringbuffer = null;
                }
                vector.addElement(obj);
                obj = null;
            }
            else 
            {
                if(stringbuffer == null)
                    stringbuffer = new StringBuffer();
                stringbuffer.append(c);
            }
        }

        if(stringbuffer != null)
            vector.addElement(stringbuffer.toString());
        expr = new Object[vector.size()];
        vector.copyInto(expr);
    }

    static final char NOT[] = new char[2];
    static final Integer ANY = new Integer(0);
    static final Integer STAR = new Integer(1);
    Object expr[];

}

Symbol, das den Typ des Artikels anzeigt. Referenzartikel



Symbol für Zeitmarke Letzte Aktualisierung: 25.05.2016
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=rsec_frsjf502
Dateiname:rsec_frsjf502.html