lldir_solaris.cpp

Go to the documentation of this file.

#include "linden_common.h"

#include "lldir_solaris.h"
#include "llerror.h"
#include "llrand.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/param.h>
#include <unistd.h>
#include <glob.h>
#include <pwd.h>
#include <sys/utsname.h>
#define _STRUCTURED_PROC 1
#include <sys/procfs.h>

static std::string getCurrentUserHome(char* fallback)
{
        const uid_t uid = getuid();
        struct passwd *pw;
        char *result_cstr = fallback;
        
        pw = getpwuid(uid);
        if ((pw != NULL) && (pw->pw_dir != NULL))
        {
                result_cstr = (char*) pw->pw_dir;
        }
        else
        {
                llinfos << "Couldn't detect home directory from passwd - trying $HOME" << llendl;
                const char *const home_env = getenv("HOME");    /* Flawfinder: ignore */ 
                if (home_env)
                {
                        result_cstr = (char*) home_env;
                }
                else
                {
                        llwarns << "Couldn't detect home directory!  Falling back to " << fallback << llendl;
                }
        }
        
        return std::string(result_cstr);
}


LLDir_Solaris::LLDir_Solaris()
{
        mDirDelimiter = "/";
        mCurrentDirIndex = -1;
        mCurrentDirCount = -1;
        mDirp = NULL;

        char tmp_str[LL_MAX_PATH];      /* Flawfinder: ignore */ 
        getcwd(tmp_str, LL_MAX_PATH);

        mExecutableFilename = "";
        mExecutablePathAndName = "";
        mExecutableDir = strdup(tmp_str);
        mWorkingDir = strdup(tmp_str);
        mAppRODataDir = strdup(tmp_str);
        mOSUserDir = getCurrentUserHome(tmp_str);
        mOSUserAppDir = "";
        mLindenUserDir = tmp_str;

        char path [LL_MAX_PATH];        /* Flawfinder: ignore */ 

        sprintf(path, "/proc/%d/psinfo", (int)getpid());
        int proc_fd = -1;
        if((proc_fd = open(path, O_RDONLY)) == -1){
                llwarns << "unable to open " << path << llendl;
                return;
        }
        psinfo_t proc_psinfo;
        if(read(proc_fd, &proc_psinfo, sizeof(psinfo_t)) != sizeof(psinfo_t)){
                llwarns << "Unable to read " << path << llendl;
                close(proc_fd);
                return;
        }

        close(proc_fd);

        mExecutableFilename = strdup(proc_psinfo.pr_fname);
        llinfos << "mExecutableFilename = [" << mExecutableFilename << "]" << llendl;

        sprintf(path, "/proc/%d/path/a.out", (int)getpid());

        char execpath[LL_MAX_PATH];
        if(readlink(path, execpath, LL_MAX_PATH) == -1){
                llwarns << "Unable to read link from " << path << llendl;
                return;
        }

        mExecutablePathAndName = strdup(execpath);
        llinfos << "mExecutablePathAndName = [" << mExecutablePathAndName << "]" << llendl;

                        // plunk a null at last '/' to get exec dir
        char *s = execpath + strlen(execpath) -1;
        while(*s != '/' && s != execpath){
                --s;
        }
        
        if(s != execpath){
                *s = (char)NULL;
        
                mExecutableDir = strdup(execpath);
                llinfos << "mExecutableDir = [" << mExecutableDir << "]" << llendl;
        }
        
        // *TODO: don't use /tmp, use $HOME/.secondlife/tmp or something.
        mTempDir = "/tmp";
}

LLDir_Solaris::~LLDir_Solaris()
{
}

// Implementation


void LLDir_Solaris::initAppDirs(const std::string &app_name)
{
        mAppName = app_name;

        LLString upper_app_name(app_name);
        LLString::toUpper(upper_app_name);

        char* app_home_env = getenv((upper_app_name + "_USER_DIR").c_str());    /* Flawfinder: ignore */ 
        if (app_home_env)
        {
                // user has specified own userappdir i.e. $SECONDLIFE_USER_DIR
                mOSUserAppDir = app_home_env;
        }
        else
        {
                // traditionally on unixoids, MyApp gets ~/.myapp dir for data
                mOSUserAppDir = mOSUserDir;
                mOSUserAppDir += "/";
                mOSUserAppDir += ".";
                LLString lower_app_name(app_name);
                LLString::toLower(lower_app_name);
                mOSUserAppDir += lower_app_name;
        }

        // create any directories we expect to write to.

        int res = LLFile::mkdir(mOSUserAppDir.c_str());
        if (res == -1)
        {
                if (errno != EEXIST)
                {
                        llwarns << "Couldn't create app user dir " << mOSUserAppDir << llendl;
                        llwarns << "Default to base dir" << mOSUserDir << llendl;
                        mOSUserAppDir = mOSUserDir;
                }
        }

        res = LLFile::mkdir(getExpandedFilename(LL_PATH_LOGS,"").c_str());
        if (res == -1)
        {
                if (errno != EEXIST)
                {
                        llwarns << "Couldn't create LL_PATH_LOGS dir " << getExpandedFilename(LL_PATH_LOGS,"") << llendl;
                }
        }
        
        res = LLFile::mkdir(getExpandedFilename(LL_PATH_USER_SETTINGS,"").c_str());
        if (res == -1)
        {
                if (errno != EEXIST)
                {
                        llwarns << "Couldn't create LL_PATH_USER_SETTINGS dir " << getExpandedFilename(LL_PATH_USER_SETTINGS,"") << llendl;
                }
        }
        
        res = LLFile::mkdir(getExpandedFilename(LL_PATH_CACHE,"").c_str());
        if (res == -1)
        {
                if (errno != EEXIST)
                {
                        llwarns << "Couldn't create LL_PATH_CACHE dir " << getExpandedFilename(LL_PATH_CACHE,"") << llendl;
                }
        }
        
        res = LLFile::mkdir(getExpandedFilename(LL_PATH_MOZILLA_PROFILE,"").c_str());
        if (res == -1)
        {
                if (errno != EEXIST)
                {
                        llwarns << "Couldn't create LL_PATH_MOZILLA_PROFILE dir " << getExpandedFilename(LL_PATH_MOZILLA_PROFILE,"") << llendl;
                }
        }

        mCAFile = getExpandedFilename(LL_PATH_APP_SETTINGS, "CA.pem");
}

