path: root/indra/newview/llfloaterabout.cpp

/**
 * @file llfloaterabout.cpp
 * @author James Cook
 * @brief The about box from Help->About
 *
 * $LicenseInfo:firstyear=2001&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 "llviewerprecompiledheaders.h"
#include <iostream>
#include <fstream>

#include "llfloaterabout.h"

// Viewer includes
#include "llagent.h"
#include "llagentui.h"
#include "llappviewer.h"
#include "llnotificationsutil.h"
#include "llslurl.h"
#include "llvoiceclient.h"
#include "lluictrlfactory.h"
#include "llviewertexteditor.h"
#include "llviewercontrol.h"
#include "llviewerstats.h"
#include "llviewerregion.h"
#include "llversioninfo.h"
#include "llweb.h"

// Linden library includes
#include "llaudioengine.h"
#include "llbutton.h"
#include "llglheaders.h"
#include "llfloater.h"
#include "llfloaterreg.h"
#include "llimagej2c.h"
#include "llsys.h"
#include "lltrans.h"
#include "lluri.h"
#include "v3dmath.h"
#include "llwindow.h"
#include "stringize.h"
#include "llsdutil_math.h"
#include "lleventapi.h"
#include "llcorehttputil.h"
#include "lldir.h"

#if LL_WINDOWS
#include "lldxhardware.h"
#endif

extern LLMemoryInfo gSysMemory;
extern U32 gPacketsIn;

///----------------------------------------------------------------------------
/// Class LLFloaterAbout
///----------------------------------------------------------------------------
class LLFloaterAbout
    : public LLFloater
{
    friend class LLFloaterReg;
private:
    LLFloaterAbout(const LLSD& key);
    virtual ~LLFloaterAbout();

public:
    bool postBuild() override;

    /// Obtain the data used to fill out the contents string. This is
    /// separated so that we can programmatically access the same info.
    static LLSD getInfo();
    void onClickCopyToClipboard();
    void onClickUpdateCheck();
    static void setUpdateListener();

private:
    void setSupportText(const std::string& server_release_notes_url);

    // notifications for user requested checks
    static void showCheckUpdateNotification(S32 state);

    // callback method for manual checks
    static bool callbackCheckUpdate(LLSD const & event);

    // listener name for update checks
    static const std::string sCheckUpdateListenerName;

    static void startFetchServerReleaseNotes();
    static void fetchServerReleaseNotesCoro(const std::string& cap_url);
    static void handleServerReleaseNotes(LLSD results);
};


// Default constructor
LLFloaterAbout::LLFloaterAbout(const LLSD& key)
:   LLFloater(key)
{

}

// Destroys the object
LLFloaterAbout::~LLFloaterAbout()
{
}

bool LLFloaterAbout::postBuild()
{
    center();
    LLViewerTextEditor *support_widget =
        getChild<LLViewerTextEditor>("support_editor", true);

    LLViewerTextEditor *contrib_names_widget =
        getChild<LLViewerTextEditor>("contrib_names", true);

    LLViewerTextEditor *licenses_widget =
        getChild<LLViewerTextEditor>("licenses_editor", true);

    getChild<LLUICtrl>("copy_btn")->setCommitCallback(
        boost::bind(&LLFloaterAbout::onClickCopyToClipboard, this));

    getChild<LLUICtrl>("update_btn")->setCommitCallback(
        boost::bind(&LLFloaterAbout::onClickUpdateCheck, this));

    static const LLUIColor about_color = LLUIColorTable::instance().getColor("TextFgReadOnlyColor");

    if (gAgent.getRegion())
    {
        // start fetching server release notes URL
        setSupportText(LLTrans::getString("RetrievingData"));
        startFetchServerReleaseNotes();
    }
    else // not logged in
    {
        LL_DEBUGS("ViewerInfo") << "cannot display region info when not connected" << LL_ENDL;
        setSupportText(LLTrans::getString("NotConnected"));
    }

    support_widget->blockUndo();

    // Fix views
    support_widget->setEnabled(false);
    support_widget->startOfDoc();

    // Get the names of contributors, extracted from .../doc/contributions.txt by viewer_manifest.py at build time
    std::string contributors_path = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"contributors.txt");
    llifstream contrib_file;
    std::string contributors;
    contrib_file.open(contributors_path.c_str());       /* Flawfinder: ignore */
    if (contrib_file.is_open())
    {
        std::getline(contrib_file, contributors); // all names are on a single line
        contrib_file.close();
    }
    else
    {
        LL_WARNS("AboutInit") << "Could not read contributors file at " << contributors_path << LL_ENDL;
    }
    contrib_names_widget->setText(contributors);
    contrib_names_widget->setEnabled(false);
    contrib_names_widget->startOfDoc();

    // Get the Versions and Copyrights, created at build time
    std::string licenses_path = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"packages-info.txt");
    llifstream licenses_file;
    licenses_file.open(licenses_path.c_str());      /* Flawfinder: ignore */
    if (licenses_file.is_open())
    {
        std::string license_line;
        licenses_widget->clear();
        while ( std::getline(licenses_file, license_line) )
        {
            licenses_widget->appendText(license_line+"\n", false,
                                        LLStyle::Params() .color(about_color));
        }
        licenses_file.close();
    }
    else
    {
        // this case will use the (out of date) hard coded value from the XUI
        LL_INFOS("AboutInit") << "Could not read licenses file at " << licenses_path << LL_ENDL;
    }
    licenses_widget->setEnabled(false);
    licenses_widget->startOfDoc();

    return true;
}

