ms_security_session.hpp

/*
##############################################################################
# file: ms_security_session.hpp                                              #
# 'msparser' toolkit                                                         #
# Encapsulates a mascot session as used in authentication                    #
##############################################################################
# COPYRIGHT NOTICE                                                           #
# Copyright 1998-2004 Matrix Science Limited  All Rights Reserved.           #
#                                                                            #
##############################################################################
#    $Archive:: /MowseBranches/ms_mascotresfile_1.2/include/ms_mascotresfi $ #
#     $Author: villek@matrixscience.com $ #
#       $Date: 2018-07-30 16:23:53 +0100 $ #
#   $Revision: 1b450440f9c97e1e41d0fc6016a27d68951d4532 | MSPARSER_REL_3_0_0-2024-09-24-0-g93ebaeb4f4 $ #
# $NoKeywords::                                                            $ #
##############################################################################
*/
 
#if !defined(mascot_session_DA3EC794_90F8_4c4f_AD5D_13C3B6971A51__INCLUDED_)
#define mascot_session_DA3EC794_90F8_4c4f_AD5D_13C3B6971A51__INCLUDED_
 
 
// Includes from the standard template library
#include <string>
#include <set>
#include <vector>
#include <map>
#include <time.h>
 
namespace matrix_science {
    class ms_security;
    class ms_security_options;
 
 
    class MS_MASCOTRESFILE_API ms_session : public ms_errors
    {
    public:
        ms_session(const std::string session_id = "");
 
        ms_session(const std::string userName, 
                   const std::string userPassword);
 
        ms_session(const std::string userName,
                   const std::string connectionID,
                   const std::string database);
 
        ms_session(const int timeout, const std::string prefix);
 
 
#if !defined(DOXYGEN_SHOULD_SKIP_THIS)
        ms_session(const ms_session& src);
#endif
        /* SWIG function dispatcher fails in Perl 5.12 for some reason, and
         * tries to use ms_session(const ms_security&, const std::string&) as
         * the constructor for cases such as ms_session(300, "score_gif")...
         * This constructor is supposed to be for internal use anyway, which
         * is why it is defined out.
         */
#if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(SWIG)
        ms_session(const ms_security &sec,
                   const std::string &session_id);
        ms_session(const ms_security &sec,
                   const ms_user & user);
        ms_session& operator =(const ms_session& right);
#endif 
 
        ~ms_session();
 
    public:
        std::string getID() const;
 
        int getUserID() const;
 
        std::string getUserName() const;
 
        std::string getFullUserName() const;
 
        std::string getEmailAddress() const;
 
        bool isSecurityEnabled() const;
 
        time_t getLastAccessed() const;
 
        time_t getTimeout() const;
 
        std::string getIPAddress() const;
 
        matrix_science::ms_security_tasks getPermittedTasks() const;
 
        bool setPermittedTasks(const matrix_science::ms_security_tasks & val);
 
        std::map<std::string, std::string> getParams() const;
 
        bool isPermitted(const int taskID) const;
 
        bool isPermitted_long(const int taskID, const long value) const;
 
        bool isPermitted_double(const int taskID, const double value) const;
 
        bool isPermitted_string(const int taskID, const std::string value) const;
 
        bool isFastaPermitted(const std::string database) const;
 
        bool canResultsFileBeViewed(const int userID) const;
 
        bool saveStringParam(const std::string name, const std::string param);
 
        bool saveIntParam(const std::string name, int param);
 
        bool saveLongParam(const std::string name, long param);
 
        bool saveTimeParam(const std::string name, time_t param);
 
        bool saveDoubleParam(const std::string name, double param);
 
        bool saveBoolParam(const std::string name, bool param);
 
#ifndef SWIG
        bool getStringParam(const std::string name, std::string & param) const;
#endif
        std::string getStringParam(const std::string name) const;
 
        bool getIntParam(const std::string name, int & param) const;
 
        int getIntParam(const std::string name) const;
 
        bool getLongParam(const std::string name, long & param) const;
 
        long getLongParam(const std::string name) const;
 
        bool getTimeParam(const std::string name, time_t & param) const;
 
        time_t getTimeParam(const std::string name) const;
 
        bool getDoubleParam(const std::string name, double & param) const;
 
        double getDoubleParam(const std::string name) const;
 
        bool getBoolParam(const std::string name, bool & param) const;
 
        bool clearParam(const std::string name);
 
        bool destroy();
 
        bool isTimedOut() const;
 
        matrix_science::ms_user::usertype getUserType() const;
 
        bool update(const ms_security & sec);
 
        std::vector<int> getSpoofableUsers() const;
    
    private:
        typedef std::map<std::string, std::string> param_t;
        std::string sessionID_;
        param_t  params_;
        param_t  customParams_;
        typedef std::set<std::string> cpIdentifier_t;
        cpIdentifier_t systemIdentifiers_;
        ms_security_tasks permittedTasks_;
        bool saveParamShouldSaveFile_;
        bool allowParamAndFileSaving_;
 
        void init();
        bool loadSessionFromFile(const ms_security * const sec);
        bool saveSessionToFile(const ms_security * const sec);
        void setDisabledSession(const ms_security_options & opts);
        bool setCommandLineSession(const ms_security_options & secOpt);
        bool setGuestSession();
        bool doesSessionFileExist(const std::string sess);
        bool getAllParams(const ms_user & u, const ms_security & sec);
        std::string getSessionIDFromUser(const ms_user & user);
        std::string getWebSvrAuthSessionID(std::string userName = "");
        bool checkIPAddressOrComputerName(const std::string ipAddress,
                                          std::string & sessionID);
        bool checkAgentString(std::string & sessionID);
        bool validateIntegraPassword(const ms_user & u, 
                                     const ms_security_options & secOpt,
                                     const std::string & userPassword,
                                     std::string & session_id,
                                     int & errorFlag) const;
        bool verifyIntegraConnection() const;
        bool isSessionIdentical(const ms_session & sess) const;
        void copyFrom(const ms_session * src);
        void createSessionFromID(const std::string session_id);
    }; // end of security_group
}
#endif // !defined(mascot_session_DA3EC794_90F8_4c4f_AD5D_13C3B6971A51__INCLUDED_)