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

 *    Release: @release@

 *

 *   '$Author: bojilova $'

 *     '$Date: 2000-09-13 13:07:55 -0700 (Wed, 13 Sep 2000) $'

 * '$Revision: 446 $'

 */

package edu.ucsb.nceas.metacat;

import javax.servlet.http.HttpSession;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.util.Properties;

import java.util.PropertyResourceBundle;

import java.util.Stack;

import java.io.FileInputStream;

import java.io.PrintWriter;

import java.rmi.*;

import SrbJavaGlueInterface;

import RMIControllerInterface;

/**

 * 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 {

    static String debug = null;

    HttpSession session = 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("MetaCatSession static: " + e.getMessage());

            System.exit(0);

        }    

    }    

    /** 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)

                            throws IllegalStateException {

      // 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)  

                            throws IllegalStateException {

      // 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.setMaxInactiveInterval(-1);

      sess.setAttribute("username", username);

      sess.setAttribute("password", password);

      return sess; 

    }

    /** handle Login action for MetaCatServlet

      */

    public String userLogin(HttpServletResponse response,

                            String username, String password,

                            String action, String htmlpath) { 

      String out = null; 

      // for public connection only

      // this does not go through auth checking in SRB

      // the final implementation will need auth checking in SRB for public

      if ( username.equals("public") ) {

        try {

          if (action.equals("Login Client")) {

            String message = "User Authentication successful";

            out = formatOutput("success", message);

            return out;

          } else {

            response.sendRedirect(

                     response.encodeRedirectUrl(htmlpath + "/index.html"));

          }    

        } catch ( java.io.IOException ioe) {

          disconnect();            

          String message = "MetaCatSession.userLogin() - " +

                      "Error on redirect of HttpServletResponse: " + 

                      ioe.getMessage();

          out = formatOutput("error", message);

          return out;

        }                

      }    

      // Auth checking in SRB.

      // It fails if not registered user provided.

      // It gets all users/groups from MCAT for implementing ACL for MetaCat

      // The last one probably will need to be done on separate MetaCatServlet

      // action instead on Login action

      try { 

        if ( userAuth(username, password) ) {

          try {

            if (action.equals("Login Client")) {

              String message = "User Authentication successful";

              out = formatOutput("success", message);

            } else {

              response.sendRedirect(

                       response.encodeRedirectUrl(htmlpath + "/metacat.html"));

            }    

          } catch ( java.io.IOException ioe) {

            disconnect();            

            String message = "MetaCatSession.userLogin() - " +

                       "Error on redirect of HttpServletResponse: " + 

                       ioe.getMessage();

            out = formatOutput("error", message);

          }                

        // the user has not been authenticated by SRB

        } else {  

            disconnect();            

            String message = "SRB Connection failed. " +

                       "SRB RMI Server is not running now or " +

                       "user " + username + 

                       " has not been authenticated to use the system.";

            out = formatOutput("error", message);

        }    

      } catch ( java.rmi.RemoteException re) {

        disconnect();            

        String message = "SRB Connection failed. " + re.getMessage();

        out = formatOutput("error", message);

      }

      return out;

    }

    /* format the output in xml for processing from client appl

     */

    private String formatOutput(String tag, String message) {

      StringBuffer out = new StringBuffer();

      out.append("<?xml version=\"1.0\"?>\n");

      out.append("<" + tag + ">");

      if ( tag.equals("error") ) {

        out.append(message);

      } else {

        out.append("\n  <message>" + message + "</message>\n");

        String username = (String)this.session.getAttribute("username");

        out.append("  <username>" + username + "</username>\n");

        if ( username.equals("public") ) { 

          out.append("</" + tag + ">");

          return out.toString();

        }

        String groupname = (String)this.session.getAttribute("groupname");

        out.append("  " + groupname + "\n");

        Stack usersGroups = new Stack();

        usersGroups = (Stack)this.session.getAttribute("usersgroups");

        String val = "";

        StringBuffer res = new StringBuffer(); 

        while ( !usersGroups.empty() ) {

          val = "    " + (String)usersGroups.pop() + "\n" + val;

          if ( val.startsWith("    <groupname>") ) {

            val = "  <group>\n" + val + "  </group>\n";

            res.insert(0, val);

            val = "";

          }  

        }  

        out.append(res.toString());

      }  

      out.append("</" + tag + ">");

      return out.toString();

    }

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

      * Using that connection to get:

      *  . the groupname of connected user;

      *  . a whole list of all groups and users in MCAT.

      */

    private boolean userAuth(String username, String password)

                    throws RemoteException  { 

//      synchronized(this) {

        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("MetaCatSession 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("MetaCatSession.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) {}

          return false;

        }

        // get the Group name of connected user;

        String groupname = null;

        try {

          groupname = getGroupname(srbconn, username);

          this.session.setAttribute("groupname", groupname);

        } catch (RemoteException e) { 

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

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

        }

        // get all users and groups from MCAT

        Stack usersGroupsList = new Stack();

        try {

          usersGroupsList = getUsersGroups(srbconn);

          this.session.setAttribute("usersgroups", usersGroupsList);

        } catch (RemoteException e) { 

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

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

        }

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

        try {

          int err = srbJG.rmiFinishJ( srbconn );

        } catch (RemoteException e) {}

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

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

//        try {

//            wait(5000);

//        } catch (Exception e) {}

//        try {

//            notifyAll();

//        } catch (Exception e) {}    

        return true; 

//      } // end of synchronized(this)

    }

    // get the Groupname of connected user

    private String getGroupname (int conn, String username) 

                throws RemoteException

    {

	    String[] qval;

	    int[] qvalInx;

	    int[] selVal;

	    qval = new String [3];

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

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

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

	    qvalInx = new int[3];

	    qvalInx[0] = USER_NAME;

	    qvalInx[1] = USER_NAME;

	    qvalInx[2] = USER_GROUP_NAME;

	    selVal = new int[2];

      selVal[0] = USER_GROUP_NAME;

      selVal[1] = USER_NAME;

	    // generate a query and get the resultset

	    Stack selRes = new Stack();

	    selRes = getGenQueResult (conn, qval, qvalInx, selVal);

	    String dummy = (String)selRes.pop();

      return (String)selRes.pop();

    }

    // get all users and groups from MCAT

    private Stack getUsersGroups (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[2];

      selVal[0] = USER_GROUP_NAME;

      selVal[1] = USER_NAME;

	    // generate a query and get the resultset

	    Stack selRes = new Stack();

	    selRes = getGenQueResult (conn, qval, qvalInx, selVal);

      return selRes;

    }

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

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

                                int qvalInx[], int selVal[])

                throws RemoteException

    {

        int queResultCount = 0;

        int queResultIndex = 0;

        int selLen = selVal.length;

        String[] queResult = new String[selLen];

        Stack resultset = new Stack();

        String currGroupname = null;

        // get first row

        try {

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

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

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

          } 

          resultset.push("<groupname>" + queResult[0] + "</groupname>"); 

          resultset.push("<username>" + queResult[1] + "</username>");

          currGroupname = 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);

            }    

            if ( !currGroupname.equals(queResult[0]) ) {

              resultset.push("<groupname>" + queResult[0] + "</groupname>");

              currGroupname = queResult[0];

            }  

            resultset.push("<username>" + queResult[1] + "</username>");

            queResultIndex++;

          }  

        } catch (RemoteException e) {

          throw new RemoteException(e.getMessage());

        }

        return resultset;

    }

    /**

     * Invalidate this HTTPSession object. 

     * All objects stored in the session are unbound 

     */

    private void disconnect() {

        this.session.invalidate();

    }    

}