Fichier FileRegistrySample.java

Cet article propose un exemple de fichier FileRegistrySample.java.

Les informations sur les utilisateurs et groupes nécessaires à cet exemple figurent dans les fichiers Fichier users.props et Fichier groups.props.

Avertissement : Les exemples fournis visent à vous familiariser avec cette fonction. Ne les utilisez pas dans un environnement de production réel.
Le contenu du fichier FileRegistrySample.java est le suivant :
//
//  5639-D57, 5630-A36, 5630-A37, 5724-D18 
// (C) COPYRIGHT International Business Machines Corp. 1997, 2005
//  All Rights Reserved *  Eléments sous licence - Propriété d'IBM
//

//----------------------------------------------------------------------
// Ce programme peut être utilisé, exécuté, copié, modifié et distribué 
// sans paiement d'une redevance aux fins de développement, d'utilisation, 
// de marketing ou de distribution.
//----------------------------------------------------------------------
// 

// Cet exemple concerne la fonction custom user registry (registre d'utilisateurs personnalisé) de WebSphere
Application Server.

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

/**
 *  Le but premier de cet exemple est de montrer l'utilisation de la fonction
 *  registre d'utilisateurs personnalisé, disponible dans WebSphere
Application Server. Cet 
 *  exemple est un registre à base de fichiers dans lequel les informations  
 *  sur les utilisateurs et les groupes sont stockées dans des fichiers (users.props et groups.props). Ainsi, 
 *  la simplicité, et non les performances, a été privilégiée. Cet 
 *  exemple ne doit donc servir qu'à se familiariser avec cette fonction. Une 
 *  implémentation réelle d'un registre doit tenir compte de divers facteurs 
 *  tels que les performances, l'évolutivité, la sécurité des unités d'exécution, etc.
 **/
public class FileRegistrySample implements UserRegistry {

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

   /** Constructeur par défaut **/
   public FileRegistrySample() throws java.rmi.RemoteException {
   }

