Archivo FileRegistrySample.java

Proporciona un ejemplo del archivo FileRegistrySample.java.

La información de usuario y de grupo necesaria para este ejemplo se incluye en los archivos Archivo users.props y Archivo groups.props.

Atención: Los ejemplos se han diseñado para que se familiarice con esta característica. No utilice estos ejemplos en un entorno de producción real.
El contenido del archivo FileRegistrySample.java es:
//
//  5639-D57, 5630-A36, 5630-A37, 5724-D18 
// (C) COPYRIGHT International Business Machines Corp. 1997, 2005
//  Todos los derechos reservados *  Material bajo licencia - Propiedad de IBM
//

//----------------------------------------------------------------------
// Este programa se puede utilizar, ejecutar, copiar, modificar y distribuir 
// sin derechos de copia para fines de desarrollo, uso, comercialización 
// o distribución.
//----------------------------------------------------------------------
// 

// Este ejemplo es para la característica Registro de usuarios personalizado en WebSphere Application Server.

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

/**
 *  El objetivo principal de este ejemplo es demostrar el uso de la característica
 *  Registro personalizado que está disponible en WebSphere Application Server. Este 
 *  ejemplo es un ejemplo de registro basado en archivos donde la información de usuarios y  
 *  grupos se lista en archivo (users.props y groups.props). De esta manera, es la simplicidad 
 *  y no el rendimiento el factor principal subyacente. Este 
 *  ejemplo se debe utilizar sólo para familiarizarse con esta característica. Una 
 *  implementación de un registro realista debe tener en cuenta varios factores como 
 * el rendimiento, la escalabilidad, la seguridad de hebras, etc.
 **/
public class FileRegistrySample implements UserRegistry {

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

   /** Constructor por omisión **/
   public FileRegistrySample() throws java.rmi.RemoteException {
   }

