viewer.cpp

Go to the documentation of this file.

#include "llviewerprecompiledheaders.h"

#include "viewer.h"

#include "llparcel.h"
#include "llviewerparcelmgr.h"
#include "llviewerjoystick.h"

// System library headers
#include <errno.h>
#include <stdexcept>
#if LL_WINDOWS
#       include <share.h>
#else
#       include <sys/file.h>
#       include <signal.h>
#endif
#include <sys/stat.h>
#include <memory>
#include <boost/tokenizer.hpp>

#if LL_WINDOWS
#include <fcntl.h>              //_O_APPEND
#include <io.h>                 //_open_osfhandle()
#include <errorrep.h>   // for AddERExcludedApplicationA()
#include <process.h>    // _spawnl()
#include <tchar.h>              // For TCHAR support

#if LL_WINDOWS && _MSC_VER < 1400
//#define LL_USE_SMARTHEAP 0
#else
#define LL_USE_SMARTHEAP 0
#endif

#if LL_WINDOWS && LL_RELEASE_FOR_DOWNLOAD && LL_USE_SMARTHEAP
#include "smrtheap/smrtheap.h"
#endif // LL_WINDOWS && LL_RELEASE_FOR_DOWNLOAD && LL_USE_SMARTHEAP

#elif LL_DARWIN || LL_LINUX || LL_SOLARIS

  #     include <sys/socket.h>
//  #   include <sys/stat.h>            // mkdir()
  #     include <netinet/in.h>
  #     include <arpa/inet.h>   // inet_ntoa()

  #if LL_LINUX
  #     include <dlfcn.h>               // RTLD_LAZY
  #     include <execinfo.h>            // backtrace - glibc only
  #     ifndef LL_ELFBIN
  #define LL_ELFBIN 1
  #     endif // LL_ELFBIN
  #     if LL_ELFBIN
  #          include <cxxabi.h>         // for symbol demangling
  #          include "ELFIO.h"          // for better backtraces
  #     endif // LL_ELFBIN
  #elif LL_SOLARIS
  #     include <sys/types.h>
  #     include <unistd.h>
  #     include <fcntl.h>
  #     include <ucontext.h>
  #endif

  #if LL_DARWIN
    #include <Carbon/Carbon.h>
    // Apple sucks!  AssertMacros.h defines these COMMONLY used names.
    #ifdef check
            #undef check
    #endif
    #ifdef verify
            #undef verify
    #endif // verify
    #ifdef require
            #undef require
    #endif
  #endif
#endif // !LL_WINDOWS

// Support for sending crash reports from the viewer?
#define LL_SEND_CRASH_REPORTS 1


//
// Linden library headers
//

#include "audioengine.h" 
#include "llcommon.h" 
#include "llapr.h" 
#include "llcachename.h"
#include "llcurl.h"
#include "llcriticaldamp.h"
#include "lldir.h"
#include "lleconomy.h"
#include "llerrorcontrol.h"
#include "llhttpnode.h"
#include "llflexibleobject.h"
#include "llfasttimer.h"
#include "llfocusmgr.h"
#include "llgroupmgr.h"
#include "llimage.h"
#include "llimageworker.h"
#include "lllfsthread.h"
#include "llmemtype.h"
#include "llmd5.h"
#include "llsecondlifeurls.h"
#include "llversionviewer.h"
#include "llvfile.h"
#include "llvfs.h"
#include "llwindow.h"           // for shell_open
#include "llworkerthread.h"
#include "llvfsthread.h"
#include "llxfermanager.h"
#include "message.h"
#include "llvoavatar.h"
#include "llglslshader.h"

//
// Viewer headers
//

#include "llagent.h"
#include "llagentpilot.h"
#include "llbutton.h" // For constants
#include "llcallbacklist.h"
#include "llchatbar.h"
//#include "llcombobox.h" // For constants
#include "llconsole.h"
#include "llcontainerview.h"
#include "lldebugview.h"
#include "lldrawpoolbump.h"
#include "lldrawpoolterrain.h"
#include "lleventnotifier.h"
#include "llfasttimerview.h"
#include "llfeaturemanager.h"
#include "llfirstuse.h"
#include "llfloateravatarlist.h"
#include "llfloateractivespeakers.h"
#include "llfloatertools.h"
#include "llfloaterworldmap.h"
#include "llfloaterhtmlhelp.h"
#include "llfloatersaveavatar.h"
#include "llfloatersnapshot.h"
#include "llfloatereventlog.h"
#include "llfolderview.h"
#include "llframestats.h"
#include "llgesturemgr.h"
#include "llhoverview.h"
#include "llhudeffecttrail.h"
#include "llhudmanager.h"
#include "llhttpclient.h"
#include "llimview.h"
#include "llimpanel.h"
#include "llinventorymodel.h"
#include "llinventoryview.h"
#include "llkeyboard.h"
#include "llkeyframemotion.h"
#include "llpanellogin.h"
#include "llmutelist.h"
#include "llmenugl.h"
#include "llnamelistctrl.h"
#include "llnamebox.h"
#include "llnameeditor.h"
#include "llpumpio.h"
#include "llnotify.h"
#include "llregionnamecache.h"
#include "llselectmgr.h"
#include "llsky.h"
#include "llsrv.h"
#include "llstartup.h"
#include "llstatusbar.h"
#include "llsurface.h"
#include "lltexlayer.h"
#include "lltexturecache.h"
#include "lltexturefetch.h"
#include "lltoolbar.h"
#include "lltoolmgr.h"
#include "lltracker.h"
#include "lltrustnet.h"
#include "llurldispatcher.h"
#include "llurlsimstring.h"
#include "llurlwhitelist.h"
#include "llv4math.h"           // LL_VECTORIZE
#include "llviewerbuild.h"
#include "llviewercamera.h"
#include "llviewercontrol.h"
#include "llviewerjointmesh.h"
#include "llviewerimagelist.h"
#include "llviewerkeyboard.h"
#include "llviewermenu.h"
#include "llviewermessage.h"
#include "llviewernetwork.h"
#include "llviewerobjectlist.h"
#include "llviewerparcelmgr.h"
#include "llviewerregion.h"
#include "llviewerstats.h"
#include "llviewerthrottle.h"
#include "llvieweruictrlfactory.h"
#include "llviewerwindow.h"
#include "llvlmanager.h"
#include "llvoavatar.h"
#include "llvograss.h"
#include "llvotree.h"
#include "llvovolume.h"         // To set a static member.
#include "llvowater.h"
#include "llvolume.h"
#include "llvolumemgr.h"
#include "llvolumemessage.h"
#include "llweb.h"
#include "llworld.h"
#include "llworldmap.h"
#include "llworldmapview.h"
#include "pipeline.h"
#include "llface.h"
#include "audiosettings.h"
#include "res/resource.h"
#include "llvoiceclient.h"

#if LL_WINDOWS
#include "llwindebug.h"
#include "lldxhardware.h"
#include "llwindowwin32.h"

// for Logitech LCD keyboards / speakers
#ifndef LL_LOGITECH_LCD_H
#include "lllogitechlcd.h"
#endif
extern void CreateLCDDebugWindows();

#endif // LL_WINDOWS

#if LL_QUICKTIME_ENABLED
#if LL_DARWIN
#include <QuickTime/QuickTime.h>
#else
// quicktime specific includes
#include "MacTypes.h"
#include "QTML.h"
#include "Movies.h"
#include "FixMath.h"
#endif
#endif

#if LL_GSTREAMER_ENABLED
// ugh, do this instead of pulling in the gstreamer headers which indirectly
// clash with expat in the monster that is viewer.cpp ... sigh.
void UnloadGStreamer();
#endif // LL_GSTREAMER_ENABLED

#include "llmediaengine.h"

#if LL_LIBXUL_ENABLED
#include "llmozlib.h"
#endif // LL_LIBXUL_ENABLED

// Support for crash handling.

void errorCallback(const std::string &error_string);
S32 gCrashBehavior = CRASH_BEHAVIOR_ASK;
void (*gCrashCallback)(void) = NULL;
BOOL gReportedCrash = FALSE;

bool gVerifySSLCert = true;

BOOL gHandleKeysAsync = FALSE;

// Use DirectX 9 to probe for hardware
BOOL gProbeHardware = TRUE;
std::string gSerialNumber;

// Application constants

BOOL gAgentMovementCompleted = FALSE;
BOOL gHaveSavedSnapshot = FALSE;

S32 gYieldMS = 0;
BOOL gYieldTime = FALSE;

const U32 COLLISION_LIST_DEPTH = 300;   // only looks at the first so many collisionable objects
const S32 MAX_CONSOLE_LINES = 500;
const S32 NUM_SESSIONS_BEFORE_SHOW_PROFILE = 5;
const F32 DEFAULT_AFK_TIMEOUT = 5.f * 60.f; // time with no input before user flagged as Away From Keyboard

const char *VFS_DATA_FILE_BASE                  = "data.db2.x.";
const char *VFS_INDEX_FILE_BASE                 = "index.db2.x.";

F32 gSimLastTime;
F32 gSimFrames;

//#define RENDER_CLOUD_DENSITY          // uncomment to look at cloud density

// Globals

//
// Core Application globals
//
#if LL_WINDOWS
llLCD   *gLcdScreen = NULL; 
#endif

LLString gSecondLife;
LLString gWindowTitle;
static char sWindowClass[] = "Dale's Unofficial Viewer";
LLString gDisabledMessage;
BOOL gHideLinks = FALSE;

// This is whether or not we are connect to a production grid.
BOOL gInProductionGrid  = FALSE;

//#define APPLE_PREVIEW // Define this if you're doing a preview build on the Mac
#if LL_RELEASE_FOR_DOWNLOAD
// Default userserver for production builds is agni
#ifndef APPLE_PREVIEW
static EUserServerDomain UserServerDefaultChoice = USERSERVER_AGNI;
#else
static EUserServerDomain UserServerDefaultChoice = USERSERVER_ADITI;
#endif
#else
// Default userserver for development builds is dmz
static EUserServerDomain UserServerDefaultChoice = USERSERVER_DMZ;
#endif

#ifdef TOGGLE_HACKED_GODLIKE_VIEWER
BOOL                            gHackGodmode = FALSE;
#endif

std::vector<std::string>        gLoginURIs;
static std::string      gHelperURI;

LLAgent                         gAgent;
LLPipeline                      gPipeline;

// Set true when the viewer has been disconnected from the server, for example,
// by the user being kicked.
BOOL                            gDoDisconnect = FALSE;
BOOL                            gDisconnected = FALSE;

// Tells us to clean up the cache directory in the case of network corruption
BOOL                            gPurgeOnExit = FALSE;
BOOL                            gPurgeCache = FALSE;

// Allow multiple viewers in ReleaseForDownload
#if LL_RELEASE_FOR_DOWNLOAD
BOOL                            gMultipleViewersOK = FALSE;
#else
BOOL                            gMultipleViewersOK = TRUE;
#endif
BOOL                            gSecondInstance = FALSE;
BOOL                            gDisableVoice = FALSE;

LLString                        gArgs;

// Setting this true will cause the app to exit cleanly at the end of the frame.
BOOL                            gQuit = FALSE;
// Set when user has indicated desire to quit, but may have modified documents open
BOOL                            gQuitRequested = FALSE;
LLString                        gLaunchFileOnQuit;
BOOL                            gDoneLogout = FALSE;

BOOL                            gInitializationComplete = FALSE;        // used in windows handlers to determine if OK to call idle()
BOOL                            gAutoLogin = FALSE;
LLString                        gOldSettingsFileName;
BOOL                            gPrintMessagesThisFrame = FALSE;
const char*                     DEFAULT_SETTINGS_FILE = "settings_dale.xml";
const char*                     LEGACY_DEFAULT_SETTINGS_FILE = "settings_dale.ini";
BOOL                            gUseWireframe = FALSE;
LLUUID                          gViewerDigest;  // MD5 digest of the viewer's executable file.
LLPumpIO*                       gServicePump = NULL;
S32                                     gNumSessions = 0;

BOOL                            gAllowIdleAFK = TRUE;
F32                                     gAFKTimeout = DEFAULT_AFK_TIMEOUT;
F32                                     gMouseSensitivity = 3.f;
BOOL                            gInvertMouse = FALSE;
BOOL                            gLogoutRequestSent = FALSE;
LLTimer                         gLogoutTimer;
BOOL                            gShowObjectUpdates = FALSE;

const F32                       LOGOUT_REQUEST_TIME = 6.f;  // this will be cut short by the LogoutReply msg.
F32                                     gLogoutMaxTime = LOGOUT_REQUEST_TIME;

// Map scale in pixels per region
F32                             gMapScale = 128.f;
F32                             gMiniMapScale = 128.f;

// Sky object, globals
LLSky                           gSky;

// HUD display lines in lower right
BOOL                            gDisplayWindInfo = FALSE;
BOOL                            gDisplayCameraPos = FALSE;
BOOL                            gDisplayNearestWater = FALSE;
BOOL                            gDoNearestWaterSearch = FALSE;
BOOL                            gDisplayFOV = FALSE;

// used to restore texture state after a mode switch
LLFrameTimer    gRestoreGLTimer;
BOOL                    gRestoreGL = FALSE;


// VFS globals - see viewer.h
LLVFS* gStaticVFS = NULL;

// Threads
LLTextureCache* gTextureCache = NULL;
LLWorkerThread* gImageDecodeThread = NULL;
LLTextureFetch* gTextureFetch = NULL;

// Debugging
FILE *gDebugFile = NULL;        // File pointer used by the function which writes debug data.
BOOL gRandomizeFramerate = FALSE;
BOOL gPeriodicSlowFrame = FALSE;
std::map<S32,LLFrameTimer> gDebugTimers;

//LLVector3                     gCameraVelocitySmoothed;
//
// Timing/Performance/statistics globals
//

// Frame timing
U64 gFrameTime = 0;
F32 gFrameTimeSeconds = 0.f;
F32 gFrameIntervalSeconds = 0.f;
U32     gFrameCount = 0;
U32 gForegroundFrameCount = 0; // number of frames that app window was in foreground
U64     gStartTime = 0; // gStartTime is "private", used only to calculate gFrameTimeSeconds
U64     gSpaceTime = 0; // gSpaceTime is the time, according to the spaceserver.

//  Timing Globals
LLTimer gRenderStartTime;
LLFrameTimer gForegroundTime;
F32 gQuitAfterSeconds = 0.f;
BOOL gRotateRight = FALSE;

// Is the Pacific time zone (aka server time zone)
// current in daylight savings time?
BOOL gPacificDaylightTime = FALSE;

//
// Simulator/SpaceServer configuration information
//
U32     gSecondsPerDay = 0;
U32     gSecondsPerYear = 0;

LLString gLastVersionChannel;

//
// Region/Object globals
//


LLVector3                       gWindVec(3.0, 3.0, 0.0);
LLVector3                       gRelativeWindVec(0.0, 0.0, 0.0);

//
// Globals for controls...
//

BOOL gVelocityInterpolate = TRUE; //  (These are written once/frame with the data from gSavedSettings)
BOOL gPingInterpolate = TRUE; 

//
// System info
//

LLMemoryInfo gSysMemory;
LLOSInfo gSysOS;

// file globals
static const char USAGE[] = "\n"
"usage:\tviewer [options]\n"
"options:\n"
" -login <first> <last> <password>     log in as a user\n"
" -autologin                           log in as last saved user\n"
" -loginuri <URI>                      login server and CGI script to use\n"
" -helperuri <URI>                     helper web CGI prefix to use\n"
" -settings <filename>                 specify the filename of a\n"
"                                        configuration file\n"
"                                        default is settings.xml\n"
" -setdefault <variable> <value>       specify the value of a particular\n"
"                                        configuration variable which can be\n"
"                                        overridden by settings.xml\n"
" -set <variable> <value>              specify the value of a particular\n"
"                                        configuration variable that\n"
"                                        overrides all other settings\n"
" -user <user_server_ip>               specify userserver in dotted quad\n"
#if !LL_RELEASE_FOR_DOWNLOAD
" -sim <simulator_ip>                  specify the simulator ip address\n"
#endif
" -god                                     log in as god if you have god access\n"
" -purge                               delete files in cache\n"
" -safe                                reset preferences, run in safe mode\n"
" -noutc                               logs in local time, not UTC\n"
" -nothread                            run vfs in single thread\n"
" -noinvlib                            Do not request inventory library\n"
" -multiple                            allow multiple viewers\n"
" -nomultiple                          block multiple viewers\n"
" -novoice                             disable voice\n"
" -ignorepixeldepth                    ignore pixel depth settings\n"
" -cooperative [ms]                    yield some idle time to local host\n"
" -skin                                ui/branding skin folder to use\n"
#if LL_WINDOWS
" -noprobe                             disable hardware probe\n"
#endif
" -noquicktime                         disable QuickTime movies, speeds startup\n"
" -nopreload                           don't preload UI images or sounds, speeds startup\n"
// these seem to be unused
//" -noenv                               turn off environmental effects\n"
//" -proxy <proxy_ip>                    specify the proxy ip address\n"
"\n";


// Variables used for passing data out of main
BOOL gGodConnect = FALSE;
BOOL gUseConsole = TRUE;
BOOL gUseAudio = TRUE;
BOOL gUseFMOD = TRUE;
BOOL gLogMessages = FALSE;
BOOL gRequestInventoryLibrary = TRUE;
BOOL gAcceptTOS = FALSE;
BOOL gAcceptCriticalMessage = FALSE;
// this is the channel the viewer uses to check for updates/login
std::string gChannelName = LL_CHANNEL;

LLUUID gInventoryLibraryOwner;
LLUUID gInventoryLibraryRoot;
bool gPreloadImages = true;
bool gPreloadSounds = true;

LLString gCmdLineFirstName;
LLString gCmdLineLastName;
LLString gCmdLinePassword;
std::map<std::string, std::string> gCommandLineSettings;
std::map<std::string, std::string> gCommandLineForcedSettings;
BOOL gLastExecFroze = FALSE;
BOOL gIgnorePixelDepth = FALSE;


LLPointer<LLImageGL> gDisconnectedImagep = NULL;


/*
class LLFirstInventoryLoadObserver : public LLInventoryObserver
{
        // Called when the inventory is first loaded.
        // Must be allocated on the heap so that the inventory model can destroy it 
        // in case the app ends before the inventory finishes loading.
public:
        virtual void changed(U32 mask);
        void observe(LLInventoryModel* model);
protected:
        LLInventoryModel* mInventory;
};
*/

//
// Forward declarations
//

//
// Application initialization and cleanup
//
void init_marker_file();
void init_crash_handler();
void init_logging();
void create_console();
void write_system_info();
int parse_args(int argc, char **argv);
void saved_settings_to_globals();
BOOL init_cache();
void purge_cache();
void cleanup_app();
void disconnect_viewer(void *); // Don't use directly - use do_disconnect()

//
// Debugging, logging, and error reporting
//
void write_debug(const char *str);      // Write a string to the debug log
void write_debug(const std::string& str);
void close_debug();                                     // Close the debug log
void catch_signals();
void viewer_crash_callback();
void remove_marker_file();
#if !LL_WINDOWS
void release_signals();
#endif

void bad_network_handler();

#if LL_WINDOWS
void disable_win_error_reporting();
#endif
std::string get_serial_number();
bool send_url_to_other_instance(const std::string& url);
BOOL another_instance_running();
void main_loop();

//
// Callbacks
//
// Callbacks and other stuff that's not directly used in main
//
void uuid_table_request_file_callback(void **user_data, S32 result, LLExtStat ext_status);
void send_stats();

//
// Apple specific stuff
//
#if LL_DARWIN
void init_apple_menu(const char* product);
OSErr AEGURLHandler(const AppleEvent *messagein, AppleEvent *reply, long refIn);
OSErr AEQuitHandler(const AppleEvent *messagein, AppleEvent *reply, long refIn);
OSStatus simpleDialogHandler(EventHandlerCallRef handler, EventRef event, void *userdata);
OSStatus DisplayReleaseNotes(void);
#endif // LL_DARWIN

void ui_audio_callback(const LLUUID& uuid)
{
        if (gAudiop)
        {
                F32 volume = gSavedSettings.getF32("AudioLevelUI");
                gAudiop->triggerSound(uuid, gAgent.getID(), volume);
        }
}

#if LL_WINDOWS
BOOL CALLBACK login_dialog_func(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lparam)
{
        char buffer[MAX_STRING];                /* Flawfinder: ignore */
        switch(msg)
        {
    case WM_INITDIALOG:
                {
                        LLString first_name = gCmdLineFirstName;
                        LLString last_name = gCmdLineLastName;
                        LLString password = gCmdLinePassword;

                        if (!first_name.empty())
                        {
                                SetDlgItemTextA( hwnd, IDC_EDIT_FIRSTNAME, first_name.c_str());
                        }
                        if (!last_name.empty())
                        {
                                SetDlgItemTextA( hwnd, IDC_EDIT_LASTNAME, last_name.c_str());
                        }
                        if (!password.empty())
                        {
                                SetDlgItemTextA( hwnd, IDC_EDIT_PASSWORD, password.c_str());
                        }

                        first_name = gSavedSettings.getString("FirstName");
                        last_name = gSavedSettings.getString("LastName");
                        password = load_password_from_disk();

                        if (!first_name.empty())
                        {
                                SetDlgItemTextA( hwnd, IDC_EDIT_FIRSTNAME, first_name.c_str());
                        }
                        if (!last_name.empty())
                        {
                                SetDlgItemTextA( hwnd, IDC_EDIT_LASTNAME, last_name.c_str());
                        }
                        if (!password.empty())
                        {
                                SetDlgItemTextA( hwnd, IDC_EDIT_PASSWORD, password.c_str());
                        }

                        // Focus on password if other fields are full
                        if (first_name.empty())
                        {
                                SetFocus(GetDlgItem(hwnd, IDC_EDIT_FIRSTNAME)); 
                        }
                        else if (last_name.empty())
                        {
                                SetFocus(GetDlgItem(hwnd, IDC_EDIT_LASTNAME)); 
                        }
                        else if (password.empty())
                        {
                                SetFocus(GetDlgItem(hwnd, IDC_EDIT_PASSWORD)); 
                        }
                        else
                        {
                                SetFocus(GetDlgItem(hwnd, IDC_EDIT_FIRSTNAME)); 
                        }

                        BOOL remember_password = gSavedSettings.getBOOL("RememberPassword");
                        if (remember_password)
                        {
                                CheckDlgButton(hwnd, IDC_REMEMBER_PASSWORD, BST_CHECKED);
                        }
                        else
                        {
                                CheckDlgButton(hwnd, IDC_REMEMBER_PASSWORD, BST_UNCHECKED);
                        }
                        return TRUE;
                }

        case WM_COMMAND:
                switch(LOWORD(wParam))
                {
                case IDOK:
                        {
                                // copy login name and password into buffer
                                if (GetDlgItemTextA(hwnd, IDC_EDIT_FIRSTNAME, buffer, MAX_STRING))
                                {
                                        gCmdLineFirstName = buffer;
                                }
                                if (GetDlgItemTextA(hwnd, IDC_EDIT_LASTNAME, buffer, MAX_STRING))
                                {
                                        gCmdLineLastName = buffer;
                                }
                                if (GetDlgItemTextA(hwnd, IDC_EDIT_PASSWORD, buffer, MAX_STRING))
                                {
                                        gCmdLinePassword = buffer;
                                }
                                BOOL remember_password = (IsDlgButtonChecked(hwnd, IDC_REMEMBER_PASSWORD) == BST_CHECKED);
                                gSavedSettings.setBOOL("RememberPassword", remember_password);
                                EndDialog(hwnd, 0);     // return success
                                return TRUE;    // handled
                        }
                }
                // If we get here, we didn't handle it
                return FALSE;

        case WM_CLOSE:
        case WM_DESTROY:
                EndDialog(hwnd, 666);   // assume user wants normal login screen
                return TRUE;    // handled

        default:
                return FALSE;
        }
}
#endif

#if LL_WINDOWS && LL_RELEASE_FOR_DOWNLOAD && LL_USE_SMARTHEAP

MEM_BOOL MEM_CALLBACK second_mem_error_handler(MEM_ERROR_INFO *errorInfo);

MEM_BOOL MEM_CALLBACK first_mem_error_handler(MEM_ERROR_INFO *errorInfo)
{
    MemSetErrorHandler(second_mem_error_handler);

        // Really should free up reserved memory here and warn users
        // with dialog they have precious little time left in Second
        // Life!

        llerrs << "Memory allocation failed; aborting." << llendl;
        // llerrs << "Memory allocation failed; reserve memory released." << llendl;

        // NOTREACHED better not be, but see second_mem_error_handler
        // Could do that freeing up reserved memory thing here and
        // return 1;
        return 0;
}

MEM_BOOL MEM_CALLBACK second_mem_error_handler(MEM_ERROR_INFO *errorInfo)
{
        // Just in case "llerrs" and "llendl" cause another out-of-memory.
        LLError::crashAndLoop("");
        // NOTREACHED better not be!
        return 0;
}

#endif // LL_WINDOWS && LL_RELEASE_FOR_DOWNLOAD && LL_USE_SMARTHEAP


