Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that tracks sessions for MetaCatServlet users.

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

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones

 *

 *   '$Author$'

 *     '$Date$'

 * '$Revision$'

 */

package edu.ucsb.nceas.metacat;

import javax.servlet.http.HttpSession;

import javax.servlet.http.HttpServletRequest;

import java.util.Properties;

import java.io.FileInputStream;

import java.rmi.*;

import SrbJavaGlueInterface;

/**

 * A Class that implements session tracking for MetaCatServlet users.

 * User's login data are stored in the session object.

 * User authentication is made through SRB RMI Connection.

 */

public class MetaCatSession {

    HttpSession session = null;

    // JNI (Java Native Interface) routines for SRB

    static String srbHost;

    static String srbPort;

    // temporary need to read user & password from srbProps.properties

    static String srbUser;

    static String srbPass;

    static SrbJavaGlueInterface srbJG;

    static {

        try {

            Properties SRBProps = new Properties();

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

            // srbProps.properties should reside on metacat server

            FileInputStream in = new FileInputStream("srbProps.properties");

            SRBProps.load(in);

            in.close();

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

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

            // temporally reading user & password from srbProps.properties

            // for existing MCAT account like higgins/neetar

            srbUser = (String)SRBProps.get("user");

            srbPass = (String)SRBProps.get("password");

            // should handle missing RMIhost name here

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

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

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

        } catch (Exception e) {

            System.out.println ("MetaCatSession static: " + e.getMessage());

        }    

    }    

    /** Construct a MetaCatSession

     *

     * @param request the request made from the client

     * @param username the username entered when login

     * @param password the password entered when login

     */

    public MetaCatSession (HttpServletRequest request, 

                            String username, String password) {

      // create a new HTTPSession object

      this.session = getSession(request, username, password);

    }

    /** Get new HttpSession and store username & password in it */

    private HttpSession getSession(HttpServletRequest request, 

                            String username, String password)  {

      // get the current session object, create one if necessary

      HttpSession sess = request.getSession(true);

      // if it is still in use unvalidate and get a new one

      if ( !sess.isNew() ) {

        sess.invalidate();

        sess = request.getSession(true);

      }

      // store username & password in the session for later use if necessary

      sess.putValue("username", username);

      sess.putValue("password", password);

      return sess; 

    }

    /** Try to make user authentication through SRB Connection */

    public boolean userAuth(String password)

                    throws RemoteException  { 

      int srbconn = 0;

      int err;

      // try SRB Connection

      // password should be used, not srbPass read from srbProps

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

      try {

        srbconn = srbJG.clConnectJ( srbHost, srbPort, srbPass );

      } catch (RemoteException e) {

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

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

      }

      // check if successfull

      if ( srbconn < 0 ) {

        // srb connection is already finished from clConnectJ() routine

        return false;

        //throw new RemoteException("MetaCatSession.userAuth() failure: " +

        //                          "SRB Connection failed");

      }

      // we don't need that connection. close it.

      try {

        err = srbJG.clFinishJ( srbconn );

      } catch (RemoteException e) {

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

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

      }

      // store SRB Connection in the session for later use if necessary

      this.session.putValue("srbconnection", new Integer(srbconn));

      return true; 

    }

    /**

     * Invalidate this HTTPSession object. 

     * All objects stored in the session are unbound 

     */

    public void disconnect() {

        this.session.invalidate();

    }    

}