  /**
   * Inicializa el registro. Se llama a este método cuando se crea el
   * registro.
   *
   * @param     props - Las propiedades específicas del registro con las que
   *                    se inicializa el registro personalizado
   * @exception CustomRegistryException
   *                    si hay algún problema específico del registro
   **/
  public void initialize(java.util.Properties props)
         throws CustomRegistryException {
               try {
    
         /* intente obtener USERFILENAME y GROUPFILENAME de las 
          * propiedades que se pasan (por ejemplo, de la consola 
          * administrativa). Establezca estos valores en la consola 
          * administrativa. Vaya a los valores personalizados especiales de la 
          * sección del registro de usuarios personalizados del panel de
autenticación.
          * Por ejemplo: 
          * 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");
      }

   }

  /**
   * Comprueba la contraseña del usuario. Se llama a este método para autenticar a un
   * usuario cuando se proporciona el nombre y la contraseña del usuario.
   *
   * @param     userSecurityName el nombre del usuario
   * @param     password la contraseña del usuario
   * @return un userSecurityName válido. Normalmente es el
   *         nombre del mismo usuario cuya contraseña se ha comprobado 
   *         pero si la implementación desea devolver otro
   *         userSecurityName válido del registro, puede hacerlo
   * @exception CheckPasswordFailedException si la combinación de
   *            userSecurityName/password no existe en 
   *            el registro
   * @exception CustomRegistryException si hay algún problema específico
   *           del registro
   **/
   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);
               // comprobar si la combinación userSecurityName:passwd existe
               if ((s.substring(0,index)).equals(userSecurityName) && 
                       s.substring(index+1,index1).equals(passwd)) {
                  // Autenticación correcta, devolver userID.
                  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;
   }

  /**
   * Correlaciona un certificado de formato X.509 con un usuario válido del registro.
   * Se utiliza para correlacionar el nombre del certificado que proporciona el navegador
   * con un userSecurityName válido del registro
   *
   * @param     cert la cadena de certificados X509
   * @return    El nombre correlacionado del userSecurityName del usuario
   * @exception CertificateMapNotSupportedException si no se da soporte 
   *            al certificado concreto.
   * @exception CertificateMapFailedException si la correlación del 
   *            certificado no se ejecuta correctamente.
   * @exception CustomRegistryException si hay algún problema específico
   *            del registro
   **/
   public String mapCertificate(X509Certificate[] cert)
      throws CertificateMapNotSupportedException,
             CertificateMapFailedException,
             CustomRegistryException {
      String name=null;
      X509Certificate cert1 = cert[0];
               try {
         // correlacionar SubjectDN en el certificado con 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;
   }

  /**
   * Devuelve el reino del registro.
   *
   * @return the realm. El reino es una serie específica del registro que indica 
   * el reino o el dominio al que se aplica 
   * el registro. Por ejemplo, para OS/400 o AIX sería el nombre del 
   * host a cuyo registro de usuarios representa este 
   * objeto. Si este método devuelve null, el reino por omisión será
   * el valor "customRealm". Se recomienda 
   * utilizar su propio valor de reino.
   * 
   * @exception CustomRegistryException si hay algún problema específico
   *           del registro
   **/
   public String getRealm()       
      throws CustomRegistryException {
      String name = "customRealm";
      return name;
   }

  /**
   * Obtiene una lista de los usuarios que coinciden con un patrón del registro.
   * El número máximo de usuarios devueltos se define mediante el argumento limit.
   *
   * La consola administrativa y los scripts (línea de mandatos) llaman a 
   * este método para poder añadir los usuarios del registro a 
   * los roles.
   *
   * @param pattern el patrón con el que se ha de hacer coincidir. (Por ejemplo, a* coincidirá 
   *             con todos los userSecurityNames que comiencen por a)
   * @param      limita el número máximo de usuarios que se deben
   *                devolver. Esto es muy útil en aquellos casos en los que 
   *             hay miles de usuarios en el registro y 
   *             obtenerlos todos a la vez no es nada práctico. El mandato    *             valor predeterminado es 100. El valor 0 significa que se han de
   *            obtener todos los usuarios y debe utilizarse con atención.
   * @return    un objeto Result que contiene la lista de usuarios 
   *            solicitados y un distintivo para indicar si hay más
   *            usuarios.
   * @exception CustomRegistryException si hay algún problema específico
   *           del registro
   **/
   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;
   }

  /**
   * Devuelve el nombre del usuario especificado mediante 
   *  userSecurityName.
   *
   * Este método sólo se llama cuando se visualiza la información
   * del usuario, es decir, para fines informativos, por ejemplo, 
   * en la consola administrativa, y no debe utilizarse en la autenticación 
   * real o para fines de autorización. Si no hay nombres de 
   * visualización en el registro se devuelve null o una serie vacía.
   *
   * En el registro personalizado de WebSphere Application Server 4, si había un    * nombre de visualización del usuario y era distinto del nombre de 
   * seguridad, el nombre de visualización se devolvía para los métodos EJB 
   * getCallerPrincipal() y los métodos del servlet
   * de servlet getUserPrincipal() y getRemoteUser().
   * En la Versión 5.x y posterior, para los
   * métodos, el nombre de seguridad se devolverá por omisión. 
   * Este es el método recomendado ya que el nombre de visualización no 
   * es exclusivo y puede crear problemas de seguridad. No obstante, para la 
   * compatibilidad con versiones anteriores si se necesita devolver el nombre de 
   * visualización, establezca la propiedad WAS_UseDisplayName en true.
   *
   * Consulte la documentación del centro de información para obtener más información.
   *
   * @param     userSecurityName el nombre del usuario.
   * @return    el nombre de visualización del usuario. El nombre de 
   *            visualización es una serie específica del registro que 
   *            representa un nombre descriptivo, no necesariamente exclusivo, 
   *            del usuario. Si no existe un nombre de visualización 
   *            se devuelve null o una serie vacía.
   * @exception EntryNotFoundException si no existe 
   *            userSecurityName.
   * @exception CustomRegistryException si hay algún problema específico 
    *           del registro
   **/
   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;
   }