U32 LLDir_Solaris::countFilesInDir(const std::string &dirname, const std::string &mask)
{
        U32 file_count = 0;
        glob_t g;

        std::string tmp_str;
        tmp_str = dirname;
        tmp_str += mask;
        
        if(glob(tmp_str.c_str(), GLOB_NOSORT, NULL, &g) == 0)
        {
                file_count = g.gl_pathc;

                globfree(&g);
        }

        return (file_count);
}

// get the next file in the directory
// automatically wrap if we've hit the end
BOOL LLDir_Solaris::getNextFileInDir(const std::string &dirname, const std::string &mask, std::string &fname, BOOL wrap)
{
        glob_t g;
        BOOL result = FALSE;
        fname = "";
        
        if(!(dirname == mCurrentDir))
        {
                // different dir specified, close old search
                mCurrentDirIndex = -1;
                mCurrentDirCount = -1;
                mCurrentDir = dirname;
        }
        
        std::string tmp_str;
        tmp_str = dirname;
        tmp_str += mask;

        if(glob(tmp_str.c_str(), GLOB_NOSORT, NULL, &g) == 0)
        {
                if(g.gl_pathc > 0)
                {
                        if((int)g.gl_pathc != mCurrentDirCount)
                        {
                                // Number of matches has changed since the last search, meaning a file has been added or deleted.
                                // Reset the index.
                                mCurrentDirIndex = -1;
                                mCurrentDirCount = g.gl_pathc;
                        }
        
                        mCurrentDirIndex++;
        
                        if((mCurrentDirIndex >= (int)g.gl_pathc) && wrap)
                        {
                                mCurrentDirIndex = 0;
                        }
                        
                        if(mCurrentDirIndex < (int)g.gl_pathc)
                        {
//                              llinfos << "getNextFileInDir: returning number " << mCurrentDirIndex << ", path is " << g.gl_pathv[mCurrentDirIndex] << llendl;

                                // The API wants just the filename, not the full path.
                                //fname = g.gl_pathv[mCurrentDirIndex];

                                char *s = strrchr(g.gl_pathv[mCurrentDirIndex], '/');
                                
                                if(s == NULL)
                                        s = g.gl_pathv[mCurrentDirIndex];
                                else if(s[0] == '/')
                                        s++;
                                        
                                fname = s;
                                
                                result = TRUE;
                        }
                }
                
                globfree(&g);
        }
        
        return(result);
}


// get a random file in the directory
// automatically wrap if we've hit the end
void LLDir_Solaris::getRandomFileInDir(const std::string &dirname, const std::string &mask, std::string &fname)
{
        S32 num_files;
        S32 which_file;
        DIR *dirp;
        dirent *entryp = NULL;

        fname = "";

        num_files = countFilesInDir(dirname,mask);
        if (!num_files)
        {
                return;
        }

        which_file = ll_rand(num_files);

//      llinfos << "Random select file #" << which_file << llendl;

    // which_file now indicates the (zero-based) index to which file to play
        
        if (!((dirp = opendir(dirname.c_str()))))
        {
                while (which_file--)
                {
                        if (!((entryp = readdir(dirp))))
                        {
                                return;
                        }
                }                  

                if ((!which_file) && entryp)
                {
                        fname = entryp->d_name;
                }
                
                closedir(dirp);
        }
}

std::string LLDir_Solaris::getCurPath()
{
        char tmp_str[LL_MAX_PATH];      /* Flawfinder: ignore */ 
        getcwd(tmp_str, LL_MAX_PATH);
        return tmp_str;
}


BOOL LLDir_Solaris::fileExists(const std::string &filename)
{
        struct stat stat_data;
        // Check the age of the file
        // Now, we see if the files we've gathered are recent...
        int res = stat(filename.c_str(), &stat_data);
        if (!res)
        {
                return TRUE;
        }
        else
        {
                return FALSE;
        }
}

---