  /**
   * Initialise le registre. Cette méthode est appelée lors de la création
   * du registre.
   *
   * @param     props - propriétés propres au registre avec lesquelles
   *                le registre personnalisé doit être initialisé
   * @exception CustomRegistryException
   *                    s'il y a une erreur liée au registre
   **/
  public void initialize(java.util.Properties props)
         throws CustomRegistryException {
      try {
    
         /* Essai d'extraction de USERFILENAME et GROUPFILENAME des 
          * propriétés transmises (par exemple, à partir de 
          * la console d'administration). Définissez ces valeurs dans 
          * la console d'administration. Allez dans la partie Paramètres 
          * personnalisés spéciaux de la section Registre d'utilisateurs
          * personnalisé de l'écran Authentification. Par exemple : 
          * 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("Informations sur les utilisateurs/groupes manquantes");
      }

   }

  /**
   * Vérifie le mot de passe de l'utilisateur. Cette méthode est appelée pour authentifier
   * un utilisateur lorsque le nom et le mot de passe sont indiqués.
   *
   * @param     userSecurityName : nom de l'utilisateur
   * @param     password : mot de passe de l'utilisateur
   * @return une valeur userSecurityName valide. En général, il s'agit
   *         du nom du même utilisateur dont le mot de passe a été vérifié, 
   *         mais si l'implémentation veut renvoyer une autre valeur
   *         userSecurityName dans le registre, elle peut le faire
   * @exception CheckPasswordFailedException si la combinaison userSecurityName/
   *            password n'existe pas dans le 
   *            registre
   * @exception CustomRegistryException s'il y a une erreur liée
   *            au registre
   **/
   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);
               // vérifie si la combinaison userSecurityName:passwd existe
               si ((s.substring(0,index)).equals(userSecurityName) && 
                       s.substring(index+1,index1).equals(passwd)) {
                  // Authentification réussie ; renvoi de l'ID utilisateur.
                  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;
   }

  /**
   * Mappe un certificat .au format X509 avec un utilisateur valide du registre.
   * Permet de mapper le nom figurant dans le certificat fourni par un navigateur
   * vers une valeur userSecurityName du registre
   *
   * @param     cert : chaîne de certificat X509
   * @return    nom mappé de l'utilisateur userSecurityName
   * @exception CertificateMapNotSupportedException : si ce certificat 
   *            particulier n'est pas supporté.
   * @exception CertificateMapFailedException : si le mappage du 
   *            certificat échoue.
   * @exception CustomRegistryException en cas d'erreur
   *            liée au registre
   **/
   public String mapCertificate(X509Certificate[]cert)
      throws CertificateMapNotSupportedException,
             CertificateMapFailedException,
             CustomRegistryException {
      String name=null;
      X509Certificate cert1 = cert[0];
      try {
         // Mapper le SubjectDN du certificat avec un userID.
         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;
   }

  /**
   * Renvoie le domaine de sécurité du registre.
   *
   * @return    le domaine. Le domaine est une chaîne propre au registre 
   * qui indique le domaine auquel ce registre 
   *            Par exemple, Par exemple, pour OS/400 ou AIX, il s'agit du 
   * nom d'hôte du système dont le registre utilisateur est 
   * représenté par cet objet. Si une valeur indéfinie est renvoyée
   * par cette méthode, le domaine prend par défaut la valeur "customRealm". Il est 
   * Il est préférable d'utiliser la valeur que vous avez définie pour le domaine.
   * 
   * @exception CustomRegistryException s'il y a une erreur liée
   *            au registre
   **/
   public String getRealm()
      throws CustomRegistryException {
      String name = "customRealm";
      return name;
   }

  /**
   * Renvoie la liste d'utilisateurs qui correspond à une valeur pattern du registre.
   * Le nombre maximal d'utilisateurs renvoyés est défini par l'argument
   * l'argument.
   * Cette méthode est appelée par la console d'administration et les scripts 
   * (ligne de commande) pour rendre les utilisateurs du registre accessibles 
   * et les ajouter aux rôles.
   *
   * @param      pattern : chaîne de recherche. (Par ex., a* sélectionne les 
   *             userSecurityNames commençant par la lettre a)
   * @param      limit : nombre maximal d'utilisateurs qui peuvent
   *            être renvoyés. Cette fonction est très utile lorsque 
   *             le registre contient beaucoup d'utilisateurs et qu'il 
   *             n'est pas pratique de les extraire tous en même temps. L'élément de 
   *             valeur par défaut est 100. La valeur O renvoie tous les
   *            utilisateurs et doit donc être utilisée avec précaution.
   * @return    un objet Result qui contient la liste des utilisateurs 
   *            demandée et un indicateur qui montre s'il existe davantage
   *            n'existe pas.
   * @exception CustomRegistryException s'il y a une erreur liée
   *            au registre
   **/
   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;
   }

  /**
   * Renvoie le nom affiché de l'utilisateur spécifié par 
   *  userSecurityName.
   *
   * Cette méthode peut être appelée uniquement lorsque les informations
   * utilisateur sont affichées (but informatif uniquement, par exemple, 
   * dans la console d'administration) et donc qu'elles ne sont pas 
   * utilisées pour l'authentification ou les droits d'accès. Si le registre 
   * ne contient aucun nom affiché, une chaîne nulle ou vide est renvoyée.
   *
   * Dans le registre personnalisé de WebSphere
Application Server 4.x, 
   * si vous aviez un nom d'utilisateur affiché différent du nom de sécurité, 
   * le nom affiché était renvoyé pour les méthodes d'EJB 
   * getCallerPrincipal() et les méthodes de servlet
   * getRemoteUser().
   * Dans les versions 5.x et ultérieures, pour les 
   * mêmes méthodes, le nom de sécurité est renvoyé par défaut. 
   * Ce procédé est conseillé car le nom affiché n'est pas unique 
   * et peut engendrer des défauts de sécurité. Mais, pour la 
   * compatibilité amont, si vous voulez que le nom affiché soit renvoyé, 
   * attribuez la valeur true à la propriété WAS_UseDisplayName.
   *
   * Pour plus d'informations, reportez-vous au centre de documentation.
   *
   * @param userSecurityName : nom de l'utilisateur.
   * @return    nom affiché de l'utilisateur. Le nom affiché 
   *            est une chaîne propre au registre qui représente 
   *            un nom descriptif, pas nécessairement unique, 
   *            d'un utilisateur. S'il n'existe aucun nom 
   *            affiché, une chaîne nulle ou vide est renvoyée.
   * @exception EntryNotFoundException si la combinaison userSecurityName 
   *            n'existe pas.
   * @exception CustomRegistryException s'il y a une erreur liée 
    *            au registre
   **/
   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;
   }