#if LL_WINDOWS
int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
#else 
int main( int argc, char **argv ) 
#endif
{
        LLMemType mt1(LLMemType::MTYPE_STARTUP);

#if LL_SOLARIS && defined(__sparc)
        asm ("ta\t6");           // NOTE:  Make sure memory alignment is enforced on SPARC
#endif

#if LL_DARWIN
        // Set the working dir to <bundle>/Contents/Resources
        (void) chdir(gDirUtilp->getAppRODataDir().c_str());
#endif
        
#if 1
        // This will eventually be done in LLApp
        LLCommon::initClass();
        // This should eventually be done in LLAppViewer
# if MEM_TRACK_MEM
        static const bool enable_threads = false;
# else
        static const bool enable_threads = true;
# endif
        LLVFSThread::initClass(enable_threads && true);
        LLLFSThread::initClass(enable_threads && true);
        // Image decoding
        gImageDecodeThread = new LLWorkerThread("ImageDecode", enable_threads && true);
        gTextureCache = new LLTextureCache(enable_threads && true);
        gTextureFetch = new LLTextureFetch(gTextureCache, enable_threads && false);
        LLImageWorker::initClass(gImageDecodeThread);
        LLImageJ2C::openDSO();
#endif

#if LL_WINDOWS
        // In Win32, we need to generate argc and argv ourselves...
        // Note: GetCommandLine() returns a  potentially return a LPTSTR
        // which can resolve to a LPWSTR (unicode string).
        // (That's why it's different from lpCmdLine which is a LPSTR.)
        // We don't currently do unicode, so call the non-unicode version
        // directly.
        LPSTR cmd_line_including_exe_name = GetCommandLineA();

        gIconResource = MAKEINTRESOURCE(IDI_LL_ICON);

        const S32       MAX_ARGS = 100;
        int argc = 0;
        char* argv[MAX_ARGS];           /* Flawfinder: ignore */

        char *token = NULL;
        if( cmd_line_including_exe_name[0] == '\"' )
        {
                // Exe name is enclosed in quotes
                token = strtok( cmd_line_including_exe_name, "\"" );
                argv[argc++] = token;
                token = strtok( NULL, " \t," );
        }
        else
        {
                // Exe name is not enclosed in quotes
                token = strtok( cmd_line_including_exe_name, " \t," );
        }

        while( (token != NULL) && (argc < MAX_ARGS) )
        {
                argv[argc++] = token;
                /* Get next token: */
                if (*(token + strlen(token) + 1) == '\"')               /* Flawfinder: ignore*/
                {
                        token = strtok( NULL, "\"");
                }
                else
                {
                        token = strtok( NULL, " \t," );
                }
        }
#endif

        // HACK! We REALLY want to know what grid they were trying to connect to if they
        // crashed hard.
        // So we walk through the command line args ONLY looking for the
        // userserver arguments first.  And we don't do ANYTHING but set
        // the gUserServerName (which gets passed to the crash reporter).
        // We're assuming that they're trying to log into the same grid as last
        // time, which seems fairly reasonable.
        snprintf(gUserServerName, MAX_STRING, "%s", gUserServerDomainName[UserServerDefaultChoice].mName);              /* Flawfinder: ignore */
        S32 j;
        for (j = 1; j < argc; j++) 
        {
                if (!strcmp(argv[j], "--aditi"))
                {
                        snprintf(gUserServerName, MAX_STRING, "%s", gUserServerDomainName[USERSERVER_ADITI].mName);             /* Flawfinder: ignore */
                }
                else if (!strcmp(argv[j], "--agni"))
                {
                        snprintf(gUserServerName, MAX_STRING, "%s", gUserServerDomainName[USERSERVER_AGNI].mName);              /* Flawfinder: ignore */
                }
                else if (!strcmp(argv[j], "--dmz"))
                {
                        snprintf(gUserServerName, MAX_STRING, "%s", gUserServerDomainName[USERSERVER_DMZ].mName);               /* Flawfinder: ignore */
                }
                else if (!strcmp(argv[j], "--siva"))
                {
                        snprintf(gUserServerName, MAX_STRING, "%s", gUserServerDomainName[USERSERVER_SIVA].mName);              /* Flawfinder: ignore */
                }
                else if (!strcmp(argv[j], "--shakti"))
                {
                        sprintf(gUserServerName,"%s", gUserServerDomainName[USERSERVER_SHAKTI].mName);
                }
                else if (!strcmp(argv[j], "--durga"))
                {
                        snprintf(gUserServerName, MAX_STRING, "%s", gUserServerDomainName[USERSERVER_DURGA].mName);             /* Flawfinder: ignore */
                }
                else if (!strcmp(argv[j], "--soma"))
                {
                        snprintf(gUserServerName, MAX_STRING, "%s", gUserServerDomainName[USERSERVER_SOMA].mName);              /* Flawfinder: ignore */
                }
                else if (!strcmp(argv[j], "--ganga"))
                {
                        snprintf(gUserServerName, MAX_STRING, "%s", gUserServerDomainName[USERSERVER_GANGA].mName);             /* Flawfinder: ignore */
                }
                else if (!strcmp(argv[j], "--vaak"))
                {
                        sprintf(gUserServerName,"%s", gUserServerDomainName[USERSERVER_VAAK].mName);
                }
                else if (!strcmp(argv[j], "--uma"))
                {
                        sprintf(gUserServerName,"%s", gUserServerDomainName[USERSERVER_UMA].mName);
                }
                else if (!strcmp(argv[j], "-user") && (++j < argc))
                {
                        if (!strcmp(argv[j], "-"))
                        {
                                snprintf(gUserServerName, MAX_STRING, "%s", LOOPBACK_ADDRESS_STRING);           /* Flawfinder: ignore */
                        }
                        else
                        {
                                snprintf(gUserServerName, MAX_STRING, "%s", argv[j]);           /* Flawfinder: ignore */
                        }
                }
                else if (!strcmp(argv[j], "-multiple"))
                {
                        // Hack to detect -multiple so we can disable the marker file check (which will always fail)
                        gMultipleViewersOK = TRUE;
                }
                else if (!strcmp(argv[j], "-novoice"))
                {
                        // May need to know this early also
                        gDisableVoice = TRUE;
                }
        }

        //
        // Start of the application
        //
        // IMPORTANT! Do NOT put anything that will write
        // into the log files during normal startup until AFTER
        // we run the "program crashed last time" error handler below.
        //

        // Need to do this initialization before we do anything else, since anything
        // that touches files should really go through the lldir API
        gDirUtilp->initAppDirs("SecondLife");

        //
        // Set up logging defaults for the viewer
        //
        LLError::initForApplication(
                                gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, ""));
        LLError::setFatalFunction(errorCallback);


#if LL_RELEASE_FOR_DOWNLOAD && LL_SEND_CRASH_REPORTS
        //
        // Crash log if we hard crashed.
        // Initialize crash logging
        //
        init_crash_handler();
#endif
        // Set up SecondLife.log
        init_logging();
        
        //
        // OK to write stuff to logs now, we've now crash reported if necessary
        //

        // Set up some defaults...
        gSettingsFileName = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, DEFAULT_SETTINGS_FILE);
        gOldSettingsFileName = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, LEGACY_DEFAULT_SETTINGS_FILE);

        //
        // Process command line arguments
        //
        S32 args_result = 0;

#if LL_DARWIN
        {
                // On the Mac, read in arguments.txt (if it exists) and process it for additional arguments.
                std::string args;
                if(_read_file_into_string(args, "arguments.txt"))
                {
                        // The arguments file exists.  
                        // It should consist of command line arguments separated by newlines.
                        // Split it into individual arguments and build a fake argv[] to pass to parse_args.
                        std::vector<std::string> arglist;
                        
                        arglist.push_back("newview");
                        
                        llinfos << "Reading additional command line arguments from arguments.txt..." << llendl;
                        
                        typedef boost::tokenizer<boost::escaped_list_separator<char> > tokenizer;
                        boost::escaped_list_separator<char> sep("\\", "\r\n ", "\"'");
                        tokenizer tokens(args, sep);
                        tokenizer::iterator token_iter;

                        for(token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
                        {
                                llinfos << "argument: '" << (token_iter->c_str()) << "'" << llendl;
                                
                                arglist.push_back(*token_iter);
                        }

                        char **fakeargv = new char*[arglist.size()];
                        int i;
                        for(i=0; i < arglist.size(); i++)
                                fakeargv[i] = const_cast<char*>(arglist[i].c_str());
                                
                        args_result = parse_args(arglist.size(), fakeargv);
                        delete[] fakeargv;
                }
                
                // Get the user's preferred language string based on the Mac OS localization mechanism.
                // To add a new localization:
                        // go to the "Resources" section of the project
                        // get info on "language.txt"
                        // in the "General" tab, click the "Add Localization" button
                        // create a new localization for the language you're adding
                        // set the contents of the new localization of the file to the string corresponding to our localization
                        //   (i.e. "en-us", "ja", etc.  Use the existing ones as a guide.)
                CFURLRef url = CFBundleCopyResourceURL(CFBundleGetMainBundle(), CFSTR("language"), CFSTR("txt"), NULL);
                char path[MAX_PATH];
                if(CFURLGetFileSystemRepresentation(url, false, (UInt8 *)path, sizeof(path)))
                {
                        std::string lang;
                        if(_read_file_into_string(lang, path))
                        {
                                gCommandLineForcedSettings["SystemLanguage"] = lang;
                        }
                }
                CFRelease(url);
        }
#endif

        //
        // Parse the command line arguments
        //
        args_result |= parse_args(argc, argv);
        if (args_result)
        {
                remove_marker_file();
                return args_result;
        }

        if (!strcmp(gUserServerName, gUserServerDomainName[USERSERVER_AGNI].mName))
        {
                gInProductionGrid = TRUE;
        }

        // *TODO:translate
        gSecondLife = "Second Life (Dale's Unofficial Viewer)";
        
        // Read skin/branding settings if specified.
        if (! gDirUtilp->getSkinDir().empty() )
        {
                std::string skin_def_file = gDirUtilp->getExpandedFilename(LL_PATH_TOP_SKIN, "skin.xml");
                LLXmlTree skin_def_tree;

                if (!skin_def_tree.parseFile(skin_def_file))
                {
                        llerrs << "Failed to parse skin definition." << llendl;
                }

                LLXmlTreeNode* rootp = skin_def_tree.getRoot();
                LLXmlTreeNode* disabled_message_node = rootp->getChildByName("disabled_message");       
                if (disabled_message_node)
                {
                        gDisabledMessage = disabled_message_node->getContents();
                }

                static LLStdStringHandle hide_links_string = LLXmlTree::addAttributeString("hide_links");
                rootp->getFastAttributeBOOL(hide_links_string, gHideLinks);

                // Legacy string.  This flag really meant we didn't want to expose references to "Second Life".
                // Just set gHideLinks instead.
                static LLStdStringHandle silent_string = LLXmlTree::addAttributeString("silent_update");
                BOOL silent_update;
                rootp->getFastAttributeBOOL(silent_string, silent_update);
                gHideLinks = (gHideLinks || silent_update);
        }

#if LL_DARWIN
        // Initialize apple menubar and various callbacks
        init_apple_menu(gSecondLife.c_str());

#if __ppc__
        // If the CPU doesn't have Altivec (i.e. it's not at least a G4), don't go any further.
        // Only test PowerPC - all Intel Macs have SSE.
        if(!gSysCPU.hasAltivec())
        {
                std::ostringstream msg;
                msg << gSecondLife << " requires a processor with AltiVec (G4 or later).";
                OSMessageBox(
                        msg.str().c_str(),
                        NULL,
                        OSMB_OK);
                remove_marker_file();
                return 1;
        }
#endif
        
#endif // LL_DARWIN

        // Display splash screen.  Must be after above check for previous
        // crash as this dialog is always frontmost.
        std::ostringstream splash_msg;
        // *TODO:translate
        splash_msg << "Loading " << gSecondLife << "...";
        LLSplashScreen::show();
        LLSplashScreen::update(splash_msg.str().c_str());

        LLVolumeMgr::initClass();

        // Initialize the feature manager
        // The feature manager is responsible for determining what features
        // are turned on/off in the app.
        gFeatureManagerp = new LLFeatureManager;

        gStartTime = totalTime();


        //
        // Process ini files
        //

        // declare all possible setting variables
        declare_settings();

#if !LL_RELEASE_FOR_DOWNLOAD
//      only write the defaults for non-release builds!
        gSavedSettings.saveToFile(gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS,"settings_default.xml").c_str(), FALSE);
#endif

        //
        // Set the name of the window
        //
#if LL_RELEASE_FOR_DOWNLOAD
        gWindowTitle = gSecondLife;
#elif LL_DEBUG
        gWindowTitle = gSecondLife + LLString(" [DEBUG] ") + gArgs;
#else
        gWindowTitle = gSecondLife + LLString(" ") + gArgs;
#endif
        LLString::truncate(gWindowTitle, 255);

        if (!gMultipleViewersOK)
        {
            //
            // Check for another instance of the app running
            //

                // RN: if we received a URL, hand it off to the existing instance
                // don't call another_instance_running() when doing URL handoff, as
                // it relies on checking a marker file which will not work when running
                // out of different directories
                std::string slurl;
                if (!LLStartUp::sSLURLCommand.empty())
                {
                        slurl = LLStartUp::sSLURLCommand;
                }
                else if (LLURLSimString::parse())
                {
                        slurl = LLURLSimString::getURL();
                }
                if (!slurl.empty())
                {
                        if (send_url_to_other_instance(slurl))
                        {
                                // successfully handed off URL to existing instance, exit
                                return 1;
                        }
                }
                
                gSecondInstance = another_instance_running();
                
                if (gSecondInstance)
                {
                        std::ostringstream msg;
                        msg << 
                                gSecondLife << " is already running.\n"
                                "\n"
                                "Check your task bar for a minimized copy of the program.\n"
                                "If this message persists, restart your computer.",
                        OSMessageBox(
                                msg.str().c_str(),
                                NULL,
                                OSMB_OK);
                        return 1;
                }

                init_marker_file();

#if LL_SEND_CRASH_REPORTS
                if (gLastExecFroze)
                {
                        llinfos << "Last execution froze, requesting to send crash report." << llendl;
                        //
                        // Pop up a freeze or crash warning dialog
                        //
                        std::ostringstream msg;
                        msg << gSecondLife
                                << " appears to have frozen or crashed on the previous run.\n"
                                << "Would you like to send a crash report?";
                        std::string alert;
                        alert = gSecondLife;
                        alert += " Alert";
                        S32 choice = OSMessageBox(msg.str().c_str(),
                                alert.c_str(),
                                OSMB_YESNO);
                        if (OSBTN_YES == choice)
                        {
                                llinfos << "Sending crash report." << llendl;

                                remove_marker_file();
#if LL_WINDOWS
                                std::string exe_path = gDirUtilp->getAppRODataDir();
                                exe_path += gDirUtilp->getDirDelimiter();
                                exe_path += "win_crash_logger.exe";

                                std::string arg_string = "-previous -user ";
                                arg_string += gUserServerName;
                                arg_string += " -name \"";
                                arg_string += gSecondLife;
                                arg_string += "\"";
                                // Spawn crash logger.
                                // NEEDS to wait until completion, otherwise log files will get smashed.
                                _spawnl(_P_WAIT, exe_path.c_str(), exe_path.c_str(), arg_string.c_str(), NULL);
#elif LL_DARWIN
                                std::string command_str;
                                command_str = "crashreporter.app/Contents/MacOS/crashreporter ";
                                command_str += "-previous -user ";
                                command_str += gUserServerName;
                                // XXX -- We need to exit fullscreen mode for this to work.
                                // XXX -- system() also doesn't wait for completion.  Hmm...
                                system(command_str.c_str());            /* Flawfinder: Ignore */
#elif LL_LINUX || LL_SOLARIS
                                std::string cmd =gDirUtilp->getAppRODataDir();
                                cmd += gDirUtilp->getDirDelimiter();
#if LL_LINUX
                                cmd += "linux-crash-logger.bin";
#else // LL_SOLARIS
                                cmd += "bin/solaris-crash-logger";
#endif
                                char* const cmdargv[] =
                                        {(char*)cmd.c_str(),
                                         (char*)"-previous",
                                         (char*)"-user",
                                         (char*)gUserServerName,
                                         (char*)"-name",
                                         (char*)gSecondLife.c_str(),
                                         NULL};
                                fflush(NULL);
                                pid_t pid = fork();
                                if (pid == 0)
                                { // child
                                        execv(cmd.c_str(), cmdargv);            /* Flawfinder: Ignore */
                                        llwarns << "execv failure when trying to start " << cmd << llendl;
                                        _exit(1); // avoid atexit()
                                } else {
                                        if (pid > 0)
                                        {
                                                // wait for child proc to die
                                                int childExitStatus;
                                                waitpid(pid, &childExitStatus, 0);
                                        } else {
                                                llwarns << "fork failure." << llendl;
                                        }
                                }
#endif
                        }
                        else
                        {
                                llinfos << "Not sending crash report." << llendl;
                        }
                }
#endif // #if LL_SEND_CRASH_REPORTS
        }
        else
        {
                gSecondInstance = another_instance_running();
                
                if (gSecondInstance)
                {
                        gDisableVoice = TRUE;
                }

                init_marker_file();
        }

        //
        // Write system information into the debug log (CPU, OS, etc.)
        //
        write_system_info();

#if LL_WINDOWS
        //
        // Turn off Windows XP Error Reporting
        // (Don't send our data to Microsoft--at least until we are Logo approved and have a way
        // of getting the data back from them.)
        //
        llinfos << "Turning off Windows error reporting." << llendl;
        disable_win_error_reporting();
#endif  // LL_WINDOWS

        // Build a string representing the current version number.
        gCurrentVersion = llformat("%s %d.%d.%d.%d.%d", gChannelName.c_str(), LL_VERSION_MAJOR, LL_VERSION_MINOR, LL_VERSION_PATCH, LL_VERSION_BUILD, LL_VERSION_REVISION );
        
        //
        // Various introspection concerning the libs we're using
        //
        llinfos << "J2C Engine is: " << LLImageJ2C::getEngineInfo() << llendl;

        //
        // Load the feature tables
        //
        llinfos << "Loading feature tables." << llendl;
        
        gFeatureManagerp->loadFeatureTables();
        gFeatureManagerp->initCPUFeatureMasks();

        // Merge with the command line overrides
        gSavedSettings.applyOverrides(gCommandLineSettings);

        // Need to do this before calling parseAlerts
        gUICtrlFactory = new LLViewerUICtrlFactory();
        
        // Pre-load alerts.xml to define the warnings settings (always loads from skins/xui/en-us/)
        // Do this *before* loading the settings file
        LLAlertDialog::parseAlerts("alerts.xml", &gSavedSettings, TRUE);
        
        // Overwrite default settings with user settings
        llinfos << "Loading configuration file " << gSettingsFileName << llendl;
        if (0 == gSavedSettings.loadFromFile(gSettingsFileName))
        {
                llinfos << "Failed to load settings from " << gSettingsFileName << llendl;
                llinfos << "Loading legacy settings from " << gOldSettingsFileName << llendl;
                gSavedSettings.loadFromFileLegacy(gOldSettingsFileName);
        }

        // need to do this here - need to have initialized global settings first
        LLString nextLoginLocation = gSavedSettings.getString( "NextLoginLocation" );
        if ( nextLoginLocation.length() )
        {
                LLURLSimString::setString( nextLoginLocation.c_str() );
        };

        // Merge with the command line overrides
        gSavedSettings.applyOverrides(gCommandLineForcedSettings);

        gLastRunVersion = gSavedSettings.getString("LastRunVersion");

        fixup_settings();
        
        // Get the single value from the crash settings file, if it exists
        std::string crash_settings_filename = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, CRASH_SETTINGS_FILE);
        gCrashSettings.loadFromFile(crash_settings_filename.c_str());

        // OS-specific login dialogs
#if LL_WINDOWS
        /*
        // Display initial login screen, comes up quickly. JC
        {
                LLSplashScreen::hide();

                INT_PTR result = DialogBox(hInstance, L"CONNECTBOX", NULL, login_dialog_func);
                if (result < 0)
                {
                        llwarns << "Connect dialog box failed, returned " << result << llendl;
                        return 1;
                }
                // success, result contains which button user clicked
                llinfos << "Connect dialog box clicked " << result << llendl;

                LLSplashScreen::show();
        }
        */
#endif

        // track number of times that app has run
        gNumSessions = gSavedSettings.getS32("NumSessions");
        gNumSessions++;
        gSavedSettings.setS32("NumSessions", gNumSessions);

        gSavedSettings.setString("HelpLastVisitedURL",gSavedSettings.getString("HelpHomeURL"));

        if (gSavedSettings.getBOOL("VerboseLogs"))
        {
                LLError::setPrintLocation(true);
        }

#if !LL_RELEASE_FOR_DOWNLOAD
        if (gUserServerChoice == USERSERVER_NONE)
        {
                // Development version: load last server choice by default (overridden by cmd line args)
                
                S32 server = gSavedSettings.getS32("ServerChoice");
                if (server != 0)
                        gUserServerChoice = (EUserServerDomain)llclamp(server, 0, (S32)USERSERVER_COUNT - 1);
                if (server == USERSERVER_OTHER)
                {
                        LLString custom_server = gSavedSettings.getString("CustomServer");
                        if (custom_server.empty())
                        {
                                snprintf(gUserServerName, MAX_STRING, "none");          /* Flawfinder: ignore */
                        }
                        else
                        {
                                snprintf(gUserServerName, MAX_STRING, "%s", custom_server.c_str());             /* Flawfinder: ignore */
                        }
                }
        }
#endif

        if (gUserServerChoice == USERSERVER_NONE)
        {
                gUserServerChoice = UserServerDefaultChoice;
        }
        
        // Load art UUID information, don't require these strings to be declared in code.
        LLString viewer_art_filename = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"viewerart.xml");
        llinfos << "Loading art table from " << viewer_art_filename << llendl;
        gViewerArt.loadFromFile(viewer_art_filename.c_str(), FALSE);
        LLString textures_filename = gDirUtilp->getExpandedFilename(LL_PATH_SKINS, "textures", "textures.xml");
        llinfos << "Loading art table from " << textures_filename << llendl;
        gViewerArt.loadFromFile(textures_filename.c_str(), FALSE);

        LLString colors_base_filename = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "colors_base.xml");
        llinfos << "Loading base colors from " << colors_base_filename << llendl;
        gColors.loadFromFile(colors_base_filename.c_str(), FALSE, TYPE_COL4U);

        // Load overrides from user colors file
        LLString user_colors_filename = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "colors.xml");
        llinfos << "Loading user colors from " << user_colors_filename << llendl;
        if (gColors.loadFromFile(user_colors_filename.c_str(), FALSE, TYPE_COL4U) == 0)
        {
                llinfos << "Failed to load user colors from " << user_colors_filename << llendl;
                LLString user_legacy_colors_filename = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "colors.ini");
                llinfos << "Loading legacy colors from " << user_legacy_colors_filename << llendl;
                gColors.loadFromFileLegacy(user_legacy_colors_filename.c_str(), FALSE, TYPE_COL4U);
        }

        // Widget construction depends on LLUI being initialized
        LLUI::initClass(&gSavedSettings, 
                                        &gColors, 
                                        &gViewerArt,
                                        &gImageList,
                                        ui_audio_callback,
                                        &LLUI::sGLScaleFactor);

        gUICtrlFactory->setupPaths(); // update paths with correct language set
        
        //
        // Load settings files
        //
        //
        LLGroupMgr::parseRoleActions("role_actions.xml");

        LLAgent::parseTeleportMessages("teleport_strings.xml");

        // Move certain saved settings into global variables for speed
        saved_settings_to_globals();

        // 1.6.10: Default crash reporting to on, because this dialog doesn't
        // make any sense for a new user.
        /*
        if (!gSavedSettings.getBOOL("AskedAboutCrashReports"))
        {
                // NOTE: Be sure to use gSecondLife if this becomes uncommented.
                S32 retval = OSMessageBox(
                        "Welcome!  You have successfully installed Second Life.\n"
                        "\n"
                        "Should performance issues or crashes occur, Second Life\n"
                        "can automatically send technical data about your computer\n"
                        "to Linden Lab to diagnose and correct the problem.\n"
                        "This information is used solely to address technical issues\n"
                        "and is kept strictly confidential.\n"
                        "You can change this setting under Preferences / General.\n"
                        "Automatically send technical data if problems occur?",
                        "Second Life",
                        OSMB_YESNO);
                if (OSBTN_YES == retval)
                {
                        gAutoReportCrashes = TRUE;
                }
                else
                {
                        gAutoReportCrashes = FALSE;
                }

                // Setting will be saved automatically at shutdown.
                gSavedSettings.setBOOL("AskedAboutCrashReports", TRUE);
        }
        */

        // Find partition serial number (Windows) or hardware serial (Mac)
        gSerialNumber = get_serial_number();

#if LL_WINDOWS
        //
        // Do driver verification and initialization based on DirectX
        // hardware polling and driver versions
        //
        if (gProbeHardware)
        {
                BOOL vram_only = !gSavedSettings.getBOOL("ProbeHardwareOnStartup");

                LLSplashScreen::update("Detecting hardware...");

                llinfos << "Attempting to poll DirectX for hardware info" << llendl;
                gDXHardware.setWriteDebugFunc(write_debug);
                BOOL probe_ok = gDXHardware.getInfo(vram_only);

                if (!probe_ok
                        && gSavedSettings.getWarning("AboutDirectX9"))
                {
                        llinfos << "DirectX probe failed, alerting user." << llendl;

                        // Warn them that runnin without DirectX 9 will
                        // not allow us to tell them about driver issues
                        std::ostringstream msg;
                        msg << 
                                gSecondLife << " is unable to detect DirectX 9.0b or greater.\n"
                                "\n" <<
                                gSecondLife << " uses DirectX to detect hardware and/or\n"
                                "outdated drivers that can cause stability problems,\n"
                                "poor performance and crashes.  While you can run\n" <<
                                gSecondLife << " without it, we highly recommend running\n"
                                "with DirectX 9.0b\n"
                                "\n"
                                "Do you wish to continue?\n";
                        S32 button = OSMessageBox(
                                msg.str().c_str(),
                                "Warning",
                                OSMB_YESNO);
                        if (OSBTN_NO== button)
                        {
                                llinfos << "User quitting after failed DirectX 9 detection" << llendl;
                                LLWeb::loadURLExternal(DIRECTX_9_URL);
                                return 0;
                        }
                        gSavedSettings.setWarning("AboutDirectX9", FALSE);
                }
                llinfos << "Done polling DirectX for hardware info" << llendl;

                // Only probe once after installation
                gSavedSettings.setBOOL("ProbeHardwareOnStartup", FALSE);

                // Disable so debugger can work
                LLSplashScreen::update(splash_msg.str().c_str());
        }

        if (!LLWinDebug::setupExceptionHandler())
        {
                llwarns << " Someone took over my exception handler (post hardware probe)!" << llendl;
        }

        gGLManager.mVRAM = gDXHardware.getVRAM();
        llinfos << "Detected VRAM: " << gGLManager.mVRAM << llendl;
#endif

        // Always fetch the Ethernet MAC address, needed both for login
        // and password load.
        LLUUID::getNodeID(gMACAddress);

        // Prepare for out-of-memory situations, during which we will crash on
        // purpose and save a dump.
#if LL_WINDOWS && LL_RELEASE_FOR_DOWNLOAD && LL_USE_SMARTHEAP
        MemSetErrorHandler(first_mem_error_handler);
#endif // LL_WINDOWS && LL_RELEASE_FOR_DOWNLOAD && LL_USE_SMARTHEAP

        gViewerStats = new LLViewerStats();

        //
        // Initialize the VFS, and gracefully handle initialization errors
        //

        if (!init_cache())
        {
                std::ostringstream msg;
                msg <<
                        gSecondLife << " is unable to access a file that it needs.\n"
                        "\n"
                        "This can be because you somehow have multiple copies running, "
                        "or your system incorrectly thinks a file is open. "
                        "If this message persists, restart your computer and try again. "
                        "If it continues to persist, you may need to completely uninstall " <<
                        gSecondLife << " and reinstall it.";
                OSMessageBox(
                        msg.str().c_str(),
                        NULL,
                        OSMB_OK);
                return 1;
        }
        
#if LL_DARWIN
        // Display the release notes for the current version
        if(!gHideLinks && gCurrentVersion != gLastRunVersion)
        {
                // Current version and last run version don't match exactly.  Display the release notes.
                DisplayReleaseNotes();
        }
