phoenix-firestorm/indra/llcrashlogger/llcrashlock.cpp

/**
 * @file llformat.cpp
 * @date   January 2007
 * @brief string formatting utility
 *
 * $LicenseInfo:firstyear=2007&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2010, Linden Research, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation;
 * version 2.1 of the License only.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
 * $/LicenseInfo$
 */

#include "linden_common.h"

#include "llapr.h" // thread-related functions
#include "llcrashlock.h"
#include "lldir.h"
#include "llsd.h"
#include "llsdserialize.h"
#include "llframetimer.h"
#include <boost/filesystem.hpp>
#include <string>
#include <iostream>
#include <stdio.h>


#if LL_WINDOWS   //For windows platform.
#include <llwin32headers.h>
#include <TlHelp32.h>

bool LLCrashLock::isProcessAlive(U32 pid, const std::string& pname)
{
    std::wstring wpname;
    wpname = std::wstring(pname.begin(), pname.end());

    HANDLE snapshot;
    PROCESSENTRY32 pe32;

    bool matched = false;

    snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (snapshot == INVALID_HANDLE_VALUE)
    {
        return false;
    }
    else
    {
        pe32.dwSize = sizeof(PROCESSENTRY32);
        if (Process32First(snapshot, &pe32))
        {
            do {
                std::wstring wexecname = pe32.szExeFile;
                std::string execname = std::string(wexecname.begin(), wexecname.end());
                if (!wpname.compare(pe32.szExeFile))
                {
                    if (pid == (U32)pe32.th32ProcessID)
                    {
                        matched = true;
                        break;
                    }
                }
            } while (Process32Next(snapshot, &pe32));
        }
    }

    CloseHandle(snapshot);
    return matched;
}

#else   //Everyone Else
bool LLCrashLock::isProcessAlive(U32 pid, const std::string& pname)
{
    //Will boost.process ever become a reality?
    std::stringstream cmd;

    cmd << "pgrep '" << pname << "' | grep '^" << pid << "$'";
    return (!system(cmd.str().c_str()));
}
#endif //Everyone else.


LLCrashLock::LLCrashLock() : mCleanUp(true), mWaitingPID(0)
{
}

void LLCrashLock::setCleanUp(bool cleanup)
{
    mCleanUp = cleanup;  //Allow cleanup to be disabled for debugging.
}

LLSD LLCrashLock::getLockFile(std::string filename)
{
    LLSD lock_sd = LLSD::emptyMap();

    llifstream ifile(filename.c_str());

    if (ifile.is_open())
    {
        LLSDSerialize::fromXML(lock_sd, ifile);
        ifile.close();
    }

    return lock_sd;
}

bool LLCrashLock::putLockFile(std::string filename, const LLSD& data)
{
    bool result = true;
    llofstream ofile(filename.c_str());

    if (!LLSDSerialize::toXML(data,ofile))
    {
        result=false;
    }
    ofile.close();
    return result;
}

bool LLCrashLock::requestMaster( F32 timeout )
{
    if (mMaster.empty())
    {
            mMaster = gDirUtilp->getExpandedFilename(LL_PATH_LOGS,
                                            "crash_master.lock");
    }

    LLSD lock_sd=getLockFile(mMaster);

    if (lock_sd.has("pid"))
    {
        mWaitingPID = lock_sd["pid"].asInteger();
        if ( isProcessAlive(mWaitingPID, gDirUtilp->getExecutableFilename()) )
        {
            mTimer.resetWithExpiry(timeout);
            return false;
        }
    }

    U32 pid = getpid();
    lock_sd["pid"] = (LLSD::Integer)pid;
    return putLockFile(mMaster,lock_sd);
}

bool LLCrashLock::checkMaster()
{
    if (mWaitingPID)
    {
        return (!isProcessAlive(mWaitingPID, gDirUtilp->getExecutableFilename()));
    }
    return  false;
}

bool LLCrashLock::isWaiting()
{
    return !mTimer.hasExpired();
}

void LLCrashLock::releaseMaster()
{
    //Yeeeeeeehaw
    unlink(mMaster.c_str());
}

LLSD LLCrashLock::getProcessList()
{
    if (mDumpTable.empty())
    {
        mDumpTable= gDirUtilp->getExpandedFilename(LL_PATH_LOGS,
                                                "crash_table.lock");
    }
   return getLockFile(mDumpTable);
}

//static
bool LLCrashLock::fileExists(std::string filename)
{
#ifdef LL_WINDOWS // or BOOST_WINDOWS_API
    boost::filesystem::path file_path(utf8str_to_utf16str(filename));
#else
    boost::filesystem::path file_path(filename);
#endif
    return boost::filesystem::exists(file_path);
}

void LLCrashLock::cleanupProcess(std::string proc_dir)
{
#ifdef LL_WINDOWS // or BOOST_WINDOWS_API
    boost::filesystem::path dir_path(utf8str_to_utf16str(proc_dir));
#else
    boost::filesystem::path dir_path(proc_dir);
#endif
    boost::filesystem::remove_all(dir_path);
}

bool LLCrashLock::putProcessList(const LLSD& proc_sd)
{
    return putLockFile(mDumpTable,proc_sd);
}