CWE-ou-minkata/Sources/Plasma/Apps/plPlasmaUpdate/plPlasmaUpdate.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "HeadSpin.h"
#include "plPlasmaUpdate.h"
#include "resource.h"
#include <windowsx.h>
#include <commctrl.h>
#include <direct.h>
#include "jvCoreUtil.h"
#include "jvDialogResizer.h"

#include "hsTypes.h"
#include "../plFile/plFileUtils.h"
#include "../plUnifiedTime/plUnifiedTime.h"
#include "hsStream.h"
#include "plManifest.h"
#include "hsUtils.h"
#include "../plStatusLog/plStatusLog.h"

static plPlasmaUpdate* gInst = nil;

#define WM_UPDATE_SERVER WM_APP+1

std::string plPlasmaUpdate::fUserName = "dataserver";
std::string plPlasmaUpdate::fPassword = "parabledata";

plPlasmaUpdate::plPlasmaUpdate() : fCanExit(true), fProgressType(kValidating), fResizer(nil), fAutoDownload(false)
{
    INITCOMMONCONTROLSEX icc = {0};
    icc.dwSize = sizeof(INITCOMMONCONTROLSEX);
    icc.dwICC = ICC_PROGRESS_CLASS;
    InitCommonControlsEx(&icc);
    gInst = this;

    _getcwd(fIniPath, sizeof(fIniPath));
    char lastChar = fIniPath[strlen(fIniPath)];
    if (lastChar != '\\' && lastChar != '/')
        strcat(fIniPath, "\\");
    strcat(fIniPath, "ParableUpdate.ini");

    fFileGrabber = new plNetShareFileGrabber;
}

plPlasmaUpdate::~plPlasmaUpdate()
{
    delete fResizer;
    if (fFileGrabber)
        delete fFileGrabber;
}

bool plPlasmaUpdate::Create()
{
    if (!fServers.GetServerInfo())
        return false;

    ICreateDialog(IDD_UPDATE, NULL);
    return true;
}

BOOL CALLBACK plPlasmaUpdate::ILoginWinProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch( msg )
    {
    case WM_INITDIALOG:
        SetFocus(GetDlgItem(hDlg, IDC_USERNAME));
        break;
    case WM_COMMAND:
        if (HIWORD(wParam) == BN_CLICKED && (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL))
        {
            bool ok = (LOWORD(wParam) == IDOK);
            if (ok)
            {
                char username[25];
                char password[25];
            
                GetDlgItemText(hDlg, IDC_USERNAME, username, 25);
                GetDlgItemText(hDlg, IDC_PASSWORD, password, 25);

                fUserName = username;
                hsAssert(false, "who uses this program?");
            //  plChallengeResponse::HashPassword(password, fPassword);
            }
            EndDialog(hDlg, ok);
            return TRUE;
        }
        break;
    }
    return FALSE;
}

