Metacat

/**

 *  '$RCSfile$'

 *    Purpose: An implementation of the AuthInterface interface that

 *             allows Metacat to use the SRB/MCAT for authentication

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Jivka Bojilova

 *    Release: @release@

 *

 *   '$Author: bojilova $'

 *     '$Date: 2000-11-03 12:02:20 -0800 (Fri, 03 Nov 2000) $'

 * '$Revision: 512 $'

 */

package edu.ucsb.nceas.metacat;

import java.net.ConnectException;

import java.util.Iterator;

import java.util.HashMap;

import java.util.Hashtable;

import java.util.Set;

import java.util.Vector;

import java.rmi.*;

import SrbJavaGlueInterface;

import RMIControllerInterface;

import java.util.PropertyResourceBundle;

/**

 * An implementation of the AuthInterface interface that

 * allows Metacat to use the SRB/MCAT for authentication.

 * The SRB/MCAT authentication service is used to determine if a user 

 * is authenticated, and whether they are a member of a particular group.

 */

class AuthMcat implements AuthInterface {

  String username = null;

  String password = null;

  // DCS-ATTRIBUTE-INDEX

  // They are from mdasC_db2_externs.h.

  final static int USER_NAME = 7;

  final static int USER_GROUP_NAME = 3;

  // JNI (Java Native Interface) routines for SRB

  static String srbHost;

  static String srbPort;

  static String RMIhost;

  static RMIControllerInterface rmicon;

  static SrbJavaGlueInterface srbJG;

  static {

    try { 

      PropertyResourceBundle SRBProps = null;

      // SRB properties that tells about the location of SRB RMI Server

      // srbProps.properties should reside on metacat server

      SRBProps = (PropertyResourceBundle)

           PropertyResourceBundle.getBundle("edu.ucsb.nceas.metacat.srbProps");

      srbHost = (String)SRBProps.handleGetObject("host");

      srbPort = (String)SRBProps.handleGetObject("port");

      // should handle missing RMIhost name here

      RMIhost = (String)SRBProps.handleGetObject("RMIhost");

      String name = "//" + RMIhost + "/RMIController";

      rmicon = (RMIControllerInterface)Naming.lookup(name);

      name = "//" + RMIhost + "/SrbJavaGlue";

      srbJG = (SrbJavaGlueInterface)Naming.lookup(name);

    } catch (Exception e) {

      System.err.println("AuthMcat static: " + e.getMessage());

    }    

  }    

  /**

   * Determine if a user/password are valid according to the authentication

   * service.

   *

   * @param user the name of the principal to authenticate

   * @param password the password to use for authentication

   * @returns boolean true if authentication successful, false otherwise

   */

  public boolean authenticate(String user, String password)

                              throws ConnectException

  {

      try { 

        // make connection to SRB.

        int srbconn = srbConnect(user, password);

        if ( srbconn > 0 ) {

          // disconnect from SRB

          srbDisconnect(srbconn);

          return true;

        }

      } catch ( RemoteException re) {

        throw new ConnectException(re.getMessage());

      }

      return false;

  }

  /**

   * Get all users from the authentication service

   */

  public String[] getUsers(String user, String password)

                            throws ConnectException

  {

      try { 

        // make connection to SRB.

        int srbconn = srbConnect(user, password);

        if ( srbconn > 0 ) {

          // get all users

          String[] userlist = getUsernames(srbconn);

          // disconnect from SRB

          srbDisconnect(srbconn);

          return userlist;

        }

      } catch ( RemoteException re) {

        throw new ConnectException(re.getMessage());

      }

      return null;

  }

  /**

   * Get the users for a particular group from the authentication service

   */

  public String[] getUsers(String user, String password, String group)

                           throws ConnectException

  {

      try { 

        // make connection to SRB.

        int srbconn = srbConnect(user, password);

        if ( srbconn > 0 ) {

          // get users for @group

          String[] userlist = getUsernames(srbconn, group);

          // disconnect from SRB

          srbDisconnect(srbconn);

          return userlist;

        }

      } catch ( RemoteException re) {

        throw new ConnectException(re.getMessage());

      }

      return null;

  }

  /**

   * Get all groups from the authentication service

   */

  public String[] getGroups(String user, String password)

                            throws ConnectException

