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: jones $'

 *     '$Date: 2001-01-18 11:52:00 -0800 (Thu, 18 Jan 2001) $'

 * '$Revision: 669 $'

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

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 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.

 */

public 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 srbDomain;

  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");

      srbDomain = (String)SRBProps.handleGetObject("domain");

      // should handle missing RMIhost name here

      String name = "//" + srbHost + "/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 foruser) 

         throws ConnectException

  {

    return getAttributes(null, null, foruser);

  }

  /**

   * 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 password, String foruser) 

         throws ConnectException

  {

    // NOT IMPLEMENTED YET

    return null;

  }

  /**

   * Get SRB RMI Connection 

   */

  private int srbConnect(String username, String password)

                                 throws RemoteException  { 

    synchronized(this) {

      int srbconn = 0;

      // try SRB RMI Connection

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

      try {

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

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

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

      } catch (Exception e) {

        throw new

        RemoteException("AuthMcat.srbConnect():" + 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 ) {

        return srbconn;

      }

      return srbconn; 

    } // end of synchronized(this)

  }

  /**

   * Close SRB RMI Connection 

   */

  private void srbDisconnect(int srbconn) throws RemoteException

  { 

    try {

      int err = srbJG.clFinishJ( 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());

    }

  }

}