void plPlasmaUpdate::IInit()
{
    char curServerAddress[256];
    GetPrivateProfileString("PlasmaUpdate", "ServerAddress", "", curServerAddress, sizeof(curServerAddress), fIniPath);
    bool external = (GetPrivateProfileInt("PlasmaUpdate", "External", 0, fIniPath) != 0);

    HWND hCombo = GetDlgItem(fDlg, IDC_BUILD_COMBO);

    for (int i = 0; i < fServers.GetNumServers(); i++)
    {
        std::string& serverAddress = fServers.GetServerAddress(i);
        std::string& serverName = fServers.GetServerName(i);
        std::string& currentDir = fServers.GetServerCurrentDir(i);

        if (!fFileGrabber->IsServerAvailable(serverAddress.c_str(), currentDir.c_str()))
            continue;

        bool thisServer = (serverAddress == curServerAddress);

        int idx = ComboBox_AddString(hCombo, serverName.c_str());
        ComboBox_SetItemData(hCombo, idx, MAKELPARAM(i, 0));
        if (thisServer && !external)
            ComboBox_SetCurSel(hCombo, idx);

        std::string extName = serverName + " (External)";
        idx = ComboBox_AddString(hCombo, extName.c_str());
        ComboBox_SetItemData(hCombo, idx, MAKELPARAM(i, 1));
        if (thisServer && external)
            ComboBox_SetCurSel(hCombo, idx);
    }

    if (ComboBox_GetCurSel(hCombo) == -1)
        ComboBox_SetCurSel(hCombo, 0);

    SendMessage(fDlg, WM_SETICON, ICON_BIG, (LPARAM)LoadIcon(jvCoreUtil::GetHInstance(), MAKEINTRESOURCE(IDI_ICON)));
    SendMessage(fDlg, WM_SETICON, ICON_SMALL, (LPARAM)LoadIcon(jvCoreUtil::GetHInstance(), MAKEINTRESOURCE(IDI_ICON)));

    fResizer = new jvDialogResizer(fDlg);
    fResizer->AddControl(IDC_BUILD_COMBO,   jvDialogResizer::kResizeX);
    fResizer->AddControl(IDC_STATUS_LIST,   jvDialogResizer::kResizeX | jvDialogResizer::kResizeY);
    fResizer->AddControl(IDC_PROGRESS,      jvDialogResizer::kLockBottom | jvDialogResizer::kResizeX);
    fResizer->AddControl(IDC_DL_TEXT,       jvDialogResizer::kLockBottom | jvDialogResizer::kResizeX);
    fResizer->AddControl(IDC_DL_BUTTON,     jvDialogResizer::kLockBottom | jvDialogResizer::kCenterX);
    fResizer->SetSize(360, 320);
    fResizer->LoadPosAndSize("PlasmaUpdate");

    bool goTime = true;
    if (fFileGrabber->NeedsAuth())
    {
        /*
        if (!DialogBox(NULL, MAKEINTRESOURCE(IDD_PLASMAUPDATE_LOGIN), fDlg, ILoginWinProc))
            goTime = false;
        else
        */
            fFileGrabber->SetUsernamePassword(fUserName, fPassword);
    }

    if (goTime)
    {
        ShowWindow(fDlg, SW_SHOW);
        PostMessage(fDlg, WM_UPDATE_SERVER, 0, 0);
    }
    else
        PostQuitMessage(0);
}

void plPlasmaUpdate::IShutdown()
{
    fResizer->SavePosAndSize("PlasmaUpdate");
    delete fResizer;
    fResizer = NULL;

    IDeleteManifests();
}

void plPlasmaUpdate::IEnableCtrls(bool enable)
{
    fCanExit = enable;
    EnableWindow(GetDlgItem(fDlg, IDC_BUILD_COMBO), enable);

    HWND hDlButton = GetDlgItem(fDlg, IDC_DL_BUTTON);

    if (fManifests.empty())
        SetWindowText(hDlButton, "Close");
    else
        SetWindowText(hDlButton, "Download");

    EnableWindow(hDlButton, enable);

    if (enable)
        SetFocus(hDlButton);
}

void plPlasmaUpdate::IDeleteManifests()
{
    for (int i = 0; i < fManifests.size(); i++)
        delete fManifests[i];
    fManifests.clear();
}

