CWE-ou-minkata/Sources/Plasma/FeatureLib/pfLoginDialog/plLoginDialog.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 "plLoginDialog.h"
#include "resource.h"
#include "plNetCommon/plNetCommonConstants.h"
#include "plNetMessage/plNetMessage.h"
// #include "plHttpServer/plHttpResponse.h"
#include "plSDL/plSDL.h"
#include "plFile/hsFiles.h"
#include "plNetMessage/plNetCommonMessage.h"

// 'this' : used in base member initializer list
#pragma warning(disable:4355)

#define kAuthTimedOut WM_USER+2

plLoginDialog::plLoginDialog( HWND parentWnd )
:   plDialog(IDD_DIALOG_LOGIN)
,   fParentWnd( parentWnd )
,   fLoginBtn(this, IDC_LOGIN_LOGIN, plDelegate(this,(TDelegate)ILogin))
,   fCancelBtn(this, IDC_LOGIN_CANCEL, plDelegate(this,(TDelegate)IExit))
,   fAccountName(this,IDC_LOGIN_USERNAME)
,   fPassword(this,IDC_LOGIN_PASSWORD)
,   fLobbyList(this,IDC_LOGIN_LOBBYLIST)
,   fLobbyText(this, IDC_LOGIN_STATIC_SERVER)
,   fRememberPassword(this, IDC_REMEMBER_PASSWORD, plDelegate(this, (TDelegate)IOnRememberPwdChanged))
,   fCancelled(false)
,   fAutoLogin(false)
#ifndef PLASMA_EXTERNAL_RELEASE
,   fServerQueryBtn(this, IDC_SERVER_QUERY_BTN)
#endif
{
    fLobbyList.fSelectionEndOkDelegate = plDelegate(this,(TDelegate)SelectedLobbyChanged);
    fLobbyList.fEditUpdateDelegate = plDelegate(this,(TDelegate)SelectedLobbyTextEdited);
    fLobbyList.fKillFocusDelegate = plDelegate(this,(TDelegate)OnLobbyListLostFocus);
#ifndef PLASMA_EXTERNAL_RELEASE
    fServerQueryBtn.fClickDelegate = plDelegate(this,(TDelegate)ServerQueryBtnClicked);
#endif
}

std::string plLoginDialog::MakeSafeLobbyServerName(const std::string & value)
{
    return "";
}


void plLoginDialog::SelectedLobbyChanged()
{
    fLobbyVal.SetValue(fLobbyList.GetValue().c_str());
    fLobbyList.SetEdited(false);
}

void plLoginDialog::SelectedLobbyTextEdited()
{
    fLobbyVal.SetValue(fLobbyList.GetValue().c_str());
    fLobbyList.SetEdited(true);
}

// Ugh
#ifdef PLASMA_EXTERNAL_RELEASE
#include <time.h>
#endif

bool plLoginDialog::RefreshLobbyList()
{
    fStatusBar.SetText(L"Refreshing lobby server list...");

    plStringList lobbies;
    std::vector<std::wstring> wLobbies;
    GetLobbyList(lobbies);

    // Strip off the shard name and just leave the address
    for (int i = 0; i < lobbies.size(); i++)
    {
        std::string& str = lobbies[i];

        std::string::size_type endofname = str.find('\t');
        if (endofname != std::string::npos)
            str.erase(str.begin() + endofname, str.end());

        wchar_t *wLobby = hsStringToWString(str.c_str());
        wLobbies.push_back(wLobby);
        delete [] wLobby;
    }

    fLobbyList.Empty();

#ifdef PLASMA_EXTERNAL_RELEASE
    // In release mode, put the user in a random lobby for rudimentary load balancing
    int numLobbies = lobbies.size();
    if (numLobbies > 0)
    {
        srand(time(NULL));
        int rnum = rand();
        int whichLobby = rnum % numLobbies;

        fLobbyList.AddString(wLobbies[whichLobby].c_str());
    }

    fLobbyList.SetCurrent(0);
#else
    if (AllowSinglePlayerLobby())
        fLobbyList.AddString(L"Single Player");
    fLobbyList.AddStrings(wLobbies);

    wchar_t *wLobby = hsStringToWString(fLobbyVal.GetValue().c_str());
    int index = fLobbyList.FindStringExact(wLobby);
    if (index==LB_ERR && fLobbyVal.GetValue().length()>0)
    {
        fLobbyList.AddString(wLobby);
        index = fLobbyList.FindStringExact(wLobby);
    }
    delete [] wLobby;

    fLobbyList.SetCurrent((index!=LB_ERR)?index:0);
#endif // PLASMA_EXTERNAL_RELEASE

    SelectedLobbyChanged();

    fStatusBar.SetText(L"");
    return true;
}