#endif

        //
        // Initialize the window
        //

        // pop up debug console if necessary
#if LL_WINDOWS
        if (gUseConsole && gSavedSettings.getBOOL("ShowConsoleWindow"))
        {
                create_console();
        }
#endif

        llinfos << "Initializing window..." << llendl;

        // store setting in a global for easy access and modification
        gNoRender = gSavedSettings.getBOOL("DisableRendering");

        // Hide the splash screen
        LLSplashScreen::hide();

        // HACK: Need a non-const char * for stupid window name (propagated deep down)
        char window_title_str[256];             /* Flawfinder: ignore */
        strncpy(window_title_str, gWindowTitle.c_str(), sizeof(window_title_str) - 1);          /* Flawfinder: ignore */
        window_title_str[sizeof(window_title_str) - 1] = '\0';

        // always start windowed
        gViewerWindow = new LLViewerWindow(window_title_str, sWindowClass,
                gSavedSettings.getS32("WindowX"), gSavedSettings.getS32("WindowY"),
                gSavedSettings.getS32("WindowWidth"), gSavedSettings.getS32("WindowHeight"),
                FALSE, gIgnorePixelDepth, gSavedSettings.getS32("StereoMode"));
                
        if (gSavedSettings.getBOOL("FullScreen"))
        {
                gViewerWindow->toggleFullscreen(FALSE);
                        // request to go full screen... which will be delayed until login
        }

        // Stereo mode may turn out to be unusable. In that case, write the new mode (none)
        gSavedSettings.setS32("StereoMode", gViewerWindow->getWindow()->getStereoMode());

        if (gSavedSettings.getBOOL("WindowMaximized"))
        {
                gViewerWindow->mWindow->maximize();
                gViewerWindow->getWindow()->setNativeAspectRatio(gSavedSettings.getF32("FullScreenAspectRatio"));
        }

        LLUI::sWindow = gViewerWindow->getWindow();

        LLAlertDialog::parseAlerts("alerts.xml");
        LLNotifyBox::parseNotify("notify.xml");

        LLMediaEngine::initClass();
        
        //
        // Clean up the feature manager lookup table - settings were updated
        // in the LLViewerWindow constructor
        //
        gFeatureManagerp->cleanupFeatureTables();

        // Show watch cursor
        gViewerWindow->setCursor(UI_CURSOR_WAIT);

        
#if LL_WINDOWS && LL_LCD_COMPILE
        // start up an LCD window on a logitech keyboard, if there is one
        gLcdScreen = new llLCD(hInstance);
        CreateLCDDebugWindows();
#endif

        // Finish view initialization
        gViewerWindow->initBase();

        // show viewer window
        gViewerWindow->mWindow->show();

        write_debug(gGLManager.getGLInfoString());
        llinfos << gGLManager.getGLInfoString() << llendl;

        //load key settings
        bind_keyboard_functions();

        // Load Default bindings
        if (!gViewerKeyboard.loadBindings(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"keys.ini").c_str()))
        {
                llerrs << "Unable to open keys.ini" << llendl;
        }
        // Load Custom bindings (override defaults)
        gViewerKeyboard.loadBindings(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"custom_keys.ini").c_str());

        // Calculate the digest for the executable (takes < 90ms on a fast machine).
        FILE* app_file = LLFile::fopen( gDirUtilp->getExecutablePathAndName().c_str(), "rb" );          /* Flawfinder: ignore */
        if( app_file )
        {
                LLMD5 app_md5;
                app_md5.update( app_file ); // Automatically closes the file
                app_md5.finalize();
                app_md5.raw_digest( gViewerDigest.mData );
        }
        llinfos << "Viewer Digest: " << gViewerDigest << llendl;

        // If we don't have the right GL requirements, exit.
        // BUG: This should just be changed to a generic GL "Not good enough" flag
        if (!gGLManager.mHasMultitexture && !gNoRender)
        {
                std::ostringstream msg;
                msg <<
                        "You do not appear to have the proper hardware requirements "
                        "for " << gSecondLife << ". " << gSecondLife << " requires an OpenGL graphics "
                        "card that has multitexture support. If this is the case, "
                        "you may want to make sure that you have the latest drivers for "
                        "your graphics card, and service packs and patches for your "
                        "operating system.\n"
                        "If you continue to have problems, please go to: "
                        "www.secondlife.com/support ";
                OSMessageBox(
                        msg.str().c_str(),
                        NULL,
                        OSMB_OK);
                return 0;
        }

        // Save the current version to the prefs file
        gSavedSettings.setString("LastRunVersion", gCurrentVersion);

        gSimLastTime = gRenderStartTime.getElapsedTimeF32();
        gSimFrames   = (F32)gFrameCount;

        //-------------------------------------------
        // Run main loop until time to quit
        //-------------------------------------------
        main_loop();

        cleanup_app();

        // If we're exiting to launch an URL, do that here so the screen
        // is at the right resolution before we launch IE.
        if (!gLaunchFileOnQuit.empty())
        {
#if LL_WINDOWS
                // Indicate an application is starting.
                SetCursor(LoadCursor(NULL, IDC_WAIT));
#endif

                // HACK: Attempt to wait until the screen res. switch is complete.
                ms_sleep(1000);

                LLWeb::loadURLExternal( gLaunchFileOnQuit );
        }

        llinfos << "Goodbye" << llendflush;
        return 0;
}

bool send_url_to_other_instance(const std::string& url)
{
#if LL_WINDOWS
        wchar_t window_class[256]; /* Flawfinder: ignore */   // Assume max length < 255 chars.
        mbstowcs(window_class, sWindowClass, 255);
        window_class[255] = 0;
        // Use the class instead of the window name.
        HWND other_window = FindWindow(window_class, NULL);
        if (other_window != NULL)
        {
                lldebugs << "Found other window with the name '" << gWindowTitle << "'" << llendl;
                COPYDATASTRUCT cds;
                const S32 SLURL_MESSAGE_TYPE = 0;
                cds.dwData = SLURL_MESSAGE_TYPE;
                cds.cbData = url.length() + 1;
                cds.lpData = (void*)url.c_str();

                LRESULT msg_result = SendMessage(other_window, WM_COPYDATA, NULL, (LPARAM)&cds);
                lldebugs << "SendMessage(WM_COPYDATA) to other window '" 
                                 << gWindowTitle << "' returned " << msg_result << llendl;
                return true;
        }
#endif
        return false;
}

BOOL another_instance_running()
{
        // We create a marker file when the program starts and remove the file when it finishes.
        // If the file is currently locked, that means another process is already running.

        std::string marker_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"SecondLife.exec_marker");
        llinfos << "Checking marker file for lock..." << llendl;

        // If file doesn't exist, we create it
        // If file does exist, try to get writing privilages
        FILE* fMarker = LLFile::fopen(marker_file.c_str(), "rb");               /* Flawfinder: ignore */
        if (fMarker != NULL)
        {
                // File exists, try opening with write permissions
                fclose(fMarker);
                fMarker = LLFile::fopen(marker_file.c_str(), "wb");             /* Flawfinder: ignore */
                if (fMarker == NULL)
                {
                        llinfos << "Marker file is locked." << llendl;
                        return TRUE;
                }
#if LL_DARWIN
                // Try to lock it. On Mac, this is the only way to test if it's actually locked.
                if (flock(fileno(fMarker), LOCK_EX | LOCK_NB) == -1)
                {
                        // Lock failed - somebody else has it.
                        fclose(fMarker);
                        llinfos << "Marker file is locked." << llendl;
                        return TRUE;
                }
#endif
                fclose(fMarker);
        }
        llinfos << "Marker file isn't locked." << llendl;
        return FALSE;
}


void check_for_events()
{
        LLFastTimer t2(LLFastTimer::FTM_MESSAGES);
#if LL_WINDOWS
        if (!LLWinDebug::setupExceptionHandler())
        {
                llwarns << " Someone took over my exception handler (post messagehandling)!" << llendl;
        }
#endif

        gViewerWindow->mWindow->gatherInput();
}

#include "moviemaker.h"
extern BOOL gbCapturing;

#if !LL_SOLARIS
extern MovieMaker gMovieMaker;
#endif

void main_loop()
{
        // Create IO Pump to use for HTTP Requests.
        gServicePump = new LLPumpIO(gAPRPoolp);
        LLHTTPClient::setPump(*gServicePump);
        LLHTTPClient::setCABundle(gDirUtilp->getCAFile());
        
        // initialize voice stuff here
        gLocalSpeakerMgr = new LLLocalSpeakerMgr();
        gActiveChannelSpeakerMgr = new LLActiveSpeakerMgr();

        LLVoiceChannel::initClass();
        LLVoiceClient::init(gServicePump);
                                
        LLMemType mt1(LLMemType::MTYPE_MAIN);
        LLTimer frameTimer,idleTimer;
        LLTimer debugTime;
        
        // Handle messages
        while (!gQuit)
        {
                LLFastTimer::reset(); // Should be outside of any timer instances
                {
                        LLFastTimer t(LLFastTimer::FTM_FRAME);

                        check_for_events();

#if 1 && !RELEASE_FOR_DOWNLOAD
                        // once per second debug info
                        if (debugTime.getElapsedTimeF32() > 1.f)
                        {
                                debugTime.reset();
                        }
#endif
                        if (!gQuit)
                        {
                                // Scan keyboard for movement keys.  Command keys and typing
                                // are handled by windows callbacks.  Don't do this until we're
                                // done initializing.  JC
                                if (gViewerWindow->mWindow->getVisible() 
                                        && gViewerWindow->getActive()
                                        && !gViewerWindow->mWindow->getMinimized()
                                        && LLStartUp::getStartupState() == STATE_STARTED
                                        && !gViewerWindow->getShowProgress()
                                        && !gFocusMgr.focusLocked())
                                {
                                        gKeyboard->scanKeyboard();
                                        LLViewerJoystick::scanJoystick();
                                }

                                // Update state based on messages, user input, object idle.
                                {
                                        LLFastTimer t3(LLFastTimer::FTM_IDLE);
                                        idle();
                                        LLCurl::process();
                                        // this pump is necessary to make the login screen show up
                                        gServicePump->pump();
                                        gServicePump->callback();
                                }

                                if (gDoDisconnect && (LLStartUp::getStartupState() == STATE_STARTED))
                                {
                                        save_final_snapshot(NULL);
                                        disconnect_viewer(NULL);
                                }

                                // Render scene.
                                if (!gQuit)
                                {
                                        display();

                                        LLFloaterSnapshot::update(); // take snapshots
                                        
#if !LL_SOLARIS
                                        if (gbCapturing)
                                        {
                                                gMovieMaker.Snap();
                                        }
#endif
#if LL_WINDOWS && LL_LCD_COMPILE
                                        // update LCD Screen
                                        gLcdScreen->UpdateDisplay();
#endif
                                }
                        }

                        // Sleep and run background threads
                        {
                                LLFastTimer t2(LLFastTimer::FTM_SLEEP);
                                bool run_multiple_threads = gSavedSettings.getBOOL("RunMultipleThreads");

                                // yield some time to the os based on command line option
                                if(gYieldTime)
                                {
                                        ms_sleep(gYieldMS);
                                }

                                // yield cooperatively when not running as foreground window
                                if (   gNoRender
                                                || !gViewerWindow->mWindow->getVisible()
                                                || !gFocusMgr.getAppHasFocus())
                                {
                                        // Sleep if we're not rendering, or the window is minimized.
                                        S32 milliseconds_to_sleep = llclamp(gSavedSettings.getS32("BackgroundYieldTime"), 0, 1000);
                                        // don't sleep when BackgroundYieldTime set to 0, since this will still yield to other threads
                                        // of equal priority on Windows
                                        if (milliseconds_to_sleep > 0)
                                        {
                                                ms_sleep(milliseconds_to_sleep);
                                                // also pause worker threads during this wait period
                                                gTextureCache->pause();
                                                gImageDecodeThread->pause();
                                        }
                                }
                                
                                if (gRandomizeFramerate)
                                {
                                        ms_sleep(rand() % 200);
                                }

                                if (gPeriodicSlowFrame
                                        && (gFrameCount % 10 == 0))
                                {
                                        llinfos << "Periodic slow frame - sleeping 500 ms" << llendl;
                                        ms_sleep(500);
                                }


                                const F64 min_frame_time = 0.0; //(.0333 - .0010); // max video frame rate = 30 fps
                                const F64 min_idle_time = 0.0; //(.0010); // min idle time = 1 ms
                                const F64 max_idle_time = run_multiple_threads ? min_idle_time : .005; // 5 ms
                                idleTimer.reset();
                                while(1)
                                {
                                        S32 work_pending = 0;
                                        S32 io_pending = 0;
                                        work_pending += gTextureCache->update(1); // unpauses the texture cache thread
                                        work_pending += gImageDecodeThread->update(1); // unpauses the image thread
                                        work_pending += gTextureFetch->update(1); // unpauses the texture fetch thread
                                        io_pending += LLVFSThread::updateClass(1);
                                        io_pending += LLLFSThread::updateClass(1);
                                        if (io_pending > 1000)
                                        {
                                                ms_sleep(llmin(io_pending/100,100)); // give the vfs some time to catch up
                                        }

                                        F64 frame_time = frameTimer.getElapsedTimeF64();
                                        F64 idle_time = idleTimer.getElapsedTimeF64();
                                        if (frame_time >= min_frame_time &&
                                                idle_time >= min_idle_time &&
                                                (!work_pending || idle_time >= max_idle_time))
                                        {
                                                break;
                                        }
                                }
                                frameTimer.reset();

                                 // Prevent the worker threads from running while rendering.
                                // if (LLThread::processorCount()==1) //pause() should only be required when on a single processor client...
                                if (run_multiple_threads == FALSE)
                                {
                                        gTextureCache->pause();
                                        gImageDecodeThread->pause();
                                        // gTextureFetch->pause(); // Don't pause the fetch (IO) thread
                                }
                                //LLVFSThread::sLocal->pause(); // Prevent the VFS thread from running while rendering.
                                //LLLFSThread::sLocal->pause(); // Prevent the LFS thread from running while rendering.
                        }
                                                
                }
        }

        // Save snapshot for next time, if we made it through initialization
        if (STATE_STARTED == LLStartUp::getStartupState())
        {
                save_final_snapshot(NULL);
        }
        
        delete gServicePump;

        llinfos << "Exiting main_loop" << llendflush;
}


void process_keystrokes_async()
{
#if LL_WINDOWS
        MSG                     msg;
        // look through all input messages, leaving them in the event queue
        while( PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE | PM_NOYIELD))
        {
                // on first mouse message, break out
                if (msg.message >= WM_MOUSEFIRST && 
                        msg.message <= WM_MOUSELAST ||
                        msg.message == WM_QUIT)
                {
                        break;
                }

                // this is a message we want to handle now, so remove it from the event queue
                PeekMessage(&msg, NULL, msg.message, msg.message, PM_REMOVE | PM_NOYIELD);
                //              if (msg.message == WM_KEYDOWN)
                //              {
                //                      llinfos << "Process async key down " << (U32)msg.wParam << llendl;
                //              }
                TranslateMessage(&msg);
                DispatchMessage(&msg);
        }

        // Scan keyboard for movement keys.  Command keys and typing
        // are handled by windows callbacks.  Don't do this until we're
        // done initializing.  JC
        if (gViewerWindow->mWindow->getVisible() 
                && gViewerWindow->getActive()
                && !gViewerWindow->mWindow->getMinimized()
                && LLStartUp::getStartupState() == STATE_STARTED
                && !gViewerWindow->getShowProgress()
                && !gFocusMgr.focusLocked())
        {
                gKeyboard->scanKeyboard();
        }
#endif
}

//
// Functions
//

FILE *gMarkerFile = NULL;

void remove_marker_file()
{
        llinfos << "remove_marker_file()" << llendl;
        if (gMarkerFile != NULL)
        {
                fclose(gMarkerFile);
                gMarkerFile = NULL;
        }
        if( gDirUtilp )
        {
                LLString marker_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"SecondLife.exec_marker");
                ll_apr_file_remove( marker_file );
        }
}

void init_marker_file()
{
#if LL_SOLARIS
        struct flock fl;
        fl.l_whence = SEEK_SET;
        fl.l_start = 0;
        fl.l_len = 1;
#endif
        // We create a marker file when the program starts and remove the file when it finishes.
        // If the file is currently locked, that means another process is already running.
        // If the file exists and isn't locked, we crashed on the last run.

        std::string marker_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"SecondLife.exec_marker");
        llinfos << "Checking marker file for lock..." << llendl;

        FILE* fMarker = LLFile::fopen(marker_file.c_str(), "rb");               /* Flawfinder: ignore */
        if (fMarker != NULL)
        {
                // File exists, try opening with write permissions
                fclose(fMarker);
                fMarker = LLFile::fopen(marker_file.c_str(), "wb");             /* Flawfinder: ignore */
                if (fMarker == NULL)
                {
                        // Another instance is running. Skip the rest of these operations.
                        llinfos << "Marker file is locked." << llendl;
                        return;
                }
#if LL_DARWIN
                // Try to lock it. On Mac, this is the only way to test if it's actually locked.
                if (flock(fileno(fMarker), LOCK_EX | LOCK_NB) == -1)
                {
                        // Lock failed - somebody else has it.
                        fclose(fMarker);
                        llinfos << "Marker file is locked." << llendl;
                        return;
                }
#endif

                // No other instances; we'll lock this file now & delete on quit.
                fclose(fMarker);
                gLastExecFroze = TRUE;
                llinfos << "Exec marker found: program froze on previous execution" << llendl;
        }

        // Create the marker file for this execution & lock it
//      FILE *fp_executing_marker;
#if LL_WINDOWS
        gMarkerFile = LLFile::_fsopen(marker_file.c_str(), "w", _SH_DENYWR);
#else
        gMarkerFile = LLFile::fopen(marker_file.c_str(), "w");          /* Flawfinder: ignore */
        if (gMarkerFile)
        {
                int fd = fileno(gMarkerFile);
                // Attempt to lock
#if LL_SOLARIS
                fl.l_type = F_WRLCK;
                if (fcntl(fd, F_SETLK, &fl) == -1)
#else
                if (flock(fd, LOCK_EX | LOCK_NB) == -1)
#endif
                {
                        llinfos << "Failed to lock file." << llendl;
                }
        }
#endif
        if (gMarkerFile)
        {
                llinfos << "Marker file created." << llendl;
        }
        else
        {
                llinfos << "Failed to create marker file." << llendl;
        }

#if LL_WINDOWS
        // Clean up SecondLife.dmp files, to avoid confusion
        llinfos << "Removing SecondLife.dmp" << llendl;
        std::string dmp_filename = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "SecondLife.dmp");
        LLFile::remove(dmp_filename.c_str());
#endif

        // This is to keep the crash reporter from constantly sending stale message logs
        // We wipe the message file now.
        llinfos << "Removing message.log" << llendl;
        std::string message_filename = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "message.log");
        LLFile::remove(message_filename.c_str());

        llinfos << "Exiting init_marker_file()." << llendl;
}

void init_crash_handler()
{
        //
        // Set up error handling and logging for LL_RELEASE_FOR_DOWNLOAD
        //

        // Signal handling (or Win32 exception handling
        catch_signals();

        // Set the crash callback for the viewer
        gCrashCallback = viewer_crash_callback;
}

void init_logging()
{
        // Remove the last ".old" log file.
        std::string old_log_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,
                                                             "SecondLife.old");
        LLFile::remove(old_log_file.c_str());

#if LL_LINUX || LL_SOLARIS
        // Remove the last stack trace, if any
        std::string old_stack_file =
                gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"stack_trace.log");
        LLFile::remove(old_stack_file.c_str());
#endif // LL_LINUX || LL_SOLARIS

        // Rename current log file to ".old"
        std::string log_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,
                                                             "SecondLife.log");
        LLFile::rename(log_file.c_str(), old_log_file.c_str());

        // Set the log file to SecondLife.log

        LLError::logToFile(log_file);
}

void write_system_info()
{
        write_debug("SL Log: ");
        write_debug(LLError::logFileName());
        write_debug("\n");

        std::string tmp_str = gSecondLife
                + llformat(" version %d.%d.%d build %d",
                                   LL_VERSION_MAJOR, LL_VERSION_MINOR, LL_VERSION_PATCH, LL_VIEWER_BUILD);
        write_debug(tmp_str.c_str());
        write_debug("\n");
        write_debug(gSysCPU.getCPUString());
        write_debug("\n");
        
        tmp_str = llformat("RAM: %u KB\n", gSysMemory.getPhysicalMemoryKB());
        write_debug(tmp_str.c_str());
        write_debug("OS: ");
        write_debug(gSysOS.getOSString().c_str());
        write_debug("\n");

        // Dump some debugging info
        llinfos << gSecondLife << " version "
                << LL_VERSION_MAJOR << "."
                << LL_VERSION_MINOR << "."
                << LL_VERSION_PATCH
                << llendl;

        // Dump the local time and time zone
        time_t now;
        time(&now);
        char tbuffer[256];              /* Flawfinder: ignore */
        strftime(tbuffer, 256, "%Y-%m-%dT%H:%M:%S %Z", localtime(&now));
        llinfos << "Local time: " << tbuffer << llendl;

        // query some system information
        llinfos << "CPU info:\n" << gSysCPU << llendl;
        llinfos << "Memory info:\n" << gSysMemory << llendl;
        llinfos << "OS info: " << gSysOS << llendl;
}

#if LL_WINDOWS
void disable_win_error_reporting()
{
        const char win_xp_string[] = "Microsoft Windows XP";
        BOOL is_win_xp = ( gSysOS.getOSString().substr(0, strlen(win_xp_string) ) == win_xp_string );           /* Flawfinder: ignore*/
        if( is_win_xp )
        {
                // Note: we need to use run-time dynamic linking, because load-time dynamic linking will fail
                // on systems that don't have the library installed (all non-Windows XP systems)
                HINSTANCE fault_rep_dll_handle = LoadLibrary(L"faultrep.dll");          /* Flawfinder: ignore */
                if( fault_rep_dll_handle )
                {
                        pfn_ADDEREXCLUDEDAPPLICATIONA pAddERExcludedApplicationA  = (pfn_ADDEREXCLUDEDAPPLICATIONA) GetProcAddress(fault_rep_dll_handle, "AddERExcludedApplicationA");
                        if( pAddERExcludedApplicationA )
                        {

                                // Strip the path off the name
                                const char* executable_name = gDirUtilp->getExecutableFilename().c_str();

                                if( 0 == pAddERExcludedApplicationA( executable_name ) )
                                {
                                        U32 error_code = GetLastError();
                                        llinfos << "AddERExcludedApplication() failed with error code " << error_code << llendl;
                                }
                                else
                                {
                                        llinfos << "AddERExcludedApplication() success for " << executable_name << llendl;
                                }
                        }
                        FreeLibrary( fault_rep_dll_handle );
                }
        }
}
#endif  // LL_WINDOWS

// On Windows, get the C:\ volume serial number.
// On Mac, return the hardware serial number.
std::string get_serial_number()
{
        char serial_md5[MD5HEX_STR_SIZE];               /* Flawfinder: ignore */
        serial_md5[0] = 0;

#if LL_WINDOWS
        DWORD serial = 0;
        DWORD flags = 0;
        BOOL success = GetVolumeInformation(
                        L"C:\\",
                        NULL,           // volume name buffer
                        0,                      // volume name buffer size
                        &serial,        // volume serial
                        NULL,           // max component length
                        &flags,         // file system flags
                        NULL,           // file system name buffer
                        0);                     // file system name buffer size
        if (success)
        {
                LLMD5 md5;
                md5.update( (unsigned char*)&serial, sizeof(DWORD));
                md5.finalize();
                md5.hex_digest(serial_md5);
        }
        else
        {
                llwarns << "GetVolumeInformation failed" << llendl;
        }
        return serial_md5;

#elif LL_DARWIN 
        // JC: Sample code from http://developer.apple.com/technotes/tn/tn1103.html
        CFStringRef serialNumber = NULL;
        io_service_t    platformExpert = IOServiceGetMatchingService(kIOMasterPortDefault,
                                                                                                                                 IOServiceMatching("IOPlatformExpertDevice"));
        if (platformExpert) {
                serialNumber = (CFStringRef) IORegistryEntryCreateCFProperty(platformExpert,
                                                                                                                                         CFSTR(kIOPlatformSerialNumberKey),
                                                                                                                                         kCFAllocatorDefault, 0);               
                IOObjectRelease(platformExpert);
        }
        
        if (serialNumber)
        {
                char buffer[MAX_STRING];                /* Flawfinder: ignore */
                if (CFStringGetCString(serialNumber, buffer, MAX_STRING, kCFStringEncodingASCII))
                {
                        LLMD5 md5( (unsigned char*)buffer );
                        md5.hex_digest(serial_md5);
                }
                CFRelease(serialNumber);
        }

        return serial_md5;

#elif LL_LINUX || LL_SOLARIS
        // TODO
        return serial_md5;

#endif
}

#if LL_LINUX
#define MAX_STACK_TRACE_DEPTH 40
// This uses glibc's basic built-in stack-trace functions for a not very
// amazing backtrace.
static inline BOOL do_basic_glibc_backtrace()
{
        void *array[MAX_STACK_TRACE_DEPTH];
        size_t size;
        char **strings;
        size_t i;
        BOOL success = FALSE;

        size = backtrace(array, MAX_STACK_TRACE_DEPTH);
        strings = backtrace_symbols(array, size);

        std::string strace_filename = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"stack_trace.log");
        llinfos << "Opening stack trace file " << strace_filename << llendl;
        FILE* StraceFile = LLFile::fopen(strace_filename.c_str(), "w");         /* Flawfinder: ignore */
        if (!StraceFile)
        {
                llinfos << "Opening stack trace file " << strace_filename << " failed. Using stderr." << llendl;
                StraceFile = stderr;
        }

        if (size)
        {
                for (i = 0; i < size; i++)
                        fputs((std::string(strings[i])+"\n").c_str(),
                              StraceFile);

                success = TRUE;
        }
        
        if (StraceFile != stderr)
                fclose(StraceFile);

        free (strings);
        return success;
}