bool plPlasmaUpdate::IGetManifests(const char* serverRoot, bool external)
{
    IDeleteManifests();

    char filePath[MAX_PATH];
    sprintf(filePath, "%sCurrent.txt", serverRoot);

    enum Sections
    {
        kVersion,
        kInternal,
        kExternal,
        kAll
    };
    int curSection = kVersion;

    hsRAMStream s;
    hsRAMStream manifestStream;

    if (fFileGrabber->FileToStream(filePath, &s))
    {
        char buf[256];
        while (s.ReadLn(buf, sizeof(buf)))
        {
            if (buf[0] == '[')
            {
                if (hsStrEQ(buf, "[Version]"))
                    curSection = kVersion;
                else if (hsStrEQ(buf, "[Internal]"))
                    curSection = kInternal;
                else if (hsStrEQ(buf, "[External]"))
                    curSection = kExternal;
                else if (hsStrEQ(buf, "[All]"))
                    curSection = kAll;
            }
            else
            {
                if (curSection == kVersion)
                {
                    int version = atoi(buf);
                    if (version != 1)
                    {
                        hsMessageBox("Your copy of PlasmaUpdate is out of date.\nPlease get the latest version.", "Error", hsMessageBoxNormal, hsMessageBoxIconError);
                        return false;
                    }
                }
                else if ((!external && curSection == kInternal)
                        || (external && curSection == kExternal)
                        || curSection == kAll)
                {
                    //if (curSection == kAll && !(!strcmp(buf, "Data\\Movies.mfs") || !strcmp(buf, "Data\\Sounds.mfs")))
                    //  continue;

                    sprintf(filePath, "%s%s", serverRoot, buf);

                    fFileGrabber->MakeProperPath(filePath);

                    manifestStream.Reset();
                    fFileGrabber->FileToStream(filePath, &manifestStream);

                    plFileUtils::StripFile(filePath);

                    plManifest* manifest = new plManifest(ILog);
                    manifest->Read(&manifestStream, filePath, buf);
                    fManifests.push_back(manifest);
                }
            }
        }

        return true;
    }

    return false;
}

void plPlasmaUpdate::IUpdateServer()
{
    char buf[256];

    IEnableCtrls(false);

    SetDlgItemText(fDlg, IDC_DL_TEXT, "Checking for updates...");

    //
    // Figure out what server we're checking
    //
    bool external = false;
    char serverRoot[MAX_PATH];

    {
        HWND hCombo = GetDlgItem(fDlg, IDC_BUILD_COMBO);
        int idx = ComboBox_GetCurSel(hCombo);
        LPARAM data = ComboBox_GetItemData(hCombo, idx);
        int server = LOWORD(data);
        external = (HIWORD(data) != 0);

        sprintf(serverRoot, "/%s/", fServers.GetServerCurrentDir(server).c_str());
        const char* serverName = fServers.GetServerAddress(server).c_str();

        ILog("===== Server set to %s %s =====", serverName, external ? "external" : "internal");

        WritePrivateProfileString("PlasmaUpdate", "ServerAddress", serverName, fIniPath);
        WritePrivateProfileString("PlasmaUpdate", "External", external ? "1" : "0", fIniPath);

        fFileGrabber->SetServer(serverName);
    }

    //
    // Get the latest publish notes
    //
    {
        HWND hList = GetDlgItem(fDlg, IDC_STATUS_LIST);
        ListBox_ResetContent(hList);

        char updateFile[MAX_PATH];
        if (external)
            sprintf(updateFile, "%sUpdates-External.txt", serverRoot);
        else
            sprintf(updateFile, "%sUpdates-Internal.txt", serverRoot);

        hsRAMStream updates;
        fFileGrabber->MakeProperPath(updateFile);
        if (fFileGrabber->FileToStream(updateFile, &updates))
        {
            while (updates.ReadLn(buf, sizeof(buf)))
                ListBox_InsertString(hList, 0, buf);
        }
    }

    //
    // Get the manifests
    //
    bool gotManifests = IGetManifests(serverRoot, external);
    UInt32 dlSize = 0;

    fProgressType = kValidating;

    if (gotManifests)
    {
        int i;

        UInt32 numFiles = 0;
        for (i = 0; i < fManifests.size(); i++)
            numFiles += fManifests[i]->NumFiles();

        HWND hProgress = GetDlgItem(fDlg, IDC_PROGRESS);
        SendMessage(hProgress, PBM_SETRANGE32, 0, numFiles);

        for (i = 0; i < fManifests.size(); i++)
        {
            fManifests[i]->ValidateFiles(ProgressFunc);
            dlSize += fManifests[i]->DownloadSize();
        }

        SendMessage(hProgress, PBM_SETPOS, 0, 0);
    }

    // Print how many megs there are to download
    if (dlSize == 0)
    {
        strcpy(buf, "No updates to download");
        IDeleteManifests();
    }
    else
    {
        float dlMegs = float(dlSize) / (1024.f*1024.f);
        if (dlMegs < .1)
            dlMegs = .1;
        sprintf(buf, "%.1f MB of updates to download", dlMegs);
    }
    SetDlgItemText(fDlg, IDC_DL_TEXT, buf);

    IEnableCtrls(true);

    if (fAutoDownload)
        PostMessage(fDlg, WM_COMMAND, MAKEWPARAM(IDC_DL_BUTTON, BN_CLICKED), LPARAM(GetDlgItem(fDlg, IDC_DL_BUTTON)));
}