void plLoginDialog::OnLobbyListLostFocus()
{
    std::string value = fLobbyList.GetValue();
    if (value.length()==0)
    {
        fLobbyList.SetCurrent(0);
        fLobbyList.SetValue(MakeSafeLobbyServerName(fLobbyList.GetValue()).c_str());
        SelectedLobbyChanged();
    }
}

#if 0
void plLoginDialog::UpdateCtrls()
{
    bool networkEnabled = IsNetworkPlayEnabled();
    bool loggedIn = GetLoggedIn();
    bool loggingIn = GetLoggingIn();
    bool loggedOut = GetLoggedOut();
    if (!networkEnabled && (loggedIn || loggingIn))
    {
        Logout();

        // these don't do anything.  need to set the vars in fMainDIalog?
        loggedIn = false;   
        loggingIn = false;
        loggedOut = true;
    }
}
#endif

bool plLoginDialog::IsNetworkPlayDisabled()
{
#ifdef PLASMA_EXTERNAL_RELEASE
    return false;
#else
    xtl::istring tmp = fLobbyVal.GetValue().c_str();
    return (tmp.compare("single player")==0);
#endif
}

bool plLoginDialog::IsNetworkPlayEnabled()
{
    return !IsNetworkPlayDisabled();
}

void plLoginDialog::OnInitDialog()
{
    plDialog::OnInitDialog();

    if ( fParentWnd )
        SetParent( Handle(), fParentWnd );

    fStatusBar.OpenWindow(this,true);

#ifdef PLASMA_EXTERNAL_RELEASE
    fLobbyList.Show(false);
    fLobbyText.Show(false);
#endif

#ifndef PLASMA_EXTERNAL_RELEASE
    fServerQueryBtn.Show(true);
#endif

    bool rememberPwd = (fRememberPasswordVal.GetValue()=="true");
    fAccountName.SetValue(fAccountNameVal.GetValue().c_str());
    if (rememberPwd)
    {
        int len = atoi(fPasswordLen.GetValue().c_str());
        std::string fakePwd(len, '*');
        fPassword.SetValue(fakePwd.c_str());
    }

    fRememberPassword.Check(rememberPwd);

    RefreshLobbyList();

    if ( fAutoLogin )
        fLoginBtn.Click();

//  SetForegroundWindow(*this);
}

bool plLoginDialog::Login()
{
    int ret = DoModal();
    if (ret<0)
    {
        hsAssert(false, xtl::format("plLoginDialog failed to initialize, err code %d, GetLastError %d", 
            ret, GetLastError()).c_str());
    }

    return (ret != 0);
}

void plLoginDialog::ILogin()
{
    OnLoginClicked();

    fAccountNameVal.SetValue(fAccountName.GetValue().c_str());
    
    std::string pwd = fPassword.GetValue();
    int pwdSize = pwd.size();

    std::string fakePwd = "*" + std::string(pwdSize-1, '*');
    if (pwd != fakePwd) // user has entered a real pwd
    {
        fPasswordLen.SetValue(xtl::format("%d",pwd.size()).c_str());
        // MD5 HASH the pwd
        std::string hex;
        plChallengeResponse::HashPassword(pwd.c_str(), hex);
        fPasswordVal.SetValue(hex.c_str());
    }
    
    SetDataServerUserName(true, fAccountNameVal.GetValue().c_str());
    SetDataServerPassword(true, fPasswordVal.GetValue().c_str());
    SetDataServerUserName(false, fAccountNameVal.GetValue().c_str());
    SetDataServerPassword(false, fPasswordVal.GetValue().c_str());

    if (IsNetworkPlayEnabled())
        StartLogin();
    else
        CompleteLogin();
}

void plLoginDialog::IOnRememberPwdChanged()
{
    fRememberPasswordVal.SetValue(fRememberPassword.IsChecked() ? "true" : "false");
}

