path: root/indra/newview/llsyntaxid.cpp

/**
 * @file LLSyntaxId
 * @brief Handles downloading, saving, and checking of LSL keyword/syntax files
 *      for each region.
 * @author Ima Mechanique, Cinder Roxley
 *
 * $LicenseInfo:firstyear=2013&license=viewerlgpl$
 * Second Life Viewer Source Code
 * Copyright (C) 2013, 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 "llviewerprecompiledheaders.h"

#include "llsyntaxid.h"
#include "llagent.h"
#include "llappviewer.h"
#include "llsdserialize.h"
#include "llviewerregion.h"
#include "llcorehttputil.h"

//-----------------------------------------------------------------------------
// LLSyntaxIdLSL
//-----------------------------------------------------------------------------
const std::string SYNTAX_ID_CAPABILITY_NAME = "LSLSyntax";
const std::string SYNTAX_ID_SIMULATOR_FEATURE = "LSLSyntaxId";
const std::string FILENAME_DEFAULT = "keywords_lsl_default.xml";

/**
 * @brief LLSyntaxIdLSL constructor
 */
LLSyntaxIdLSL::LLSyntaxIdLSL()
:   mKeywordsXml(LLSD())
,   mCapabilityURL(std::string())
,   mFilePath(LL_PATH_APP_SETTINGS)
,   mSyntaxId(LLUUID())
,   mInitialized(false)
{
    loadDefaultKeywordsIntoLLSD();
    mRegionChangedCallback = gAgent.addRegionChangedCallback(boost::bind(&LLSyntaxIdLSL::handleRegionChanged, this));
    handleRegionChanged(); // Kick off an initial caps query and fetch
}

void LLSyntaxIdLSL::buildFullFileSpec()
{
    ELLPath path = mSyntaxId.isNull() ? LL_PATH_APP_SETTINGS : LL_PATH_CACHE;
    const std::string filename = mSyntaxId.isNull() ? FILENAME_DEFAULT : "keywords_lsl_" + mSyntaxId.asString() + ".llsd.xml";
    mFullFileSpec = gDirUtilp->getExpandedFilename(path, filename);
}

//-----------------------------------------------------------------------------
// syntaxIdChange()
//-----------------------------------------------------------------------------
bool LLSyntaxIdLSL::syntaxIdChanged()
{
    LLViewerRegion* region = gAgent.getRegion();

    if (region)
    {
        if (region->capabilitiesReceived())
        {
            LLSD sim_features;
            region->getSimulatorFeatures(sim_features);

            if (sim_features.has(SYNTAX_ID_SIMULATOR_FEATURE))
            {
                // get and check the hash
                LLUUID new_syntax_id = sim_features[SYNTAX_ID_SIMULATOR_FEATURE].asUUID();
                mCapabilityURL = region->getCapability(SYNTAX_ID_CAPABILITY_NAME);
                LL_DEBUGS("SyntaxLSL") << SYNTAX_ID_SIMULATOR_FEATURE << " capability URL: " << mCapabilityURL << LL_ENDL;
                if (new_syntax_id != mSyntaxId)
                {
                    LL_DEBUGS("SyntaxLSL") << "New SyntaxID '" << new_syntax_id << "' found." << LL_ENDL;
                    mSyntaxId = new_syntax_id;
                    return true;
                }
                else
                    LL_DEBUGS("SyntaxLSL") << "SyntaxID matches what we have." << LL_ENDL;
            }
        }
        else
        {
            region->setCapabilitiesReceivedCallback(boost::bind(&LLSyntaxIdLSL::handleCapsReceived, this, _1));
            LL_DEBUGS("SyntaxLSL") << "Region has not received capabilities. Waiting for caps..." << LL_ENDL;
        }
    }
    return false;
}

//-----------------------------------------------------------------------------
// fetchKeywordsFile
//-----------------------------------------------------------------------------
void LLSyntaxIdLSL::fetchKeywordsFile(const std::string& filespec)
{
    LLCoros::instance().launch("LLSyntaxIdLSL::fetchKeywordsFileCoro",
        boost::bind(&LLSyntaxIdLSL::fetchKeywordsFileCoro, this, mCapabilityURL, filespec));
    LL_DEBUGS("SyntaxLSL") << "LSLSyntaxId capability URL is: " << mCapabilityURL << ". Filename to use is: '" << filespec << "'." << LL_ENDL;
}

//-----------------------------------------------------------------------------
// fetchKeywordsFileCoro
//-----------------------------------------------------------------------------
void LLSyntaxIdLSL::fetchKeywordsFileCoro(std::string url, std::string fileSpec)
{
    LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
    LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
        httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("genericPostCoro", httpPolicy));
    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);

    std::pair<std::set<std::string>::iterator, bool> insrt = mInflightFetches.insert(fileSpec);
    if (!insrt.second)
    {
        LL_WARNS("SyntaxLSL") << "Already downloading keyword file called \"" << fileSpec << "\"." << LL_ENDL;
        return;
    }

    LLSD result = httpAdapter->getAndSuspend(httpRequest, url);

    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);

    mInflightFetches.erase(fileSpec);

    if (!status)
    {
        LL_WARNS("SyntaxLSL") << "Failed to fetch syntax file \"" << fileSpec << "\"" << LL_ENDL;
        return;
    }

    result.erase(LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS);

    if (isSupportedVersion(result))
    {
        setKeywordsXml(result);
        cacheFile(fileSpec, result);
        loadKeywordsIntoLLSD();
    }
    else
    {
        LL_WARNS("SyntaxLSL") << "Unknown or unsupported version of syntax file." << LL_ENDL;
    }

}