  {

      try { 

        // make connection to SRB.

        int srbconn = srbConnect(user, password);

        if ( srbconn > 0 ) {

          // get all group

          String[] userlist = getGroupnames(srbconn);

          // disconnect from SRB

          srbDisconnect(srbconn);

          return userlist;

        }

      } catch ( RemoteException re) {

        throw new ConnectException(re.getMessage());

      }

      return null;

  }

  /**

   * Get the groups for a particular user from the authentication service

   */

  public String[] getGroups(String user, String password, String foruser)

                            throws ConnectException

  {

      try { 

        // make connection to SRB.

        int srbconn = srbConnect(user, password);

        if ( srbconn > 0 ) {

          // get groups for @foruser

          String[] userlist = getGroupnames(srbconn, foruser);

          // disconnect from SRB

          srbDisconnect(srbconn);

          return userlist;

        }

      } catch ( RemoteException re) {

        throw new ConnectException(re.getMessage());

      }

      return null;

  }

  /**

   * Get attributes describing a user or group

   *

   * @param user the user for which the attribute list is requested

   * @returns HashMap a map of attribute name to a Vector of values

   */

  public HashMap getAttributes(String user) 

         throws ConnectException

  {

    return getAttributes(user, null, null);

  }

  /**

   * Get attributes describing a user or group

   *

   * @param user the user for which the attribute list is requested

   * @param authuser the user for authenticating against the service

   * @param password the password for authenticating against the service

   * @returns HashMap a map of attribute name to a Vector of values

   */

  public HashMap getAttributes(String user, String authuser, String password) 

         throws ConnectException

  {

    // NOT IMPLEMENTED YET

    return null;

  }

  /**

   * Get SRB RMI Connection 

   */

  private int srbConnect(String username, String password)

                                 throws RemoteException  { 

    int srbconn = 0;

    // look up for SRBJavaGlue

    try {

      String name = "//" + RMIhost + "/SrbJavaGlue";

      srbJG = (SrbJavaGlueInterface)Naming.lookup(name);

    } catch (Exception e) {

      try {

        rmicon.restart();

      } catch (Exception rmie) {}

      // The SRB server is not running or it is busy now

      throw new 

      RemoteException("AuthMcat look up for SrbJavaGlue failed");

    }

    // try SRB RMI Connection

    // integer value of the SBR Connection ID is returned only

    try { 

      srbconn = srbJG.rmiConnectJ( srbHost, srbPort, password, username );

    } catch (RemoteException e) {

      try {

        rmicon.restart();

      } catch (Exception rmie) {}

      throw new RemoteException("AuthMcat.userAuth() - " +

                                "Error on rmiConnectJ(): " + e.getMessage());

    }

    // check if successfull

    if ( srbconn == 0 ) {

      throw new 

      RemoteException("The SRB Server is not running or it is busy now");

    } else if ( srbconn < 0 ) {

      try {

        rmicon.restart();

      } catch (Exception rmie) {}

      if ( srbconn == -1003 ) {

        throw new 

        RemoteException("SrbJavaGlue.c: Connection to srbMaster failed.");

      }

      return srbconn;

    }

    return srbconn; 

  }

  /**

   * Close SRB RMI Connection 

   */

  private void srbDisconnect(int srbconn) throws RemoteException

  { 

    try {

      int err = srbJG.rmiFinishJ( srbconn );

    } catch (RemoteException e) {}

  }

  // get the names of groups for given user

  private String[] getGroupnames (int conn, String username) 

                                throws RemoteException    {

    String[] qval;

	  int[] qvalInx;

    int[] selVal;

    qval = new String [2];

    qval[0] = new String (" not like  '%$deleted%'");

    qval[1] = new String (" = '" + username + "'");

//    qval[2] = new String (" <> 'public'");

    qvalInx = new int[2];

    qvalInx[0] = USER_NAME;

    qvalInx[1] = USER_NAME;

//    qvalInx[2] = USER_GROUP_NAME;

    selVal = new int[1];

    selVal[0] = USER_GROUP_NAME;

    // generate a query and get the resultset

    String[] selRes = getGenQueResult (conn, qval, qvalInx, selVal);

    return selRes;

  }

  // get the names of all groups

  private String[] getGroupnames (int conn) 

                            throws RemoteException    {

    String[] qval;

	  int[] qvalInx;

    int[] selVal;

    qval = new String [1];

    qval[0] = new String (" not like  '%$deleted%'");

//    qval[1] = new String (" <> 'public'");

    qvalInx = new int[1];

    qvalInx[0] = USER_NAME;

//    qvalInx[1] = USER_GROUP_NAME;

    selVal = new int[1];

    selVal[0] = USER_GROUP_NAME;

    // generate a query and get the resultset

    String[] selRes = getGenQueResult (conn, qval, qvalInx, selVal);

    return selRes;

  }