  /**
   * Devuelve el ID exclusivo de un userSecurityName. Se llama a este método cuando 
   * se crea la credencial de un usuario.
   *
   * @param    userSecurityName - El nombre del usuario.
   * @return   El ID exclusivo del usuario. El ID exclusivo de un usuario son datos 
   *           exclusivos, específicos del registro y con formato de serie 
   *           que representan al usuario. Por ejemplo, para el registro de 
   *           usuarios de UNIX, el ID exclusivo de un usuario puede ser el 
   *					      UID.
   * @exception EntryNotFoundException si userSecurityName no 
   *            existe.
   * @exception CustomRegistryException si hay algún problema específico
   *           del registro
   **/
   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;
   }

  /**
   * Devuelve el nombre de un usuario a partir de su ID exclusivo.
   *
   * @param        uniqueUserId - El ID exclusivo del usuario.
   * @return       El userSecurityName del usuario.
   * @exception    EntryNotFoundException si no existe el ID de usuario exclusivo.
   * @exception CustomRegistryException si hay algún problema específico
   *            del registro
   **/
   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;

   }

  /**
   * Determina si userSecurityName existe en el registro
   *
   * @param    userSecurityName - El nombre del usuario
   * @return    True si el usuario es válido, de lo contrario, false
   * @exception CustomRegistryException si hay algún problema específico
   *           del registro
   * @exception RemoteException as this extends 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;
   }


  /**
   * Obtiene una lista de los grupos que coinciden con un patrón del registro
   * El número máximo de grupos devueltos se define mediante el argumento 
   * limit. La consola administrativa y los scripts (línea de mandatos) llaman a este
   * método para poder añadir los grupos del registro a  
   * los roles.
   *
   * @param pattern el patrón con el que se ha de hacer coincidir. (Por ejemplo, a* coincide con todos 
   *              los groupSecurityNames que comiencen por a)
   * @param       Limita el número máximo de grupos que se devuelven. 
   *              Esto es muy útil en aquellos casos en los que hay 
   *              miles de grupos en el registro y obtenerlos todos a la vez 
   *              no es nada práctico. El valor predeterminado es 100. 
   *              El valor 0 significa que se han de obtener todos los grupos 
   *              y debe utilizarse con atención.
   * @return    Un objeto Result que contiene la lista de grupos 
   *            solicitados y un distintivo para indicar si hay más grupos.
   * @exception CustomRegistryException si hay algún problema específico
   *            del registro
   **/
   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;
   }

  /**
   * Devuelve el nombre del grupo especificado mediante groupSecurityName.
   * Para esta versión de WebSphere Application Server este método sólo se usa para  
   * que los clientes (consola administrativa y los scripts) presenten un nombre   
   * descriptivo del usuario, si existe.
   *
   * @param     groupSecurityName el nombre del grupo.
   * @return    el nombre de visualización del grupo. El nombre de visualización
   *            es una serie específica del registro que representa un nombre  
   *            descriptivo del grupo, que no siempre es exclusivo.  
   *            Si no existe un nombre de visualización, se devuelve null o 
   *            una serie vacía.
   * @exception EntryNotFoundException si groupSecurityName no 
   *            existe.
   * @exception CustomRegistryException si hay algún problema específico
   *           del registro
   **/
   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;
   }

  /**
   * Devuelve el ID exclusivo de un grupo.

   * @param     groupSecurityName el nombre del grupo.
   * @return    El ID exclusivo del grupo. El ID exclusivo del
   *            grupo son los datos exclusivos y específicos del registro,
   *            en formato de serie que representan al
   *            grupo. Por ejemplo, para el registro de usuarios de UNIX,
   *            el ID exclusivo puede ser el GID.
   * @exception EntryNotFoundException si groupSecurityName no 
   *            existe.
   * @exception CustomRegistryException si hay algún problema específico
   *           del registro
   * @exception RemoteException as this extends 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;
   }

  /**
   * Devuelve los ID exclusivos de todos los grupos que contienen el ID exclusivo de 
   * un usuario. Se llama cuando se crean las credenciales de un usuario.
   *
   * @param        uniqueUserId el ID exclusivo del usuario.
   * @return    Una lista de todos los ID exclusivos del grupo A los que pertenece el ID 
   *            de usuario exclusivo. El ID exclusivo de una entrada son los datos exclusivos y 
   *            específicos del registro y con formato de serie 
   *            que representan a la entrada.  Por ejemplo, para el registro de
   *            de usuarios de UNIX, el ID exclusivo de un grupo puede ser el GID 
   *            y el ID exclusivo del usuario puede ser el UID.
   * @exception EntryNotFoundException si uniqueUserId no existe.
   * @exception CustomRegistryException si hay algún problema específico
   *            del registro
   **/
   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;
   }

  /**
   * Devuelve el nombre de un grupo a partir de su ID exclusivo.
   *
   * @param  uniqueGroupId el ID exclusivo del grupo.
   * @return    El nombre del grupo.
   * @exception EntryNotFoundException si uniqueGroupId 
   *            existe.
   * @exception CustomRegistryException si hay algún problema específico
   *           del registro
   **/
   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;

   }

  /**
   * Determina si groupSecurityName existe en el registro
   *
   * @param groupSecurityName el nombre del grupo
   * @return    True si el grupo existe; de lo contrario, false
   * @exception CustomRegistryException si hay algún problema específico
   *           del registro
   **/
   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;
   }

  /**
   * Devuelve los securityNames de todos los grupos que contienen al usuario
   *
   * La consola administrativa y los scripts (línea de mandatos) llaman a 
   * este método para verificar si el usuario especificado para la correlación  
   * de RunAsRole pertenece a dicho rol en la correlación de roles con usuarios. Inicialmente, la 
   * comprobación se realiza para ver si el rol contiene al usuario. Si el rol no 
   * contiene explícitamente al usuario, se llama a este método para obtener los grupos 
   * a los que pertenece este usuario y así realizar una comprobación en los grupos que 
   * contienen el rol.
   *
   * @param     userSecurityName el nombre del usuario
   * @return    Una lista de todos los securityNames del grupo al que pertenece el
usuario.
   *
   * @exception EntryNotFoundException si el usuario no existe.
   * @exception CustomRegistryException si hay algún problema específico
   *           del registro
   * @exception RemoteException ya que amplía la interfaz
   *            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;
   }

  /**
   * Obtiene una lista de los usuarios de un grupo.  
   *
   * El número máximo de usuarios devueltos se define mediante el argumento 
   * limit.
   *
   * Este método lo utiliza WebSphere Application Server
   * Enterprise Process Choreographer (Enterprise) cuando
   * las asignaciones de personal se modelan utilizando grupos.
   *
   * En raras ocasiones, si está trabajando con un registro donde obtener  
   * todos los usuarios de cualquiera de los grupos no es práctico, por ejemplo, si   
   * hay muchos usuarios, puede generar una excepción
   * NotImplementedException para ese grupo concreto. Asegúrese de que si   
   * Process Choreographer está instalado (o se instalará más tarde) 
   * las asignaciones de personal no se modelan utilizando estos grupos.
   * Si no importa si se devuelven los usuarios de los grupos 
   * del registro, se recomienda implementar este método
   * sin crear la excepción NotImplemented.
   * @param groupSecurityName el nombre del grupo
   * @param         Limita el número máximo de usuarios que se deben 
   *                devolver. Esto es muy útil en aquellos casos en los que hay 
   *                muchos usuarios en el registro y obtenerlos todos a la vez  
   *                no es nada práctico. El valor 0 significa que se han de   
   *                obtener todos los usuarios y debe utilizarse con atención. 
   * @return    Un objeto Result que contiene la lista de usuarios
   *            solicitados y un distintivo para indicar si hay más usuarios
   * @deprecated Este método se pondrá en desuso en el futuro.
   * @exception     NotImplementedException emite esta excepción en raras ocasiones 
   *            si no es práctico obtener esta información de ninguno de los   
   *            grupos del registro.
   * @exception EntryNotFoundException si el grupo no existe en el 
   *            registro
   * @exception CustomRegistryException si hay algún problema específico 
   *            del registro
   **/
   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;
   }

  /**
   * Este método lo implementa de forma interna el código de WebSphere Application Server
   * Server en este release. No se invoca este método para el
   * registro personalizado en este release. Devuelve null en la 
   * implementación.
   *
   **/
   public com.ibm.websphere.security.cred.WSCredential 
         createCredential(String userSecurityName)
         throws CustomRegistryException,
                NotImplementedException,
                EntryNotFoundException {

      // No se llama a este método.
      return null;
   }

   // métodos privados
   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;
   }
}


//----------------------------------------------------------------------
// El programa proporciona la implementación de la expresión regular 
// utilizada en el ejemplo del registro de usuarios personalizado (FileRegistrySample). 
// El patrón coincidente en el ejemplo utiliza este programa para buscar el patrón 
// (para usuarios y grupos).
//----------------------------------------------------------------------

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

}

Icon that indicates the type of topic Reference topic



Timestamp icon Last updated: last_date
http://www14.software.ibm.com/webapp/wsbroker/redirect?version=cord&product=was-nd-mp&topic=rsec_frsjf502
File name: rsec_frsjf502.html