6 files changed, 523 insertions, 23 deletions

diff --git a/linden/indra/llvfs/files.sunos5.lst b/linden/indra/llvfs/files.sunos5.lst
new file mode 100644
index 0000000..f1b74d8
--- /dev/null
+++ b/linden/indra/llvfs/files.sunos5.lst
@@ -0,0 +1 @@
+llvfs/lldir_solaris.cpp
diff --git a/linden/indra/llvfs/lldir.cpp b/linden/indra/llvfs/lldir.cpp
index d71224a..5f0efbe 100644
--- a/linden/indra/llvfs/lldir.cpp
+++ b/linden/indra/llvfs/lldir.cpp
@@ -45,6 +45,9 @@ LLDir_Win32 gDirUtil;
 #elif LL_DARWIN
 #include "lldir_mac.h"
 LLDir_Mac gDirUtil;
+#elif LL_SOLARIS
+#include "lldir_solaris.h"
+LLDir_Solaris gDirUtil;
 #else
 #include "lldir_linux.h"
 LLDir_Linux gDirUtil;
diff --git a/linden/indra/llvfs/lldir_linux.cpp b/linden/indra/llvfs/lldir_linux.cpp
index e3aada6..7cf1c2a 100644
--- a/linden/indra/llvfs/lldir_linux.cpp
+++ b/linden/indra/llvfs/lldir_linux.cpp
@@ -75,7 +75,16 @@ LLDir_Linux::LLDir_Linux()
         mDirp = NULL;
 
         char tmp_str[LL_MAX_PATH];      /* Flawfinder: ignore */ 
-        getcwd(tmp_str, LL_MAX_PATH);
+        if (getcwd(tmp_str, LL_MAX_PATH) == NULL)
+        {
+                strcpy(tmp_str, "/tmp");
+                llwarns << "Could not get current directory; changing to "
+                                << tmp_str << llendl;
+                if (chdir(tmp_str) == -1)
+                {
+                        llerrs << "Could not change directory to " << tmp_str << llendl;
+                }
+        }
 
         mExecutableFilename = "";
         mExecutablePathAndName = "";
@@ -328,7 +337,11 @@ void LLDir_Linux::getRandomFileInDir(const std::string &dirname, const std::stri
 std::string LLDir_Linux::getCurPath()
 {
         char tmp_str[LL_MAX_PATH];      /* Flawfinder: ignore */ 
-        getcwd(tmp_str, LL_MAX_PATH);
+        if (getcwd(tmp_str, LL_MAX_PATH) == NULL)
+        {
+                llwarns << "Could not get current directory" << llendl;
+                tmp_str[0] = '\0';
+        }
         return tmp_str;
 }
 
diff --git a/linden/indra/llvfs/lldir_solaris.cpp b/linden/indra/llvfs/lldir_solaris.cpp
new file mode 100644
index 0000000..41262aa
--- /dev/null
+++ b/linden/indra/llvfs/lldir_solaris.cpp
@@ -0,0 +1,374 @@
+/** 
+ * @file fmodwrapper.cpp
+ * @brief dummy source file for building a shared library to wrap libfmod.a
+ *
+ * Copyright (c) 2005-2007, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#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;
+        }
+}
+
diff --git a/linden/indra/llvfs/lldir_solaris.h b/linden/indra/llvfs/lldir_solaris.h
new file mode 100644
index 0000000..4a8feed
--- /dev/null
+++ b/linden/indra/llvfs/lldir_solaris.h
@@ -0,0 +1,61 @@
+/** 
+ * @file fmodwrapper.cpp
+ * @brief dummy source file for building a shared library to wrap libfmod.a
+ *
+ * Copyright (c) 2005-2007, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#ifndef LL_LLDIR_SOLARIS_H
+#define LL_LLDIR_SOLARIS_H
+
+#include "lldir.h"
+
+#include <stdio.h>
+#include <dirent.h>
+#include <errno.h>
+
+class LLDir_Solaris : public LLDir
+{
+public:
+        LLDir_Solaris();
+        virtual ~LLDir_Solaris();
+
+        virtual void initAppDirs(const std::string &app_name);
+public: 
+        virtual std::string getCurPath();
+        virtual U32 countFilesInDir(const std::string &dirname, const std::string &mask);
+        virtual BOOL getNextFileInDir(const std::string &dirname, const std::string &mask, std::string &fname, BOOL wrap);
+        virtual void getRandomFileInDir(const std::string &dirname, const std::string &mask, std::string &fname);
+        /*virtual*/ BOOL fileExists(const std::string &filename);
+
+private:
+        DIR *mDirp;
+        int mCurrentDirIndex;
+        int mCurrentDirCount;
+        std::string mCurrentDir;        
+};
+
+#endif // LL_LLDIR_SOLARIS_H
+
+
diff --git a/linden/indra/llvfs/llvfs.cpp b/linden/indra/llvfs/llvfs.cpp
index dd5854c..a05d1b9 100644
--- a/linden/indra/llvfs/llvfs.cpp
+++ b/linden/indra/llvfs/llvfs.cpp
@@ -35,6 +35,10 @@
 #include <map>
 #if LL_WINDOWS
 #include <share.h>