void plLoginDialog::IExit()
{
    fAccountNameVal.SetValue(fAccountName.GetValue().c_str());
    fPasswordVal.SetValue(fPassword.GetValue().c_str());
    fLobbyVal.SetValue(fLobbyList.GetValue().c_str());
    SetDataServerUserName(true, fAccountNameVal.GetValue().c_str());
    SetDataServerPassword(true, fPasswordVal.GetValue().c_str());
    SetDataServerUserName(false, fAccountNameVal.GetValue().c_str());
    SetDataServerPassword(false, fPasswordVal.GetValue().c_str());
    SHORT state = GetKeyState(VK_SHIFT);
    if (state&0x8000)
        EndDialogTrue();
    else
        EndDialogFalse();
    fCancelled=true;
}

int plLoginDialog::ICheckNetVersion(plNetMsgAuthenticateChallenge * msg)
{
    if (msg)
    {
        if (msg->GetVersionMajor() != plNetMessage::kVerMajor ||
            msg->GetVersionMinor() != plNetMessage::kVerMinor)
        {
            std::string str = xtl::format("Login Failed, client/server version mismatch, client %d.%d, server %d.%d",
                plNetMessage::kVerMajor, plNetMessage::kVerMinor, 
                msg->GetVersionMajor(),
                msg->GetVersionMinor());
            FailLogin(str.c_str());
            return hsFail;
        }
        return hsOK;
    }
    return hsFail;  
}

void plLoginDialog::HandleAuthChallenge(plNetMsgAuthenticateChallenge * msg)
{
    int cnt = msg->PeekBuffer(msg->GetNetCoreMsg()->GetData(),msg->GetNetCoreMsg()->GetLen());

    // check protocol version first, in case msg contents are hosed
    if (ICheckNetVersion(msg) == hsFail)
        return;     // version err

    if (msg->IsContinuing())
    {
        // Respond to the Challenge
        std::string hex = plChallengeResponse::GetBufferAsHexStr(msg->GetChallenge().data(), msg->GetChallenge().size(), true);
        fChallengeResponse.SetChallenge(hex);
        fChallengeResponse.GenerateResponse(fAccountNameVal.GetValue().c_str(),fPasswordVal.GetValue().c_str());
        KillTimer(*this,kAuthTimedOut);
        SendAuthenticateResponse();
    }
    else
    {
        FailLogin(msg->GetHelloResult());
    }
}

void plLoginDialog::HandleAccountAuthenticated(plNetMsgAccountAuthenticated * msg)
{
    int cnt = msg->PeekBuffer(msg->GetNetCoreMsg()->GetData(),msg->GetNetCoreMsg()->GetLen());
    if (msg->IsAuthenticated())
    {
        CompleteLogin();
    }
    else
    {
        FailLogin(msg->GetAuthResult());
    }
}


void plLoginDialog::StartLogin()
{
    fLoginBtn.SetEnabled(false);
    std::string value = fLobbyList.GetValue();
    if (value.length()==0)
    {
        fLobbyList.SetCurrent(0);
        fLobbyList.SetValue(MakeSafeLobbyServerName(fLobbyList.GetValue()).c_str());
        SelectedLobbyChanged();
    }
    fStatusBar.SetText(L"Authenticating...");
//  fMainDialog->InitNetCore();
//  fMainDialog->fLoginState = kLoggingIn;
//  fAccountTab.UpdateCtrls();
//  fPlayerTab.SetPlayerVault(nil);
    SendAuthenticateHello();
}

void plLoginDialog::CompleteLogin()
{
    if ( Handle() )
        fLoginBtn.SetEnabled(true);

    KillTimer(*this,kAuthTimedOut);

    fStatusBar.SetText(L"");
    if (IsNetworkPlayEnabled())
        NotifyConnected();
    else
        NotifyDisconnected();

    EndDialogTrue();
    
    GetClientManifests();
    UpdateAllCtrls();
}

void plLoginDialog::FailLogin(const char* str)
{
    fLoginBtn.SetEnabled(true);
    KillTimer(*this, kAuthTimedOut);
    fStatusBar.SetText(L"");
    hsMessageBoxWithOwner((void*)*this,str,"Error",hsMessageBoxNormal);
    Logout();
}

void plLoginDialog::FailLogin(int reasonCode)
{
    std::string str = xtl::format("Failed to login to lobby server %s: %s", 
        fLobbyVal.GetValue().c_str(), plNetMsgAccountAuthenticated::GetAuthResultString(reasonCode));
    FailLogin(str.c_str());
}

void plLoginDialog::TimeoutLogin()
{
    fLoginBtn.SetEnabled(true);

    wchar_t *wStr = hsStringToWString(xtl::format("Timed out logging into lobby server %s.", fLobbyVal.GetValue().c_str()).c_str());
    fStatusBar.SetText(wStr);
    delete [] wStr;

    KillTimer(*this, kAuthTimedOut);
    Logout();
}