#if LL_ELFBIN
// This uses glibc's basic built-in stack-trace functions together with
// ELFIO's ability to parse the .symtab ELF section for better symbol
// extraction without exporting symbols (which'd cause subtle, fatal bugs).
static inline BOOL do_elfio_glibc_backtrace()
{
        void *array[MAX_STACK_TRACE_DEPTH];
        size_t btsize;
        char **strings;
        BOOL success = FALSE;

        std::string appfilename = gDirUtilp->getExecutablePathAndName();

        std::string strace_filename = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"stack_trace.log");
        llinfos << "Opening stack trace file " << strace_filename << llendl;
        FILE* StraceFile = LLFile::fopen(strace_filename.c_str(), "w");         /* Flawfinder: ignore */
        if (!StraceFile)
        {
                llinfos << "Opening stack trace file " << strace_filename << " failed. Using stderr." << llendl;
                StraceFile = stderr;
        }

        // get backtrace address list and basic symbol info
        btsize = backtrace(array, MAX_STACK_TRACE_DEPTH);
        strings = backtrace_symbols(array, btsize);

        // create ELF reader for our app binary
        IELFI* pReader;
        const IELFISection* pSec = NULL;
        IELFISymbolTable* pSymTbl = 0;
        if (ERR_ELFIO_NO_ERROR != ELFIO::GetInstance()->CreateELFI(&pReader) ||
            ERR_ELFIO_NO_ERROR != pReader->Load(appfilename.c_str()) ||
            // find symbol table, create reader-object
            NULL == (pSec = pReader->GetSection( ".symtab" )) ||
            ERR_ELFIO_NO_ERROR != pReader->CreateSectionReader(IELFI::ELFI_SYMBOL, pSec, (void**)&pSymTbl) )
        {
                // Failed to open our binary and read its symbol table somehow
                llinfos << "Could not initialize ELF symbol reading - doing basic backtrace." << llendl;
                if (StraceFile != stderr)
                        fclose(StraceFile);
                // note that we may be leaking some of the above ELFIO
                // objects now, but it's expected that we'll be dead soon
                // and we want to tread delicately until we get *some* kind
                // of useful backtrace.
                return do_basic_glibc_backtrace();
        }

        // iterate over trace and symtab, looking for plausible symbols
        std::string   name;
        Elf32_Addr    value;
        Elf32_Word    ssize;
        unsigned char bind;
        unsigned char type;
        Elf32_Half    section;
        int nSymNo = pSymTbl->GetSymbolNum();
        size_t btpos;
        for (btpos = 0; btpos < btsize; ++btpos)
        {
                fprintf(StraceFile, "%d:\t", btpos);
                int symidx;
                for (symidx = 0; symidx < nSymNo; ++symidx)
                {
                        if (ERR_ELFIO_NO_ERROR ==
                            pSymTbl->GetSymbol(symidx, name, value, ssize,
                                               bind, type, section))
                        {
                                // check if trace address within symbol range
                                if (uintptr_t(array[btpos]) >= value &&
                                    uintptr_t(array[btpos]) < value+ssize)
                                {
                                        char *demangled_str = NULL;
                                        int demangle_result = 1;
                                        demangled_str =
                                                abi::__cxa_demangle
                                                (name.c_str(), NULL, NULL,
                                                 &demangle_result);
                                        if (0 == demangle_result &&
                                            NULL != demangled_str) {
                                                fprintf(StraceFile,
                                                        "ELF(%s", demangled_str);
                                                free(demangled_str);
                                        }
                                        else // failed demangle; print it raw
                                        {
                                                fprintf(StraceFile,
                                                        "ELF(%s", name.c_str());
                                        }
                                        // print offset from symbol start
                                        fprintf(StraceFile,
                                                "+0x%lx) [%p]\n",
                                                uintptr_t(array[btpos]) -
                                                value,
                                                array[btpos]);
                                        goto got_sym; // early escape
                                }
                        }
                }
                // Fallback:
                // Didn't find a suitable symbol in the binary - it's probably
                // a symbol in a DSO; use glibc's idea of what it should be.
                fprintf(StraceFile, "%s\n", strings[btpos]);
        got_sym:;
        }
        
        if (StraceFile != stderr)
                fclose(StraceFile);

        pSymTbl->Release();
        pSec->Release();
        pReader->Release();

        free(strings);

        llinfos << "Finished generating stack trace." << llendl;

        success = TRUE;
        return success;
}
#endif // LL_ELFBIN
#endif // LL_LINUX

/* Report whether we're being run under the control of a debugger. */
static inline bool being_debugged()
{
        static enum {unknown, no, yes} debugged = unknown;
        
        if (debugged == unknown)
        {
#if LL_LINUX
                pid_t ppid = getppid();
                char *name;
                int ret;

                ret = asprintf(&name, "/proc/%d/exe", ppid);
                if (ret != -1)
                {
                        char buf[1024];
                        ssize_t n;
                        
                        n = readlink(name, buf, sizeof(buf) - 1);
                        if (n != -1)
                        {
                                char *base = strrchr(buf, '/');
                                buf[n + 1] = '\0';
                                if (base == NULL)
                                {
                                        base = buf;
                                } else {
                                        base += 1;
                                }
                                
                                if (strcmp(base, "gdb") == 0)
                                {
                                        debugged = yes;
                                }
                        }
                        free(name);
                }
#endif // LL_LINUX
        }

        return debugged == yes;
}

#ifdef LL_SOLARIS
static inline BOOL do_basic_glibc_backtrace()
{
        BOOL success = FALSE;

        std::string strace_filename = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"stack_trace.log");
        llinfos << "Opening stack trace file " << strace_filename << llendl;
        FILE* StraceFile = LLFile::fopen(strace_filename.c_str(), "w");
        if (!StraceFile)
        {
                llinfos << "Opening stack trace file " << strace_filename << " failed. Using stderr." << llendl;
                StraceFile = stderr;
        }

        printstack(fileno(StraceFile));

        if (StraceFile != stderr)
                fclose(StraceFile);

        return success;
}
#endif // LL_SOLARIS

void viewer_crash_callback()
{
        // This will drop us into the debugger.
        if (being_debugged())
        {
                abort();
        }

        // Returns whether a dialog was shown.
        // Only do the logic in here once
        if (gReportedCrash)
        {
                return;
        }
        gReportedCrash = TRUE;

        BOOL do_crash_report = FALSE;

        do_crash_report = TRUE;

        write_debug("Viewer exe: ");
        write_debug(gDirUtilp->getExecutablePathAndName().c_str());
        write_debug("\n");
        write_debug("Cur path: ");
        write_debug(gDirUtilp->getCurPath().c_str());
        write_debug("\n\n");

        if (gMessageSystem && gDirUtilp)
        {
                std::string filename;
                filename = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "stats.log");
                llofstream file(filename.c_str(), llofstream::binary);
                if(file.good())
                {
                        gMessageSystem->summarizeLogs(file);
                }
        }

        if (gMessageSystem)
        {
                write_debug(gMessageSystem->getCircuitInfoString());
                gMessageSystem->stopLogging();
        }
        write_debug("\n");
        if (gWorldp)
        {
                write_debug(gWorldp->getInfoString());
        }

        // Close the debug file
        close_debug();
        LLError::logToFile("");

        // Close the SecondLife.log

        remove_marker_file();

#if LL_WINDOWS
        // Windows
        std::string exe_path = gDirUtilp->getAppRODataDir();
        exe_path += gDirUtilp->getDirDelimiter();
        exe_path += "win_crash_logger.exe";

        std::string arg_string = "-user ";
        arg_string += gUserServerName;

        switch(gCrashBehavior)
        {
        case CRASH_BEHAVIOR_ASK:
        default:
                arg_string += " -dialog ";
                _spawnl(_P_NOWAIT, exe_path.c_str(), exe_path.c_str(), arg_string.c_str(), NULL);
                break;

        case CRASH_BEHAVIOR_ALWAYS_SEND:
                _spawnl(_P_NOWAIT, exe_path.c_str(), exe_path.c_str(), arg_string.c_str(), NULL);
                break;

        case CRASH_BEHAVIOR_NEVER_SEND:
                break;
        }

#elif LL_DARWIN
        // Macintosh
        LLString command_str;
        command_str = "crashreporter.app/Contents/MacOS/crashreporter ";
        command_str += "-user ";
        command_str += gUserServerName;
        command_str += " &";    // This backgrounds the command so system() doesn't block until the crashreporter exits.
        system(command_str.c_str());            /* Flawfinder: ignore */
                
        // Sometimes signals don't seem to quit the viewer.  
        // Make sure we exit so as to not totally confuse the user.
        exit(1);
#elif LL_LINUX || LL_SOLARIS
        // Always generate the report, have the logger do the asking, and
        // don't wait for the logger before exiting (-> total cleanup).
        if (CRASH_BEHAVIOR_NEVER_SEND != gCrashBehavior)
        {       
                // This backtrace writes into stack_trace.log
#  if LL_ELFBIN
                do_elfio_glibc_backtrace(); // more useful backtrace
#  else
                do_basic_glibc_backtrace(); // only slightly useful backtrace
#  endif // LL_ELFBIN
                // launch the actual crash logger
                char* ask_dialog = "-dialog";
                if (CRASH_BEHAVIOR_ASK != gCrashBehavior)
                        ask_dialog = ""; // omit '-dialog' option
                std::string cmd =gDirUtilp->getAppRODataDir();
                cmd += gDirUtilp->getDirDelimiter();
                cmd += "linux-crash-logger.bin";
                char* const cmdargv[] =
                        {(char*)cmd.c_str(),
                         ask_dialog,
                         (char*)"-user",
                         (char*)gUserServerName,
                         (char*)"-name",
                         (char*)gSecondLife.c_str(),
                         NULL};
                fflush(NULL);
                pid_t pid = fork();
                if (pid == 0)
                { // child
                        execv(cmd.c_str(), cmdargv);            /* Flawfinder: ignore */
                        llwarns << "execv failure when trying to start " << cmd << llendl;
                        _exit(1); // avoid atexit()
                } else {
                        if (pid > 0)
                        {
                                // DO NOT wait for child proc to die; we want
                                // the logger to outlive us while we quit to
                                // free up the screen/keyboard/etc.
                        } else {
                                llwarns << "fork failure." << llendl;
                        }
                }
        }
        // Sometimes signals don't seem to quit the viewer.  
        // Make sure we exit so as to not totally confuse the user.
        exit(1);
#else
    #error do something with your platform.
#endif // LL_DARWIN

        return;
}



BOOL init_cache()
{
        gPurgeCache = FALSE;
        // Purge cache if user requested it
        if (gSavedSettings.getBOOL("PurgeCacheOnStartup") ||
                gSavedSettings.getBOOL("PurgeCacheOnNextStartup"))
        {
                gSavedSettings.setBOOL("PurgeCacheOnNextStartup", FALSE);
                gPurgeCache = TRUE;
        }
        // Purge cache if it belongs to an old version
        else
        {
                static const S32 cache_version = 5;
                if (gSavedSettings.getS32("LocalCacheVersion") != cache_version)
                {
                        gPurgeCache = TRUE;
                        gSavedSettings.setS32("LocalCacheVersion", cache_version);
                }
        }
        
        // Setup and verify the cache location
        LLString cache_location = gSavedSettings.getString("CacheLocation");
        LLString new_cache_location = gSavedSettings.getString("NewCacheLocation");
        if (new_cache_location != cache_location)
        {
                gDirUtilp->setCacheDir(gSavedSettings.getString("CacheLocation"));
                purge_cache(); // purge old cache
                gSavedSettings.setString("CacheLocation", new_cache_location);
        }
        
        if (!gDirUtilp->setCacheDir(gSavedSettings.getString("CacheLocation")))
        {
                llwarns << "Unable to set cache location" << llendl;
                gSavedSettings.setString("CacheLocation", "");
        }
        
        if (gPurgeCache)
        {
                LLSplashScreen::update("Clearing cache...");
                purge_cache();
        }

        LLSplashScreen::update("Initializing Texture Cache...");
        
        // Init the texture cache
        // Allocate 80% of the cache size for textures
        BOOL read_only = gSecondInstance ? TRUE : FALSE;
        const S32 MB = 1024*1024;
        S64 cache_size = (S64)(gSavedSettings.getU32("CacheSize")) * MB;
        const S64 MAX_CACHE_SIZE = 1024*MB;
        cache_size = llmin(cache_size, MAX_CACHE_SIZE);
        S64 texture_cache_size = ((cache_size * 8)/10);
        S64 extra = gTextureCache->initCache(LL_PATH_CACHE, texture_cache_size, read_only);
        texture_cache_size -= extra;

        LLSplashScreen::update("Initializing VFS...");
        
        // Init the VFS
        S64 vfs_size = cache_size - texture_cache_size;
        const S64 MAX_VFS_SIZE = 1024 * MB; // 1 GB
        vfs_size = llmin(vfs_size, MAX_VFS_SIZE);
        vfs_size = (vfs_size / MB) * MB; // make sure it is MB aligned
        U32 vfs_size_u32 = (U32)vfs_size;
        U32 old_vfs_size = gSavedSettings.getU32("VFSOldSize") * MB;
        bool resize_vfs = (vfs_size_u32 != old_vfs_size);
        if (resize_vfs)
        {
                gSavedSettings.setU32("VFSOldSize", vfs_size_u32/MB);
        }
        llinfos << "VFS CACHE SIZE: " << vfs_size/(1024*1024) << " MB" << llendl;
        
        // This has to happen BEFORE starting the vfs
        //time_t        ltime;
        srand(time(NULL));              /* Flawfinder: ignore */
        U32 old_salt = gSavedSettings.getU32("VFSSalt");
        U32 new_salt;
        char old_vfs_data_file[LL_MAX_PATH];            /* Flawfinder: ignore */
        char old_vfs_index_file[LL_MAX_PATH];   /* Flawfinder: ignore */                
        char new_vfs_data_file[LL_MAX_PATH];            /* Flawfinder: ignore */
        char new_vfs_index_file[LL_MAX_PATH];   /* Flawfinder: ignore */
        char static_vfs_index_file[LL_MAX_PATH];        /* Flawfinder: ignore */
        char static_vfs_data_file[LL_MAX_PATH]; /* Flawfinder: ignore */

        if (gMultipleViewersOK)
        {
                // don't mess with renaming the VFS in this case
                new_salt = old_salt;
        }
        else
        {
                do
                {
                        new_salt = rand();
                } while( new_salt == old_salt );
        }

        snprintf(old_vfs_data_file,  LL_MAX_PATH, "%s%u",               /* Flawfinder: ignore */
                gDirUtilp->getExpandedFilename(LL_PATH_CACHE,VFS_DATA_FILE_BASE).c_str(),
                old_salt);

        // make sure this file exists
        llstat s;
        S32 stat_result = LLFile::stat(old_vfs_data_file, &s);
        if (stat_result)
        {
                // doesn't exist, look for a data file
                std::string mask;
                mask = gDirUtilp->getDirDelimiter();
                mask += VFS_DATA_FILE_BASE;
                mask += "*";

                std::string dir;
                dir = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,"");

                std::string found_file;
                if (gDirUtilp->getNextFileInDir(dir, mask, found_file, FALSE))
                {
                        snprintf(old_vfs_data_file, LL_MAX_PATH, "%s%s%s", dir.c_str(), gDirUtilp->getDirDelimiter().c_str(), found_file.c_str());              /* Flawfinder: ignore */

                        S32 start_pos;
                        S32 length = strlen(found_file.c_str());                /* Flawfinder: ignore*/
                        for (start_pos = length - 1; start_pos >= 0; start_pos--)
                        {
                                if (found_file[start_pos] == '.')
                                {
                                        start_pos++;
                                        break;
                                }
                        }
                        if (start_pos > 0)
                        {
                                sscanf(found_file.c_str() + start_pos, "%d", &old_salt);
                        }
                        llinfos << "Default vfs data file not present, found " << old_vfs_data_file << llendl;
                        llinfos << "Old salt: " << old_salt << llendl;
                }
        }

        snprintf(old_vfs_index_file, LL_MAX_PATH, "%s%u",               /* Flawfinder: ignore */
                        gDirUtilp->getExpandedFilename(LL_PATH_CACHE,VFS_INDEX_FILE_BASE).c_str(),
                        old_salt);

        stat_result = LLFile::stat(old_vfs_index_file, &s);
        if (stat_result)
        {
                // We've got a bad/missing index file, nukem!
                llwarns << "Bad or missing vfx index file " << old_vfs_index_file << llendl;
                llwarns << "Removing old vfs data file " << old_vfs_data_file << llendl;
                LLFile::remove(old_vfs_data_file);
                LLFile::remove(old_vfs_index_file);
                
                // Just in case, nuke any other old cache files in the directory.
                std::string dir;
                dir = gDirUtilp->getExpandedFilename(LL_PATH_CACHE,"");

                std::string mask;
                mask = gDirUtilp->getDirDelimiter();
                mask += VFS_DATA_FILE_BASE;
                mask += "*";

                gDirUtilp->deleteFilesInDir(dir, mask);

                mask = gDirUtilp->getDirDelimiter();
                mask += VFS_INDEX_FILE_BASE;
                mask += "*";

                gDirUtilp->deleteFilesInDir(dir, mask);
        }

        snprintf(new_vfs_data_file, LL_MAX_PATH, "%s%u",                /* Flawfinder: ignore */
                gDirUtilp->getExpandedFilename(LL_PATH_CACHE,VFS_DATA_FILE_BASE).c_str(),
                new_salt);

        snprintf(new_vfs_index_file, LL_MAX_PATH, "%s%u", gDirUtilp->getExpandedFilename(LL_PATH_CACHE, VFS_INDEX_FILE_BASE).c_str(),           /* Flawfinder: ignore */
                new_salt);


        strncpy(static_vfs_data_file, gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"static_data.db2").c_str(), LL_MAX_PATH -1);          /* Flawfinder: ignore */
        static_vfs_data_file[LL_MAX_PATH -1] = '\0';
        strncpy(static_vfs_index_file, gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"static_index.db2").c_str(), LL_MAX_PATH -1);                /* Flawfinder: ignore */
        static_vfs_index_file[LL_MAX_PATH -1] = '\0';

        if (resize_vfs)
        {
                llinfos << "Removing old vfs and re-sizing" << llendl;
                
                LLFile::remove(old_vfs_data_file);
                LLFile::remove(old_vfs_index_file);
        }
        else if (old_salt != new_salt)
        {
                // move the vfs files to a new name before opening
                llinfos << "Renaming " << old_vfs_data_file << " to " << new_vfs_data_file << llendl;
                llinfos << "Renaming " << old_vfs_index_file << " to " << new_vfs_index_file << llendl;
                LLFile::rename(old_vfs_data_file, new_vfs_data_file);
                LLFile::rename(old_vfs_index_file, new_vfs_index_file);
        }

        // Startup the VFS...
        gSavedSettings.setU32("VFSSalt", new_salt);

        // Don't remove VFS after viewer crashes.  If user has corrupt data, they can reinstall. JC
        gVFS = new LLVFS(new_vfs_index_file, new_vfs_data_file, FALSE, vfs_size_u32, FALSE);
        if( VFSVALID_BAD_CORRUPT == gVFS->getValidState() )
        {
                // Try again with fresh files 
                // (The constructor deletes corrupt files when it finds them.)
                llwarns << "VFS corrupt, deleted.  Making new VFS." << llendl;
                delete gVFS;
                gVFS = new LLVFS(new_vfs_index_file, new_vfs_data_file, FALSE, vfs_size_u32, FALSE);
        }

        gStaticVFS = new LLVFS(static_vfs_index_file, static_vfs_data_file, TRUE, 0, FALSE);

        BOOL success = gVFS->isValid() && gStaticVFS->isValid();
        if( !success )
        {
                return FALSE;
        }
        else
        {
                LLVFile::initClass();
                return TRUE;
        }
}

#if LL_DARWIN

OSErr AEGURLHandler(const AppleEvent *messagein, AppleEvent *reply, long refIn)
{
        OSErr result = noErr;
        DescType actualType;
        char buffer[1024];              /* Flawfinder: ignore */
        Size size;
        
        result = AEGetParamPtr (
                messagein,
                keyDirectObject,
                typeCString,
                &actualType,
                (Ptr)buffer,
                sizeof(buffer),
                &size); 
        
        if(result == noErr)
        {
                std::string url = buffer;
                LLURLDispatcher::dispatch(url);
        }
        
        return(result);
}

OSErr AEQuitHandler(const AppleEvent *messagein, AppleEvent *reply, long refIn)
{
        OSErr result = noErr;
        
        app_user_quit();
        
        return(result);
}

OSStatus simpleDialogHandler(EventHandlerCallRef handler, EventRef event, void *userdata)
{
        OSStatus result = eventNotHandledErr;
        OSStatus err;
        UInt32 evtClass = GetEventClass(event);
        UInt32 evtKind = GetEventKind(event);
        WindowRef window = (WindowRef)userdata;
        
        if((evtClass == kEventClassCommand) && (evtKind == kEventCommandProcess))
        {
                HICommand cmd;
                err = GetEventParameter(event, kEventParamDirectObject, typeHICommand, NULL, sizeof(cmd), NULL, &cmd);
                
                if(err == noErr)
                {
                        switch(cmd.commandID)
                        {
                                case kHICommandOK:
                                        QuitAppModalLoopForWindow(window);
                                        result = noErr;
                                break;
                                
                                case kHICommandCancel:
                                        QuitAppModalLoopForWindow(window);
                                        result = userCanceledErr;
                                break;
                        }
                }
        }
        
        return(result);
}

OSStatus DisplayReleaseNotes(void)
{
        OSStatus err;
        IBNibRef nib = NULL;
        WindowRef window = NULL;
        
        err = CreateNibReference(CFSTR("SecondLife"), &nib);
        
        if(err == noErr)
        {
                CreateWindowFromNib(nib, CFSTR("Release Notes"), &window);
        }
                
        if(err == noErr)
        {
                // Get the text view control
                HIViewRef textView;
                ControlID id;

                id.signature = 'text';
                id.id = 0;

                std::string releaseNotesText;
                _read_file_into_string(releaseNotesText, "releasenotes.txt");

                err = HIViewFindByID(HIViewGetRoot(window), id, &textView);
                
                if(err == noErr)
                {
                        // Convert from the encoding used in the release notes.
                        CFStringRef str = CFStringCreateWithBytes(
                                NULL, 
                                (const UInt8*)releaseNotesText.c_str(), 
                                releaseNotesText.size(), 
                                kCFStringEncodingWindowsLatin1,                 // This matches the way the Windows version displays the release notes.
                                FALSE);
                        
                        if(str != NULL)
                        {
                                int size = CFStringGetLength(str);

                                if(size > 0)
                                {
                                        UniChar *chars = new UniChar[size + 1];
                                        CFStringGetCharacters(str, CFRangeMake(0, size), chars);
                                
                                        err = TXNSetData(HITextViewGetTXNObject(textView), kTXNUnicodeTextData, chars, size * sizeof(UniChar), kTXNStartOffset, kTXNStartOffset);
                                        
                                        delete[] chars;
                                }
                                
                                CFRelease(str);
                        }
                        else
                        {
                                // Creating the string failed.  Probably an encoding problem.  Display SOMETHING...
                                err = TXNSetData(HITextViewGetTXNObject(textView), kTXNTextData, releaseNotesText.c_str(), releaseNotesText.size(), kTXNStartOffset, kTXNStartOffset);
                        }
                }
                
                // Set the selection to the beginning of the text and scroll it into view.
                if(err == noErr)
                {
                        err = TXNSetSelection(HITextViewGetTXNObject(textView), kTXNStartOffset, kTXNStartOffset);
                }
                
                if(err == noErr)
                {
                        // This function returns void.
                        TXNShowSelection(HITextViewGetTXNObject(textView), false);
                }
        }

        if(err == noErr)
        {
                ShowWindow(window);
        }

        if(err == noErr)
        {
                // Set up an event handler for the window.
                EventHandlerRef handler = NULL;
                EventTypeSpec handlerEvents[] = 
                {
                        { kEventClassCommand, kEventCommandProcess }
                };

                InstallWindowEventHandler(
                                window, 
                                NewEventHandlerUPP(simpleDialogHandler), 
                                GetEventTypeCount (handlerEvents), 
                                handlerEvents, 
                                (void*)window, 
                                &handler);
        }
                        
        if(err == noErr)
        {
                RunAppModalLoopForWindow(window);
        }
                        
        if(window != NULL)
        {
                DisposeWindow(window);
        }
        
        if(nib != NULL)
        {
                DisposeNibReference(nib);
        }

        return(err);
}

void init_apple_menu(const char* product)
{
        // Load up a proper menu bar.
        {
                OSStatus err;
                IBNibRef nib = NULL;
                // NOTE: DO NOT translate or brand this string.  It's an internal name in the .nib file, and MUST match exactly.
                err = CreateNibReference(CFSTR("SecondLife"), &nib);
                
                if(err == noErr)
                {
                        // NOTE: DO NOT translate or brand this string.  It's an internal name in the .nib file, and MUST match exactly.
                        SetMenuBarFromNib(nib, CFSTR("MenuBar"));
                }

                if(nib != NULL)
                {
                        DisposeNibReference(nib);
                }
        }
        
        // Install a handler for 'gurl' AppleEvents.  This is how secondlife:// URLs get passed to the viewer.
        
        if(AEInstallEventHandler('GURL', 'GURL', NewAEEventHandlerUPP(AEGURLHandler),0, false) != noErr)
        {
                // Couldn't install AppleEvent handler.  This error shouldn't be fatal.
                llinfos << "Couldn't install 'GURL' AppleEvent handler.  Continuing..." << llendl;
        }

        // Install a handler for 'quit' AppleEvents.  This makes quitting the application from the dock work.
        if(AEInstallEventHandler(kCoreEventClass, kAEQuitApplication, NewAEEventHandlerUPP(AEQuitHandler),0, false) != noErr)
        {
                // Couldn't install AppleEvent handler.  This error shouldn't be fatal.
                llinfos << "Couldn't install Quit AppleEvent handler.  Continuing..." << llendl;
        }
}
#endif

void user_logout()
{
        if (!gDoneLogout)
        {
                LLMessageSystem* msg = gMessageSystem;
                if (msg)
                {
                                gSavedSettings.setBOOL("LoggedIn", FALSE);
                }
                gDoneLogout = TRUE;
        }
}


// This routine may get called more than once during the shutdown process.
// This can happen because we need to get the screenshot before the window
// is destroyed.
void save_final_snapshot(void*)
{
        if (!gHaveSavedSnapshot && !gNoRender)
        {
                gSavedSettings.setVector3d("FocusPosOnLogout", gAgent.calcFocusPositionTargetGlobal());
                gSavedSettings.setVector3d("CameraPosOnLogout", gAgent.calcCameraPositionTargetGlobal());
                gViewerWindow->setCursor(UI_CURSOR_WAIT);
                gAgent.changeCameraToThirdPerson( FALSE );      // don't animate, need immediate switch
                gSavedSettings.setBOOL("ShowParcelOwners", FALSE);
                idle();

                LLString snap_filename = gDirUtilp->getLindenUserDir();
                snap_filename += gDirUtilp->getDirDelimiter();
                snap_filename += SCREEN_LAST_FILENAME;
                gViewerWindow->saveSnapshot(snap_filename, gViewerWindow->getWindowWidth(), gViewerWindow->getWindowHeight(), FALSE, TRUE);
                gHaveSavedSnapshot = TRUE;
        }
}

