Changeset 25258

Show
Ignore:
Timestamp:
23.03.2012 14:13:07 (8 years ago)
Author:
sjm84
Message:

Some major changes tidying up and adding functionality to the Administration functionality

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • main/trunk/greenstone3/src/java/org/greenstone/gsdl3/service/Authentication.java

    r25124 r25258  
    77 
    88import org.w3c.dom.Element; 
    9 import org.w3c.dom.NodeList; 
    10  
     9 
     10import java.util.ArrayList; 
    1111import java.util.HashMap; 
     12import java.util.Properties; 
     13import java.util.UUID; 
    1214import java.util.Vector; 
     15import java.security.MessageDigest; 
    1316import java.sql.SQLException; 
    1417import java.util.regex.Pattern; 
    1518import java.io.File; 
    16 import java.io.UnsupportedEncodingException; 
     19 
     20import javax.mail.Message; 
     21import javax.mail.Session; 
     22import javax.mail.Transport; 
     23import javax.mail.internet.InternetAddress; 
     24import javax.mail.internet.MimeMessage; 
     25 
     26import net.tanesha.recaptcha.ReCaptchaImpl; 
     27import net.tanesha.recaptcha.ReCaptchaImpl; 
     28import net.tanesha.recaptcha.ReCaptchaResponse; 
    1729 
    1830public class Authentication extends ServiceRack 
    1931{ 
     32    //Error codes 
     33    protected static final int NO_ERROR = 0; 
     34    protected static final int ERROR_REQUEST_HAS_NO_PARAM_LIST = -1; 
     35    protected static final int ERROR_NOT_LOGGED_IN = -2; 
     36    protected static final int ERROR_ADMIN_NOT_LOGGED_IN = -3; 
     37    protected static final int ERROR_COULD_NOT_GET_USER_INFO = -4; 
     38    protected static final int ERROR_USERNAME_NOT_SPECIFIED = -5; 
     39    protected static final int ERROR_REQUESTED_USER_NOT_FOUND = -6; 
     40    protected static final int ERROR_SQL_EXCEPTION = -7; 
     41    protected static final int ERROR_INVALID_USERNAME = -8; 
     42    protected static final int ERROR_INVALID_PASSWORD = -9; 
     43    protected static final int ERROR_INCORRECT_PASSWORD = -10; 
     44    protected static final int ERROR_USER_ALREADY_EXISTS = -11; 
     45    protected static final int ERROR_ADDING_USER = -12; 
     46    protected static final int ERROR_REMOVING_USER = -13; 
     47    protected static final int ERROR_CAPTCHA_DOES_NOT_MATCH = -14; 
     48    protected static final int ERROR_CAPTCHA_MISSING = -15; 
     49    protected static final int ERROR_NOT_AUTHORISED = -16; 
     50    protected static final int ERROR_COULD_NOT_RESET_PASSWORD = -17; 
     51 
     52    protected static final HashMap<Integer, String> _errorMessageMap; 
     53    static 
     54    { 
     55        //Corresponding error messages 
     56        HashMap<Integer, String> errorMessageMap = new HashMap<Integer, String>(); 
     57        errorMessageMap.put(ERROR_REQUEST_HAS_NO_PARAM_LIST, "The list of parameters for this request was empty."); 
     58        errorMessageMap.put(ERROR_NOT_LOGGED_IN, "You must be logged in to access this page."); 
     59        errorMessageMap.put(ERROR_ADMIN_NOT_LOGGED_IN, "You must be logged in as an administrator to access this page."); 
     60        errorMessageMap.put(ERROR_COULD_NOT_GET_USER_INFO, "There was a error getting the user information."); 
     61        errorMessageMap.put(ERROR_USERNAME_NOT_SPECIFIED, "No username was specified."); 
     62        errorMessageMap.put(ERROR_REQUESTED_USER_NOT_FOUND, "The requested user was not found in the database."); 
     63        errorMessageMap.put(ERROR_SQL_EXCEPTION, "There was an SQL exception while accessing the database."); 
     64        errorMessageMap.put(ERROR_INVALID_USERNAME, "The username specified was invalid."); 
     65        errorMessageMap.put(ERROR_INVALID_PASSWORD, "The password specified was invalid."); 
     66        errorMessageMap.put(ERROR_INCORRECT_PASSWORD, "The password specified was incorrect."); 
     67        errorMessageMap.put(ERROR_USER_ALREADY_EXISTS, "This user already exists and therefore cannot be added."); 
     68        errorMessageMap.put(ERROR_ADDING_USER, "There was an error adding this user to the database."); 
     69        errorMessageMap.put(ERROR_REMOVING_USER, "There was an error removing this user from the database."); 
     70        errorMessageMap.put(ERROR_CAPTCHA_DOES_NOT_MATCH, "The words you entered did not match the image, please try again."); 
     71        errorMessageMap.put(ERROR_CAPTCHA_MISSING, "The information from the captcha is missing."); 
     72        errorMessageMap.put(ERROR_NOT_AUTHORISED, "You are not authorised to access this page."); 
     73        errorMessageMap.put(ERROR_COULD_NOT_RESET_PASSWORD, "Your password could not be reset, your email address may be invalid."); 
     74 
     75        _errorMessageMap = errorMessageMap; 
     76    } 
     77 
     78    //Admin-required operations 
     79    protected static final String LIST_USERS = "ListUsers"; 
     80    protected static final String PERFORM_ADD = "PerformAdd"; 
     81    protected static final String PERFORM_EDIT = "PerformEdit"; 
     82    protected static final String ADD_USER = "AddUser"; 
     83    protected static final String EDIT_USER = "EditUser"; 
     84    protected static final String PERFORM_DELETE_USER = "PerformDeleteUser"; 
     85 
     86    protected static final ArrayList<String> _adminOpList; 
     87    static 
     88    { 
     89        ArrayList<String> opList = new ArrayList<String>(); 
     90        opList.add(LIST_USERS); 
     91        opList.add(PERFORM_ADD); 
     92        opList.add(PERFORM_EDIT); 
     93        opList.add(EDIT_USER); 
     94        opList.add(PERFORM_DELETE_USER); 
     95 
     96        _adminOpList = opList; 
     97    } 
     98 
     99    //User-required operations 
     100    protected static final String ACCOUNT_SETTINGS = "AccountSettings"; 
     101    protected static final String PERFORM_ACCOUNT_EDIT = "PerformAccEdit"; 
     102    protected static final String PERFORM_RESET_PASSWORD = "PerformResetPassword"; 
     103    protected static final ArrayList<String> _userOpList; 
     104    static 
     105    { 
     106        ArrayList<String> opList = new ArrayList<String>(); 
     107        opList.add(ACCOUNT_SETTINGS); 
     108        opList.add(PERFORM_ACCOUNT_EDIT); 
     109        opList.add(PERFORM_RESET_PASSWORD); 
     110        opList.addAll(_adminOpList); 
     111        _userOpList = opList; 
     112    } 
     113 
     114    //Other operations 
     115    protected static final String REGISTER = "Register"; 
     116    protected static final String PERFORM_REGISTER = "PerformRegister"; 
     117    protected static final String LOGIN = "Login"; 
     118 
    20119    //the services on offer 
    21120    protected static final String AUTHENTICATION_SERVICE = "Authentication"; 
    22121    protected static final String GET_USER_INFORMATION_SERVICE = "GetUserInformation"; 
     122 
     123    protected DerbyWrapper _derbyWrapper = null; 
    23124 
    24125    /** constructor */ 
     
    109210        if (paramList == null) 
    110211        { 
    111             logger.error(GET_USER_INFORMATION_SERVICE + ": Param list does not exist "); 
    112             return null; 
     212            GSXML.addError(this.doc, result, _errorMessageMap.get(ERROR_REQUEST_HAS_NO_PARAM_LIST)); 
     213            return result; 
    113214        } 
    114215 
     
    119220        if (username == null) 
    120221        { 
    121             logger.error(GET_USER_INFORMATION_SERVICE + ": No username specified"); 
     222            GSXML.addError(this.doc, result, _errorMessageMap.get(ERROR_USERNAME_NOT_SPECIFIED)); 
    122223            return result; 
    123224        } 
     
    136237            if (terms.size() == 0) 
    137238            { 
    138                 logger.error(GET_USER_INFORMATION_SERVICE + ": Requested user was not found"); 
     239                GSXML.addError(this.doc, result, _errorMessageMap.get(ERROR_REQUESTED_USER_NOT_FOUND)); 
    139240                return result; 
    140241            } 
     
    144245            result.appendChild(userInfoList); 
    145246 
    146             Element usernameField = GSXML.createParameter(this.doc, "username", userInfo.username_); 
    147             Element passwordField = GSXML.createParameter(this.doc, "password", userInfo.password_); 
    148             Element groupsField = GSXML.createParameter(this.doc, "groups", userInfo.groups_); 
    149             Element accountStatusField = GSXML.createParameter(this.doc, "accountstatus", userInfo.accountstatus_); 
    150             Element commentField = GSXML.createParameter(this.doc, "comment", userInfo.comment_); 
     247            Element usernameField = GSXML.createParameter(this.doc, "username", userInfo.username); 
     248            Element passwordField = GSXML.createParameter(this.doc, "password", userInfo.password); 
     249            Element groupsField = GSXML.createParameter(this.doc, "groups", userInfo.groups); 
     250            Element accountStatusField = GSXML.createParameter(this.doc, "accountstatus", userInfo.accountstatus); 
     251            Element commentField = GSXML.createParameter(this.doc, "comment", userInfo.comment); 
    151252 
    152253            userInfoList.appendChild(usernameField); 
     
    156257            userInfoList.appendChild(commentField); 
    157258        } 
    158         catch (Exception ex) 
    159         { 
     259        catch (SQLException ex) 
     260        { 
     261            GSXML.addError(this.doc, result, _errorMessageMap.get(ERROR_SQL_EXCEPTION)); 
    160262            ex.printStackTrace(); 
    161263        } 
     
    164266    } 
    165267 
    166     protected Element processAuthentication(Element request) throws SQLException, UnsupportedEncodingException 
    167     { 
     268    protected Element processAuthentication(Element request) 
     269    { 
     270        checkAdminUserExists(); 
    168271 
    169272        // Create a new (empty) result message 
    170273        Element result = this.doc.createElement(GSXML.RESPONSE_ELEM); 
    171  
    172274        result.setAttribute(GSXML.FROM_ATT, AUTHENTICATION_SERVICE); 
    173275        result.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_PROCESS); 
    174276 
    175         String lang = request.getAttribute(GSXML.LANG_ATT); 
     277        // Create an Authentication node put into the result 
     278        Element authenNode = this.doc.createElement(GSXML.AUTHEN_NODE_ELEM); 
     279        result.appendChild(authenNode); 
     280        result.appendChild(getCollectList(this.site_home + File.separatorChar + "collect")); 
     281 
     282        // Create a service node added into the Authentication node 
     283        Element serviceNode = this.doc.createElement(GSXML.SERVICE_ELEM); 
     284        authenNode.appendChild(serviceNode); 
     285 
    176286        // Get the parameters of the request 
    177287        Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM + GSXML.LIST_MODIFIER); 
    178  
    179288        if (param_list == null) 
    180289        { 
    181             logger.error("AddUsers request had no paramList."); 
     290            serviceNode.setAttribute("operation", LOGIN); 
     291            GSXML.addError(this.doc, result, _errorMessageMap.get(ERROR_REQUEST_HAS_NO_PARAM_LIST)); 
    182292            return result; // Return the empty result 
    183293        } 
    184  
    185         String aup = null; //Actions: ListUsers, AddUser, ModifyPassword, DeleteUser, Login 
    186         String un = ""; //login user's name 
    187         String pw = ""; //login user's password 
    188         String asn = ""; //whether a user is authenticated 
    189         String uan = ""; //whether a authentication for a particular action is needed 
    190         String cm = ""; //whether the action is confirmed 
    191  
    192         String umun = ""; //the new user name 
    193         String umpw = ""; //user's new password 
    194         String umas = ""; //user account status 
    195         String umgp = ""; //user greoups 
    196         String umc = ""; // comments for the user 
    197  
    198         String oumun = ""; //the original user's name 
    199         String umpw1 = ""; //user's new password 
    200         String umpw2 = ""; //user's retyped new password 
    201  
    202         //used for adding a list of users at one time. Format: name,password,role]name,password,role]... 
    203         //in which, role may be in the format: student:[teacher's username] 
    204         String unpwlist = ""; 
    205         String service = ""; 
    206  
    207         // get parameters from the request 
    208         NodeList params = param_list.getElementsByTagName(GSXML.PARAM_ELEM); 
    209         for (int i = 0; i < params.getLength(); i++) 
    210         { 
    211             Element param = (Element) params.item(i); 
    212             String p_name = param.getAttribute(GSXML.NAME_ATT); 
    213             String p_value = GSXML.getValue(param); 
    214  
    215             if (p_name.equals("aup")) 
    216             { 
    217                 aup = p_value; 
    218             } 
    219             else if (p_name.equals("un")) 
    220             { 
    221                 un = p_value; 
    222             } 
    223             else if (p_name.equals("pw")) 
    224             { 
    225                 pw = p_value; 
    226             } 
    227             else if (p_name.equals("umun")) 
    228             { 
    229                 umun = p_value; 
    230             } 
    231             else if (p_name.equals("umpw")) 
    232             { 
    233                 umpw = p_value; 
    234             } 
    235             else if (p_name.equals("umas")) 
    236             { 
    237                 umas = p_value; 
    238             } 
    239             else if (p_name.equals("umgp")) 
    240             { 
    241                 umgp = p_value; 
    242             } 
    243             else if (p_name.equals("umc")) 
    244             { 
    245                 umc = p_value; 
    246             } 
    247             else if (p_name.equals("asn")) 
    248             { 
    249                 asn = p_value; 
    250             } 
    251             else if (p_name.equals("uan")) 
    252             { 
    253                 uan = p_value; 
    254             } 
    255             else if (p_name.equals("cm")) 
    256             { 
    257                 cm = p_value; 
    258             } 
    259             else if (p_name.equals("umpw1")) 
    260             { 
    261                 umpw1 = p_value; 
    262             } 
    263             else if (p_name.equals("umpw2")) 
    264             { 
    265                 umpw2 = p_value; 
    266             } 
    267             else if (p_name.equals("oumun")) 
    268             { 
    269                 oumun = p_value; 
    270             } 
    271             else if (p_name.equals("unpwlist")) 
    272             { 
    273                 unpwlist = p_value; 
    274             } 
    275  
    276         } 
    277  
    278         // create a Authentication node put into the result 
    279         Element authen_node = this.doc.createElement(GSXML.AUTHEN_NODE_ELEM); 
    280         result.appendChild(authen_node); 
    281         result.appendChild(getCollectList(this.site_home + File.separatorChar + "collect")); 
    282         // create a service node added into the Authentication node 
    283         Element service_node = this.doc.createElement(GSXML.SERVICE_ELEM); 
    284         authen_node.appendChild(service_node); 
    285         service_node.setAttribute("aup", aup); 
    286         // user's info  
    287         UserQueryResult userQueryResult = null; 
     294        HashMap paramMap = GSXML.extractParams(param_list, false); 
     295        String op = (String) paramMap.get("authpage"); 
     296        serviceNode.setAttribute("operation", op); 
     297 
     298        String username = null; 
     299        String groups = null; 
     300 
     301        Element userInformation = (Element) GSXML.getChildByTagName(request, GSXML.USER_INFORMATION_ELEM); 
     302        if (userInformation == null && _userOpList.contains(op)) 
     303        { 
     304            serviceNode.setAttribute("operation", LOGIN); 
     305            GSXML.addError(this.doc, result, _errorMessageMap.get(ERROR_NOT_LOGGED_IN)); 
     306            return result; 
     307        } 
     308 
     309        if (userInformation != null) 
     310        { 
     311            username = userInformation.getAttribute(GSXML.USERNAME_ATT); 
     312            groups = userInformation.getAttribute(GSXML.GROUPS_ATT); 
     313        } 
     314 
     315        if (username == null && _userOpList.contains(op)) 
     316        { 
     317            serviceNode.setAttribute("operation", LOGIN); 
     318            GSXML.addError(this.doc, result, _errorMessageMap.get(ERROR_NOT_LOGGED_IN)); 
     319            return result; 
     320        } 
     321 
     322        if (_adminOpList.contains(op) && (groups == null || !groups.matches(".*\\badministrator\\b.*"))) 
     323        { 
     324            serviceNode.setAttribute("operation", LOGIN); 
     325            GSXML.addError(this.doc, result, _errorMessageMap.get(ERROR_ADMIN_NOT_LOGGED_IN)); 
     326            return result; 
     327        } 
     328 
     329        if (op.equals(LIST_USERS)) 
     330        { 
     331            int error = addUserInformationToNode(null, serviceNode); 
     332            if (error != NO_ERROR) 
     333            { 
     334                GSXML.addError(this.doc, result, _errorMessageMap.get(error)); 
     335            } 
     336        } 
     337        else if (op.equals(PERFORM_ADD)) 
     338        { 
     339            String newUsername = (String) paramMap.get("username"); 
     340            String newPassword = (String) paramMap.get("password"); 
     341            String newGroups = (String) paramMap.get("groups"); 
     342            String newStatus = (String) paramMap.get("status"); 
     343            String newComment = (String) paramMap.get("comment"); 
     344            String newEmail = (String) paramMap.get("email"); 
     345 
     346            int error = addUser(newUsername, newPassword, newGroups, newStatus, newComment, newEmail); 
     347            if (error != NO_ERROR) 
     348            { 
     349                serviceNode.setAttribute("operation", ADD_USER); 
     350                GSXML.addError(this.doc, result, _errorMessageMap.get(error)); 
     351            } 
     352            else 
     353            { 
     354                addUserInformationToNode(null, serviceNode); 
     355                serviceNode.setAttribute("operation", LIST_USERS); 
     356            } 
     357        } 
     358        else if (op.equals(PERFORM_REGISTER)) 
     359        { 
     360            String newUsername = (String) paramMap.get("username"); 
     361            String newPassword = (String) paramMap.get("password"); 
     362            String newEmail = (String) paramMap.get("email"); 
     363 
     364            ReCaptchaImpl reCaptcha = new ReCaptchaImpl(); 
     365            reCaptcha.setPrivateKey("6LckI88SAAAAAGnGy1PwuXYZzIMXZYoPxN51bWWG"); //TODO: MOVE TO SITECONFIG.XML FILE 
     366 
     367            String challenge = (String) paramMap.get("recaptcha_challenge_field"); 
     368            String uResponse = (String) paramMap.get("recaptcha_response_field"); 
     369 
     370            if (challenge == null || uResponse == null) 
     371            { 
     372                serviceNode.setAttribute("operation", REGISTER); 
     373                GSXML.addError(this.doc, result, _errorMessageMap.get(ERROR_CAPTCHA_MISSING)); 
     374                return result; 
     375            } 
     376 
     377            ReCaptchaResponse reCaptchaResponse = reCaptcha.checkAnswer(request.getAttribute("remoteAddress"), challenge, uResponse); 
     378 
     379            if (!reCaptchaResponse.isValid()) 
     380            { 
     381                serviceNode.setAttribute("operation", REGISTER); 
     382                GSXML.addError(this.doc, result, _errorMessageMap.get(ERROR_CAPTCHA_DOES_NOT_MATCH)); 
     383                return result; 
     384            } 
     385 
     386            int error = addUser(newUsername, newPassword, "", "true", "", newEmail); 
     387            if (error != NO_ERROR) 
     388            { 
     389                serviceNode.setAttribute("operation", REGISTER); 
     390                GSXML.addError(this.doc, result, _errorMessageMap.get(error)); 
     391            } 
     392        } 
     393        else if (op.equals(PERFORM_EDIT)) 
     394        { 
     395            String previousUsername = (String) paramMap.get("prevUsername"); 
     396            String newUsername = (String) paramMap.get("newUsername"); 
     397            String newPassword = (String) paramMap.get("password"); 
     398            String newGroups = (String) paramMap.get("groups"); 
     399            String newStatus = (String) paramMap.get("status"); 
     400            String newComment = (String) paramMap.get("comment"); 
     401            String newEmail = (String) paramMap.get("email"); 
     402 
     403            if (newPassword == null) 
     404            { 
     405                newPassword = retrieveDataForUser(previousUsername, "password"); 
     406            } 
     407 
     408            int error = removeUser(previousUsername); 
     409            if (error != NO_ERROR) 
     410            { 
     411                if (error == ERROR_USERNAME_NOT_SPECIFIED) 
     412                { 
     413                    addUserInformationToNode(null, serviceNode); 
     414                    serviceNode.setAttribute("operation", LIST_USERS); 
     415                } 
     416                else 
     417                { 
     418                    serviceNode.setAttribute("operation", EDIT_USER); 
     419                    GSXML.addError(this.doc, result, _errorMessageMap.get(error)); 
     420                } 
     421                return result; 
     422            } 
     423            error = addUser(newUsername, newPassword, newGroups, newStatus, newComment, newEmail); 
     424            if (error != NO_ERROR) 
     425            { 
     426                serviceNode.setAttribute("operation", EDIT_USER); 
     427                GSXML.addError(this.doc, result, _errorMessageMap.get(error)); 
     428            } 
     429            else 
     430            { 
     431                addUserInformationToNode(null, serviceNode); 
     432                serviceNode.setAttribute("operation", LIST_USERS); 
     433            } 
     434        } 
     435        else if (op.equals(PERFORM_ACCOUNT_EDIT)) 
     436        { 
     437            String previousUsername = (String) paramMap.get("prevUsername"); 
     438            String newUsername = (String) paramMap.get("newUsername"); 
     439            String oldPassword = (String) paramMap.get("oldPassword"); 
     440            String newPassword = (String) paramMap.get("newPassword"); 
     441            String newEmail = (String) paramMap.get("newEmail"); 
     442 
     443            //Make sure the user name does not already exist 
     444            if (!previousUsername.equals(newUsername) && checkUserExists(newUsername)) 
     445            { 
     446                addUserInformationToNode(previousUsername, serviceNode); 
     447                serviceNode.setAttribute("operation", ACCOUNT_SETTINGS); 
     448                GSXML.addError(this.doc, result, _errorMessageMap.get(ERROR_USER_ALREADY_EXISTS)); 
     449                return result; 
     450            } 
     451 
     452            String prevPassword = retrieveDataForUser(previousUsername, "password"); 
     453 
     454            if (newPassword != null) 
     455            { 
     456                oldPassword = hashPassword(oldPassword); 
     457 
     458                if (oldPassword == null || !oldPassword.equals(prevPassword)) 
     459                { 
     460                    addUserInformationToNode(previousUsername, serviceNode); 
     461                    serviceNode.setAttribute("operation", ACCOUNT_SETTINGS); 
     462                    GSXML.addError(this.doc, result, _errorMessageMap.get(ERROR_INCORRECT_PASSWORD)); 
     463                    return result; 
     464                } 
     465            } 
     466            else 
     467            { 
     468                newPassword = prevPassword; 
     469            } 
     470 
     471            String prevGroups = retrieveDataForUser(previousUsername, "groups"); 
     472            String prevStatus = retrieveDataForUser(previousUsername, "status"); 
     473            String prevComment = retrieveDataForUser(previousUsername, "comment"); 
     474 
     475            int error = removeUser(previousUsername); 
     476            if (error != NO_ERROR) 
     477            { 
     478                if (error == ERROR_USERNAME_NOT_SPECIFIED) 
     479                { 
     480                    addUserInformationToNode(null, serviceNode); 
     481                    serviceNode.setAttribute("operation", LIST_USERS); 
     482                } 
     483                else 
     484                { 
     485                    addUserInformationToNode(previousUsername, serviceNode); 
     486                    serviceNode.setAttribute("operation", ACCOUNT_SETTINGS); 
     487                    GSXML.addError(this.doc, result, _errorMessageMap.get(error)); 
     488                } 
     489                return result; 
     490            } 
     491 
     492            error = addUser(newUsername, newPassword, prevGroups, prevStatus, prevComment, newEmail); 
     493            if (error != NO_ERROR) 
     494            { 
     495                GSXML.addError(this.doc, result, _errorMessageMap.get(error)); 
     496            } 
     497 
     498            addUserInformationToNode(null, serviceNode); 
     499            serviceNode.setAttribute("operation", LIST_USERS); 
     500        } 
     501        else if (op.equals(EDIT_USER)) 
     502        { 
     503            String editUsername = (String) paramMap.get("username"); 
     504            int error = addUserInformationToNode(editUsername, serviceNode); 
     505            if (error != NO_ERROR) 
     506            { 
     507                GSXML.addError(this.doc, result, _errorMessageMap.get(error)); 
     508            } 
     509        } 
     510        else if (op.equals(ACCOUNT_SETTINGS)) 
     511        { 
     512            String editUsername = (String) paramMap.get("username"); 
     513             
     514            if(editUsername == null) 
     515            { 
     516                serviceNode.setAttribute("operation", ""); 
     517                GSXML.addError(this.doc, result, _errorMessageMap.get(ERROR_USERNAME_NOT_SPECIFIED)); 
     518                return result; 
     519            } 
     520             
     521            if(!editUsername.equals(username)) 
     522            { 
     523                serviceNode.setAttribute("operation", LOGIN); 
     524                GSXML.addError(this.doc, result, _errorMessageMap.get(ERROR_NOT_AUTHORISED)); 
     525                return result; 
     526            } 
     527            int error = addUserInformationToNode(editUsername, serviceNode); 
     528            if (error != NO_ERROR) 
     529            { 
     530                GSXML.addError(this.doc, result, _errorMessageMap.get(error)); 
     531            } 
     532        } 
     533        else if (op.equals(PERFORM_RESET_PASSWORD)) 
     534        { 
     535            String passwordResetUser = (String) paramMap.get("username"); 
     536             
     537            String newPassword = UUID.randomUUID().toString(); 
     538            newPassword = newPassword.substring(0, newPassword.indexOf("-")); 
     539             
     540            String email = retrieveDataForUser(passwordResetUser, "email"); 
     541            String from = "admin@greenstone.org"; 
     542            String host = request.getAttribute("remoteAddress"); 
     543             
     544            Properties props = System.getProperties(); 
     545            props.setProperty("mail.smtp.host", host); 
     546             
     547            Session session = Session.getDefaultInstance(props); 
     548             
     549            try 
     550            { 
     551                MimeMessage message = new MimeMessage(session); 
     552                message.setFrom(new InternetAddress(from)); 
     553                message.addRecipient(Message.RecipientType.TO, new InternetAddress(email)); 
     554                message.setSubject("Password reset"); 
     555                message.setText("Your password was reset to " + newPassword); 
     556                 
     557                Transport.send(message); 
     558            } 
     559            catch(Exception ex) 
     560            { 
     561                GSXML.addError(this.doc, result, _errorMessageMap.get(ERROR_COULD_NOT_RESET_PASSWORD)); 
     562                serviceNode.setAttribute("operation", ACCOUNT_SETTINGS); 
     563                ex.printStackTrace(); 
     564                return result; 
     565            } 
     566             
     567            System.err.println("MAIL SUCCESS"); 
     568        } 
     569        else if (op.equals(PERFORM_DELETE_USER)) 
     570        { 
     571            String usernameToDelete = (String) paramMap.get("username"); 
     572            int error = removeUser(usernameToDelete); 
     573            if (error != NO_ERROR) 
     574            { 
     575                GSXML.addError(this.doc, result, _errorMessageMap.get(error)); 
     576            } 
     577            addUserInformationToNode(null, serviceNode); 
     578            serviceNode.setAttribute("operation", LIST_USERS); 
     579        } 
     580 
     581        return result; 
     582    } 
     583 
     584    public static String hashPassword(String password) 
     585    { 
     586        String hashedPassword = null; 
     587        try 
     588        { 
     589            MessageDigest digest = MessageDigest.getInstance("SHA-1"); 
     590            digest.reset(); 
     591            hashedPassword = new String(digest.digest(password.getBytes("UTF-8"))); 
     592        } 
     593        catch (Exception ex) 
     594        { 
     595            ex.printStackTrace(); 
     596        } 
     597        return hashedPassword; 
     598    } 
     599 
     600    private void checkAdminUserExists() 
     601    { 
     602        if (_derbyWrapper == null) 
     603        { 
     604            openDatabase(); 
     605        } 
     606 
     607        UserQueryResult userQueryResult = _derbyWrapper.findUser(null, null); 
     608        closeDatabase(); 
     609 
     610        if (userQueryResult != null) 
     611        { 
     612            Vector userInfo = userQueryResult.users; 
     613 
     614            boolean adminFound = false; 
     615            for (int i = 0; i < userQueryResult.getSize(); i++) 
     616            { 
     617                if (((UserTermInfo) userInfo.get(i)).groups != null && ((UserTermInfo) userInfo.get(i)).groups.matches(".*\\badministrator\\b.*")) 
     618                { 
     619                    adminFound = true; 
     620                } 
     621            } 
     622 
     623            if (!adminFound) 
     624            { 
     625                addUser("admin", "admin", "administrator", "true", "Change the password for this account as soon as possible", ""); 
     626            } 
     627        } 
     628 
     629        closeDatabase(); 
     630    } 
     631 
     632    private boolean openDatabase() 
     633    { 
     634        _derbyWrapper = new DerbyWrapper(); 
    288635 
    289636        // check the usersDb database, if it isn't existing, check the etc dir, create the etc dir if it isn't existing, then create the  user database and add a "admin" user 
    290637        String usersDB_dir = this.site_home + File.separatorChar + "etc" + File.separatorChar + "usersDB"; 
    291         DerbyWrapper derbyWrapper = new DerbyWrapper(); 
    292638        File usersDB_file = new File(usersDB_dir); 
    293639        if (!usersDB_file.exists()) 
     
    301647                { 
    302648                    logger.error("Couldn't create the etc dir under " + this.site_home + "."); 
    303                     return result; 
    304                 } 
    305             } 
    306             derbyWrapper.connectDatabase(usersDB_dir, true); 
    307             derbyWrapper.createDatabase(); 
     649                    return false; 
     650                } 
     651            } 
     652            _derbyWrapper.connectDatabase(usersDB_dir, true); 
     653            _derbyWrapper.createDatabase(); 
    308654        } 
    309655        else 
    310656        { 
    311             derbyWrapper.connectDatabase(usersDB_dir, false); 
    312         } 
    313  
    314         // Action: login 
    315         if (aup.equals("Login")) 
    316         { 
    317             if (uan.equals("")) 
    318             { //return a login page, if the user's name is not given 
    319                 service_node.setAttribute("info", "Login"); 
    320                 derbyWrapper.closeDatabase(); 
    321                 return result; 
    322             } 
    323             String groups = ""; 
    324             // if the authentication(uan=1) is required,but the user hasn't been authenticated(asn=0),the user is asked to login first 
    325             if ((uan.equals("1") && asn.equals("0"))) 
    326             { 
    327                 if ((un.length() == 0) && (pw.length() == 0)) 
    328                 { 
    329                     service_node.setAttribute("asn", "0"); 
    330                     service_node.setAttribute("info", "Login"); 
    331                     derbyWrapper.closeDatabase(); 
    332                     return result; 
    333                 } 
    334                 if ((un.length() == 0) || (pw.length() == 0)) 
    335                 { 
    336                     service_node.setAttribute("asn", "0"); 
    337                     service_node.setAttribute("info", "Login"); 
    338                     service_node.setAttribute("err", "un-pw-err"); 
    339                     derbyWrapper.closeDatabase(); 
    340                     return result; 
    341                 } 
    342                 else 
    343                 { 
    344                     userQueryResult = derbyWrapper.findUser(un, pw);//looking for the user from the users table 
    345                     service_node.setAttribute(GSXML.NAME_ATT, "Authentication"); 
    346                     service_node.setAttribute("un", un); 
    347                     if (userQueryResult == null) 
    348                     { 
    349                         //the user isn't a vaild user 
    350                         service_node.setAttribute("asn", "0"); 
    351                         service_node.setAttribute("err", "un-pw-err");// either unsername or password is wrong 
    352                         service_node.setAttribute("info", "Login"); 
    353                         derbyWrapper.closeDatabase(); 
    354                         return result; 
    355                     } 
    356                     else 
    357                     { 
    358                         // asn="1"; //the user is a member of the "administrator" group 
    359                         Vector userInfo = userQueryResult.users_; 
    360                         groups = ((UserTermInfo) userInfo.get(0)).groups_; 
    361                         String accountstatus = ((UserTermInfo) userInfo.get(0)).accountstatus_; 
    362                         if (accountstatus.trim().equals("false")) 
    363                         { 
    364                             service_node.setAttribute("asn", "0"); 
    365                             service_node.setAttribute("err", "as-false");//the account status is false 
    366                             service_node.setAttribute("info", "Login"); 
    367                             derbyWrapper.closeDatabase(); 
    368                             return result; 
    369                         } 
    370                         String[] groups_array = groups.split(","); 
    371                         for (int i = 0; i < groups_array.length; i++) 
    372                         { 
    373                             if ((groups_array[i].trim().toLowerCase()).equals("administrator")) 
    374                             {// check whether the user is in the administrator group 
    375                                 asn = "1"; 
    376                                 service_node.setAttribute("asn", "1"); 
    377                                 break; 
    378                             } 
    379                         } 
    380                         if (!asn.equals("1")) 
    381                         { 
    382                             asn = "2"; 
    383                             service_node.setAttribute("asn", "2");//the user is authenticated                            
    384                         } 
    385                     } 
    386                 } 
    387             } 
    388  
    389             //asn!=0 This is a valid user  
    390             if (!asn.equals("0")) 
    391             { 
    392                 service_node.setAttribute("info", "Login"); 
    393                 service_node.setAttribute("un", un); 
    394                 service_node.setAttribute("pw", pw); 
    395                 service_node.setAttribute("asn", asn); 
    396                 service_node.setAttribute("umgp", groups); 
    397                 derbyWrapper.closeDatabase(); 
    398                 return result; 
    399             } 
    400         } 
    401  
    402         //Action: listuser 
    403         if (aup.equals("ListUsers")) 
    404         { 
    405             if (asn.equals("") && un.equals("")) 
    406             { 
    407                 service_node.setAttribute("info", "Login"); 
    408                 derbyWrapper.closeDatabase(); 
    409                 return result; 
    410             } 
    411  
    412             //valid users but not in the administrator group(asn=2), they cannot list all users 
    413             if (asn.equals("2")) 
    414             { 
    415                 service_node.setAttribute("info", "Login"); 
    416                 service_node.setAttribute("err", "no-permission"); 
    417                 service_node.setAttribute("un", un); 
    418                 service_node.setAttribute("asn", asn); 
    419                 derbyWrapper.closeDatabase(); 
    420                 return result; 
    421             } 
    422             //valid users belong to the administrator group(asn=1), they can list all users 
    423             if (asn.equals("1")) 
    424             { 
    425                 userQueryResult = derbyWrapper.findUser(null, null); 
    426                 derbyWrapper.closeDatabase(); 
    427                 service_node.setAttribute(GSXML.NAME_ATT, "Authentication"); 
    428                 service_node.setAttribute("un", un); 
    429                 service_node.setAttribute("asn", asn); 
    430  
    431                 if (userQueryResult != null && userQueryResult.getSize() > 0) 
    432                 { 
    433                     service_node.setAttribute("info", "all-un"); // got a user list 
    434                     Element user_node = getUserNode(userQueryResult); 
    435                     service_node.appendChild(user_node); 
    436                     derbyWrapper.closeDatabase(); 
    437                     return result; 
    438                 } 
    439                 else 
    440                 { 
    441                     service_node.setAttribute("err", "no-un"); // no user returned 
    442                     derbyWrapper.closeDatabase(); 
    443                     return result; 
    444                 } 
    445             } 
    446         } 
    447         //TODO: Action : addStudents (bulk adding) 
    448         if (aup.equals("AddStudents")) 
    449         { 
    450             String[] users = unpwlist.split("]"); 
    451             for (int i = 0; i < users.length; i++) 
    452             { 
    453                 String[] user = users[i].split(","); 
    454                 String uname = user[0]; 
    455                 String password = user[1]; 
    456                 String group = user[2].split(":")[0]; 
    457                 String add_user = derbyWrapper.addUser(uname, password, group, "true", ""); 
    458                 if (add_user.equals("succeed")) 
    459                 { 
    460                     userQueryResult = derbyWrapper.findUser(null, null); 
    461                     derbyWrapper.closeDatabase(); 
    462                     service_node.setAttribute("info", "all-un"); // return a list of all users if the user has been added 
    463                     Element user_node = getUserNode(userQueryResult); 
    464                     service_node.appendChild(user_node); 
    465                     derbyWrapper.closeDatabase(); 
    466                     return result; 
    467                 } 
    468             } 
    469         } 
    470  
    471         //Action : adduder 
    472         if (aup.equals("AddUser")) 
    473         { 
    474             if (asn.equals("") && un.equals("")) 
    475             { 
    476                 service_node.setAttribute("info", "Login"); 
    477                 derbyWrapper.closeDatabase(); 
    478                 return result; 
    479             } 
    480             //valid users can't add a new user because they aren't in the administrator group(asn=2) 
    481             if (asn.equals("2")) 
    482             { 
    483                 service_node.setAttribute("info", "Login"); 
    484                 service_node.setAttribute("err", "no-permission"); 
    485                 service_node.setAttribute("un", un); 
    486                 service_node.setAttribute("asn", asn); 
    487                 derbyWrapper.closeDatabase(); 
    488                 return result; 
    489             } 
    490             //valid users are in the administrator group, they can add a new user(asn=1) 
    491             if (asn.equals("1")) 
    492             { 
    493                 service_node.setAttribute(GSXML.NAME_ATT, "Authentication"); 
    494                 service_node.setAttribute("un", un); 
    495                 service_node.setAttribute("asn", asn); 
    496  
    497                 if (umun.length() == 0 && umpw.length() == 0 && umgp.length() == 0 && umas.length() == 0 && umc.length() == 0) 
    498                 { 
    499                     service_node.setAttribute("info", "adduser_interface"); 
    500                     derbyWrapper.closeDatabase(); 
    501                     return result; 
    502                 } 
    503  
    504                 //check the strings of username and password 
    505                 if ((umun == null) || (umun.length() < 2) || (umun.length() > 30) || (!(Pattern.matches("[a-zA-Z0-9//_//.]+", umun)))) 
    506                 { 
    507                     service_node.setAttribute("err", "un-err"); //the input username string is illegal 
    508                     service_node.setAttribute("info", "adduser_interface"); 
    509                     derbyWrapper.closeDatabase(); 
    510                     return result; 
    511                 } 
    512  
    513                 if ((umpw == null) || (umpw.length() < 3) || (umpw.length() > 8) || (!(Pattern.matches("[\\p{ASCII}]+", umpw)))) 
    514                 { 
    515                     service_node.setAttribute("err", "pw-err"); //the input passwrod string is illegal 
    516                     service_node.setAttribute("info", "adduser_interface"); 
    517                     derbyWrapper.closeDatabase(); 
    518                     return result; 
    519                 } 
    520  
    521                 // add the new users into the users table 
    522                 umgp = umgp.replaceAll(" ", "");//get rid of the space of the groups string 
    523                 userQueryResult = derbyWrapper.findUser(umun, null);// check whether the new user name has existed in the table. 
    524                 if (userQueryResult != null) 
    525                 { 
    526                     service_node.setAttribute("err", "un-exist"); //the new username string is duplicated 
    527                     service_node.setAttribute("info", "adduser_interface"); 
    528                     derbyWrapper.closeDatabase(); 
    529                     return result; 
    530                 } 
    531                 else 
    532                 { 
    533                     String add_user = derbyWrapper.addUser(umun, umpw, umgp, umas, umc); 
    534                     if (add_user.equals("succeed")) 
    535                     { 
    536                         userQueryResult = derbyWrapper.findUser(null, null); 
    537                         derbyWrapper.closeDatabase(); 
    538                         service_node.setAttribute("info", "all-un"); // return a list of all users if the user has been added 
    539                         Element user_node = getUserNode(userQueryResult); 
    540                         service_node.appendChild(user_node); 
    541                         derbyWrapper.closeDatabase(); 
    542                         return result; 
    543                     } 
    544                     else 
    545                     { 
    546                         derbyWrapper.closeDatabase(); 
    547                         service_node.setAttribute("err", add_user);// return the error message if the user couldn't be added  
    548                         derbyWrapper.closeDatabase(); 
    549                         return result; 
    550                     } 
    551                 } 
    552             } 
    553         } 
    554  
    555         //Action: edituser 
    556         if (aup.equals("EditUser")) 
    557         { 
    558             service_node.setAttribute(GSXML.NAME_ATT, "Authentication"); 
    559             service_node.setAttribute("un", un); 
    560             service_node.setAttribute("asn", asn); 
    561  
    562             //Get the user's info from the database 
    563             if (cm.length() == 0) 
    564             { 
    565                 service_node.setAttribute("info", "edituser-interface"); 
    566                 userQueryResult = derbyWrapper.findUser(umun, null); 
    567                 derbyWrapper.closeDatabase(); 
    568                 Vector userInfo = userQueryResult.users_; 
    569                 String username = ((UserTermInfo) userInfo.get(0)).username_; 
    570                 String password = ((UserTermInfo) userInfo.get(0)).password_; 
    571                 String groups = ((UserTermInfo) userInfo.get(0)).groups_; 
    572                 String accountstatus = ((UserTermInfo) userInfo.get(0)).accountstatus_; 
    573                 String comment = ((UserTermInfo) userInfo.get(0)).comment_; 
    574  
    575                 service_node.setAttribute("oumun", oumun); 
    576                 service_node.setAttribute("umun", username); 
    577                 service_node.setAttribute("umpw", password); 
    578                 service_node.setAttribute("umgp", groups); 
    579                 service_node.setAttribute("umas", accountstatus); 
    580                 service_node.setAttribute("umc", comment); 
    581                 derbyWrapper.closeDatabase(); 
    582                 return result; 
    583             } 
    584  
    585             //Commit the modified user's info to the database 
    586             if (cm.toLowerCase().equals("submit")) 
    587             { 
    588                 if (oumun.equals(umun)) 
    589                 {// the user's name hasn't been changed, update the user's info 
    590                     if (umpw.length() == 0) 
    591                     { 
    592                         derbyWrapper.modifyUserInfo(umun, null, umgp, umas, umc); 
    593                         userQueryResult = derbyWrapper.findUser(null, null); 
    594                         derbyWrapper.closeDatabase(); 
    595                         service_node.setAttribute("info", "all-un"); // the user's info has been updated, return a list of all users  
    596                         Element user_node = getUserNode(userQueryResult); 
    597                         service_node.appendChild(user_node); 
    598                         derbyWrapper.closeDatabase(); 
    599                         return result; 
    600                     } 
    601                     else 
    602                     { 
    603                         if ((umpw.length() == 0) || (umpw.length() < 3) || (umpw.length() > 8) || (!(Pattern.matches("[\\p{ASCII}]+", umpw)))) 
    604                         { 
    605                             service_node.setAttribute("err", "umpw-err"); //the input passwrod string is illegal 
    606                             service_node.setAttribute("info", "edituser-interface"); 
    607                             service_node.setAttribute("umun", umun); 
    608                             service_node.setAttribute("umpw", umpw); 
    609                             service_node.setAttribute("umgp", umgp); 
    610                             service_node.setAttribute("umas", umas); 
    611                             service_node.setAttribute("umc", umc); 
    612                             service_node.setAttribute("oumun", oumun); 
    613                             derbyWrapper.closeDatabase(); 
    614                             return result; 
    615                         } 
    616                         umgp = umgp.replaceAll(" ", "");// get rid of the space 
    617                         derbyWrapper.modifyUserInfo(umun, umpw, umgp, umas, umc); 
    618                         userQueryResult = derbyWrapper.listAllUser(); 
    619                         derbyWrapper.closeDatabase(); 
    620                         service_node.setAttribute("info", "all-un"); // if the new user has been added successfully, return a list of all users  
    621                         Element user_node = getUserNode(userQueryResult); 
    622                         service_node.appendChild(user_node); 
    623                         derbyWrapper.closeDatabase(); 
    624                         return result; 
    625                     } 
    626                 } 
    627                 // The user's name has been changed, add a new user record to the database 
    628                 else 
    629                 { 
    630                     if ((umun.length() == 0) || (umun.length() < 2) || (umun.length() > 30) || (!(Pattern.matches("[a-zA-Z0-9//_//.]+", umun)))) 
    631                     { 
    632                         service_node.setAttribute("err", "umun-err"); //the input username string is illegal 
    633                         service_node.setAttribute("umun", umun); 
    634                         service_node.setAttribute("umpw", umpw); 
    635                         service_node.setAttribute("umgp", umgp); 
    636                         service_node.setAttribute("umas", umas); 
    637                         service_node.setAttribute("umc", umc); 
    638                         service_node.setAttribute("oumun", oumun); 
    639                         service_node.setAttribute("info", "edituser-interface"); 
    640                         derbyWrapper.closeDatabase(); 
    641                         return result; 
    642                     } 
    643                     if (umpw.length() == 0) 
    644                     { 
    645                         service_node.setAttribute("err", "ini-umpw-err"); //the input passwrod string is illegal 
    646                         service_node.setAttribute("info", "edituser-interface"); 
    647                         service_node.setAttribute("umun", umun); 
    648                         service_node.setAttribute("umpw", umpw); 
    649                         service_node.setAttribute("umgp", umgp); 
    650                         service_node.setAttribute("umas", umas); 
    651                         service_node.setAttribute("umc", umc); 
    652                         service_node.setAttribute("oumun", oumun); 
    653                         derbyWrapper.closeDatabase(); 
    654                         return result; 
    655                     } 
    656                     if ((umpw.length() < 3) || (umpw.length() > 8) || (!(Pattern.matches("[\\p{ASCII}]+", umpw)))) 
    657                     { 
    658                         service_node.setAttribute("err", "umpw-err"); //the input passwrod string is illegal 
    659                         service_node.setAttribute("info", "edituser-interface"); 
    660                         service_node.setAttribute("umun", umun); 
    661                         service_node.setAttribute("umpw", umpw); 
    662                         service_node.setAttribute("umgp", umgp); 
    663                         service_node.setAttribute("umas", umas); 
    664                         service_node.setAttribute("umc", umc); 
    665                         service_node.setAttribute("oumun", oumun); 
    666                         derbyWrapper.closeDatabase(); 
    667                         return result; 
    668                     } 
    669                     umgp = umgp.replaceAll(" ", "");// get rid of the space 
    670                     userQueryResult = derbyWrapper.findUser(umun, null);// check whether the new user name has existed in the table. 
    671                     if (userQueryResult != null) 
    672                     { 
    673                         service_node.setAttribute("err", "un-exist"); //the new username string is duplicated 
    674                         service_node.setAttribute("info", "edituser-interface"); 
    675                         service_node.setAttribute("umun", ""); 
    676                         service_node.setAttribute("umpw", ""); 
    677                         service_node.setAttribute("umgp", umgp); 
    678                         service_node.setAttribute("umas", umas); 
    679                         service_node.setAttribute("umc", umc); 
    680                         service_node.setAttribute("oumun", oumun); 
    681                         derbyWrapper.closeDatabase(); 
    682                         return result; 
    683                     } 
    684                     else 
    685                     { 
    686                         derbyWrapper.addUser(umun, umpw, umgp, umas, umc); 
    687                         userQueryResult = derbyWrapper.listAllUser(); 
    688                         derbyWrapper.closeDatabase(); 
    689                         service_node.setAttribute("info", "all-un"); // if the new user has been added successfully, return a list of all users  
    690                         Element user_node = getUserNode(userQueryResult); 
    691                         service_node.appendChild(user_node); 
    692                         derbyWrapper.closeDatabase(); 
    693                         return result; 
    694                     } 
    695                 } 
    696             } 
    697  
    698             if (cm.toLowerCase().equals("cancel")) 
    699             { 
    700                 userQueryResult = derbyWrapper.listAllUser(); 
    701                 derbyWrapper.closeDatabase(); 
    702                 service_node.setAttribute("info", "all-un"); // if the new user has been added successfully, return a list of all users  
    703                 Element user_node = getUserNode(userQueryResult); 
    704                 service_node.appendChild(user_node); 
    705                 derbyWrapper.closeDatabase(); 
    706                 return result; 
    707             } 
    708         } 
    709  
    710         //Action: modifypassword 
    711         if (aup.equals("ModifyPassword")) 
    712         { 
    713             if (un.equals("")) 
    714             { 
    715                 service_node.setAttribute("info", "Login"); 
    716                 derbyWrapper.closeDatabase(); 
    717                 return result; 
    718             } 
    719  
    720             service_node.setAttribute(GSXML.NAME_ATT, "Authentication"); 
    721             service_node.setAttribute("un", un); 
    722             service_node.setAttribute("asn", asn); 
    723  
    724             userQueryResult = derbyWrapper.findUser(un, null); 
    725             Vector userInfo = userQueryResult.users_; 
    726             pw = ((UserTermInfo) userInfo.get(0)).password_; 
    727  
    728             if ((umpw1.length() == 0) && (umpw2.length() == 0) && (umpw.length() == 0)) 
    729             { 
    730                 service_node.setAttribute("info", "modify_interface");// call the interface of the modifying password  
    731                 derbyWrapper.closeDatabase(); 
    732                 return result; 
    733             } 
    734  
    735             if (!pw.equals(umpw) && umpw.length() > 0) 
    736             { 
    737                 service_node.setAttribute("info", "modify_interface"); 
    738                 service_node.setAttribute("err", "pw-umpw-nm-err");//if the original password is not match 
    739                 derbyWrapper.closeDatabase(); 
    740                 return result; 
    741             } 
    742  
    743             if ((umpw1.length() == 0) || (umpw2.length() == 0)) 
    744             { 
    745                 service_node.setAttribute("info", "modify_interface"); 
    746                 service_node.setAttribute("err", "umpw1-umpw2-null-err");//if one of the password strings is none,return the err info back 
    747                 derbyWrapper.closeDatabase(); 
    748                 return result; 
    749             } 
    750  
    751             if (!umpw1.equals(umpw2)) 
    752             { 
    753                 service_node.setAttribute("info", "modify_interface"); 
    754                 service_node.setAttribute("err", "umpw1-umpw2-nm-err");//if one of the password strings is none,return the err info back 
    755                 derbyWrapper.closeDatabase(); 
    756                 return result; 
    757             } 
    758  
    759             if (umpw.length() == 0) 
    760             { 
    761                 service_node.setAttribute("info", "modify_interface"); 
    762                 service_node.setAttribute("err", "umpw-null-err");//if one of the password strings is none,return the err info back 
    763                 derbyWrapper.closeDatabase(); 
    764                 return result; 
    765             } 
    766             //check the new password and the retyped password 
    767             if ((umpw1 == null) || (umpw1.length() < 3) || (umpw1.length() > 8) || (!(Pattern.matches("[\\p{ASCII}]+", umpw1)))) 
    768             { 
    769                 service_node.setAttribute("info", "modify_interface"); 
    770                 service_node.setAttribute("err", "umpw1-err");// the new password is illegal 
    771                 derbyWrapper.closeDatabase(); 
    772                 return result; 
    773             } 
    774  
    775             if ((umpw2 == null) || (umpw2.length() < 3) || (umpw2.length() > 8) || (!(Pattern.matches("[\\p{ASCII}]+", umpw2)))) 
    776             { 
    777                 service_node.setAttribute("info", "modify_interface"); 
    778                 service_node.setAttribute("err", "umpw2-err"); // the retyped password is illegal 
    779                 derbyWrapper.closeDatabase(); 
    780                 return result; 
    781             } 
    782             String modify_user_info = derbyWrapper.modifyUserInfo(un, umpw1, null, null, null); 
    783             if (modify_user_info.equals("succeed")) 
    784             { 
    785                 service_node.setAttribute("err", "");// the passsword has been changed successfully 
    786                 derbyWrapper.closeDatabase(); 
    787                 return result; 
     657            _derbyWrapper.connectDatabase(usersDB_dir, false); 
     658        } 
     659        return true; 
     660    } 
     661 
     662    private void closeDatabase() 
     663    { 
     664        if (_derbyWrapper != null) 
     665        { 
     666            _derbyWrapper.closeDatabase(); 
     667            _derbyWrapper = null; 
     668        } 
     669    } 
     670 
     671    private int addUserInformationToNode(String username, Element serviceNode) 
     672    { 
     673        if (_derbyWrapper == null) 
     674        { 
     675            openDatabase(); 
     676        } 
     677 
     678        UserQueryResult userQueryResult = _derbyWrapper.findUser(username, null); 
     679        closeDatabase(); 
     680 
     681        if (userQueryResult != null) 
     682        { 
     683            Element user_node = getUserNode(userQueryResult); 
     684            serviceNode.appendChild(user_node); 
     685            closeDatabase(); 
     686            return NO_ERROR; 
     687        } 
     688 
     689        closeDatabase(); 
     690        return ERROR_COULD_NOT_GET_USER_INFO; 
     691    } 
     692 
     693    private int removeUser(String username) 
     694    { 
     695        if (username == null) 
     696        { 
     697            return ERROR_USERNAME_NOT_SPECIFIED; 
     698        } 
     699 
     700        if (_derbyWrapper == null) 
     701        { 
     702            openDatabase(); 
     703        } 
     704 
     705        boolean success = _derbyWrapper.deleteUser(username); 
     706        closeDatabase(); 
     707 
     708        if (success) 
     709        { 
     710            return NO_ERROR; 
     711        } 
     712 
     713        return ERROR_REMOVING_USER; 
     714    } 
     715 
     716    private int addUser(String newUsername, String newPassword, String newGroups, String newStatus, String newComment, String newEmail) 
     717    { 
     718        if (_derbyWrapper == null) 
     719        { 
     720            openDatabase(); 
     721        } 
     722 
     723        //Check the given user name 
     724        if ((newUsername == null) || (newUsername.length() < 2) || (newUsername.length() > 30) || (!(Pattern.matches("[a-zA-Z0-9//_//.]+", newUsername)))) 
     725        { 
     726            closeDatabase(); 
     727            return ERROR_INVALID_USERNAME; 
     728        } 
     729 
     730        //Check the given password 
     731        if ((newPassword == null) || (newPassword.length() < 3) || (newPassword.length() > 8) || (!(Pattern.matches("[\\p{ASCII}]+", newPassword)))) 
     732        { 
     733            closeDatabase(); 
     734            return ERROR_INVALID_PASSWORD; 
     735        } 
     736 
     737        newPassword = hashPassword(newPassword); 
     738 
     739        newGroups = newGroups.replaceAll(" ", ""); 
     740 
     741        //Check if the user already exists 
     742        UserQueryResult userQueryResult = _derbyWrapper.findUser(newUsername, null); 
     743        if (userQueryResult != null) 
     744        { 
     745            return ERROR_USER_ALREADY_EXISTS; 
     746        } 
     747        else 
     748        { 
     749            System.err.println("ADDING " + newUsername + " " + newPassword); 
     750            boolean success = _derbyWrapper.addUser(newUsername, newPassword, newGroups, newStatus, newComment, newEmail); 
     751            if (!success) 
     752            { 
     753                closeDatabase(); 
     754                return ERROR_ADDING_USER; 
     755            } 
     756        } 
     757        closeDatabase(); 
     758        return NO_ERROR; 
     759    } 
     760 
     761    private boolean checkUserExists(String username) 
     762    { 
     763        if (_derbyWrapper == null) 
     764        { 
     765            openDatabase(); 
     766        } 
     767 
     768        try 
     769        { 
     770            UserQueryResult result = _derbyWrapper.findUser(username); 
     771 
     772            if (result != null) 
     773            { 
     774                return true; 
    788775            } 
    789776            else 
    790777            { 
    791                 service_node.setAttribute("err", modify_user_info);// return the error message of the pasword couldn't be modified  
    792                 derbyWrapper.closeDatabase(); 
    793                 return result; 
    794             } 
    795         } 
    796  
    797         //Action: deleteuser 
    798         if (aup.equals("DeleteUser")) 
    799         { 
    800             service_node.setAttribute("un", un); 
    801             service_node.setAttribute("asn", asn); 
    802             service_node.setAttribute("umun", umun); 
    803             if (cm.equals("yes")) 
    804             { 
    805                 String delete_user = derbyWrapper.deleteUser(umun); 
    806                 if (delete_user.equals("succeed")) 
    807                 { 
    808                     service_node.setAttribute("err", ""); 
    809                     userQueryResult = derbyWrapper.listAllUser(); 
    810                     service_node.setAttribute("info", "all-un"); //  return a list of all users  
    811                     Element user_node = getUserNode(userQueryResult); 
    812                     service_node.appendChild(user_node); 
    813                 } 
    814                 else 
    815                 { 
    816                     service_node.setAttribute("err", delete_user);//return the error message 
    817                     derbyWrapper.closeDatabase(); 
    818                     return result; 
    819                 } 
    820             } 
    821             else if (cm.equals("no")) 
    822             { 
    823                 service_node.setAttribute("err", ""); 
    824                 userQueryResult = derbyWrapper.listAllUser(); 
    825                 service_node.setAttribute("info", "all-un"); //  return a list of all users  
    826                 Element user_node = getUserNode(userQueryResult); 
    827                 service_node.appendChild(user_node); 
    828                 derbyWrapper.closeDatabase(); 
    829                 return result; 
    830             } 
    831             else 
    832             { 
    833                 service_node.setAttribute("info", "confirm"); 
    834                 derbyWrapper.closeDatabase(); 
    835                 return result; 
    836             } 
    837         } 
    838  
    839         return result; 
     778                return false; 
     779            } 
     780 
     781        } 
     782        catch (Exception ex) 
     783        { 
     784            return false; 
     785        } 
     786        finally 
     787        { 
     788            closeDatabase(); 
     789        } 
     790    } 
     791 
     792    private String retrieveDataForUser(String username, String dataType) 
     793    { 
     794        if (_derbyWrapper == null) 
     795        { 
     796            openDatabase(); 
     797        } 
     798 
     799        String password = null; 
     800 
     801        try 
     802        { 
     803            UserQueryResult result = _derbyWrapper.findUser(username); 
     804            Vector userInfo = result.users; 
     805 
     806            for (int i = 0; i < result.getSize(); i++) 
     807            { 
     808                if (dataType.equals("password")) 
     809                { 
     810                    return ((UserTermInfo) userInfo.get(i)).password; 
     811                } 
     812                else if (dataType.equals("groups")) 
     813                { 
     814                    return ((UserTermInfo) userInfo.get(i)).groups; 
     815                } 
     816                else if (dataType.equals("status")) 
     817                { 
     818                    return ((UserTermInfo) userInfo.get(i)).accountstatus; 
     819                } 
     820                else if (dataType.equals("comment")) 
     821                { 
     822                    return ((UserTermInfo) userInfo.get(i)).comment; 
     823                } 
     824                else if (dataType.equals("email")) 
     825                { 
     826                    return ((UserTermInfo) userInfo.get(i)).email; 
     827                } 
     828            } 
     829        } 
     830        catch (Exception ex) 
     831        { 
     832            ex.printStackTrace(); 
     833        } 
     834 
     835        closeDatabase(); 
     836        return password; 
    840837    } 
    841838 
     
    844841        Element user_list_node = this.doc.createElement(GSXML.USER_NODE_ELEM + "List"); 
    845842 
    846         Vector userInfo = userQueryResult.users_; 
     843        Vector userInfo = userQueryResult.users; 
    847844 
    848845        for (int i = 0; i < userQueryResult.getSize(); i++) 
    849846        { 
    850847            Element user_node = this.doc.createElement(GSXML.USER_NODE_ELEM); 
    851             String username = ((UserTermInfo) userInfo.get(i)).username_; 
    852             String password = ((UserTermInfo) userInfo.get(i)).password_; 
    853             String groups = ((UserTermInfo) userInfo.get(i)).groups_; 
    854             String accountstatus = ((UserTermInfo) userInfo.get(i)).accountstatus_; 
    855             String comment = ((UserTermInfo) userInfo.get(i)).comment_; 
    856             user_node.setAttribute("umun", username); 
    857             user_node.setAttribute("umpw", password); 
    858             user_node.setAttribute("umgp", groups); 
    859             user_node.setAttribute("umas", accountstatus); 
    860             user_node.setAttribute("umc", comment); 
     848            String username = ((UserTermInfo) userInfo.get(i)).username; 
     849            String groups = ((UserTermInfo) userInfo.get(i)).groups; 
     850            String accountstatus = ((UserTermInfo) userInfo.get(i)).accountstatus; 
     851            String comment = ((UserTermInfo) userInfo.get(i)).comment; 
     852            String email = ((UserTermInfo) userInfo.get(i)).email; 
     853            user_node.setAttribute("username", username); 
     854            user_node.setAttribute("groups", groups); 
     855            user_node.setAttribute("status", accountstatus); 
     856            user_node.setAttribute("comment", comment); 
     857            user_node.setAttribute("email", email); 
    861858 
    862859            user_list_node.appendChild(user_node);