  // get the names of users for given group

  private String[] getUsernames (int conn, String groupname) 

                              throws RemoteException    {

    String[] qval;

	  int[] qvalInx;

    int[] selVal;

    qval = new String [2];

    qval[0] = new String (" not like  '%$deleted%'");

    qval[1] = new String (" = '" + groupname + "'");

//    qval[2] = new String (" <> 'public'");

    qvalInx = new int[2];

    qvalInx[0] = USER_NAME;

    qvalInx[1] = USER_GROUP_NAME;

//    qvalInx[2] = USER_GROUP_NAME;

    selVal = new int[1];

    selVal[0] = USER_NAME;

    // generate a query and get the resultset

    String[] selRes = getGenQueResult (conn, qval, qvalInx, selVal);

    return selRes;

  }

  // get the names of all users

  private String[] getUsernames (int conn) 

                            throws RemoteException    {

    String[] qval;

	  int[] qvalInx;

    int[] selVal;

    qval = new String [1];

    qval[0] = new String (" not like  '%$deleted%'");

//    qval[1] = new String (" <> 'public'");

    qvalInx = new int[1];

    qvalInx[0] = USER_NAME;

//    qvalInx[1] = USER_GROUP_NAME;

    selVal = new int[1];

    selVal[0] = USER_NAME;

    // generate a query and get the resultset

    String[] selRes = getGenQueResult (conn, qval, qvalInx, selVal);

    return selRes;

  }

  // try to generate query and run and retrieve all rows

  private String[] getGenQueResult(int conn, String[] qval,

                                int qvalInx[], int selVal[])

                                throws RemoteException      {

    int inx = 0;

    int queResultCount = 0;

    int queResultIndex = 0;

    int selLen = selVal.length;

    String[] queResult = new String[selLen];

    String[] resultset;

    try {

      queResultCount = srbJG.srbGenQuery( conn, 0, qval, qvalInx, selVal);

      resultset = new String[queResultCount];

      // get first rows

      for (int i = 0; i < queResultCount; i++) {

        for (int j = 0; j < selLen; j++) {

          queResult[j] = srbJG.getGenQueResultJ(j, queResultIndex);

        }

        resultset[inx++] = queResult[0]; 

        queResultIndex++;

      } 

      // get next rows

      while (queResult != null) {

        if ( queResultIndex >= queResultCount ) {

          queResultIndex = 0;

          queResultCount = srbJG.getMoreGenQueRowsJ(conn, 0);

          if (queResultCount <= 0) {

            return resultset;

          }  

        } 

        for (int i = 0; i < selLen; i++) {

          queResult[i] = srbJG.getGenQueResultJ(i, queResultIndex);

        }    

        resultset[inx++] = queResult[0];

        queResultIndex++;

      }  

    } catch (RemoteException re) {

      throw re;

    }

    return resultset;

  }

  /**

   * Test method for the class

   */

  public static void main(String[] args) {

    // Provide a user, such as: "cn=Matt Jones"

    String user = args[0];

    String password = args[1];

    AuthMcat authservice = new AuthMcat();

    boolean isValid = false;

    try {

  //    isValid = authservice.authenticate(user, password);

      if (isValid) {

        System.out.println("Authentication successful for: " + user );

        System.out.println(" ");

      } else {

        System.out.println("Authentication failed for: " + user);

      }

      String[] userlist = authservice.getUsers(user, password);

      for (int i = 0; i < userlist.length; i++) {

        System.out.println(userlist[i]);

      }

      System.out.println("All Users: " + userlist.length);

/*

      if (isValid) {

        HashMap userInfo = authservice.getAttributes(user);

        // Print all of the attributes

        Iterator attList = (Iterator)(((Set)userInfo.keySet()).iterator());

        while (attList.hasNext()) {

          String att = (String)attList.next();

          Vector values = (Vector)userInfo.get(att);

          System.out.println(att + ": " );

          Iterator attvalues = values.iterator();

          while (attvalues.hasNext()) {

            String value = (String)attvalues.next();

            System.out.println("  value: " + value);

          }

        }

      }

*/

    } catch (ConnectException ce) {

      System.err.println(ce.getMessage());

    }

  }

}