LLSD LLFloaterAbout::getInfo()
{
    return LLAppViewer::instance()->getViewerInfo();
}

/*static*/
void LLFloaterAbout::startFetchServerReleaseNotes()
{
    LLViewerRegion* region = gAgent.getRegion();
    if (!region) return;

    // We cannot display the URL returned by the ServerReleaseNotes capability
    // because opening it in an external browser will trigger a warning about untrusted
    // SSL certificate.
    // So we query the URL ourselves, expecting to find
    // an URL suitable for external browsers in the "Location:" HTTP header.
    std::string cap_url = region->getCapability("ServerReleaseNotes");

    LLCoros::instance().launch("fetchServerReleaseNotesCoro", boost::bind(&LLFloaterAbout::fetchServerReleaseNotesCoro, cap_url));

}

/*static*/
void LLFloaterAbout::fetchServerReleaseNotesCoro(const std::string& cap_url)
{
    LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
        httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("fetchServerReleaseNotesCoro", LLCore::HttpRequest::DEFAULT_POLICY_ID));
    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);

    httpOpts->setWantHeaders(true);
    httpOpts->setFollowRedirects(false);
    httpOpts->setSSLVerifyPeer(false); // We want this data even if SSL verification fails

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

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

    if (!status)
    {
        handleServerReleaseNotes(httpResults);
    }
    else
    {
        handleServerReleaseNotes(result);
    }
}