// If you pass a path+file or URL in as a 
// Note: This may get called multiple times during shutdown.
void app_force_quit(const char* launch_file_on_quit)
{
        // Don't actually DO anything complicated here, because
        // it's called from signal handlers for the Mac on SIGTERM.
        // It calls this with NULL.
        if (launch_file_on_quit)
        {
                gLaunchFileOnQuit.assign( (const char*)launch_file_on_quit );
        }

        gQuit = TRUE;
}

static void finish_quit(S32 option, void *userdata)
{
        if (option == 0)
        {
                app_request_quit();
        }
}

void app_user_quit()
{
        gViewerWindow->alertXml("ConfirmQuit", finish_quit, NULL);
}

  
// Don't quit instantly.  Instead, request to be logged off.
// Called from control-Q handler, Windows(tm) close-window message (WM_CLOSE), and Mac Quit AppleEvent handler.
void app_request_quit()
{
        llinfos << "app_request_quit" << llendl;

        LLViewerRegion* region = gAgent.getRegion();
        
        if( (LLStartUp::getStartupState() < STATE_STARTED) || !region )
        {
                // Quit immediately
                app_force_quit(NULL);
                return;
        }

        if (gHUDManager)
        {
                LLHUDEffectSpiral *effectp = (LLHUDEffectSpiral*)gHUDManager->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_POINT, TRUE);
                effectp->setPositionGlobal(gAgent.getPositionGlobal());
                effectp->setColor(LLColor4U(gAgent.getEffectColor()));
                gHUDManager->sendEffects();
        }

        // Attempt to close all floaters that might be
        // editing things.
        if (gFloaterView)
        {
                // application is quitting
                gFloaterView->closeAllChildren(true);
        }

        send_stats();

        gLogoutTimer.reset();
        gQuitRequested = TRUE;
}


// User didn't really want to quit, for example, clicked "Cancel"
// in a floater save dialog.
void app_abort_quit()
{
        llinfos << "app_abort_quit()" << llendl;
        gQuitRequested = FALSE;
}

void idle_shutdown()
{
        // Wait for all modal alerts to get resolved
        if (LLModalDialog::activeCount() > 0)
        {
                return;
        }

        // close IM interface
        if(gIMMgr)
        {
                gIMMgr->disconnectAllSessions();
        }
        
        // Wait for all floaters to get resolved
        if (gFloaterView
                && !gFloaterView->allChildrenClosed())
        {
                return;
        }

        static bool saved_snapshot = false;
        if (!saved_snapshot)
        {
                saved_snapshot = true;
                save_final_snapshot(NULL);
                return;
        }

        const F32 SHUTDOWN_UPLOAD_SAVE_TIME = 5.f;

        S32 pending_uploads = gAssetStorage->getNumPendingUploads();
        if (pending_uploads > 0
                && gLogoutTimer.getElapsedTimeF32() < SHUTDOWN_UPLOAD_SAVE_TIME
                && !gLogoutRequestSent)
        {
                static S32 total_uploads = 0;
                // Sometimes total upload count can change during logout.
                total_uploads = llmax(total_uploads, pending_uploads);
                gViewerWindow->setShowProgress(TRUE);
                S32 finished_uploads = total_uploads - pending_uploads;
                F32 percent = 100.f * finished_uploads / total_uploads;
                gViewerWindow->setProgressPercent(percent);
                char buffer[MAX_STRING];                /* Flawfinder: ignore */
                snprintf(buffer, MAX_STRING, "Saving final data...");           /* Flawfinder: ignore */
                gViewerWindow->setProgressString(buffer);
                return;
        }

        // All floaters are closed.  Tell server we want to quit.
        if( !gLogoutRequestSent )
        {
                send_logout_request();

                // Wait for a LogoutReply message
                gViewerWindow->setShowProgress(TRUE);
                gViewerWindow->setProgressPercent(100.f);
                gViewerWindow->setProgressString("Logging out...");
                return;
        }

        // Make sure that we quit if we haven't received a reply from the server.
        if( gLogoutRequestSent 
                && gLogoutTimer.getElapsedTimeF32() > gLogoutMaxTime )
        {
                app_force_quit(NULL);
                return;
        }
}


U32             gTotalLandIn = 0, gTotalLandOut = 0;
U32             gTotalWaterIn = 0, gTotalWaterOut = 0;

F32             gAveLandCompression = 0.f, gAveWaterCompression = 0.f;
F32             gBestLandCompression = 1.f, gBestWaterCompression = 1.f;
F32             gWorstLandCompression = 0.f, gWorstWaterCompression = 0.f;

F32             gFPSClamped = 10.f;                                             // Pretend we start at target rate.
F32             gFrameDTClamped = 0.f;                                  // Time between adjacent checks to network for packets
F32             gFrameDT = 0.f;

//S32           gDecodedBits = 0;
U32             gPacketsIn = 0;

U32             gTotalWorldBytes = 0, gTotalObjectBytes = 0, gTotalTextureBytes = 0, gSimPingCount = 0;
U32             gObjectBits = 0;
F32             gAvgSimPing = 0.f;


extern U32  gVisCompared;
extern U32  gVisTested;


void update_statistics(U32 frame_count)
{
        gTotalWorldBytes += gVLManager.getTotalBytes();
        gTotalObjectBytes += gObjectBits / 8;
        gTotalTextureBytes += LLViewerImageList::sTextureBits / 8;

        // make sure we have a valid time delta for this frame
        if (gFrameIntervalSeconds > 0.f)
        {
                if (gAgent.getCameraMode() == CAMERA_MODE_MOUSELOOK)
                {
                        gViewerStats->incStat(LLViewerStats::ST_MOUSELOOK_SECONDS, gFrameIntervalSeconds);
                }
                else if (gAgent.getCameraMode() == CAMERA_MODE_CUSTOMIZE_AVATAR)
                {
                        gViewerStats->incStat(LLViewerStats::ST_AVATAR_EDIT_SECONDS, gFrameIntervalSeconds);
                }
                else if (gFloaterTools && gFloaterTools->getVisible())
                {
                        gViewerStats->incStat(LLViewerStats::ST_TOOLBOX_SECONDS, gFrameIntervalSeconds);
                }
        }
        gViewerStats->setStat(LLViewerStats::ST_ENABLE_VBO, (F64)gSavedSettings.getBOOL("RenderVBOEnable"));
        gViewerStats->setStat(LLViewerStats::ST_LIGHTING_DETAIL, (F64)gSavedSettings.getS32("RenderLightingDetail"));
        gViewerStats->setStat(LLViewerStats::ST_DRAW_DIST, (F64)gSavedSettings.getF32("RenderFarClip"));
        gViewerStats->setStat(LLViewerStats::ST_CHAT_BUBBLES, (F64)gSavedSettings.getBOOL("UseChatBubbles"));
#if 0 // 1.9.2
        gViewerStats->setStat(LLViewerStats::ST_SHADER_OBJECTS, (F64)gSavedSettings.getS32("VertexShaderLevelObject"));
        gViewerStats->setStat(LLViewerStats::ST_SHADER_AVATAR, (F64)gSavedSettings.getBOOL("VertexShaderLevelAvatar"));
        gViewerStats->setStat(LLViewerStats::ST_SHADER_ENVIRONMENT, (F64)gSavedSettings.getBOOL("VertexShaderLevelEnvironment"));
#endif
        gViewerStats->setStat(LLViewerStats::ST_FRAME_SECS, gDebugView->mFastTimerView->getTime(LLFastTimer::FTM_FRAME));
        F64 idle_secs = gDebugView->mFastTimerView->getTime(LLFastTimer::FTM_IDLE);
        F64 network_secs = gDebugView->mFastTimerView->getTime(LLFastTimer::FTM_NETWORK);
        gViewerStats->setStat(LLViewerStats::ST_UPDATE_SECS, idle_secs - network_secs);
        gViewerStats->setStat(LLViewerStats::ST_NETWORK_SECS, network_secs);
        gViewerStats->setStat(LLViewerStats::ST_IMAGE_SECS, gDebugView->mFastTimerView->getTime(LLFastTimer::FTM_IMAGE_UPDATE));
        gViewerStats->setStat(LLViewerStats::ST_REBUILD_SECS, gDebugView->mFastTimerView->getTime(LLFastTimer::FTM_REBUILD));
        gViewerStats->setStat(LLViewerStats::ST_RENDER_SECS, gDebugView->mFastTimerView->getTime(LLFastTimer::FTM_RENDER_GEOMETRY));
                
        LLCircuitData *cdp = gMessageSystem->mCircuitInfo.findCircuit(gAgent.getRegion()->getHost());
        if (cdp)
        {
                gViewerStats->mSimPingStat.addValue(cdp->getPingDelay());
                gAvgSimPing = ((gAvgSimPing * (F32)gSimPingCount) + (F32)(cdp->getPingDelay())) / ((F32)gSimPingCount + 1);
                gSimPingCount++;
        }
        else
        {
                gViewerStats->mSimPingStat.addValue(10000);
        }

        if (gFocusMgr.getAppHasFocus())
        {
                gViewerStats->mFPSStat.addValue(1);
        }
        F32 layer_bits = (F32)(gVLManager.getLandBits() + gVLManager.getWindBits() + gVLManager.getCloudBits());
        gViewerStats->mLayersKBitStat.addValue(layer_bits/1024.f);
        gViewerStats->mObjectKBitStat.addValue(gObjectBits/1024.f);
        gViewerStats->mTextureKBitStat.addValue(LLViewerImageList::sTextureBits/1024.f);
        gViewerStats->mVFSPendingOperations.addValue(LLVFile::getVFSThread()->getPending());
        gViewerStats->mAssetKBitStat.addValue(gTransferManager.getTransferBitsIn(LLTCT_ASSET)/1024.f);
        gTransferManager.resetTransferBitsIn(LLTCT_ASSET);

        static S32 tex_bits_idle_count = 0;
        if (LLViewerImageList::sTextureBits == 0)
        {
                if (++tex_bits_idle_count >= 30)
                        gDebugTimers[0].pause();
        }
        else
        {
                tex_bits_idle_count = 0;
                gDebugTimers[0].unpause();
        }
        
        gViewerStats->mTexturePacketsStat.addValue(LLViewerImageList::sTexturePackets);

        gViewerStats->mUserserverPingStat.addValue(0); // userserver doesn't exist, therefore ping time is always awesome

        // log when the LibXUL (aka Mozilla) widget is used and opened so we can monitor framerate changes
        #if LL_LIBXUL_ENABLED
        {
                BOOL result = gViewerHtmlHelp.getFloaterOpened();
                gViewerStats->setStat(LLViewerStats::ST_LIBXUL_WIDGET_USED, (F64)result);
        }
        #endif

        {
                static F32 visible_avatar_frames = 0.f;
                static F32 avg_visible_avatars = 0;
                F32 visible_avatars = (F32)LLVOAvatar::sNumVisibleAvatars;
                if (visible_avatars > 0.f)
                {
                        visible_avatar_frames = 1.f;
                        avg_visible_avatars = (avg_visible_avatars * (F32)(visible_avatar_frames - 1.f) + visible_avatars) / visible_avatar_frames;
                }
                gViewerStats->setStat(LLViewerStats::ST_VISIBLE_AVATARS, (F64)avg_visible_avatars);
        }
        gWorldp->updateNetStats();
        gWorldp->requestCacheMisses();
        
        // Reset all of these values.
        gVLManager.resetBitCounts();
        gObjectBits = 0;
//      gDecodedBits = 0;

        LLViewerImageList::sTextureBits = 0;
        LLViewerImageList::sTexturePackets = 0;

#if LL_WINDOWS && LL_LCD_COMPILE
        bool LCDenabled = gLcdScreen->Enabled();
        gViewerStats->setStat(LLViewerStats::ST_LOGITECH_LCD, LCDenabled);
#else
        gViewerStats->setStat(LLViewerStats::ST_LOGITECH_LCD, false);
#endif

}

//
// Handle messages, and all message related stuff
//

#define TIME_THROTTLE_MESSAGES

#ifdef TIME_THROTTLE_MESSAGES
#define CHECK_MESSAGES_DEFAULT_MAX_TIME .020f // 50 ms = 50 fps (just for messages!)
static F32 CheckMessagesMaxTime = CHECK_MESSAGES_DEFAULT_MAX_TIME;
#endif

void idle_network()
{
        gObjectList.mNumNewObjects = 0;
        S32 total_decoded = 0;

        if (!gSavedSettings.getBOOL("SpeedTest"))
        {
                LLFastTimer t(LLFastTimer::FTM_IDLE_NETWORK); // decode
                
                // deal with any queued name requests and replies.
                gCacheName->processPending();

                LLTimer check_message_timer;
                //  Read all available packets from network 
                stop_glerror();
                const S64 frame_count = gFrameCount;  // U32->S64
                F32 total_time = 0.0f;
                while (gMessageSystem->checkAllMessages(frame_count, gServicePump)) 
                {
                        if (gDoDisconnect)
                        {
                                // We're disconnecting, don't process any more messages from the server
                                // We're usually disconnecting due to either network corruption or a
                                // server going down, so this is OK.
                                break;
                        }
                        stop_glerror();

                        total_decoded++;
                        gPacketsIn++;

                        if (total_decoded > MESSAGE_MAX_PER_FRAME)
                        {
                                break;
                        }

#ifdef TIME_THROTTLE_MESSAGES
                        // Prevent slow packets from completely destroying the frame rate.
                        // This usually happens due to clumps of avatars taking huge amount
                        // of network processing time (which needs to be fixed, but this is
                        // a good limit anyway).
                        total_time = check_message_timer.getElapsedTimeF32();
                        if (total_time >= CheckMessagesMaxTime)
                                break;
#endif
                }
                // Handle per-frame message system processing.
                gMessageSystem->processAcks();

#ifdef TIME_THROTTLE_MESSAGES
                if (total_time >= CheckMessagesMaxTime)
                {
                        // Increase CheckMessagesMaxTime so that we will eventually catch up
                        CheckMessagesMaxTime *= 1.035f; // 3.5% ~= x2 in 20 frames, ~8x in 60 frames
                }
                else
                {
                        // Reset CheckMessagesMaxTime to default value
                        CheckMessagesMaxTime = CHECK_MESSAGES_DEFAULT_MAX_TIME;
                }
#endif
                


                // we want to clear the control after sending out all necessary agent updates
                gAgent.resetControlFlags();
                stop_glerror();

                
                // Decode enqueued messages...
                S32 remaining_possible_decodes = MESSAGE_MAX_PER_FRAME - total_decoded;

                if( remaining_possible_decodes <= 0 )
                {
                        llinfos << "Maxed out number of messages per frame at " << MESSAGE_MAX_PER_FRAME << llendl;
                }

                if (gPrintMessagesThisFrame)
                {
                        llinfos << "Decoded " << total_decoded << " msgs this frame!" << llendl;
                        gPrintMessagesThisFrame = FALSE;
                }
        }

        gObjectList.mNumNewObjectsStat.addValue(gObjectList.mNumNewObjects);

        // Retransmit unacknowledged packets.
        gXferManager->retransmitUnackedPackets();
        gAssetStorage->checkForTimeouts();

        gViewerThrottle.updateDynamicThrottle();
}

void idle_afk_check()
{
        // check idle timers
        if (gAllowIdleAFK && (gAwayTriggerTimer.getElapsedTimeF32() > gAFKTimeout))
        {
                gAgent.setAFK();
        }
}
void request_initial_instant_messages()
{
        static BOOL requested = FALSE;
        if (!requested
                && gMuteListp
                && gMuteListp->isLoaded()
                && gAgent.getAvatarObject())
        {
                // Auto-accepted inventory items may require the avatar object
                // to build a correct name.  Likewise, inventory offers from
                // muted avatars require the mute list to properly mute.
                LLMessageSystem* msg = gMessageSystem;
                msg->newMessageFast(_PREHASH_RetrieveInstantMessages);
                msg->nextBlockFast(_PREHASH_AgentData);
                msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
                msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
                gAgent.sendReliableMessage();
                requested = TRUE;
        }
}

// idle()
//
// Called every time the window is not doing anything.
// Receive packets, update statistics, and schedule a redisplay.

void idle()
{
        // Update frame timers
        static LLTimer idle_timer;

        LLControlBase::updateAllListeners();

        LLFrameTimer::updateFrameTime();
        LLEventTimer::updateClass();
        LLCriticalDamp::updateInterpolants();
        LLMortician::updateClass();
        F32 dt_raw = idle_timer.getElapsedTimeAndResetF32();

        // Cap out-of-control frame times
        // Too low because in menus, swapping, debugger, etc.
        // Too high because idle called with no objects in view, etc.
        const F32 MIN_FRAME_RATE = 1.f;
        const F32 MAX_FRAME_RATE = 200.f;

        F32 frame_rate_clamped = 1.f / dt_raw;
        frame_rate_clamped = llclamp(frame_rate_clamped, MIN_FRAME_RATE, MAX_FRAME_RATE);
        gFrameDTClamped = 1.f / frame_rate_clamped;

        // Global frame timer
        // Smoothly weight toward current frame
        gFPSClamped = (frame_rate_clamped + (4.f * gFPSClamped)) / 5.f;

        if (gQuitAfterSeconds > 0.f)
        {
                if (gRenderStartTime.getElapsedTimeF32() > gQuitAfterSeconds)
                {
                        app_force_quit(NULL);
                }
        }

        // Must wait until both have avatar object and mute list, so poll
        // here.
        request_initial_instant_messages();

        //
        // Special case idle if still starting up
        //

        if (LLStartUp::getStartupState() < STATE_STARTED)
        {
                // Skip rest if idle startup returns false (essentially, no world yet)
                if (!idle_startup())
                {
                        return;
                }
        }

        
    F32 yaw = 0.f;                              // radians

        if (!gDisconnected)
        {
                LLFastTimer t(LLFastTimer::FTM_NETWORK);
                
            // Update spaceserver timeinfo
            gWorldp->setSpaceTimeUSec(gWorldp->getSpaceTimeUSec() + (U32)(dt_raw * SEC_TO_MICROSEC));
    
    
            //
            // Update simulator agent state
            //

                if (gRotateRight)
                {
                        gAgent.moveYaw(-1.f);
                }

            // Handle automatic walking towards points
            gAgentPilot.updateTarget();
            gAgent.autoPilot(&yaw);
    
            static LLFrameTimer agent_update_timer;
            static U32                          last_control_flags;
    
            //  When appropriate, update agent location to the simulator.
            F32 agent_update_time = agent_update_timer.getElapsedTimeF32();
            BOOL flags_changed = gAgent.controlFlagsDirty() || (last_control_flags != gAgent.getControlFlags());
    
            if (flags_changed || (agent_update_time > (1.0f / (F32) AGENT_UPDATES_PER_SECOND)))
            {
                    // Send avatar and camera info
                    last_control_flags = gAgent.getControlFlags();
                    send_agent_update(TRUE);
                    agent_update_timer.reset();
            }
        }

        //
        // Manage statistics
        //
        //

        {
                static LLFrameTimer     viewer_stats_timer;
                reset_statistics();

                // Update session stats every large chunk of time
                // *FIX: (???) SAMANTHA

                if (viewer_stats_timer.getElapsedTimeF32() >= 300.f && !gDisconnected)
                {
                        llinfos << "Transmitting sessions stats" << llendl;
                        send_stats();
                        viewer_stats_timer.reset();
                }

                // Print the object debugging stats
                static LLFrameTimer object_debug_timer;
                if (object_debug_timer.getElapsedTimeF32() > 5.f)
                {
                        object_debug_timer.reset();
                        if (gObjectList.mNumDeadObjectUpdates)
                        {
                                llinfos << "Dead object updates: " << gObjectList.mNumDeadObjectUpdates << llendl;
                                gObjectList.mNumDeadObjectUpdates = 0;
                        }
                        if (gObjectList.mNumUnknownKills)
                        {
                                llinfos << "Kills on unknown objects: " << gObjectList.mNumUnknownKills << llendl;
                                gObjectList.mNumUnknownKills = 0;
                        }
                        if (gObjectList.mNumUnknownUpdates)
                        {
                                llinfos << "Unknown object updates: " << gObjectList.mNumUnknownUpdates << llendl;
                                gObjectList.mNumUnknownUpdates = 0;
                        }
                }
                gFrameStats.addFrameData();
        }

        // Update avatar list
        gFloaterAvatarList->updateAvatarList();

        gFloaterEventLog->updateWindow();

        if (!gDisconnected)
        {
                LLFastTimer t(LLFastTimer::FTM_NETWORK);
        
            //
            // Network processing
            //
            // NOTE: Starting at this point, we may still have pointers to "dead" objects
            // floating throughout the various object lists.
            //
    
            gFrameStats.start(LLFrameStats::IDLE_NETWORK);
                idle_network();
            stop_glerror();
                
            gFrameStats.start(LLFrameStats::AGENT_MISC);

                // Check for away from keyboard, kick idle agents.
                idle_afk_check();

                //  Update statistics for this frame
                update_statistics(gFrameCount);

                gViewerWindow->updateDebugText();
        }

        //
        // Handle the regular UI idle callbacks as well as
        // hover callbacks
        //

        {
//              LLFastTimer t(LLFastTimer::FTM_IDLE_CB);

                // Do event notifications if necessary.  Yes, we may want to move this elsewhere.
                gEventNotifier.update();
                
                gIdleCallbacks.callFunctions();
        }
        
        if (gDisconnected)
    {
                return;
    }

        gViewerWindow->handlePerFrameHover();

        // Agent and camera movement
        //
                LLCoordGL current_mouse = gViewerWindow->getCurrentMouse();

//              BOOL was_in_prelude = gAgent.inPrelude();

        {
                //LLFastTimer t(LLFastTimer::FTM_TEMP1);
                
                // After agent and camera moved, figure out if we need to
                // deselect objects.
                gSelectMgr->deselectAllIfTooFar();
                gSelectMgr->update(); // once per frame updat
        }

        {
                LLFastTimer t(LLFastTimer::FTM_RESET_DRAWORDER);
                        
                //
                // Clear draw orders
                //
                // Should actually be done after render, but handlePerFrameHover actually does a "render"
                // to do its selection.
                //

                gPipeline.resetDrawOrders();
        }
        {
                // Handle pending gesture processing
                gGestureManager.update();

                gAgent.updateAgentPosition(gFrameDTClamped, yaw, current_mouse.mX, current_mouse.mY);
        }

        {
                LLFastTimer t(LLFastTimer::FTM_OBJECTLIST_UPDATE); // Actually "object update"
                gFrameStats.start(LLFrameStats::OBJECT_UPDATE);
                
                if (!(gLogoutRequestSent && gHaveSavedSnapshot))
                {
                        gObjectList.update(gAgent, *gWorldp);
                }
        }
        
        {
                LLFastTimer t(LLFastTimer::FTM_UPDATE_SKY);     
                gSky.updateSky();
        }

        //
        // Deletes objects...
        // Has to be done after doing idleUpdates (which can kill objects)
        //

        {
                LLFastTimer t(LLFastTimer::FTM_CLEANUP);
                gFrameStats.start(LLFrameStats::CLEAN_DEAD);
                gObjectList.cleanDeadObjects();
                LLDrawable::cleanupDeadDrawables();
        }
        
        //
        // After this point, in theory we should never see a dead object
        // in the various object/drawable lists.
        //

        //
        // Update/send HUD effects
        //
        // At this point, HUD effects may clean up some references to
        // dead objects.
        //

        {
                //LLFastTimer t(LLFastTimer::FTM_TEMP3);
                
                gFrameStats.start(LLFrameStats::UPDATE_EFFECTS);
                gSelectMgr->updateEffects();
                gHUDManager->cleanupEffects();
                gHUDManager->sendEffects();
        }

        stop_glerror();

        //
        // Unpack layer data that we've received
        //

        {
                LLFastTimer t(LLFastTimer::FTM_NETWORK);
                gVLManager.unpackData();
        }
        
        //
        // Update surfaces, and surface textures as well.
        //

        gWorldp->updateVisibilities();
        {
                const F32 max_region_update_time = .001f; // 1ms
                LLFastTimer t(LLFastTimer::FTM_REGION_UPDATE);
                gWorldp->updateRegions(max_region_update_time);
        }
        
        //
        // Update weather effects
        //

        if (!gNoRender)
        {
                gWorldp->updateClouds(gFrameDTClamped);
                gSky.propagateHeavenlyBodies(gFrameDTClamped);                          // moves sun, moon, and planets

                // Update wind vector 
                LLVector3 wind_position_region;
                static LLVector3 average_wind;

                LLViewerRegion *regionp;
                regionp = gWorldp->resolveRegionGlobal(wind_position_region, gAgent.getPositionGlobal());       // puts agent's local coords into wind_position 
                if (regionp)
                {
                        gWindVec = regionp->mWind.getVelocity(wind_position_region);

                        // Compute average wind and use to drive motion of water
                        
                        average_wind = regionp->mWind.getAverage();
                        F32 cloud_density = regionp->mCloudLayer.getDensityRegion(wind_position_region);
                        
                        gSky.setCloudDensityAtAgent(cloud_density);
                        gSky.setWind(average_wind);
                        //LLVOWater::setWind(average_wind);
                }
                else
                {
                        gWindVec.setVec(0.0f, 0.0f, 0.0f);
                }
        }
        stop_glerror();
        
        //
        // Update images, using the image stats generated during object update/culling
        //
        // Can put objects onto the retextured list.
        //
        gFrameStats.start(LLFrameStats::IMAGE_UPDATE);

        LLFastTimer t(LLFastTimer::FTM_IMAGE_UPDATE);
        
        LLViewerImage::updateClass(gCamera->getVelocityStat()->getMean(),
                                                                gCamera->getAngularVelocityStat()->getMean());

        gBumpImageList.updateImages();  // must be called before gImageList version so that it's textures are thrown out first.

        const F32 max_image_decode_time = 0.005f; // 5 ms decode time
        gImageList.updateImages(max_image_decode_time);
        stop_glerror();

        //
        // Sort and cull in the new renderer are moved to pipeline.cpp
        // Here, particles are updated and drawables are moved.
        //
        
        if (!gNoRender)
        {
                gFrameStats.start(LLFrameStats::UPDATE_MOVE);
                gPipeline.updateMove();

                gFrameStats.start(LLFrameStats::UPDATE_PARTICLES);
                gWorldp->updateParticles();
        }
        stop_glerror();

        if (!LLViewerJoystick::sOverrideCamera)
        {
                gAgent.updateCamera();
        }
        else
        {
                LLViewerJoystick::updateCamera();
        }

        // objects and camera should be in sync, do LOD calculations now
        {
                LLFastTimer t(LLFastTimer::FTM_LOD_UPDATE);
                gObjectList.updateApparentAngles(gAgent);
        }

        {
                gFrameStats.start(LLFrameStats::AUDIO);
                LLFastTimer t(LLFastTimer::FTM_AUDIO_UPDATE);
                
                if (gAudiop)
                {
                        audio_update_volume(false);
                        audio_update_listener();
                        audio_update_wind(false);

                        // this line actually commits the changes we've made to source positions, etc.
                        const F32 max_audio_decode_time = 0.002f; // 2 ms decode time
                        gAudiop->idle(max_audio_decode_time);
                }
        }
        
        if ( gTrustNet )
        {
                gTrustNet->processRequests();
        }

        // Handle shutdown process, for example, 
        // wait for floaters to close, send quit message,
        // forcibly quit if it has taken too long
        if (gQuitRequested)
        {
                idle_shutdown();
        }

        stop_glerror();
}