void plPlasmaUpdate::IDownloadUpdates()
{
    fProgressType = kDownloading;

    IEnableCtrls(false);

    int i;

    UInt32 dlSize = 0;
    for (i = 0; i < fManifests.size(); i++)
        dlSize += fManifests[i]->DownloadSize();

    HWND hProgress = GetDlgItem(fDlg, IDC_PROGRESS);
    SendMessage(hProgress, PBM_SETRANGE32, 0, dlSize);

    for (i = 0; i < fManifests.size(); i++)
        fManifests[i]->DownloadUpdates(ProgressFunc, fFileGrabber);

    SendMessage(hProgress, PBM_SETPOS, 0, 0);

    EnableWindow(GetDlgItem(fDlg, IDC_DL_BUTTON), false);
    SetDlgItemText(fDlg, IDC_DL_TEXT, "No updates to download");

    IDeleteManifests();

    IEnableCtrls(true);

    if (fAutoDownload)
        PostMessage(fDlg, WM_COMMAND, MAKEWPARAM(IDC_DL_BUTTON, BN_CLICKED), LPARAM(GetDlgItem(fDlg, IDC_DL_BUTTON)));
}

void plPlasmaUpdate::ProgressFunc(const char* name, int delta)
{
    static const char* lastName = nil;
    if (lastName != name)
    {
        lastName = name;

        char buf[256];
        if (gInst->fProgressType == kValidating)
            strcpy(buf, "Checking ");
        else
            strcpy(buf, "Downloading ");
        strcat(buf, name);

        SetDlgItemText(gInst->fDlg, IDC_DL_TEXT, buf);
    }

    SendDlgItemMessage(gInst->fDlg, IDC_PROGRESS, PBM_DELTAPOS, delta, 0);

    jvBaseDlg::PumpQueue();
}

void plPlasmaUpdate::ILog(const char* format, ...)
{
    static plStatusLog* log = nil;

    if (!log)
        log = plStatusLogMgr::GetInstance().CreateStatusLog(0, "PlasmaUpdate.log");

    va_list args;
    va_start(args, format);
    log->AddLineV(format, args);
    va_end(args);
}

BOOL plPlasmaUpdate::IDlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
    case WM_INITDIALOG:
        IInit();
        SetFocus(GetDlgItem(fDlg, IDC_DL_BUTTON));
        return FALSE;

    case WM_CLOSE:
        if (fCanExit)
            DestroyWindow(hDlg);
        return TRUE;

    case WM_DESTROY:
        IShutdown();
        PostQuitMessage(0);
        return TRUE;

    case WM_COMMAND:
        if (HIWORD(wParam) == BN_CLICKED && LOWORD(wParam) == IDC_DL_BUTTON)
        {
            if (fManifests.empty())
                SendMessage(fDlg, WM_CLOSE, 0, 0);
            else
                IDownloadUpdates();
            return TRUE;
        }
        else if (HIWORD(wParam) == CBN_SELCHANGE && LOWORD(wParam) == IDC_BUILD_COMBO)
        {
            IUpdateServer();
            return TRUE;
        }
        break;

    case WM_UPDATE_SERVER:
        IUpdateServer();
        return TRUE;
    }

    return FALSE;
}