/*static*/
void LLFloaterAbout::handleServerReleaseNotes(LLSD results)
{
    LLSD http_headers;
    if (results.has(LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS))
    {
        LLSD http_results = results[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
        http_headers = http_results[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS_HEADERS];
    }
    else
    {
        http_headers = results[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS_HEADERS];
    }

    std::string location = http_headers[HTTP_IN_HEADER_LOCATION].asString();
    if (location.empty())
    {
        location = LLTrans::getString("ErrorFetchingServerReleaseNotesURL");
    }
    LLAppViewer::instance()->setServerReleaseNotesURL(location);

    LLFloaterAbout* floater_about = LLFloaterReg::findTypedInstance<LLFloaterAbout>("sl_about");
    if (floater_about)
    {
        floater_about->setSupportText(location);
    }
}

class LLFloaterAboutListener: public LLEventAPI
{
public:
    LLFloaterAboutListener():
        LLEventAPI("LLFloaterAbout",
                   "LLFloaterAbout listener to retrieve About box info")
    {
        add("getInfo",
            "Request an LLSD::Map containing information used to populate About box",
            &LLFloaterAboutListener::getInfo,
            LLSD().with("reply", LLSD()));
    }

private:
    void getInfo(const LLSD& request) const
    {
        LLReqID reqid(request);
        LLSD reply(LLFloaterAbout::getInfo());
        reqid.stamp(reply);
        LLEventPumps::instance().obtain(request["reply"]).post(reply);
    }
};

static LLFloaterAboutListener floaterAboutListener;

void LLFloaterAbout::onClickCopyToClipboard()
{
    LLViewerTextEditor *support_widget =
        getChild<LLViewerTextEditor>("support_editor", true);
    support_widget->selectAll();
    support_widget->copy();
    support_widget->deselect();
}

void LLFloaterAbout::onClickUpdateCheck()
{
    setUpdateListener();
}

void LLFloaterAbout::setSupportText(const std::string& server_release_notes_url)
{
#if LL_WINDOWS
    getWindow()->incBusyCount();
    getWindow()->setCursor(UI_CURSOR_ARROW);
#endif
#if LL_WINDOWS
    getWindow()->decBusyCount();
    getWindow()->setCursor(UI_CURSOR_ARROW);
#endif

    LLViewerTextEditor *support_widget =
        getChild<LLViewerTextEditor>("support_editor", true);

    LLUIColor about_color = LLUIColorTable::instance().getColor("TextFgReadOnlyColor");
    support_widget->clear();
    support_widget->appendText(LLAppViewer::instance()->getViewerInfoString(),
                               false, LLStyle::Params() .color(about_color));
}

//This is bound as a callback in postBuild()
void LLFloaterAbout::setUpdateListener()
{
    typedef std::vector<std::string> vec;

    //There are four possibilities:
    //no downloads directory or version directory in "getOSUserAppDir()/downloads"
    //   => no update
    //version directory exists and .done file is not present
    //   => download in progress
    //version directory exists and .done file exists
    //   => update ready for install
    //version directory, .done file and either .skip or .next file exists
    //   => update deferred
    bool downloads = false;
    std::string downloadDir = "";
    bool done = false;
    bool next = false;
    bool skip = false;

    LLSD info(LLFloaterAbout::getInfo());
    std::string version = info["VIEWER_VERSION_STR"].asString();
    std::string appDir = gDirUtilp->getOSUserAppDir();

    //drop down two directory levels so we aren't searching for markers among the log files and crash dumps
    //or among other possible viewer upgrade directories if the resident is running multiple viewer versions
    //we should end up with a path like ../downloads/1.2.3.456789
    vec file_vec = gDirUtilp->getFilesInDir(appDir);

    for(vec::const_iterator iter=file_vec.begin(); iter!=file_vec.end(); ++iter)
    {
        if ( (iter->rfind("downloads") ) )
        {
            vec dir_vec = gDirUtilp->getFilesInDir(*iter);
            for(vec::const_iterator dir_iter=dir_vec.begin(); dir_iter!=dir_vec.end(); ++dir_iter)
            {
                if ( (dir_iter->rfind(version)))
                {
                    downloads = true;
                    downloadDir = *dir_iter;
                }
            }
        }
    }

    if ( downloads )
    {
        for(vec::const_iterator iter=file_vec.begin(); iter!=file_vec.end(); ++iter)
        {
            if ( (iter->rfind(version)))
            {
                if ( (iter->rfind(".done") ) )
                {
                    done = true;
                }
                else if ( (iter->rfind(".next") ) )
                {
                    next = true;
                }
                else if ( (iter->rfind(".skip") ) )
                {
                    skip = true;
                }
            }
        }
    }

    if ( !downloads )
    {
        LLNotificationsUtil::add("UpdateViewerUpToDate");
    }
    else
    {
        if ( !done )
        {
            LLNotificationsUtil::add("UpdateDownloadInProgress");
        }
        else if ( (!next) && (!skip) )
        {
            LLNotificationsUtil::add("UpdateDownloadComplete");
        }
        else //done and there is a next or skip
        {
            LLNotificationsUtil::add("UpdateDeferred");
        }
    }
}

///----------------------------------------------------------------------------
/// LLFloaterAboutUtil
///----------------------------------------------------------------------------
void LLFloaterAboutUtil::registerFloater()
{
    LLFloaterReg::add("sl_about", "floater_about.xml",
        &LLFloaterReg::build<LLFloaterAbout>);
}

void LLFloaterAboutUtil::checkUpdatesAndNotify()
{
    LLFloaterAbout::setUpdateListener();
}