F32 mouse_x_from_center(S32 x)
{
        return ((F32) x / (F32) gViewerWindow->getWindowWidth() ) - 0.5f;
}


F32 mouse_y_from_center(S32 y)
{
        return ((F32) y / (F32) gViewerWindow->getWindowHeight() ) - 0.5f;
}



void init_audio() 
{
        if (!gAudiop) 
        {
                llwarns << "Failed to create an appropriate Audio Engine" << llendl;
                return;
        }
        LLVector3d lpos_global = gAgent.getCameraPositionGlobal();
        LLVector3 lpos_global_f;

        lpos_global_f.setVec(lpos_global);
                                        
        gAudiop->setListener(lpos_global_f,
                                                  LLVector3::zero,      // gCamera->getVelocity(),    // !!! BUG need to replace this with smoothed velocity!
                                                  gCamera->getUpAxis(),
                                                  gCamera->getAtAxis());

// load up our initial set of sounds we'll want so they're in memory and ready to be played

        BOOL mute_audio = gSavedSettings.getBOOL("MuteAudio");

        if (!mute_audio && gPreloadSounds)
        {
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndAlert")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndBadKeystroke")));
                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndChatFromObject")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndClick")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndClickRelease")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndHealthReductionF")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndHealthReductionM")));
                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndIncomingChat")));
                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndIncomingIM")));
                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndInvApplyToObject")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndInvalidOp")));
                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndInventoryCopyToInv")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndMoneyChangeDown")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndMoneyChangeUp")));
                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndObjectCopyToInv")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndObjectCreate")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndObjectDelete")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndObjectRezIn")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndObjectRezOut")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuAppear")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuHide")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight0")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight1")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight2")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight3")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight4")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight5")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight6")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndPieMenuSliceHighlight7")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndSnapshot")));
                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndStartAutopilot")));
                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndStartFollowpilot")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndStartIM")));
                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndStopAutopilot")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndTeleportOut")));
                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndTextureApplyToObject")));
                //gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndTextureCopyToInv")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndTyping")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndWindowClose")));
                gAudiop->preloadSound(LLUUID(gSavedSettings.getString("UISndWindowOpen")));
        }

        audio_update_volume(true);
}

void audio_update_volume(bool force_update)
{
        F32 master_volume = gSavedSettings.getF32("AudioLevelMaster");
        BOOL mute_audio = gSavedSettings.getBOOL("MuteAudio");
        if (!gViewerWindow->getActive() && (gSavedSettings.getBOOL("MuteWhenMinimized")))
        {
                mute_audio = TRUE;
        }
        F32 mute_volume = mute_audio ? 0.0f : 1.0f;

        // Sound Effects
        if (gAudiop) 
        {
                gAudiop->setMasterGain ( master_volume );

                gAudiop->setDopplerFactor(gSavedSettings.getF32("AudioLevelDoppler"));
                gAudiop->setDistanceFactor(gSavedSettings.getF32("AudioLevelDistance")); 
                gAudiop->setRolloffFactor(gSavedSettings.getF32("AudioLevelRolloff"));
#ifdef kAUDIO_ENABLE_WIND
                gAudiop->enableWind(!mute_audio);
#endif

                gAudiop->setMuted(mute_audio);
                
                if (force_update)
                {
                        audio_update_wind(true);
                }
        }

        // Streaming Music
        if (gAudiop) 
        {               
                F32 music_volume = gSavedSettings.getF32("AudioLevelMusic");
                music_volume = mute_volume * master_volume * (music_volume*music_volume);
                gAudiop->setInternetStreamGain ( music_volume );
        }

        // Streaming Media
        if(LLMediaEngine::getInstance())
        {
                F32 media_volume = gSavedSettings.getF32("AudioLevelMedia");
                media_volume = mute_volume * master_volume * (media_volume*media_volume);
                LLMediaEngine::getInstance()->setVolume(media_volume);
        }

        // Voice
        if (gVoiceClient)
        {
                F32 voice_volume = gSavedSettings.getF32("AudioLevelVoice");
                voice_volume = mute_volume * master_volume * voice_volume;
                gVoiceClient->setVoiceVolume(voice_volume);
                gVoiceClient->setMicGain(gSavedSettings.getF32("AudioLevelMic"));

                if (!gViewerWindow->getActive() && (gSavedSettings.getBOOL("MuteWhenMinimized")))
                {
                        gVoiceClient->setMuteMic(true);
                }
                else
                {
                        gVoiceClient->setMuteMic(false);
                }
        }
}

void audio_update_listener()
{
        if (gAudiop)
        {
                // update listener position because agent has moved     
                LLVector3d lpos_global = gAgent.getCameraPositionGlobal();              
                LLVector3 lpos_global_f;
                lpos_global_f.setVec(lpos_global);
        
                gAudiop->setListener(lpos_global_f,
                                                         // gCameraVelocitySmoothed, 
                                                         // LLVector3::zero,    
                                                         gAgent.getVelocity(),    // !!! *TODO: need to replace this with smoothed velocity!
                                                         gCamera->getUpAxis(),
                                                         gCamera->getAtAxis());
        }
}

void audio_update_wind(bool force_update)
{
#ifdef kAUDIO_ENABLE_WIND
        //
        //  Extract height above water to modulate filter by whether above/below water 
        // 
        LLViewerRegion* region = gAgent.getRegion();
        if (region)
        {
                static F32 last_camera_water_height = -1000.f;
                LLVector3 camera_pos = gAgent.getCameraPositionAgent();
                F32 camera_water_height = camera_pos.mV[VZ] - region->getWaterHeight();
                
                //
                //  Don't update rolloff factor unless water surface has been crossed
                //
                if (force_update || (last_camera_water_height * camera_water_height) < 0.f)
                {
                        if (camera_water_height < 0.f)
                        {
                                gAudiop->setRolloffFactor(gSavedSettings.getF32("AudioLevelRolloff") * LL_ROLLOFF_MULTIPLIER_UNDER_WATER);
                        }
                        else 
                        {
                                gAudiop->setRolloffFactor(gSavedSettings.getF32("AudioLevelRolloff"));
                        }
                }
                // this line rotates the wind vector to be listener (agent) relative
                // unfortunately we have to pre-translate to undo the translation that
                // occurs in the transform call
                gRelativeWindVec = gAgent.getFrameAgent().rotateToLocal(gWindVec - gAgent.getVelocity());

                // don't use the setter setMaxWindGain() because we don't
                // want to screw up the fade-in on startup by setting actual source gain
                // outside the fade-in.
                gAudiop->mMaxWindGain = gSavedSettings.getF32("AudioLevelAmbient");
                
                last_camera_water_height = camera_water_height;
                gAudiop->updateWind(gRelativeWindVec, camera_water_height);
        }
#endif
}



BOOL raycast_for_new_obj_pos( S32 x, S32 y, LLViewerObject** hit_obj, S32* hit_face, 
                                                         BOOL* b_hit_land, LLVector3* ray_start_region, LLVector3* ray_end_region, LLViewerRegion** region )
{
        F32 max_dist_from_camera = gSavedSettings.getF32( "MaxSelectDistance" ) - 1.f;

        // Viewer-side pick to find the right sim to create the object on.  
        // First find the surface the object will be created on.
        gViewerWindow->hitObjectOrLandGlobalImmediate(x, y, NULL, FALSE);
        
        // Note: use the frontmost non-flora version because (a) plants usually have lots of alpha and (b) pants' Havok
        // representations (if any) are NOT the same as their viewer representation.
        *hit_obj = gObjectList.findObject( gLastHitNonFloraObjectID );
        *hit_face = gLastHitNonFloraObjectFace;
        *b_hit_land = !(*hit_obj) && !gLastHitNonFloraPosGlobal.isExactlyZero();
        LLVector3d land_pos_global = gLastHitNonFloraPosGlobal;

        // Make sure there's a surface to place the new object on.
        BOOL bypass_sim_raycast = FALSE;
        LLVector3d      surface_pos_global;
        if (*b_hit_land)
        {
                surface_pos_global = land_pos_global; 
                bypass_sim_raycast = TRUE;
        }
        else 
        if (*hit_obj)
        {
                surface_pos_global = (*hit_obj)->getPositionGlobal();
        }
        else
        {
                return FALSE;
        }

        // Make sure the surface isn't too far away.
        LLVector3d ray_start_global = gAgent.getCameraPositionGlobal();
        F32 dist_to_surface_sq = (F32)((surface_pos_global - ray_start_global).magVecSquared());
        if( dist_to_surface_sq > (max_dist_from_camera * max_dist_from_camera) )
        {
                return FALSE;
        }

        // Find the sim where the surface lives.
        LLViewerRegion *regionp = gWorldp->getRegionFromPosGlobal(surface_pos_global);
        if (!regionp)
        {
                llwarns << "Trying to add object outside of all known regions!" << llendl;
                return FALSE;
        }

        // Find the simulator-side ray that will be used to place the object accurately
        LLVector3d              mouse_direction;
        mouse_direction.setVec( gViewerWindow->mouseDirectionGlobal( x, y ) );

        *region = regionp;
        *ray_start_region =     regionp->getPosRegionFromGlobal( ray_start_global );
        F32 near_clip = gCamera->getNear() + 0.01f;  // Include an epsilon to avoid rounding issues.
        *ray_start_region += gCamera->getAtAxis() * near_clip;

        if( bypass_sim_raycast )
        {
                // Hack to work around Havok's inability to ray cast onto height fields
                *ray_end_region = regionp->getPosRegionFromGlobal( surface_pos_global );  // ray end is the viewer's intersection point
        }
        else
        {
                LLVector3d              ray_end_global = ray_start_global + (1.f + max_dist_from_camera) * mouse_direction;  // add an epsilon to the sim version of the ray to avoid rounding problems.
                *ray_end_region = regionp->getPosRegionFromGlobal( ray_end_global );
        }

        return TRUE;
}

const LLVector3 DEFAULT_OBJECT_SCALE(0.5f, 0.5f, 0.5f);

BOOL add_object( LLPCode pcode, S32 x, S32 y, U8 use_physics )
{
        LLVector3 ray_start_region;
        LLVector3 ray_end_region;
        LLViewerRegion* regionp = NULL;
        BOOL b_hit_land = FALSE;
        S32 hit_face = -1;
        LLViewerObject* hit_obj = NULL;
        U8 state = 0;
        BOOL success = raycast_for_new_obj_pos( x, y, &hit_obj, &hit_face, &b_hit_land, &ray_start_region, &ray_end_region, &regionp );
        if( !success )
        {
                return FALSE;
        }

        if( hit_obj && (hit_obj->isAvatar() || hit_obj->isAttachment()) )
        {
                // Can't create objects on avatars or attachments
                return FALSE;
        }

        if (NULL == regionp)
        {
                llwarns << "regionp was NULL; aborting function." << llendl;
                return FALSE;
        }

        if (regionp->getRegionFlags() & REGION_FLAGS_SANDBOX)
        {
                LLFirstUse::useSandbox();
        }

        // Set params for new object based on its PCode.
        LLQuaternion    rotation;
        LLVector3               scale = DEFAULT_OBJECT_SCALE;
        U8                              material = LL_MCODE_WOOD;
        BOOL                    create_selected = FALSE;
        LLVolumeParams  volume_params;
        
        switch (pcode) 
        {
        case LL_PCODE_LEGACY_GRASS:
                //  Randomize size of grass patch 
                scale.setVec(10.f + ll_frand(20.f), 10.f + ll_frand(20.f),  1.f + ll_frand(2.f));
                state = rand() % LLVOGrass::sMaxGrassSpecies;
                break;


        case LL_PCODE_LEGACY_TREE:
        case LL_PCODE_TREE_NEW:
                state = rand() % LLVOTree::sMaxTreeSpecies;
                break;

        case LL_PCODE_SPHERE:
        case LL_PCODE_CONE:
        case LL_PCODE_CUBE:
        case LL_PCODE_CYLINDER:
        case LL_PCODE_TORUS:
        case LLViewerObject::LL_VO_SQUARE_TORUS:
        case LLViewerObject::LL_VO_TRIANGLE_TORUS:
        default:
                create_selected = TRUE;
                break;
        }

        // Play creation sound
        if (gAudiop)
        {
                F32 volume = gSavedSettings.getF32("AudioLevelUI");
                gAudiop->triggerSound( LLUUID(gSavedSettings.getString("UISndObjectCreate")), gAgent.getID(), volume);
        }

        gMessageSystem->newMessageFast(_PREHASH_ObjectAdd);
        gMessageSystem->nextBlockFast(_PREHASH_AgentData);
        gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
        gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
        gMessageSystem->addUUIDFast(_PREHASH_GroupID, gAgent.getGroupID());
        gMessageSystem->nextBlockFast(_PREHASH_ObjectData);
        gMessageSystem->addU8Fast(_PREHASH_Material,    material);

        U32 flags = 0;          // not selected
        if (use_physics)
        {
                flags |= FLAGS_USE_PHYSICS;
        }
        if (create_selected)
        {
                flags |= FLAGS_CREATE_SELECTED;
        }
        gMessageSystem->addU32Fast(_PREHASH_AddFlags, flags );

        LLPCode volume_pcode;   // ...PCODE_VOLUME, or the original on error
        switch (pcode)
        {
        case LL_PCODE_SPHERE:
                rotation.setQuat(90.f * DEG_TO_RAD, LLVector3::y_axis);

                volume_params.setType( LL_PCODE_PROFILE_CIRCLE_HALF, LL_PCODE_PATH_CIRCLE );
                volume_params.setBeginAndEndS( 0.f, 1.f );
                volume_params.setBeginAndEndT( 0.f, 1.f );
                volume_params.setRatio  ( 1, 1 );
                volume_params.setShear  ( 0, 0 );
                LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
                volume_pcode = LL_PCODE_VOLUME;
                break;

        case LL_PCODE_TORUS:
                rotation.setQuat(90.f * DEG_TO_RAD, LLVector3::y_axis);

                volume_params.setType( LL_PCODE_PROFILE_CIRCLE, LL_PCODE_PATH_CIRCLE );
                volume_params.setBeginAndEndS( 0.f, 1.f );
                volume_params.setBeginAndEndT( 0.f, 1.f );
                volume_params.setRatio  ( 1.f, 0.25f ); // "top size"
                volume_params.setShear  ( 0, 0 );
                LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
                volume_pcode = LL_PCODE_VOLUME;
                break;

        case LLViewerObject::LL_VO_SQUARE_TORUS:
                rotation.setQuat(90.f * DEG_TO_RAD, LLVector3::y_axis);

                volume_params.setType( LL_PCODE_PROFILE_SQUARE, LL_PCODE_PATH_CIRCLE );
                volume_params.setBeginAndEndS( 0.f, 1.f );
                volume_params.setBeginAndEndT( 0.f, 1.f );
                volume_params.setRatio  ( 1.f, 0.25f ); // "top size"
                volume_params.setShear  ( 0, 0 );
                LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
                volume_pcode = LL_PCODE_VOLUME;
                break;

        case LLViewerObject::LL_VO_TRIANGLE_TORUS:
                rotation.setQuat(90.f * DEG_TO_RAD, LLVector3::y_axis);

                volume_params.setType( LL_PCODE_PROFILE_EQUALTRI, LL_PCODE_PATH_CIRCLE );
                volume_params.setBeginAndEndS( 0.f, 1.f );
                volume_params.setBeginAndEndT( 0.f, 1.f );
                volume_params.setRatio  ( 1.f, 0.25f ); // "top size"
                volume_params.setShear  ( 0, 0 );
                LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
                volume_pcode = LL_PCODE_VOLUME;
                break;

        case LL_PCODE_SPHERE_HEMI:
                volume_params.setType( LL_PCODE_PROFILE_CIRCLE_HALF, LL_PCODE_PATH_CIRCLE );
                //volume_params.setBeginAndEndS( 0.5f, 1.f );
                volume_params.setBeginAndEndT( 0.f, 0.5f );
                volume_params.setRatio  ( 1, 1 );
                volume_params.setShear  ( 0, 0 );
                LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
                volume_pcode = LL_PCODE_VOLUME;
                break;

        case LL_PCODE_CUBE:
                volume_params.setType( LL_PCODE_PROFILE_SQUARE, LL_PCODE_PATH_LINE );
                volume_params.setBeginAndEndS( 0.f, 1.f );
                volume_params.setBeginAndEndT( 0.f, 1.f );
                volume_params.setRatio  ( 1, 1 );
                volume_params.setShear  ( 0, 0 );
                LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
                volume_pcode = LL_PCODE_VOLUME;
                break;

        case LL_PCODE_PRISM:
                volume_params.setType( LL_PCODE_PROFILE_SQUARE, LL_PCODE_PATH_LINE );
                volume_params.setBeginAndEndS( 0.f, 1.f );
                volume_params.setBeginAndEndT( 0.f, 1.f );
                volume_params.setRatio  ( 0, 1 );
                volume_params.setShear  ( -0.5f, 0 );
                LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
                volume_pcode = LL_PCODE_VOLUME;
                break;

        case LL_PCODE_PYRAMID:
                volume_params.setType( LL_PCODE_PROFILE_SQUARE, LL_PCODE_PATH_LINE );
                volume_params.setBeginAndEndS( 0.f, 1.f );
                volume_params.setBeginAndEndT( 0.f, 1.f );
                volume_params.setRatio  ( 0, 0 );
                volume_params.setShear  ( 0, 0 );
                LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
                volume_pcode = LL_PCODE_VOLUME;
                break;

        case LL_PCODE_TETRAHEDRON:
                volume_params.setType( LL_PCODE_PROFILE_EQUALTRI, LL_PCODE_PATH_LINE );
                volume_params.setBeginAndEndS( 0.f, 1.f );
                volume_params.setBeginAndEndT( 0.f, 1.f );
                volume_params.setRatio  ( 0, 0 );
                volume_params.setShear  ( 0, 0 );
                LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
                volume_pcode = LL_PCODE_VOLUME;
                break;

        case LL_PCODE_CYLINDER:
                volume_params.setType( LL_PCODE_PROFILE_CIRCLE, LL_PCODE_PATH_LINE );
                volume_params.setBeginAndEndS( 0.f, 1.f );
                volume_params.setBeginAndEndT( 0.f, 1.f );
                volume_params.setRatio  ( 1, 1 );
                volume_params.setShear  ( 0, 0 );
                LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
                volume_pcode = LL_PCODE_VOLUME;
                break;

        case LL_PCODE_CYLINDER_HEMI:
                volume_params.setType( LL_PCODE_PROFILE_CIRCLE, LL_PCODE_PATH_LINE );
                volume_params.setBeginAndEndS( 0.25f, 0.75f );
                volume_params.setBeginAndEndT( 0.f, 1.f );
                volume_params.setRatio  ( 1, 1 );
                volume_params.setShear  ( 0, 0 );
                LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
                volume_pcode = LL_PCODE_VOLUME;
                break;

        case LL_PCODE_CONE:
                volume_params.setType( LL_PCODE_PROFILE_CIRCLE, LL_PCODE_PATH_LINE );
                volume_params.setBeginAndEndS( 0.f, 1.f );
                volume_params.setBeginAndEndT( 0.f, 1.f );
                volume_params.setRatio  ( 0, 0 );
                volume_params.setShear  ( 0, 0 );
                LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
                volume_pcode = LL_PCODE_VOLUME;
                break;

        case LL_PCODE_CONE_HEMI:
                volume_params.setType( LL_PCODE_PROFILE_CIRCLE, LL_PCODE_PATH_LINE );
                volume_params.setBeginAndEndS( 0.25f, 0.75f );
                volume_params.setBeginAndEndT( 0.f, 1.f );
                volume_params.setRatio  ( 0, 0 );
                volume_params.setShear  ( 0, 0 );
                LLVolumeMessage::packVolumeParams(&volume_params, gMessageSystem);
                volume_pcode = LL_PCODE_VOLUME;
                break;

        default:
                LLVolumeMessage::packVolumeParams(0, gMessageSystem);
                volume_pcode = pcode;
                break;
        }
        gMessageSystem->addU8Fast(_PREHASH_PCode, volume_pcode);

        gMessageSystem->addVector3Fast(_PREHASH_Scale,                  scale );
        gMessageSystem->addQuatFast(_PREHASH_Rotation,                  rotation );
        gMessageSystem->addVector3Fast(_PREHASH_RayStart,               ray_start_region );
        gMessageSystem->addVector3Fast(_PREHASH_RayEnd,                 ray_end_region );
        gMessageSystem->addU8Fast(_PREHASH_BypassRaycast,               (U8)b_hit_land );
        gMessageSystem->addU8Fast(_PREHASH_RayEndIsIntersection, (U8)FALSE );
        gMessageSystem->addU8Fast(_PREHASH_State, state);

        // Limit raycast to a single object.  
        // Speeds up server raycast + avoid problems with server ray hitting objects
        // that were clipped by the near plane or culled on the viewer.
        LLUUID ray_target_id;
        if( hit_obj )
        {
                ray_target_id = hit_obj->getID();
        }
        else
        {
                ray_target_id.setNull();
        }
        gMessageSystem->addUUIDFast(_PREHASH_RayTargetID,                       ray_target_id );
        
        // Pack in name value pairs
        gMessageSystem->sendReliable(regionp->getHost());

        // Spawns a message, so must be after above send
        if (create_selected)
        {
                gSelectMgr->deselectAll();
                gViewerWindow->getWindow()->incBusyCount();
        }

        // VEFFECT: AddObject
        LLHUDEffectSpiral *effectp = (LLHUDEffectSpiral *)gHUDManager->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_BEAM, TRUE);
        effectp->setSourceObject(gAgent.getAvatarObject());
        effectp->setPositionGlobal(regionp->getPosGlobalFromRegion(ray_end_region));
        effectp->setDuration(LL_HUD_DUR_SHORT);
        effectp->setColor(LLColor4U(gAgent.getEffectColor()));

        gViewerStats->incStat(LLViewerStats::ST_CREATE_COUNT);

        return TRUE;
}



#if LL_WINDOWS
void create_console()
{
        int h_con_handle;
        long l_std_handle;

        CONSOLE_SCREEN_BUFFER_INFO coninfo;
        FILE *fp;

        // allocate a console for this app
        AllocConsole();

        // set the screen buffer to be big enough to let us scroll text
        GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &coninfo);
        coninfo.dwSize.Y = MAX_CONSOLE_LINES;
        SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), coninfo.dwSize);

        // redirect unbuffered STDOUT to the console
        l_std_handle = (long)GetStdHandle(STD_OUTPUT_HANDLE);
        h_con_handle = _open_osfhandle(l_std_handle, _O_TEXT);
        fp = _fdopen( h_con_handle, "w" );
        *stdout = *fp;
        setvbuf( stdout, NULL, _IONBF, 0 );

        // redirect unbuffered STDIN to the console
        l_std_handle = (long)GetStdHandle(STD_INPUT_HANDLE);
        h_con_handle = _open_osfhandle(l_std_handle, _O_TEXT);
        fp = _fdopen( h_con_handle, "r" );
        *stdin = *fp;
        setvbuf( stdin, NULL, _IONBF, 0 );

        // redirect unbuffered STDERR to the console
        l_std_handle = (long)GetStdHandle(STD_ERROR_HANDLE);
        h_con_handle = _open_osfhandle(l_std_handle, _O_TEXT);
        fp = _fdopen( h_con_handle, "w" );
        *stderr = *fp;
        setvbuf( stderr, NULL, _IONBF, 0 );
}
#endif



//-------------------------------------------------------------------
//-------------------------------------------------------------------
// Vector Performance Options
//-------------------------------------------------------------------
//-------------------------------------------------------------------

// Initially, we test the performance of the vectorization code, then
// turn it off if it ends up being slower. JC
BOOL    gVectorizePerfTest      = TRUE;
BOOL    gVectorizeEnable        = FALSE;
U32             gVectorizeProcessor     = 0;
BOOL    gVectorizeSkin          = FALSE;

void update_vector_performances(void)
{
        char *vp;
        
        switch(gVectorizeProcessor)
        {
                case 2: vp = "SSE2"; break;                                     // *TODO: replace the magic #s
                case 1: vp = "SSE"; break;
                default: vp = "COMPILER DEFAULT"; break;
        }
        llinfos << "Vectorization         : " << ( gVectorizeEnable ? "ENABLED" : "DISABLED" ) << llendl ;
        llinfos << "Vector Processor      : " << vp << llendl ;
        llinfos << "Vectorized Skinning   : " << ( gVectorizeSkin ? "ENABLED" : "DISABLED" ) << llendl ;
        
        if(gVectorizeEnable && gVectorizeSkin)
        {
                switch(gVectorizeProcessor)
                {
                        case 2:
                                LLViewerJointMesh::sUpdateGeometryFunc = &LLViewerJointMesh::updateGeometrySSE2;
                                break;
                        case 1:
                                LLViewerJointMesh::sUpdateGeometryFunc = &LLViewerJointMesh::updateGeometrySSE;
                                break;
                        default:
                                LLViewerJointMesh::sUpdateGeometryFunc = &LLViewerJointMesh::updateGeometryVectorized;
                                break;
                }
        }
        else
        {
                LLViewerJointMesh::sUpdateGeometryFunc = &LLViewerJointMesh::updateGeometryOriginal;
        }
}


class LLVectorizationEnableListener: public LLSimpleListener
{
        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
        {
                gVectorizeEnable = event->getValue().asBoolean();
                update_vector_performances();
                return true;
        }
};
static LLVectorizationEnableListener vectorization_enable_listener;

class LLVectorizeSkinListener: public LLSimpleListener
{
        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
        {
                gVectorizeSkin = event->getValue().asBoolean();
                update_vector_performances();
                return true;
        }
};
static LLVectorizeSkinListener vectorize_skin_listener;

class LLVectorProcessorListener: public LLSimpleListener
{
        bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
        {
                gVectorizeProcessor = event->getValue().asInteger();
                update_vector_performances();
                return true;
        }
};
static LLVectorProcessorListener vector_processor_listener;