void plLoginDialog::Logout()
{
    KillTimer(*this, kAuthTimedOut);
    SendLobbyLeave();
    //fMainDialog->ShutdownNetCore();
    NotifyDisconnected();
}

void plLoginDialog::SendLobbyLeave()
{
    plNetMsgLeave msg;
    msg.SetReason( plPlayerUpdateConstants::kPlayerQuitting );
    SendMsg(&msg,plNetAddress(fLobbyVal.GetValue().c_str(),plNetLobbyServerConstants::GetPort()));
    RemoveLobbyPeer();
}

#define MSG_TIMEOUT 8000
#include "../pnNetCommon/plNetAddress.h"

void plLoginDialog::SendAuthenticateHello()
{
    SetTimer(*this,kAuthTimedOut,MSG_TIMEOUT,nil);
    plNetMsgAuthenticateHello msg;
    msg.SetAccountName(fAccountNameVal.GetValue().c_str());
    msg.SetMaxPacketSize(GetPacketSize());
    SendMsg(&msg,plNetAddress(fLobbyVal.GetValue().c_str(),plNetLobbyServerConstants::GetPort()));
}

void plLoginDialog::SendAuthenticateResponse()
{
    SetTimer(*this,kAuthTimedOut,MSG_TIMEOUT,nil);
    plNetMsgAuthenticateResponse msg;
    msg.SetResponse(fChallengeResponse.GetResponse());
    SendMsg(&msg,plNetAddress(fLobbyVal.GetValue().c_str(),plNetLobbyServerConstants::GetPort()));
}

int plLoginDialog::CallDefaultProc( unsigned int message, unsigned int wParam, LONG lParam )
{
    switch (message)
    {
    case WM_TIMER:
        switch (wParam)
        {
        case kAuthTimedOut:
            TimeoutLogin();
            break;
        }
    }

    return 0;
}




/////////////////////////////////////////////////////////////////////////////
#ifndef PLASMA_EXTERNAL_RELEASE
#define kServerInfoFilename "server_info.html"

static void StringToLines(std::string str, plStringList & lines, bool includeBlankLines=true)
{
    xtl::trim(str);
    if (str.length()==0)
        return;
    str.append("\n");
    int pos;
    while ((pos=str.find("\n"))!=std::string::npos)
    {
        std::string line = xtl::trim(str.substr(0,pos).c_str());
        str.erase(0,pos+1);
        if (includeBlankLines || (!includeBlankLines && line.length()>0))
            lines.push_back(line);
    }
}

static void GetPathElements(std::string filename, plStringList & lst)
{
    int pos;
    while ((pos=filename.find_first_of("\\/"))!=std::string::npos)
    {
        std::string element = filename.substr(0,pos);
        filename.erase(0,pos+1);
        if (element.length())
            lst.push_back(element);
    }
}

struct SDLInfoParser
{
    std::string fFilename;
    std::string fDescriptorName;
    int         fVersion;
    void ParseString( const char * s )
    {
        std::string str = s;
        int p = str.find(",");
        fFilename = str.substr(0,p);
        str.erase(0,p+1);
        p = str.find(",");
        fDescriptorName = str.substr(0,p);
        str.erase(0,p+1);
        fVersion = atoi(str.c_str());

        p = fFilename.find_last_of("\\");
        if( p!=std::string::npos )
            fFilename.erase(0,p+1);
        p = fFilename.find_last_of("/");
        if( p!=std::string::npos )
            fFilename.erase(0,p+1);
    }
};


struct DescriptorReport
{
    int         fServerVersion;     // 0 means the descriptor is missing
    int         fClientVersion;
    DescriptorReport(): fServerVersion(0),fClientVersion(0){}
};

#define kStyleSheet \
    "<style>"   \
    "BODY {"    \
    "   font-size : 10pt;"  \
    "   font-family : Verdana, Geneva, Arial, Helvetica, sans-serif;"   \
    "}" \
    "TD {"  \
    "   font-size : 10pt;"  \
    "   font-family : Verdana, Geneva, Arial, Helvetica, sans-serif;"   \
    "}" \
    "PRE {" \
    "   margin-top : 0px;"  \
    "}" \
    ".SDLFile  { background-color : #FFFF99; }" \
    ".Title {"  \
    "   font-weight : bold;"    \
    "   text-align : center;"   \
    "   text-decoration : underline;"   \
    "}" \
    ".SectionHeader {"  \
    "   margin-bottom : 0px;"   \
    "}" \
    "</style>"