//-----------------------------------------------------------------------------
// cacheFile
//-----------------------------------------------------------------------------
void LLSyntaxIdLSL::cacheFile(const std::string &fileSpec, const LLSD& content_ref)
{
    std::stringstream str;
    LLSDSerialize::toXML(content_ref, str);
    const std::string xml = str.str();

    // save the str to disk, usually to the cache.
    llofstream file(fileSpec.c_str(), std::ios_base::out);
    file.write(xml.c_str(), str.str().size());
    file.close();

    LL_DEBUGS("SyntaxLSL") << "Syntax file received, saving as: '" << fileSpec << "'" << LL_ENDL;
}

//-----------------------------------------------------------------------------
// initialize
//-----------------------------------------------------------------------------
void LLSyntaxIdLSL::initialize()
{
    if(mInitialized) return;
    if (mSyntaxId.isNull())
    {
        loadDefaultKeywordsIntoLLSD();
    }
    else if (!mCapabilityURL.empty())
    {
        LL_DEBUGS("SyntaxLSL") << "LSL version has changed, getting appropriate file." << LL_ENDL;

        // Need a full spec regardless of file source, so build it now.
        buildFullFileSpec();
        if (mSyntaxId.notNull())
        {
            if (!gDirUtilp->fileExists(mFullFileSpec))
            { // Does not exist, so fetch it from the capability
                LL_DEBUGS("SyntaxLSL") << "LSL syntax not cached, attempting download." << LL_ENDL;
                fetchKeywordsFile(mFullFileSpec);
            }
            else
            {
                LL_DEBUGS("SyntaxLSL") << "Found cached Syntax file: " << mFullFileSpec << " Loading keywords." << LL_ENDL;
                loadKeywordsIntoLLSD();
            }
        }
        else
        {
            LL_DEBUGS("SyntaxLSL") << "LSLSyntaxId is null. Loading default values" << LL_ENDL;
            loadDefaultKeywordsIntoLLSD();
        }
    }
    else
    {
        LL_DEBUGS("SyntaxLSL") << "LSLSyntaxId capability URL is empty." << LL_ENDL;
        loadDefaultKeywordsIntoLLSD();
    }
    mInitialized = true;
}

//-----------------------------------------------------------------------------
// isSupportedVersion
//-----------------------------------------------------------------------------
const U32         LLSD_SYNTAX_LSL_VERSION_EXPECTED = 2;
const std::string LLSD_SYNTAX_LSL_VERSION_KEY("llsd-lsl-syntax-version");

bool LLSyntaxIdLSL::isSupportedVersion(const LLSD& content)
{
    bool is_valid = false;
    /*
     * If the schema used to store LSL keywords and hints changes, this value is incremented
     * Note that it should _not_ be changed if the keywords and hints _content_ changes.
     */

    if (content.has(LLSD_SYNTAX_LSL_VERSION_KEY))
    {
        LL_DEBUGS("SyntaxLSL") << "LSL syntax version: " << content[LLSD_SYNTAX_LSL_VERSION_KEY].asString() << LL_ENDL;

        if (content[LLSD_SYNTAX_LSL_VERSION_KEY].asInteger() == LLSD_SYNTAX_LSL_VERSION_EXPECTED)
        {
            is_valid = true;
        }
    }
    else
    {
        LL_DEBUGS("SyntaxLSL") << "Missing LSL syntax version key." << LL_ENDL;
    }

    return is_valid;
}

//-----------------------------------------------------------------------------
// loadDefaultKeywordsIntoLLSD()
//-----------------------------------------------------------------------------
void LLSyntaxIdLSL::loadDefaultKeywordsIntoLLSD()
{
    mSyntaxId.setNull();
    buildFullFileSpec();
    loadKeywordsIntoLLSD();
}

//-----------------------------------------------------------------------------
// loadKeywordsFileIntoLLSD
//-----------------------------------------------------------------------------
/**
 * @brief   Load xml serialized LLSD
 * @desc    Opens the specified filespec and attempts to deserializes the
 *          contained data to the specified LLSD object. indicate success/failure with
 *          sLoaded/sLoadFailed members.
 */
void LLSyntaxIdLSL::loadKeywordsIntoLLSD()
{
    LLSD content;
    llifstream file;
    file.open(mFullFileSpec.c_str());
    if (file.is_open())
    {
        if (LLSDSerialize::fromXML(content, file) != LLSDParser::PARSE_FAILURE)
        {
            if (isSupportedVersion(content))
            {
                LL_DEBUGS("SyntaxLSL") << "Deserialized: " << mFullFileSpec << LL_ENDL;
            }
            else
            {
                LL_WARNS("SyntaxLSL") << "Unknown or unsupported version of syntax file." << LL_ENDL;
            }
        }
    }
    else
    {
        LL_WARNS("SyntaxLSL") << "Failed to open: " << mFullFileSpec << LL_ENDL;
    }
    mKeywordsXml = content;
    mSyntaxIDChangedSignal();
}

bool LLSyntaxIdLSL::keywordFetchInProgress()
{
    return !mInflightFetches.empty();
}

void LLSyntaxIdLSL::handleRegionChanged()
{
    if (syntaxIdChanged())
    {
        buildFullFileSpec();
        fetchKeywordsFile(mFullFileSpec);
        mInitialized = false;
    }
}

void LLSyntaxIdLSL::handleCapsReceived(const LLUUID& region_uuid)
{
    LLViewerRegion* current_region = gAgent.getRegion();

    if (region_uuid.notNull()
        && current_region->getRegionID() == region_uuid)
    {
        syntaxIdChanged();
    }
}

boost::signals2::connection LLSyntaxIdLSL::addSyntaxIDCallback(const syntax_id_changed_signal_t::slot_type& cb)
{
    return mSyntaxIDChangedSignal.connect(cb);
}