// Use these strictly for things that are constructed at startup,
// or for things that are performance critical.  JC
void saved_settings_to_globals()
{
        LLBUTTON_H_PAD          = gSavedSettings.getS32("ButtonHPad");
        LLBUTTON_V_PAD          = gSavedSettings.getS32("ButtonVPad");
        BTN_HEIGHT_SMALL        = gSavedSettings.getS32("ButtonHeightSmall");
        BTN_HEIGHT                      = gSavedSettings.getS32("ButtonHeight");

        MENU_BAR_HEIGHT         = gSavedSettings.getS32("MenuBarHeight");
        MENU_BAR_WIDTH          = gSavedSettings.getS32("MenuBarWidth");
        STATUS_BAR_HEIGHT       = gSavedSettings.getS32("StatusBarHeight");

        LLCOMBOBOX_HEIGHT       = BTN_HEIGHT - 2;
        LLCOMBOBOX_WIDTH        = 128;

        LLSurface::setTextureSize(gSavedSettings.getU32("RegionTextureSize"));

        LLVOSky::sNighttimeBrightness           = gSavedSettings.getF32("RenderNightBrightness");
        
        LLImageGL::sGlobalUseAnisotropic        = gSavedSettings.getBOOL("RenderAnisotropic");
        LLVOVolume::sLODFactor                          = gSavedSettings.getF32("RenderVolumeLODFactor");
        LLVOVolume::sDistanceFactor                     = 1.f-LLVOVolume::sLODFactor * 0.1f;
        LLVolumeImplFlexible::sUpdateFactor = gSavedSettings.getF32("RenderFlexTimeFactor");
        LLVOTree::sTreeFactor                           = gSavedSettings.getF32("RenderTreeLODFactor");
        LLVOAvatar::sLODFactor                          = gSavedSettings.getF32("RenderAvatarLODFactor");
        LLVOAvatar::sMaxVisible                         = gSavedSettings.getS32("RenderAvatarMaxVisible");
        LLVOAvatar::sVisibleInFirstPerson       = gSavedSettings.getBOOL("FirstPersonAvatarVisible");
        // clamp auto-open time to some minimum usable value
        LLFolderView::sAutoOpenTime                     = llmax(0.25f, gSavedSettings.getF32("FolderAutoOpenDelay"));
        LLToolBar::sInventoryAutoOpenTime       = gSavedSettings.getF32("InventoryAutoOpenDelay");
        LLSelectMgr::sRectSelectInclusive       = gSavedSettings.getBOOL("RectangleSelectInclusive");
        LLSelectMgr::sRenderHiddenSelections = gSavedSettings.getBOOL("RenderHiddenSelections");
        LLSelectMgr::sRenderLightRadius = gSavedSettings.getBOOL("RenderLightRadius");

        gFrameStats.setTrackStats(gSavedSettings.getBOOL("StatsSessionTrackFrameStats"));
        gAgentPilot.mNumRuns            = gSavedSettings.getS32("StatsNumRuns");
        gAgentPilot.mQuitAfterRuns      = gSavedSettings.getBOOL("StatsQuitAfterRuns");
        gAgent.mHideGroupTitle          = gSavedSettings.getBOOL("RenderHideGroupTitle");

        gDebugWindowProc = gSavedSettings.getBOOL("DebugWindowProc");
        gAllowIdleAFK = gSavedSettings.getBOOL("AllowIdleAFK");
        gAFKTimeout = gSavedSettings.getF32("AFKTimeout");
        gMouseSensitivity = gSavedSettings.getF32("MouseSensitivity");
        gInvertMouse = gSavedSettings.getBOOL("InvertMouse");
        gShowObjectUpdates = gSavedSettings.getBOOL("ShowObjectUpdates");
        gMapScale = gSavedSettings.getF32("MapScale");
        gMiniMapScale = gSavedSettings.getF32("MiniMapScale");
        gHandleKeysAsync = gSavedSettings.getBOOL("AsyncKeyboard");
        LLHoverView::sShowHoverTips = gSavedSettings.getBOOL("ShowHoverTips");

#if LL_VECTORIZE
        if (gSysCPU.hasAltivec())
        {
                gSavedSettings.setBOOL("VectorizeEnable", TRUE );
                gSavedSettings.setU32("VectorizeProcessor", 0 );
        }
        else
        if (gSysCPU.hasSSE2())
        {
                gSavedSettings.setBOOL("VectorizeEnable", TRUE );
                gSavedSettings.setU32("VectorizeProcessor", 2 );
        }
        else
        if (gSysCPU.hasSSE())
        {
                gSavedSettings.setBOOL("VectorizeEnable", TRUE );
                gSavedSettings.setU32("VectorizeProcessor", 1 );
        }
        else
        {
                // Don't bother testing or running if CPU doesn't support it. JC
                gSavedSettings.setBOOL("VectorizePerfTest", FALSE );
                gSavedSettings.setBOOL("VectorizeEnable", FALSE );
                gSavedSettings.setU32("VectorizeProcessor", 0 );
                gSavedSettings.setBOOL("VectorizeSkin", FALSE);
        }
#else
        // This build target doesn't support SSE, don't test/run.
        gSavedSettings.setBOOL("VectorizePerfTest", FALSE );
        gSavedSettings.setBOOL("VectorizeEnable", FALSE );
        gSavedSettings.setU32("VectorizeProcessor", 0 );
        gSavedSettings.setBOOL("VectorizeSkin", FALSE);
#endif

        gVectorizePerfTest = gSavedSettings.getBOOL("VectorizePerfTest");
        gVectorizeEnable = gSavedSettings.getBOOL("VectorizeEnable");
        gVectorizeProcessor = gSavedSettings.getU32("VectorizeProcessor");
        gVectorizeSkin = gSavedSettings.getBOOL("VectorizeSkin");
        update_vector_performances();

        // Into a global in case we corrupt the list on crash.
        gCrashBehavior = gCrashSettings.getS32(CRASH_BEHAVIOR_SETTING);

        // propagate push to talk preference to current status
        gSavedSettings.setBOOL("PTTCurrentlyEnabled", gSavedSettings.getBOOL("EnablePushToTalk"));

        settings_setup_listeners();
        
        // these are currently static in this file, so they can't move to settings_setup_listeners
        gSavedSettings.getControl("VectorizeEnable")->addListener(&vectorization_enable_listener);
        gSavedSettings.getControl("VectorizeProcessor")->addListener(&vector_processor_listener);
        gSavedSettings.getControl("VectorizeSkin")->addListener(&vectorize_skin_listener);

        // gAgent.init() also loads from saved settings.
}

void cleanup_saved_settings()
{
        gSavedSettings.setBOOL("MouseSun", FALSE);

        gSavedSettings.setBOOL("FlyBtnState", FALSE);

        gSavedSettings.setBOOL("FirstPersonBtnState", FALSE);
        gSavedSettings.setBOOL("ThirdPersonBtnState", TRUE);
        gSavedSettings.setBOOL("BuildBtnState", FALSE);

        gSavedSettings.setBOOL("UseEnergy", TRUE);                              // force toggle to turn off, since sends message to simulator

        gSavedSettings.setBOOL("DebugWindowProc", gDebugWindowProc);
                
        gSavedSettings.setBOOL("AllowIdleAFK", gAllowIdleAFK);
        gSavedSettings.setBOOL("ShowObjectUpdates", gShowObjectUpdates);
        
        if (!gNoRender)
        {
                if (gDebugView)
                {
                        gSavedSettings.setBOOL("ShowDebugConsole", gDebugView->mDebugConsolep->getVisible());
                        gSavedSettings.setBOOL("ShowDebugStats", gDebugView->mStatViewp->getVisible());
                }
        }

        // save window position if not fullscreen
        // as we don't track it in callbacks
        BOOL fullscreen = gViewerWindow->mWindow->getFullscreen();
        BOOL maximized = gViewerWindow->mWindow->getMaximized();
        if (!fullscreen && !maximized)
        {
                LLCoordScreen window_pos;

                if (gViewerWindow->mWindow->getPosition(&window_pos))
                {
                        gSavedSettings.setS32("WindowX", window_pos.mX);
                        gSavedSettings.setS32("WindowY", window_pos.mY);
                }
        }

        gSavedSettings.setF32("MapScale", gMapScale );
        gSavedSettings.setF32("MiniMapScale", gMiniMapScale );
        gSavedSettings.setBOOL("AsyncKeyboard", gHandleKeysAsync);
        gSavedSettings.setBOOL("ShowHoverTips", LLHoverView::sShowHoverTips);

        // Some things are cached in LLAgent.
        if (gAgent.mInitialized)
        {
                gSavedSettings.setF32("RenderFarClip", gAgent.mDrawDistance);
        }

        gCrashSettings.setS32(CRASH_BEHAVIOR_SETTING, gCrashBehavior);
}


void callback_cache_name(const LLUUID& id, const char* firstname, const char* lastname, BOOL is_group, void* data)
{
        LLNameListCtrl::refreshAll(id, firstname, lastname, is_group);
        LLNameBox::refreshAll(id, firstname, lastname, is_group);
        LLNameEditor::refreshAll(id, firstname, lastname, is_group);
        
        // TODO: Actually be intelligent about the refresh.
        // For now, just brute force refresh the dialogs.
        dialog_refresh_all();
}


void write_debug(const std::string& str)
{
        write_debug(str.c_str());
}

void write_debug(const char *str)
{
        if (!gDebugFile)
        {
                std::string debug_filename = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,"debug_info.log");
                llinfos << "Opening debug file " << debug_filename << llendl;
                gDebugFile = LLFile::fopen(debug_filename.c_str(), "w");                /* Flawfinder: ignore */
        if (!gDebugFile)
        {
                    llinfos << "Opening debug file " << debug_filename << " failed. Using stderr." << llendl;
            gDebugFile = stderr;
        }
        }
        fputs(str, gDebugFile);
        fflush(gDebugFile);
}

void close_debug()
{
        if (gDebugFile)
        {
                fclose(gDebugFile);
        }
        gDebugFile = NULL;
}

void print_agent_nvpairs(void*)
{
        LLViewerObject *objectp;

        llinfos << "Agent Name Value Pairs" << llendl;

        objectp = gObjectList.findObject(gAgentID);
        if (objectp)
        {
                objectp->printNameValuePairs();
        }
        else
        {
                llinfos << "Can't find agent object" << llendl;
        }

        llinfos << "Camera at " << gAgent.getCameraPositionGlobal() << llendl;
}


void reset_statistics()
{
        gPipeline.resetFrameStats();    // Reset per-frame statistics.
        if (LLSurface::sTextureUpdateTime)
        {
                LLSurface::sTexelsUpdatedPerSecStat.addValue(0.001f*(LLSurface::sTexelsUpdated / LLSurface::sTextureUpdateTime));
                LLSurface::sTexelsUpdated = 0;
                LLSurface::sTextureUpdateTime = 0.f;
        }
}


void output_statistics(void*)
{
        llinfos << "Number of orphans: " << gObjectList.getOrphanCount() << llendl;
        llinfos << "Number of dead objects: " << gObjectList.mNumDeadObjects << llendl;
        llinfos << "Num images: " << gImageList.getNumImages() << llendl;
        llinfos << "Texture usage: " << LLImageGL::sGlobalTextureMemory << llendl;
        llinfos << "Texture working set: " << LLImageGL::sBoundTextureMemory << llendl;
        llinfos << "Raw usage: " << LLImageRaw::sGlobalRawMemory << llendl;
        llinfos << "Formatted usage: " << LLImageFormatted::sGlobalFormattedMemory << llendl;
        llinfos << "Zombie Viewer Objects: " << LLViewerObject::getNumZombieObjects() << llendl;
        llinfos << "Number of lights: " << gPipeline.getLightCount() << llendl;

        llinfos << "Memory Usage:" << llendl;
        llinfos << "--------------------------------" << llendl;
        llinfos << "Pipeline:" << llendl;
        llinfos << llendl;

#if LL_SMARTHEAP
        llinfos << "--------------------------------" << llendl;
        {
                llinfos << "sizeof(LLVOVolume) = " << sizeof(LLVOVolume) << llendl;

                U32 total_pool_size = 0;
                U32 total_used_size = 0;
                MEM_POOL_INFO pool_info;
                MEM_POOL_STATUS pool_status;
                U32 pool_num = 0;
                for(pool_status = MemPoolFirst( &pool_info, 1 ); 
                        pool_status != MEM_POOL_END; 
                        pool_status = MemPoolNext( &pool_info, 1 ) )
                {
                        llinfos << "Pool #" << pool_num << llendl;
                        if( MEM_POOL_OK != pool_status )
                        {
                                llwarns << "Pool not ok" << llendl;
                                continue;
                        }

                        llinfos << "Pool blockSizeFS " << pool_info.blockSizeFS
                                << " pageSize " << pool_info.pageSize
                                << llendl;

                        U32 pool_count = MemPoolCount(pool_info.pool);
                        llinfos << "Blocks " << pool_count << llendl;

                        U32 pool_size = MemPoolSize( pool_info.pool );
                        if( pool_size == MEM_ERROR_RET )
                        {
                                llinfos << "MemPoolSize() failed (" << pool_num << ")" << llendl;
                        }
                        else
                        {
                                llinfos << "MemPool Size " << pool_size / 1024 << "K" << llendl;
                        }

                        total_pool_size += pool_size;

                        if( !MemPoolLock( pool_info.pool ) )
                        {
                                llinfos << "MemPoolLock failed (" << pool_num << ") " << llendl;
                                continue;
                        }

                        U32 used_size = 0; 
                        MEM_POOL_ENTRY entry;
                        entry.entry = NULL;
                        while( MemPoolWalk( pool_info.pool, &entry ) == MEM_POOL_OK )
                        {
                                if( entry.isInUse )
                                {
                                        used_size += entry.size;
                                }
                        }

                        MemPoolUnlock( pool_info.pool );

                        llinfos << "MemPool Used " << used_size/1024 << "K" << llendl;
                        total_used_size += used_size;
                        pool_num++;
                }
                
                llinfos << "Total Pool Size " << total_pool_size/1024 << "K" << llendl;
                llinfos << "Total Used Size " << total_used_size/1024 << "K" << llendl;

        }
#endif

        llinfos << "--------------------------------" << llendl;
        llinfos << "Avatar Memory (partly overlaps with above stats):" << llendl;
        gTexStaticImageList.dumpByteCount();
        LLVOAvatar::dumpScratchTextureByteCount();
        LLTexLayerSetBuffer::dumpTotalByteCount();
        LLVOAvatar::dumpTotalLocalTextureByteCount();
        LLTexLayerParamAlpha::dumpCacheByteCount();
        LLVOAvatar::dumpBakedStatus();

        llinfos << llendl;

        llinfos << "Object counts:" << llendl;
        S32 i;
        S32 obj_counts[256];
//      S32 app_angles[256];
        for (i = 0; i < 256; i++)
        {
                obj_counts[i] = 0;
        }
        for (i = 0; i < gObjectList.getNumObjects(); i++)
        {
                LLViewerObject *objectp = gObjectList.getObject(i);
                if (objectp)
                {
                        obj_counts[objectp->getPCode()]++;
                }
        }
        for (i = 0; i < 256; i++)
        {
                if (obj_counts[i])
                {
                        llinfos << LLPrimitive::pCodeToString(i) << ":" << obj_counts[i] << llendl;
                }
        }

        /*
        llinfos << "Object size distribution" << llendl;
        llinfos << "------------------------" << llendl;
        for (i = 0; i < 256; i++)
        {
                obj_counts[i] = 0;
                //app_angles[i] = 0;
        }
        for (i = 0; i < gObjectList.getNumObjects(); i++)
        {
                LLViewerObject *objectp = gObjectList.getObject(i);
                S32 size = llmin(255, (S32)objectp->getRadius()/2);
                obj_counts[size]++;
        }
        for (i = 0; i < 256; i++)
        {
                if (obj_counts[i])
                {
                        llinfos << i*2 << ":" << (i+1)*2 << " - " << obj_counts[i] << llendl;
                }
        }
        */

        /*

        llinfos << llendl;
        llinfos << "Lighting statistics" << llendl;
        llinfos << "-------------------" << llendl;
        S32 light_bins[256];
        S32 light_counts[256];
        for (i = 0; i < 256; i++)
        {
                light_bins[i] = 0;
                light_counts[i] = 0;
        }
        for (i = 0; i < gPipeline.mLightSet.count(); i++)
        {
                LLDrawable *drawablep = gPipeline.mLightSet[i];
                F32 light_range = drawablep->getMetric() * LIGHT_RANGE_FACTOR;
                S32 light_bin = light_range / 4;
                S32 count_bin = llmin(drawablep->mLightSet.getLength() / 25, 255);

                if (count_bin > 20)
                {
                        llinfos << drawablep->getVObj()->getPCodeString() << ":" << count_bin*25 << llendl;
                        drawablep->getVObj()->dump();
                }
                //llinfos << i << ": " << light_range << llendl;
                light_bins[light_bin]++;
                light_counts[count_bin]++;
        }
        for (i = 0; i < 256; i++)
        {
                if (light_bins[i])
                {
                        llinfos << i*4 << ":" << (i+1)*4 << " - " << light_bins[i] << llendl;
                }
        }
        llinfos << llendl;
        llinfos << "LightSet counts" << llendl;
        for (i = 0; i < 256; i++)
        {
                if (light_counts[i])
                {
                        llinfos << i*25 << ":" << (i+1)*25 << " - " << light_counts[i] << llendl;
                }
        }
        */
}

class ViewerStatsResponder : public LLHTTPClient::Responder
{
public:
    ViewerStatsResponder() { }

    void error(U32 statusNum, const std::string& reason)
    {
                llinfos << "ViewerStatsResponder::error " << statusNum << " "
                                << reason << llendl;
    }

    void result(const LLSD& content)
    {
                llinfos << "ViewerStatsResponder::result" << llendl;
        }
};

/*
 * The sim-side LLSD is in newsim/llagentinfo.cpp:forwardViewerStats.
 *
 * There's also a compatibility shim for the old fixed-format sim
 * stats in newsim/llagentinfo.cpp:processViewerStats.
 *
 * If you move stats around here, make the corresponding changes in
 * those locations, too.
 */
void send_stats()
{
        // IW 9/23/02 I elected not to move this into LLViewerStats
        // because it depends on too many viewer.cpp globals.
        // Someday we may want to merge all our stats into a central place
        // but that day is not today.

        // Only send stats if the agent is connected to a region.
        if (!gAgent.getRegion() || gNoRender)
        {
                return;
        }

        LLSD body;
        std::string url = gAgent.getRegion()->getCapability("ViewerStats");

        if (url.empty()) {
                llwarns << "Could not get ViewerStats capability" << llendl;
                return;
        }
        
        body["session_id"] = gAgentSessionID;
        
        LLSD &agent = body["agent"];
        
        time_t ltime;
        time(&ltime);
        F32 run_time = F32(LLFrameTimer::getElapsedSeconds());

        agent["start_time"] = ltime - run_time;
        agent["run_time"] = run_time;
        // send fps only for time app spends in foreground
        agent["fps"] = (F32)gForegroundFrameCount / gForegroundTime.getElapsedTimeF32();
        agent["version"] = gCurrentVersion;
        agent["language"] = gSavedSettings.getString("Language");
        
        agent["sim_fps"] = ((F32) gFrameCount - gSimFrames) /
                (F32) (gRenderStartTime.getElapsedTimeF32() - gSimLastTime);

        gSimLastTime = gRenderStartTime.getElapsedTimeF32();
        gSimFrames   = (F32) gFrameCount;

        agent["agents_in_view"] = LLVOAvatar::sNumVisibleAvatars;
        agent["ping"] = gAvgSimPing;
        agent["meters_traveled"] = gAgent.getDistanceTraveled();
        agent["regions_visited"] = gAgent.getRegionsVisited();
        agent["mem_use"] = getCurrentRSS() / 1024.0;

        LLSD &system = body["system"];
        
        system["ram"] = (S32) gSysMemory.getPhysicalMemoryKB();
        system["os"] = gSysOS.getOSString();
        system["cpu"] = gSysCPU.getCPUString();

        std::string gpu_desc = llformat(
                "%-6s Class %d ",
                gGLManager.mGLVendorShort.substr(0,6).c_str(),
                gFeatureManagerp->getGPUClass())
                + gFeatureManagerp->getGPUString();

        system["gpu"] = gpu_desc;
        system["gpu_class"] = gFeatureManagerp->getGPUClass();
        system["gpu_vendor"] = gGLManager.mGLVendorShort;
        system["gpu_version"] = gGLManager.mDriverVersionVendorString;

        LLSD &download = body["downloads"];

        download["world_kbytes"] = gTotalWorldBytes / 1024.0;
        download["object_kbytes"] = gTotalObjectBytes / 1024.0;
        download["texture_kbytes"] = gTotalTextureBytes / 1024.0;

        LLSD &in = body["stats"]["net"]["in"];

        in["kbytes"] = gMessageSystem->mTotalBytesIn / 1024.0;
        in["packets"] = (S32) gMessageSystem->mPacketsIn;
        in["compressed_packets"] = (S32) gMessageSystem->mCompressedPacketsIn;
        in["savings"] = (gMessageSystem->mUncompressedBytesIn -
                                         gMessageSystem->mCompressedBytesIn) / 1024.0;
        
        LLSD &out = body["stats"]["net"]["out"];
        
        out["kbytes"] = gMessageSystem->mTotalBytesOut / 1024.0;
        out["packets"] = (S32) gMessageSystem->mPacketsOut;
        out["compressed_packets"] = (S32) gMessageSystem->mCompressedPacketsOut;
        out["savings"] = (gMessageSystem->mUncompressedBytesOut -
                                          gMessageSystem->mCompressedBytesOut) / 1024.0;

        LLSD &fail = body["stats"]["failures"];

        fail["send_packet"] = (S32) gMessageSystem->mSendPacketFailureCount;
        fail["dropped"] = (S32) gMessageSystem->mDroppedPackets;
        fail["resent"] = (S32) gMessageSystem->mResentPackets;
        fail["failed_resends"] = (S32) gMessageSystem->mFailedResendPackets;
        fail["off_circuit"] = (S32) gMessageSystem->mOffCircuitPackets;
        fail["invalid"] = (S32) gMessageSystem->mInvalidOnCircuitPackets;

        gViewerStats->addToMessage(body);

        LLHTTPClient::post(url, body, new ViewerStatsResponder());
}

#if !LL_WINDOWS
// catch the first signal and send logout messages logout
void signal_handlers(S32 s)
{
        release_signals();

        // Check for graceful exit conditions
        if(SIGTERM == s)
        {
                // Raise the flag telling the system to shut down
                app_force_quit(NULL);
                return;
        }

# if LL_LINUX || LL_SOLARIS
        // Really useful to know what KIND of crash we got.
        // Might want this on OSX too!
        llwarns << "*** Caught signal " << s << llendl;
# endif

        if (gCrashCallback)
        {
                gCrashCallback();
        }
}
#endif

// Assign signal handler to be called in case we crash.
void catch_signals()
{
#if LL_WINDOWS
        // Win32 signal handling uses a Microsoft API instead of signal handlers
        LLWinDebug::setupExceptionHandler();
        return;
#else
        // This happens before log file output is properly set up, so this would go to the system log.
//      llinfos << "Assigning signal handlers!" << llendl;

        // Handle the signals that default to causing a core image to be created, as per the man page on signal(2).
        signal(SIGILL, signal_handlers);
        signal(SIGTRAP, signal_handlers);
        if (being_debugged())
        {
                // If we're being run under the control of a debugger, give
                // ourselves a way to bail into the debugger.
                signal(SIGABRT, SIG_DFL);
        } else {
                signal(SIGABRT, signal_handlers);
        }
        signal(SIGFPE, signal_handlers);
        signal(SIGBUS, signal_handlers);
        signal(SIGSEGV, signal_handlers);
        signal(SIGSYS, signal_handlers);

        // SIGEMT is an 'emulator trap' which is not defined on linux.
#if !LL_LINUX && !LL_SOLARIS
        signal(SIGEMT, signal_handlers);
#endif

        // This one is treated specially in the signal handler.
        signal(SIGTERM, signal_handlers);

#endif // LL_WINDOWS
}

#if !LL_WINDOWS
void release_signals()
{
        signal(SIGTERM, SIG_DFL);
        signal(SIGABRT, SIG_DFL);
        signal(SIGILL, SIG_DFL);
        signal(SIGFPE, SIG_DFL);
        signal(SIGSEGV, SIG_DFL);

#ifdef SIGBUS
        signal(SIGBUS, SIG_DFL);
#endif

#ifdef SIGSYS
        signal(SIGSYS, SIG_DFL);
#endif
}
#endif // !LL_WINDOWS

void purge_cache()
{
        llinfos << "Purging Texture Cache..." << llendl;
        gTextureCache->purgeCache(LL_PATH_CACHE);
        llinfos << "Purging Cache..." << llendl;
        std::string mask = gDirUtilp->getDirDelimiter() + "*.*";
        gDirUtilp->deleteFilesInDir(gDirUtilp->getExpandedFilename(LL_PATH_CACHE,"").c_str(),mask);
}