void plLoginDialog::ServerQueryBtnClicked()
{
    hsUNIXStream file;
    file.Open( kServerInfoFilename, "wt" );
    file.WriteString("<html>"kStyleSheet"<body>\n");

    try
    {
        typedef std::map< std::string, DescriptorReport > DescriptorReports;
        typedef std::map< std::string, DescriptorReports > FileReports;

        FileReports fileReports;


        /*plURL url;
        plHttpRequest request;
        plHttpResponse response;

        // read server build date etc.
        url.SetHost( fLobbyList.GetValue().c_str() );
        url.SetPort( 7676 );
        url.SetFile( "VersionInfo" );
        request.SetUrl( url );
        request.SetType( plHttpRequest::kGet );
        if ( !request.MakeRequest( response ) )
            throw 0;
        file.WriteString("<h3 class=SectionHeader>Server Info</h3>\n" );
        file.WriteString( "<pre>\n" );
        file.WriteString( response.c_str() );
        file.WriteString( "</pre>\n" );

        // get server's SDL info
        url.SetFile( "SDLInfo" );
        request.SetUrl( url );
        if ( !request.MakeRequest( response ) )
            throw 0;
        plStringList lines;
        StringToLines( response, lines, false );
        SDLInfoParser parser;
        {for ( plStringList::iterator ii=lines.begin(); ii!=lines.end(); ++ii )
        {
            parser.ParseString( (*ii).c_str() );
            fileReports[ parser.fFilename ][ parser.fDescriptorName ].fServerVersion = parser.fVersion;
        }}

        // get client's SDL info
        plSDLMgr::GetInstance()->DeInit();
        plSDLMgr::GetInstance()->SetSDLDir( "SDL" );
        plSDLMgr::GetInstance()->Init();
        const plSDL::DescriptorList * cds = plSDLMgr::GetInstance()->GetDescriptors();
        {for ( plSDL::DescriptorList::const_iterator ii=cds->begin(); ii!=cds->end(); ++ii )
        {
            plStateDescriptor * descriptor = *ii;
            std::string filename = descriptor->GetFilename();
            int p = filename.find_last_of(PATH_SEPARATOR_STR);
            if( p!=std::string::npos )
                filename.erase(0,p+1);
            fileReports[ filename ][ descriptor->GetName() ].fClientVersion = descriptor->GetVersion();
        }}

        // write SDL comparison report
        file.WriteString("<h3 class=SectionHeader>SDL File Comparison</h3>\n" );
        file.WriteString("Version=0 means descriptor doesn't exist.<br><br>\n" );
        file.WriteString( "<table><tr class=Title><td>File</td><td>Server Version</td><td>Client Version</td><td>Status</td></tr>\n" );


        { for ( FileReports::iterator ii=fileReports.begin(); ii!=fileReports.end(); ++ii )
        {
            std::string sdlFilename = ii->first;
            DescriptorReports & descrReports = ii->second;
            file.WriteFmt( "<tr><td colspan=5 class=SDLFile>%s</td></tr>\n", sdlFilename.c_str() );
            { for ( DescriptorReports::iterator jj=descrReports.begin(); jj!=descrReports.end(); ++jj )
            {
#define kSDLBad "<font color=red><b>Bad</b></font>"
#define kSDLOk  "<font color=green><b>Ok</b></font>"
                std::string descrName = jj->first;
                DescriptorReport & descrReport = jj->second;
                file.WriteFmt( "<tr><td>&nbsp;&nbsp;&nbsp;%s</td><td align=right>%d</td><td align=right>%d</td><td align=center>%s</td></tr>\n",
                    descrName.c_str(), descrReport.fServerVersion, descrReport.fClientVersion,
                    ( descrReport.fServerVersion==descrReport.fClientVersion ) ? kSDLOk:kSDLBad );
            }}
        }}

        file.WriteString("</table>\n");*/
    }
    catch (...)
    {
        file.WriteString("<p>An error occurred while querying the server.\n");
    }

    file.WriteString("</body></html>\n");
    file.Close();

    ShellExecute( nil, nil, kServerInfoFilename, nil, nil, SW_SHOWNORMAL );
}
#endif
/////////////////////////////////////////////////////////////////////////////