  /**
   * Renvoie l'ID unique associé à un userSecurityName. Cette méthode est appelée pour 
   * créer l'identificateur unique d'un utilisateur.
   *
   * @param    userSecurityName - nom de l'utilisateur.
   * @return   ID unique de l'utilisateur. Il se présente sous forme 
   *            de chaîne de données uniques propres au registre et servant à 
   *            à représenter l'utilisateur. Par exemple, pour le registre 
   *            d'utilisateurs UNIX l'ID unique d'un utilisateur peut être 
   *					        son UID.
   * @exception EntryNotFoundException si userSecurityName 
   *            n'existe pas.
   * @exception CustomRegistryException s'il y a une erreur liée
   *            au registre
   **/
   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;
   }

  /**
   * Renvoie le nom d'un utilisateur à partir de son ID unique.
   *
   * @param      uniqueUserId  - ID unique de l'utilisateur.
   * @return :  nom userSecurityName de l'utilisateur.
   * @exception EntryNotFoundException si l'ID unique d'utilisateur n'existe pas.
   * @exception CustomRegistryException s'il y a une erreur liée
   * au registre
   **/
   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;

   }

  /**
   * Détermine si le userSecurityName existe dans le registre
   *
   * @param     userSecurityName - nom de l'utilisateur
   * @return    True si l'utilisateur est valide ; sinon, false
   * @exception CustomRegistryException s'il y a une erreur liée
   *            au registre
   * @exception RemoteException lorsque cela étend java.rmi.Remote 
   *            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;
   }


  /**
   * Renvoie la liste des groupes qui correspond à une valeur pattern du registre.
   * Le nombre maximal de groupes renvoyés est défini par 
   * l'argument limit. Cette méthode est appelée par la console d'administration
   * et les scripts (ligne de commande) pour rendre les groupes du registre  
   * accessibles et les ajouter aux rôles.
   *
   * @param      pattern : chaîne de recherche. (Par ex., a* sélectionne les 
   *              groupSecurityNames commençant par la lettre a)
   * @param       limit : nombre maximal de groupes à renvoyer. 
   *              Cette fonction est très utile lorsque le registre 
   *            contient des milliers de groupes et qu'il n'est pas pratique de 
   *            les obtenir tous en même temps. La valeur par défaut est égale à 100. 
   *            La valeur O renvoie tous les groupes et 
   *            doit donc être utilisée avec précaution.
   * @return    un objet Result qui contient la liste des groupes 
   *            demandée et un indicateur montrant s'il existe davantage de groupes.
   * @exception CustomRegistryException s'il y a une erreur liée
   * au registre
   **/
   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;
   }

  /**
   * Renvoie le nom affiché du groupe spécifié par groupSecurityName.
   * Pour cette version de WebSphere
Application Server, cette méthode est  
   * uniquement utilisée par les clients (console d'administration et scripts)   
   * pour présenter le nom descriptif de l'utilisateur, s'il existe.
   *
   * @param     groupSecurityName : nom du groupe.
   * @return nom affiché du groupe. Le nom affiché est une
   *            chaîne propre au registre qui représente un nom  
   *          descriptif, pas nécessairement unique, d'un groupe.  
   *          Si aucun nom ne s'affiche, une chaîne nulle ou vide 
   *          est renvoyée.
   * @exception EntryNotFoundException si groupSecurityName 
   *            n'existe pas.
   * @exception CustomRegistryException s'il y a une erreur liée
   *            au registre
   **/
   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;
   }

  /**
   * Renvoie l'ID unique d'un groupe.

   * @param     groupSecurityName : nom du groupe.
   * @return    ID unique du groupe. Il se présente
   * sous forme de chaîne de données uniques propres au registre
   *            et servant à représenter le
   *            groupe. Par exemple, pour le registre d'utilisateurs UNIX,
   *             l'ID unique peut être le GID.
   * @exception EntryNotFoundException si groupSecurityName 
   *            n'existe pas.
   * @exception CustomRegistryException s'il y a une erreur liée
   *            au registre
   * @exception RemoteException lorsque cela étend 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;
   }

  /**
   * Renvoie les ID uniques de tous les groupes qui contiennent l'ID unique d'un 
   * utilisateur. Cette méthode est appelée lors de la création de l'identificateur unique d'un utilisateur.
   *
   * @param      uniqueUserId : ID unique de l'utilisateur.
   * @return    liste de tous les ID uniques de groupe à laquelle appartient 
   *            l'ID unique. L'ID unique d'une entrée est la représentation 
   *            de chaîne de données uniques propres au registre et servant 
   *            à représenter l'utilisateur.  Par exemple, pour le registre d'utilisateurs
   *            UNIX l'ID unique d'un groupe peut être le 
   *            GID et l'ID unique de l'utilisateur peut être l'UID.
   * @exception EntryNotFoundException : si uniqueUserId n'existe pas.
   * @exception CustomRegistryException s'il y a une erreur liée
   * au registre
   **/
   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;
   }

  /**
   * Renvoie le nom d'un groupe à partir de son ID unique.
   *
   * @param     uniqueGroupId :  ID unique du groupe.
   * @return    nom du groupe.
   * @exception EntryNotFoundException si uniqueGroupId 
   *            n'existe pas.
   * @exception CustomRegistryException s'il y a une erreur liée
   *            au registre
   **/
   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;

   }

  /**
   * Détermine si le groupSecurityName existe dans le registre
   *
   * @param     groupSecurityName : nom du groupe
   * @return    True si le group existe ; sinon, false
   * @exception CustomRegistryException s'il y a une erreur liée
   *            au registre
   **/
   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;
   }

  /**
   * Renvoie les noms de sécurité de tous les groupes contenant l'utilisateur
   *
   * Cette méthode est appelée par la console d'administration et les scripts 
   * (ligne de commande) pour vérifier si l'utilisateur entré pour le mappage  
   * RunAsRole appartient à ce rôle parmi ceux adéquats. A l'origine, la 
   * vérification a lieu pour voir si le rôle contient l'utilisateur. Si tel 
   * n'est pas explicitement le cas, cette méthode est appelée pour extraire 
   * les groupes auxquels cet utilisateur appartient afin d'effectuer une 
   * vérification pour les groupes inclus dans le rôle.
   *
   * @param     userSecurityName : nom de l'utilisateur
   * @return    liste de tous les securityNames de groupe à laquelle
   * l'utilisateur.
   * @exception EntryNotFoundException si l'utilisateur n'existe pas.
   * @exception CustomRegistryException s'il y a une erreur liée
   *            au registre
   * @exception RemoteException car cela étend l'interface
   *            java.rmi.Remote 
   **/
   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;
   }

  /**
   * Renvoie la liste d'utilisateurs d'un groupe.  
   *
   * Le nombre maximal d'utilisateurs renvoyés est défini par 
   * l'argument limit.
   *
   * Cette méthode est utilisée par WebSphere
Application Server 
   * Enterprise Process Choreographer (Enterprise) lorsque 
   * les attributions d'équipe sont définies à l'aide de groupes.
   *
   * Très rarement, si vous utilisez un registre pour lequel il n'est  
   * pas pratique d'extraire tous les utilisateurs de chacun de vos groupes   
   * (par exemple, si les utilisateurs sont très nombreux), vous pouvez générer
   * l'exception NotImplementedException pour ce groupe. Assurez-vous que   
   * Process Choreographer est installé (ou en cas d'installation ultérieure), 
   * les attributions d'équipe ne sont pas définies à l'aide de ces groupes
   * particuliers. S'il n'est pas nécessaire de renvoyer des utilisateurs 
   * à partir de groupes du registre, il est recommandé que cette méthode
   * soit appliquée sans générer d'exception NotImplemented.
   * @param     groupSecurityName : nom du groupe
   * @param     Limite le nombre maximal d'utilisateurs qui peuvent 
   *            être renvoyés. Cette fonction est très utile lorsque le registre 
   *            contient des milliers de groupes et qu'il n'est pas pratique de  
   *            les extraire tous en même temps. La valeur O extrait tous les   
   *            utilisateurs et doit donc être utilisée avec précaution. 
   * @return    un objet Result qui contient la liste des utilisateurs
   * demandée et un indicateur qui montre s'il existe davantage d'utilisateurs.
   * @deprecated : cette méthode sera déconseillée par la suite.
   * @exception     NotImplementedException génère cette exception dans de rares cas 
   *                lorsqu'il n'est pas facile d'extraire ces informations   
   *                des groupes à partir du registre.
   * @exception EntryNotFoundException : si le groupe n'existe pas dans 
   * le registre
   * @exception CustomRegistryException s'il y a une erreur liée 
   * au registre
   **/
   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;
   }

  /**
   * Cette méthode est implémentée en interne par WebSphere
Application Server 
   * Server de cette version. Elle n'est pas appelée pour les implémentations 
   * du registre personnalisé de cette version. Renvoyez null dans 
   * l'implémentation.
   *
   **/
   public com.ibm.websphere.security.cred.WSCredential 
         createCredential(String userSecurityName)
         throws CustomRegistryException,
                NotImplementedException,
                EntryNotFoundException {

      // Cette méthode n'est pas appelée.
      return null;
   }

   // méthodes privées
   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;
   }
}


//----------------------------------------------------------------------
// Le programme fournit l'implémentation Regular Expression utilisé 
// dans l'exemple de registre d'utilisateurs personnalisé (FileRegistrySample). 
// La recherche de chaîne de l'exemple utilise ce programme pour rechercher 
// les chaînes (pour les utilisateurs et les groupes).
//----------------------------------------------------------------------

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[];

}

Icône indiquant le type de rubrique Rubrique de référence



Icône d'horodatage Dernière mise à jour: last_date
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=rsec_frsjf502
Nom du fichier : rsec_frsjf502.html