int parse_args(int argc, char **argv)
{
        // Sometimes IP addresses passed in on the command line have leading
        // or trailing white space.  Use LLString to clean that up.
        LLString ip_string;
        S32 j;

        for (j = 1; j < argc; j++) 
        {
                gArgs += argv[j];
                gArgs += " ";

                if ((!strcmp(argv[j], "-port")) && (++j < argc)) 
                {
                        sscanf(argv[j], "%u", &(gAgent.mViewerPort));
                }
                else if ((!strcmp(argv[j], "-drop")) && (++j < argc)) 
                {
                        sscanf(argv[j], "%f", &gPacketDropPercentage);
                }
                else if ((!strcmp(argv[j], "-inbw")) && (++j < argc))
                {
                        sscanf(argv[j], "%f", &gInBandwidth);
                }
                else if ((!strcmp(argv[j], "-outbw")) && (++j < argc))
                {
                        sscanf(argv[j], "%f", &gOutBandwidth);
                }
                else if (!strcmp(argv[j], "--aditi"))
                {
                        gUserServerChoice = USERSERVER_ADITI;
                        snprintf(gUserServerName, MAX_STRING, "%s", gUserServerDomainName[gUserServerChoice].mName);            /* Flawfinder: ignore */
                }
                else if (!strcmp(argv[j], "--agni"))
                {
                        gUserServerChoice = USERSERVER_AGNI;
                        snprintf(gUserServerName, MAX_STRING, "%s", gUserServerDomainName[gUserServerChoice].mName);            /* Flawfinder: ignore */
                }
                else if (!strcmp(argv[j], "--dmz"))
                {
                        gUserServerChoice = USERSERVER_DMZ;
                        snprintf(gUserServerName, MAX_STRING, "%s", gUserServerDomainName[gUserServerChoice].mName);            /* Flawfinder: ignore */
                }
                else if (!strcmp(argv[j], "--siva"))
                {
                        gUserServerChoice = USERSERVER_SIVA;
                        snprintf(gUserServerName, MAX_STRING, "%s", gUserServerDomainName[gUserServerChoice].mName);            /* Flawfinder: ignore */
                }
                else if (!strcmp(argv[j], "--shakti"))
                {
                        gUserServerChoice = USERSERVER_SHAKTI;
                        snprintf(gUserServerName, MAX_STRING, "%s", gUserServerDomainName[gUserServerChoice].mName);            /* Flawfinder: ignore */
                }
                else if (!strcmp(argv[j], "--durga"))
                {
                        gUserServerChoice = USERSERVER_DURGA;
                        snprintf(gUserServerName, MAX_STRING, "%s", gUserServerDomainName[gUserServerChoice].mName);            /* Flawfinder: ignore */
                }
                else if (!strcmp(argv[j], "--soma"))
                {
                        gUserServerChoice = USERSERVER_SOMA;
                        snprintf(gUserServerName, MAX_STRING, "%s", gUserServerDomainName[gUserServerChoice].mName);            /* Flawfinder: ignore */
                }
                else if (!strcmp(argv[j], "--ganga"))
                {
                        gUserServerChoice = USERSERVER_GANGA;
                        sprintf(gUserServerName,"%s", gUserServerDomainName[gUserServerChoice].mName);
                }
                else if (!strcmp(argv[j], "--vaak"))
                {
                        gUserServerChoice = USERSERVER_VAAK;
                        sprintf(gUserServerName,"%s", gUserServerDomainName[gUserServerChoice].mName);
                }
                else if (!strcmp(argv[j], "--uma"))
                {
                        gUserServerChoice = USERSERVER_UMA;
                        sprintf(gUserServerName,"%s", gUserServerDomainName[gUserServerChoice].mName);
                }
                else if (!strcmp(argv[j], "-user") && (++j < argc)) 
                {
                        if (!strcmp(argv[j], "-"))
                        {
                                gUserServerChoice = USERSERVER_LOCAL;
                                snprintf(gUserServerName, MAX_STRING, "%s", LOOPBACK_ADDRESS_STRING);           /* Flawfinder: ignore */
                        }
                        else
                        {
                                gUserServerChoice = USERSERVER_OTHER;
                                ip_string.assign( argv[j] );
                                LLString::trim(ip_string);
                                snprintf(gUserServerName, MAX_STRING, "%s", ip_string.c_str());         /* Flawfinder: ignore */
                        }
                }
                else if (!strcmp(argv[j], "-loginuri") && (++j < argc))
                {
                        gLoginURIs.push_back(utf8str_trim(argv[j]));
                }
                else if (!strcmp(argv[j], "-helperuri") && (++j < argc))
                {
                        gHelperURI = argv[j];
                        gHelperURI = utf8str_trim(gHelperURI);
                }
                else if (!strcmp(argv[j], "-debugviews"))
                {
                        LLView::sDebugRects = TRUE;
                }
                else if (!strcmp(argv[j], "-skin") && (++j < argc))
                {
                        std::string folder(argv[j]);
                        gDirUtilp->setSkinFolder(folder);
                }
                else if (!strcmp(argv[j], "-autologin") || !strcmp(argv[j], "--autologin")) // keep --autologin for compatibility
                {
                        gAutoLogin = TRUE;
                }
                else if (!strcmp(argv[j], "-quitafter") && (++j < argc))
                {
                        gQuitAfterSeconds = (F32)atof(argv[j]);
                }
                else if (!strcmp(argv[j], "-rotate"))
                {
                        gRotateRight = TRUE;
                }
//              else if (!strcmp(argv[j], "-noenv")) 
//              {
                        //turn OFF environmental effects for slow machines/video cards
//                      gRequestParaboloidMap = FALSE;
//              }
                else if (!strcmp(argv[j], "-noaudio"))
                {
                        gUseAudio = FALSE;
                }
                else if (!strcmp(argv[j], "-nosound"))  // tends to be popular cmdline on Linux.
                {
                        gUseAudio = FALSE;
                }
                else if (!strcmp(argv[j], "-nofmod"))
                {
                        gUseFMOD = FALSE;
                }
                else if (!strcmp(argv[j], "-noprobe"))
                {
                        gProbeHardware = FALSE;
                }
                else if (!strcmp(argv[j], "-noquicktime"))
                {
                        // Developers can log in faster if they don't load all the
                        // quicktime dlls.
                        gUseQuickTime = false;
                }
                else if (!strcmp(argv[j], "-nopreload"))
                {
                        // Developers can log in faster if they don't decode sounds
                        // or images on startup, ~5 seconds faster.
                        gPreloadSounds = false;
                        gPreloadImages = false;
                }
                else if (!strcmp(argv[j], "-purge"))
                {
                        purge_cache();
                }
                else if(!strcmp(argv[j], "-noinvlib"))
                {
                        gRequestInventoryLibrary = FALSE;
                }
                else if (!strcmp(argv[j], "-log"))
                {
                        gLogMessages = TRUE;
                        continue;
                }
                else if (!strcmp(argv[j], "-logfile") && (++j < argc)) 
                {
                        // *NOTE: This buffer size is hard coded into scanf() below.
                        char logfile[256];      /* Flawfinder: ignore */
                        sscanf(argv[j], "%255s", logfile);      /* Flawfinder: ignore */
                        llinfos << "Setting log file to " << logfile << llendl;
                        LLFile::remove(logfile);
                        LLError::logToFile(logfile);
                }
                else if (!strcmp(argv[j], "-settings") && (++j < argc)) 
                {
                        gSettingsFileName = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, argv[j]);
                }
                else if (!strcmp(argv[j], "-setdefault") && (j + 2 < argc)) 
                {
                        std::string control_name;
                        std::string control_value;
                        
                        j++;
                        if (argv[j]) control_name = std::string(argv[j]);

                        j++;
                        if (argv[j]) control_value = std::string(argv[j]);
                        
                        // grab control name and value
                        if (!control_name.empty())
                        {
                                gCommandLineSettings[control_name] = control_value;
                        }
                }
                else if (!strcmp(argv[j], "-set") && (j + 2 < argc)) 
                {
                        std::string control_name;
                        std::string control_value;
                        
                        j++;
                        if (argv[j]) control_name = std::string(argv[j]);

                        j++;
                        if (argv[j]) control_value = std::string(argv[j]);
                        
                        // grab control name and value
                        if (!control_name.empty())
                        {
                                gCommandLineForcedSettings[control_name] = control_value;
                        }
                }
                else if (!strcmp(argv[j], "-login"))
                {
                        if (j + 3 < argc)
                        {
                                j++;
                                gCmdLineFirstName = argv[j];
                                j++;
                                gCmdLineLastName = argv[j];
                                j++;
                                gCmdLinePassword = argv[j];
                        }
                        else
                        {
                                // only works if -login is last parameter on command line
                                llerrs << "Not enough parameters to -login. Did you mean -loginuri?" << llendl;
                        }
                }
                else if (!strcmp(argv[j], "-god"))
                {
                        gGodConnect = TRUE;
                }
                else if (!strcmp(argv[j], "-noconsole"))
                {
                        gUseConsole = FALSE;
                }
                else if (!strcmp(argv[j], "-safe"))
                {
                        llinfos << "Setting viewer feature table to run in safe mode, resetting prefs" << llendl;
                        gFeatureManagerp->setSafe(TRUE);
                }
                else if (!strcmp(argv[j], "-multiple"))
                {
                        gMultipleViewersOK = TRUE;
                }
                else if (!strcmp(argv[j], "-nomultiple"))
                {
                        gMultipleViewersOK = FALSE;
                }
                else if (!strcmp(argv[j], "-novoice"))
                {
                        gDisableVoice = TRUE;
                }
                else if (!strcmp(argv[j], "-nothread"))
                {
                        LLVFile::ALLOW_ASYNC = FALSE;
                        llinfos << "Running VFS in nothread mode" << llendl;
                }
                // some programs don't respect the command line options in protocol handlers (I'm looking at you, Opera)
                // so this allows us to parse the URL straight off the command line without a "-url" paramater
                else if (LLURLDispatcher::isSLURL(argv[j])
                                 || !strcmp(argv[j], "-url") && (++j < argc)) 
                {
                        std::string slurl = argv[j];
                        if (LLURLDispatcher::isSLURLCommand(slurl))
                        {
                                LLStartUp::sSLURLCommand = slurl;
                        }
                        else
                        {
                                LLURLSimString::setString(slurl);
                        }
                        // *NOTE: After setting the url, bail. What can happen is
                        // that someone can use IE (or potentially other browsers)
                        // and do the rough equivalent of command injection and
                        // steal passwords. Phoenix. SL-55321
                        gArgs += argv[j];
                        return 0;
                }
                else if (!strcmp(argv[j], "-ignorepixeldepth"))
                {
                        gIgnorePixelDepth = TRUE;
                }
                else if (!strcmp(argv[j], "-cooperative"))
                {
                        S32 ms_to_yield = 0;
                        if(++j < argc)
                        {
                                S32 rv = sscanf(argv[j], "%d", &ms_to_yield);
                                if(0 == rv)
                                {
                                        --j;
                                }
                        }
                        else
                        {
                                --j;
                        }
                        gYieldMS = ms_to_yield;
                        gYieldTime = TRUE;
                }
                else if (!strncmp(argv[j], "-lang", 5))
                {
                        j++;
                        if (argv[j])
                                gSavedSettings.setString("Language", std::string(argv[j]));
                }
                else if (!strcmp(argv[j], "-no-verify-ssl-cert"))
                {
                        gVerifySSLCert = false;
                }
                else if ( (!strcmp(argv[j], "--channel") || !strcmp(argv[j], "-channel"))  && (++j < argc)) 
                {
                        gChannelName = argv[j];
                }
#if LL_DARWIN
                else if (!strncmp(argv[j], "-psn_", 5))
                {
                        // this is the Finder passing the process session number
                        // we ignore this
                }
#endif
                else
                {

                        // DBC - Mac OS X passes some stuff by default on the command line (e.g. psn).
                        // Second Life URLs are passed this way as well?
                        llwarns << "Possible unknown keyword " << argv[j] << llendl;

                        // print usage information
                        llinfos << USAGE << llendl;
                        // return 1;
                }
        }
        return 0;
}

//============================================================================

void load_name_cache()
{
        if (!gCacheName) return;

        std::string name_cache;
        name_cache = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "name.cache");
        FILE* name_cache_fp = LLFile::fopen(name_cache.c_str(), "r");           /* Flawfinder: ignore*/
        if (name_cache_fp)
        {
                gCacheName->importFile(name_cache_fp);
                fclose(name_cache_fp);
        }
}

void save_name_cache()
{
        if (!gCacheName) return;

        std::string name_cache;
        name_cache = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "name.cache");
        FILE* name_cache_fp = LLFile::fopen(name_cache.c_str(), "w");           /* Flawfinder: ignore*/
        if (name_cache_fp)
        {
                gCacheName->exportFile(name_cache_fp);
                fclose(name_cache_fp);
        }
}

void load_region_name_cache()
{
        if (!gCacheName) return;

        // Load static cache, then user specific one
        gRegionNameCache->importFile(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "region_names.xml"), true);
        gRegionNameCache->importFile(gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "region_names.xml"), false);
}

void save_region_name_cache()
{
        if (!gCacheName) return;

        std::string name_cache;
        name_cache = gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "region_names.xml");
        gRegionNameCache->exportFile(name_cache);
}


void login_alert_done(S32 option, void* user_data)
{
        LLPanelLogin::giveFocus();
}

void disconnect_viewer(void *)
{
        if (gDisconnected)
        {
                return;
        }
        //
        // Cleanup after quitting.
        //      
        // Save snapshot for next time, if we made it through initialization

        llinfos << "Disconnecting viewer!" << llendl;

        // Dump our frame statistics
        gFrameStats.dump();


        // Signal handlers may need resources that we're destroying here, so don't use them.
#if !LL_WINDOWS
        release_signals();
#endif

        // Remember if we were flying
        gSavedSettings.setBOOL("FlyingAtExit", gAgent.getFlying() );

        // Un-minimize all windows so they don't get saved minimized
        if (!gNoRender)
        {
                if (gFloaterView)
                {
                        gFloaterView->restoreAll();
                }
        }

        if (gSelectMgr)
        {
                gSelectMgr->deselectAll();
        }

        if (!gNoRender)
        {
                // save inventory if appropriate
                gInventory.cache(gAgent.getInventoryRootID(), gAgent.getID());
                if(gInventoryLibraryRoot.notNull() && gInventoryLibraryOwner.notNull())
                {
                        gInventory.cache(gInventoryLibraryRoot, gInventoryLibraryOwner);
                }
        }

        save_name_cache();
        save_region_name_cache();

        // close inventory interface, close all windows
        LLInventoryView::cleanup();

        // Log out of userserver
        user_logout();

        // Delete stuff that would result in net connections

        // Also writes cached agent settings to gSavedSettings
        gAgent.cleanup();

        gObjectList.destroy();
        delete gWorldp;
        gWorldp = NULL;

        cleanup_xfer_manager();
        gDisconnected = TRUE;
}

// helper function for cleanup_app
void remove_cache_files(const char* file_mask)
{
        char mask[LL_MAX_PATH];         /* Flawfinder: ignore */
        snprintf(mask, LL_MAX_PATH, "%s%s", gDirUtilp->getDirDelimiter().c_str(), file_mask);           /* Flawfinder: ignore */
        gDirUtilp->deleteFilesInDir(gDirUtilp->getExpandedFilename(LL_PATH_CACHE, "").c_str(), mask);
}




void finish_early_exit(S32 option, void* userdata)
{
        app_force_quit(NULL);
}

void app_early_exit(const LLString& mesg)
{
        llwarns << "app_early_exit: " << mesg << llendl;
        gDoDisconnect = TRUE;
//      LLStringBase<char>::format_map_t args;
//      args["[MESSAGE]"] = mesg;
//      gViewerWindow->alertXml("AppEarlyExit", args, finish_early_exit);
        LLAlertDialog::showCritical(mesg, finish_early_exit, NULL);
}

// Used for drones, etc
void app_force_exit(S32 arg)
{
        remove_marker_file();
        exit(arg);
}

// Callback from a dialog indicating user was logged out.  
void finish_disconnect(S32 option, void* userdata)
{
        if (1 == option)
        {
                app_force_quit(NULL);
        }
}

// Callback from an early disconnect dialog, force an exit
void finish_forced_disconnect(S32 /* option */, void* /* userdata */)
{
        app_force_quit(NULL);
}

void send_logout_request()
{
        if(!gLogoutRequestSent)
        {
                LLMessageSystem* msg = gMessageSystem;
                msg->newMessageFast(_PREHASH_LogoutRequest);
                msg->nextBlockFast(_PREHASH_AgentData);
                msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
                msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
                gAgent.sendReliableMessage();

                gLogoutTimer.reset();
                gLogoutMaxTime = LOGOUT_REQUEST_TIME;
                gLogoutRequestSent = TRUE;
                
                gVoiceClient->leaveChannel();
        }
}

void do_disconnect(const LLString& mesg)
{
        if (gDoDisconnect)
    {
                // Already popped up one of these dialogs, don't
                // do this again.
                return;
    }

        // Translate the message if possible
        LLString big_reason = LLAgent::sTeleportErrorMessages[mesg];
        if ( big_reason.size() == 0 )
        {
                big_reason = mesg;
        }

        LLStringBase<char>::format_map_t args;
        gDoDisconnect = TRUE;

        if (LLStartUp::getStartupState() < STATE_STARTED)
        {
                // Tell users what happened
                args["[ERROR_MESSAGE]"] = big_reason;
                gViewerWindow->alertXml("ErrorMessage", args, finish_forced_disconnect);
        }
        else
        {
                args["[MESSAGE]"] = big_reason;
                gViewerWindow->alertXml("YouHaveBeenLoggedOut", args, finish_disconnect );
        }
}

const LLUUID& agent_get_id()
{
        return gAgent.getID();
}

const LLUUID& agent_get_session_id()
{
        return gAgent.getSessionID();
}

void agent_send_reliable_message()
{
        gAgent.sendReliableMessage();
}

void bad_network_handler()
{
        // Dump the packet
        gMessageSystem->dumpPacketToLog();

        // Flush all of our caches on exit in the case of disconnect due to
        // invalid packets.

        gPurgeOnExit = TRUE;

#if LL_WINDOWS
        LLWinDebug::handleException(NULL);
#else
        // Call the crash callback
        if (gCrashCallback)
        {
                gCrashCallback();
        }
#endif

        std::ostringstream message;
        message <<
                "The viewer has detected mangled network data indicative\n"
                "of a bad upstream network connection or an incomplete\n"
                "local installation of " << gSecondLife << ". \n"
                " \n"
                "Try uninstalling and reinstalling to see if this resolves \n"
                "the issue. \n"
                " \n"
                "If the problem continues, see the Tech Support FAQ at: \n"
                "www.secondlife.com/support";
        do_disconnect(message.str());
}


// dump current avatar to .cal file
void save_avatar(void*)
{
        LLFloaterSaveAvatar::show();
}

void cleanup_app()
{
        //flag all elements as needing to be destroyed immediately
        // to ensure shutdown order
        LLMortician::setZealous(TRUE);

        LLVoiceClient::terminate();
        
        disconnect_viewer(NULL);

        llinfos << "Viewer disconnected" << llendflush;

        gDisconnectedImagep = NULL;
        release_start_screen(); // just in case

        LLError::logToFixedBuffer(NULL);

        llinfos << "Cleaning Up" << llendflush;

        LLKeyframeDataCache::clear();
        
        // Must clean up texture references before viewer window is destroyed.
        LLHUDObject::cleanupHUDObjects();
        llinfos << "HUD Objects cleaned up" << llendflush;

        // End TransferManager before deleting systems it depends on (Audio, VFS, AssetStorage)
#if 0 // this seems to get us stuck in an infinite loop...
        gTransferManager.cleanup();
#endif
        
        // Clean up map data storage
        delete gWorldMap;
        gWorldMap = NULL;

        delete gHUDManager;
        gHUDManager = NULL;

        delete gToolMgr;
        gToolMgr = NULL;

        delete gAssetStorage;
        gAssetStorage = NULL;

        LLPolyMesh::freeAllMeshes();

        delete gCacheName;
        gCacheName = NULL;

        delete gGlobalEconomy;
        gGlobalEconomy = NULL;

        delete gLocalSpeakerMgr;
        gLocalSpeakerMgr = NULL;

        LLNotifyBox::cleanup();

        llinfos << "Global stuff deleted" << llendflush;

#if !LL_RELEASE_FOR_DOWNLOAD
        if (gAudiop)
        {
                gAudiop->shutdown();
        }
#else
        // This hack exists because fmod likes to occasionally hang forever
        // when shutting down for no apparent reason.
        llwarns << "Hack, skipping audio engine cleanup" << llendflush;
#endif


        // moved to main application shutdown for now because it's non-trivial and only needs to be done once
        // (even though it goes against the media framework design)

        LLMediaEngine::cleanupClass();
        
#if LL_QUICKTIME_ENABLED
        if (gQuickTimeInitialized)
        {
                // clean up media stuff
                llinfos << "Cleaning up QuickTime" << llendl;
                ExitMovies ();
                #if LL_WINDOWS
                        // Only necessary/available on Windows.
                        TerminateQTML ();
                #endif
        }
        llinfos << "Quicktime cleaned up" << llendflush;
#endif

#if LL_GSTREAMER_ENABLED
        llinfos << "Cleaning up GStreamer" << llendl;
        UnloadGStreamer();
        llinfos << "GStreamer cleaned up" << llendflush;        
#endif

        llinfos << "Cleaning up feature manager" << llendflush;
        delete gFeatureManagerp;
        gFeatureManagerp = NULL;

        // Patch up settings for next time
        // Must do this before we delete the viewer window,
        // such that we can suck rectangle information out of
        // it.
        cleanup_saved_settings();
        llinfos << "Settings patched up" << llendflush;

        delete gAudiop;
        gAudiop = NULL;

        // delete some of the files left around in the cache.
        remove_cache_files("*.wav");
        remove_cache_files("*.tmp");
        remove_cache_files("*.lso");
        remove_cache_files("*.out");
        remove_cache_files("*.dsf");
        remove_cache_files("*.bodypart");
        remove_cache_files("*.clothing");

        llinfos << "Cache files removed" << llendflush;


        cleanup_menus();

        // Wait for any pending VFS IO
        while (1)
        {
                S32 pending = LLVFSThread::updateClass(0);
                pending += LLLFSThread::updateClass(0);
                if (!pending)
                {
                        break;
                }
                llinfos << "Waiting for pending IO to finish: " << pending << llendflush;
                ms_sleep(100);
        }
        llinfos << "Shutting down." << llendflush;
        
        // Destroy Windows(R) window, and make sure we're not fullscreen
        // This may generate window reshape and activation events.
        // Therefore must do this before destroying the message system.
        delete gViewerWindow;
        gViewerWindow = NULL;
        llinfos << "ViewerWindow deleted" << llendflush;

        // viewer UI relies on keyboard so keep it aound until viewer UI isa gone
        delete gKeyboard;
        gKeyboard = NULL;

        // Clean up selection managers after UI is destroyed, as UI
        // may be observing them.
        LLSelectMgr::cleanupGlobals();

        LLViewerObject::cleanupVOClasses();
                
        LLTracker::cleanupInstance();
        
#if LL_LIBXUL_ENABLED
        // this must be done after floater cleanup (delete gViewerWindow) since 
        // floaters  potentially need the manager to destroy their contents.
        LLMozLib::getInstance()->reset();
#endif

#if LL_WINDOWS
        gDXHardware.cleanup();
#endif // LL_WINDOWS

#if LL_WINDOWS && LL_LCD_COMPILE
        // shut down the LCD window on a logitech keyboard, if there is one
        delete gLcdScreen;
#endif

        if (!gVolumeMgr->cleanup())
        {
                llwarns << "Remaining references in the volume manager!" << llendflush;
        }

        LLViewerParcelMgr::cleanupGlobals();

        delete gViewerStats;
        gViewerStats = NULL;

        end_messaging_system();

        LLFollowCamMgr::cleanupClass();
        LLVolumeMgr::cleanupClass();
        LLWorldMapView::cleanupClass();
        LLUI::cleanupClass();
        
        //
        // Shut down the VFS's AFTER the decode manager cleans up (since it cleans up vfiles).
        // Also after viewerwindow is deleted, since it may have image pointers (which have vfiles)
        // Also after shutting down the messaging system since it has VFS dependencies
        //
        LLVFile::cleanupClass();
        llinfos << "VFS cleaned up" << llendflush;

        // Store the time of our current logoff
        gSavedPerAccountSettings.setU32("LastLogoff", time_corrected());

        // Must do this after all panels have been deleted because panels that have persistent rects
        // save their rects on delete.
        gSavedSettings.saveToFile(gSettingsFileName, TRUE);
        if (!gPerAccountSettingsFileName.empty())
        {
                gSavedPerAccountSettings.saveToFile(gPerAccountSettingsFileName, TRUE);
        }
        llinfos << "Saved settings" << llendflush;

        std::string crash_settings_filename = gDirUtilp->getExpandedFilename(LL_PATH_USER_SETTINGS, CRASH_SETTINGS_FILE);
        // save all settings, even if equals defaults
        gCrashSettings.saveToFile(crash_settings_filename.c_str(), FALSE);

        delete gUICtrlFactory;
        gUICtrlFactory = NULL;

        gSavedSettings.cleanup();
        gViewerArt.cleanup();
        gColors.cleanup();
        gCrashSettings.cleanup();

        if (gMuteListp)
        {
                // save mute list
                gMuteListp->cache(gAgent.getID());

                delete gMuteListp;
                gMuteListp = NULL;
        }

        if (gPurgeOnExit)
        {
                llinfos << "Purging all cache files on exit" << llendflush;
                char mask[LL_MAX_PATH];         /* Flawfinder: ignore */
                snprintf(mask, LL_MAX_PATH, "%s*.*", gDirUtilp->getDirDelimiter().c_str());             /* Flawfinder: ignore */
                gDirUtilp->deleteFilesInDir(gDirUtilp->getExpandedFilename(LL_PATH_CACHE,"").c_str(),mask);
        }

        remove_marker_file(); // Any crashes from here on we'll just have to ignore
        
        close_debug();

        // Let threads finish
        LLTimer idleTimer;
        idleTimer.reset();
        const F64 max_idle_time = 5.f; // 5 seconds
        while(1)
        {
                S32 pending = 0;
                pending += gTextureCache->update(1); // unpauses the worker thread
                pending += gImageDecodeThread->update(1); // unpauses the image thread
                pending += gTextureFetch->update(1); // unpauses the texture fetch thread
                pending += LLVFSThread::updateClass(0);
                pending += LLLFSThread::updateClass(0);
                F64 idle_time = idleTimer.getElapsedTimeF64();
                if (!pending || idle_time >= max_idle_time)
                {
                        llwarns << "Quitting with pending background tasks." << llendl;
                        break;
                }
        }
        
        // Delete workers first
        // shotdown all worker threads before deleting them in case of co-dependencies
        gTextureCache->shutdown();
        gTextureFetch->shutdown();
        gImageDecodeThread->shutdown();
        delete gTextureCache;
        delete gTextureFetch;
        delete gImageDecodeThread;

        gImageList.shutdown(); // shutdown again in case a callback added something
        
        // This should eventually be done in LLAppViewer
        LLImageJ2C::closeDSO();
        LLImageFormatted::cleanupClass();
        LLVFSThread::cleanupClass();
        LLLFSThread::cleanupClass();

        llinfos << "VFS Thread finished" << llendflush;

#ifndef LL_RELEASE_FOR_DOWNLOAD
        llinfos << "Auditing VFS" << llendl;
        gVFS->audit();
#endif

        // For safety, the LLVFS has to be deleted *after* LLVFSThread. This should be cleaned up.
        // (LLVFS doesn't know about LLVFSThread so can't kill pending requests) -Steve
        delete gStaticVFS;
        gStaticVFS = NULL;
        delete gVFS;
        gVFS = NULL;
        
        LLCurl::cleanup();

        // This will eventually be done in LLApp
        LLCommon::cleanupClass();

        end_messaging_system();
}

// Clear URIs when picking a new server
void resetURIs()
{
        gLoginURIs.clear();
        gHelperURI.clear();
}

const std::vector<std::string>& getLoginURIs()
{
        if (gLoginURIs.empty())
        {
                // not specified on the command line, use value from table
                gLoginURIs = LLSRV::rewriteURI(gUserServerDomainName[gUserServerChoice].mLoginURI);
        }
        return gLoginURIs;
}

const std::string& getHelperURI()
{
        if (gHelperURI.empty())
        {
                // not specified on the command line, use value from table
                gHelperURI = gUserServerDomainName[gUserServerChoice].mHelperURI;
        }
        return gHelperURI;
}

void errorCallback(const std::string &error_string)
{
#ifndef LL_RELEASE_FOR_DOWNLOAD
        OSMessageBox(error_string.c_str(), "Fatal Error", OSMB_OK);
#endif
        LLError::crashAndLoop(error_string);
}
// JC - Please don't put code here.  Find the right file, perhaps
// llviewermessage.cpp, and put it there.  Thanks!

---