+#elif LL_SOLARIS
+#include <sys/types.h>
+#include <unistd.h>
+#include <fcntl.h>
 #else
 #include <sys/file.h>
 #endif
@@ -379,13 +383,13 @@ LLVFS::LLVFS(const char *index_filename, const char *data_filename, const BOOL r
                 )
         {       
                 U8 *buffer = new U8[fbuf.st_size];
-                fread(buffer, fbuf.st_size, 1, mIndexFP);
+                size_t nread = fread(buffer, 1, fbuf.st_size, mIndexFP);
     
                 U8 *tmp_ptr = buffer;
     
                 std::vector<LLVFSFileBlock*> files_by_loc;
                 
-                while (tmp_ptr < buffer + fbuf.st_size)
+                while (tmp_ptr < buffer + nread)
                 {
                         LLVFSFileBlock *block = new LLVFSFileBlock();
     
@@ -881,12 +885,18 @@ BOOL LLVFS::setMaxSize(const LLUUID &file_id, const LLAssetType::EType file_type
                                                 // move the file into the new block
                                                 U8 *buffer = new U8[block->mSize];
                                                 fseek(mDataFP, block->mLocation, SEEK_SET);
-                                                fread(buffer, block->mSize, 1, mDataFP);
-                                                fseek(mDataFP, free_block->mLocation, SEEK_SET);
-                                                fwrite(buffer, block->mSize, 1, mDataFP);
-                                                // fflush(mDataFP);
-    
-                                                delete[] buffer;
+                                                if (fread(buffer, block->mSize, 1, mDataFP) == 1)
+                                                {
+                                                        fseek(mDataFP, free_block->mLocation, SEEK_SET);
+                                                        if (fwrite(buffer, block->mSize, 1, mDataFP) != 1)
+                                                        {
+                                                                llwarns << "Short write" << llendl;
+                                                        }
+    
+                                                        delete[] buffer;
+                                                } else {
+                                                        llwarns << "Short read" << llendl;
+                                                }
                                         }
                                 }
     
@@ -1486,7 +1496,7 @@ void LLVFS::sync(LLVFSFileBlock *block, BOOL remove)
         }
 
     BOOL set_index_to_end = FALSE;
-        S32 seek_pos = block->mIndexLocation;
+        long seek_pos = block->mIndexLocation;
                 
         if (-1 == seek_pos)
         {
@@ -1534,7 +1544,11 @@ void LLVFS::sync(LLVFSFileBlock *block, BOOL remove)
                 fseek(mIndexFP, seek_pos, SEEK_SET);
         }
 
-        fwrite(buffer, LLVFSFileBlock::SERIAL_SIZE, 1, mIndexFP);
+        if (fwrite(buffer, LLVFSFileBlock::SERIAL_SIZE, 1, mIndexFP) != 1)
+        {
+                llwarns << "Short write" << llendl;
+        }
+        
         // fflush(mIndexFP);
         
         lockData();
@@ -1663,18 +1677,24 @@ void LLVFS::pokeFiles()
         // only write data if we actually read 4 bytes
         // otherwise we're writing garbage and screwing up the file
         fseek(mDataFP, 0, SEEK_SET);
-        if (fread(&word, 1, 4, mDataFP) == 4)
+        if (fread(&word, sizeof(word), 1, mDataFP) == 1)
         {
                 fseek(mDataFP, 0, SEEK_SET);
-                fwrite(&word, 1, 4, mDataFP);
+                if (fwrite(&word, sizeof(word), 1, mDataFP) != 1)
+                {
+                        llwarns << "Could not write to data file" << llendl;
+                }
                 fflush(mDataFP);
         }
 
         fseek(mIndexFP, 0, SEEK_SET);
-        if (fread(&word, 1, 4, mIndexFP) == 4)
+        if (fread(&word, sizeof(word), 1, mIndexFP) == 1)
         {
                 fseek(mIndexFP, 0, SEEK_SET);
-                fwrite(&word, 1, 4, mIndexFP);
+                if (fwrite(&word, sizeof(word), 1, mIndexFP) != 1)
+                {
+                        llwarns << "Could not write to index file" << llendl;
+                }
                 fflush(mIndexFP);
         }
 }
@@ -1709,21 +1729,26 @@ void LLVFS::audit()
         fflush(mIndexFP);
 
         fseek(mIndexFP, 0, SEEK_END);
-        S32 index_size = ftell(mIndexFP);
+        long index_size = ftell(mIndexFP);
         fseek(mIndexFP, 0, SEEK_SET);
     
+        BOOL vfs_corrupt = FALSE;
+        
         U8 *buffer = new U8[index_size];
-        fread(buffer, index_size, 1, mIndexFP);
+
+        if (fread(buffer, 1, index_size, mIndexFP) != index_size)
+        {
+                llwarns << "Index truncated" << llendl;
+                vfs_corrupt = TRUE;
+        }
     
         U8 *tmp_ptr = buffer;
     
         std::map<LLVFSFileSpecifier, LLVFSFileBlock*>   found_files;
         U32 cur_time = (U32)time(NULL);
 
-        BOOL vfs_corrupt = FALSE;
-        
         std::vector<LLVFSFileBlock*> audit_blocks;
-        while (tmp_ptr < buffer + index_size)
+        while (!vfs_corrupt && tmp_ptr < buffer + index_size)
         {
                 LLVFSFileBlock *block = new LLVFSFileBlock();
                 audit_blocks.push_back(block);
@@ -1803,7 +1828,11 @@ void LLVFS::audit()
                                         llwarns << "VFile " << block->mFileID << ":" << block->mFileType << " in memory, not on disk, loc " << block->mIndexLocation<< llendl;
                                         fseek(mIndexFP, block->mIndexLocation, SEEK_SET);
                                         U8 buf[LLVFSFileBlock::SERIAL_SIZE];
-                                        fread(buf, LLVFSFileBlock::SERIAL_SIZE, 1, mIndexFP);
+                                        if (fread(buf, LLVFSFileBlock::SERIAL_SIZE, 1, mIndexFP) != 1)
+                                        {
+                                                llwarns << "VFile " << block->mFileID
+                                                                << " gave short read" << llendl;
+                                        }
                         
                                         LLVFSFileBlock disk_block;
                                         disk_block.deserialize(buf, block->mIndexLocation);
@@ -2116,6 +2145,12 @@ FILE *LLVFS::openAndLock(const char *filename, const char *mode, BOOL read_lock)
         int fd;
         
         // first test the lock in a non-destructive way
+#if LL_SOLARIS
+        struct flock fl;
+        fl.l_whence = SEEK_SET;
+        fl.l_start = 0;
+        fl.l_len = 1;
+#else // !LL_SOLARIS
         if (strstr(mode, "w"))
         {
                 fp = LLFile::fopen(filename, "rb");     /* Flawfinder: ignore */
@@ -2131,13 +2166,19 @@ FILE *LLVFS::openAndLock(const char *filename, const char *mode, BOOL read_lock)
                         fclose(fp);
                 }
         }
+#endif // !LL_SOLARIS
 
         // now actually open the file for use
         fp = LLFile::fopen(filename, mode);     /* Flawfinder: ignore */
         if (fp)
         {
                 fd = fileno(fp);
+#if LL_SOLARIS
+                fl.l_type = read_lock ? F_RDLCK : F_WRLCK;
+                if (fcntl(fd, F_SETLK, &fl) == -1)
+#else
                 if (flock(fd, (read_lock ? LOCK_SH : LOCK_EX) | LOCK_NB) == -1)
+#endif
                 {
                         fclose(fp);
                         fp = NULL;
@@ -2165,7 +2206,14 @@ void LLVFS::unlockAndClose(FILE *fp)
           flock(fd, LOCK_UN);
           #endif
     */
-    
+#if LL_SOLARIS
+                struct flock fl;
+                fl.l_whence = SEEK_SET;
+                fl.l_start = 0;
+                fl.l_len = 1;
+                fl.l_type = F_UNLCK;
+                fcntl(fileno(fp), F_SETLK, &fl);
+#endif
                 fclose(fp);
         }
 }