nigger/CnC_Generals_Zero_Hour
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
CnC_Generals_Zero_Hour/GeneralsMD/Code/Tools/PATCHGET/CHATAPI.CPP

1797 lines
41 KiB
C++
Raw Permalink Blame History

/*
** Command & Conquer Generals Zero Hour(tm)
** Copyright 2025 Electronic Arts 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/>.
*/
//
// This module takes care of all the Chat API stuff
//
#include <list>
#include "GameSpy/ghttp/ghttp.h"
#include "downloadManager.h"
#include "chatapi.h"
//#include "api/wolapi_i.c" // This should only be in one .cpp file
#include <objbase.h>
#include <windows.h>
#include <initguid.h>
#include <olectl.h>
#include <mapicode.h>
#include "resource.h"
#include "winblows.h"
#include <crtdbg.h>
#include "process.h"
#include "WWDownload/registry.h"
#include "WWDownload/urlBuilder.h"
#include "debug.h"
enum EVENT_TYPES
{
NOUPDATE_EVENT=0, // don't need to update
ABORT_EVENT,
NUM_EVENTS // keep last
};
#define GAME_NAME "Command & Conquer"
HANDLE Events[NUM_EVENTS];
char g_UpdateString[256]; // for the filename
char g_DLTimeRem[80];
char g_DLBytesLeft[80];
char g_DLBPS[80];
int g_Finished=0;
HWND g_DownloadWindow;
HWND g_ContactWindow;
HWND g_PrimaryWindow;
static bool checkingForPatch = false;
static int checksLeft = 0;
static bool cantConnect = false;
static std::list<QueuedDownload> queuedDownloads;
BOOL CALLBACK downloadDialogProc( HWND hwndDlg, UINT uMsg, WPARAM wParam,
LPARAM lParam );
///////////////////////////////////////////////////////////////////////////////////////
static void startOnline( void );
///////////////////////////////////////////////////////////////////////////////////////
QueuedDownload TheDownload;
class DownloadManagerMunkee : public DownloadManager
{
public:
DownloadManagerMunkee() { }
virtual HRESULT OnError( int error );
virtual HRESULT OnEnd();
virtual HRESULT OnProgressUpdate( int bytesread, int totalsize, int timetaken, int timeleft );
virtual HRESULT OnStatusUpdate( int status );
virtual HRESULT downloadFile( std::string server, std::string username, std::string password, std::string file, std::string localfile, std::string regkey, bool tryResume );
};
///////////////////////////////////////////////////////////////////////////////////////
HRESULT DownloadManagerMunkee::downloadFile( std::string server, std::string username, std::string password, std::string file, std::string localfile, std::string regkey, bool tryResume )
{
/*
if (staticTextFile)
{
UnicodeString fileString;
fileString.translate(file);
GadgetStaticTextSetText(staticTextFile, fileString);
}
*/
return DownloadManager::downloadFile( server, username, password, file, localfile, regkey, tryResume );
}
HRESULT DownloadManagerMunkee::OnError( int error )
{
HRESULT ret = DownloadManager::OnError( error );
g_Finished = -1;
return ret;
}
HRESULT DownloadManagerMunkee::OnEnd()
{
HRESULT ret = DownloadManager::OnEnd();
g_Finished = 1;
return ret;
}
HRESULT DownloadManagerMunkee::OnProgressUpdate( int bytesread, int totalsize, int timetaken, int timeleft )
{
HRESULT ret = DownloadManager::OnProgressUpdate( bytesread, totalsize, timetaken, timeleft );
SendDlgItemMessage( g_DownloadWindow, IDC_PROGRESS, PBM_SETPOS, (WPARAM)(bytesread * 100) / totalsize, 0 );
char temp[256];
if( timeleft > 0 )
{
//DBGMSG("Bytes read: "<<bytesread<<". Time left: "<<timeleft<<" seconds");
LoadString(Global_instance, TXT_TIME_REMAIN, temp, sizeof(temp));
sprintf(g_DLTimeRem,temp,(timeleft/60),(timeleft%60));
LoadString(Global_instance, TXT_BPS, temp, sizeof(temp));
sprintf(g_DLBPS,temp,bytesread/timetaken);
}
LoadString(Global_instance, TXT_BYTES_READ, temp, sizeof(temp));
sprintf(g_DLBytesLeft,temp,bytesread,totalsize);
return ret;
}
HRESULT DownloadManagerMunkee::OnStatusUpdate( int status )
{
HRESULT ret = DownloadManager::OnStatusUpdate( status );
SetWindowText(g_DownloadWindow, getStatusString().c_str());
return ret;
}
///////////////////////////////////////////////////////////////////////////////////////
BOOL CALLBACK simpleDialogProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
switch( uMsg )
{
case WM_INITDIALOG:
return(TRUE);
break;
case WM_CLOSE:
DestroyWindow(hwnd);
PostQuitMessage(0);
exit(0);
break;
}
return(FALSE);
}
static void startOnline( void )
{
checkingForPatch = false;
// Close that contacting window
DestroyWindow(g_ContactWindow);
g_ContactWindow=NULL;
if (cantConnect)
{
MessageBox(NULL, "Can't Connect", GAME_NAME, MB_OK);
exit(0);
}
else if (queuedDownloads.size())
{
if (MessageBox(NULL, "Patches Available. Download?", GAME_NAME, MB_YESNO) == IDYES)
{
DEBUG_LOG(("Downloading patches\n"));
while (queuedDownloads.size())
{
TheDownload = queuedDownloads.front();
queuedDownloads.pop_front();
TheDownloadManager = new DownloadManagerMunkee;
/**/
int retVal = DialogBox(Global_instance, MAKEINTRESOURCE(IDD_DOWNLOAD_DIALOG), g_PrimaryWindow, downloadDialogProc);
if (retVal)
{
DEBUG_LOG(("Error %d\n", GetLastError()));
}
/**/
/*
{
//char *res = MAKEINTRESOURCE(IDD_CONNECTING);
char *res = MAKEINTRESOURCE(IDD_DOWNLOAD_DIALOG1);
g_DownloadWindow=CreateDialog(Global_instance,res,g_PrimaryWindow,simpleDialogProc);
ShowWindow(g_DownloadWindow,SW_SHOWNORMAL);
SetForegroundWindow(g_DownloadWindow);
}
*/
delete TheDownloadManager;
TheDownloadManager = NULL;
if (g_Finished != 1)
{
// Download failed
//DBGMSG("Download failed: "<<retval);
SetEvent(Events[ABORT_EVENT]);
return;
}
}
exit(0);
}
else
{
exit(0);
}
}
else
{
MessageBox(NULL, "No Patches Available", GAME_NAME, MB_OK);
exit(0);
}
}
///////////////////////////////////////////////////////////////////////////////////////
static std::string trim(std::string s, const std::string& delim)
{
unsigned int i;
i = s.find_first_not_of(delim);
if (i != s.npos)
{
s = s.substr(i);
}
i = s.find_last_not_of(delim);
if (i>=0 && i<s.npos)
{
s = s.substr(0, i+1);
}
return s;
}
///////////////////////////////////////////////////////////////////////////////////////
static std::string getNextLine(std::string in, std::string& remainder)
{
int lineEnd;
lineEnd = in.find_first_of("\n\r", 0);
if (lineEnd < 1)
{
remainder = "";
return in;
}
std::string out = in.substr(0, lineEnd);
remainder = in.substr(lineEnd+1);
remainder = trim(remainder, "\r\n\t ");
out = trim(out, "\r\t\n ");
}
///////////////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
inline const char* skipSeps(const char* p, const char* seps)
{
while (*p && strchr(seps, *p) != NULL)
++p;
return p;
}
//-----------------------------------------------------------------------------
inline const char* skipNonSeps(const char* p, const char* seps)
{
while (*p && strchr(seps, *p) == NULL)
++p;
return p;
}
//-----------------------------------------------------------------------------
bool nextToken(std::string& base, std::string& tok, const char* seps = NULL)
{
if (base.empty())
return false;
if (seps == NULL)
seps = " \n\r\t";
const char* start = skipSeps(base.c_str(), seps);
const char* end = skipNonSeps(start, seps);
if (end > start)
{
int len = end - start;
char* tmp = new char[len+1];
memcpy(tmp, start, len);
tmp[len] = 0;
tok = tmp;
delete[] tmp;
base = end;
return true;
}
else
{
base = tok = "";
return false;
}
}
///////////////////////////////////////////////////////////////////////////////////////
static void queuePatch(bool mandatory, std::string downloadURL)
{
// downloadURL is of the form "ftp://ftp.ea.com:user@pass/pub/munkee/bananna.rtp"
QueuedDownload q;
bool success = true;
std::string connectionType;
success = success && nextToken(downloadURL, connectionType, ":");
std::string server;
success = success && nextToken(downloadURL, server, ":/");
std::string user;
success = success && nextToken(downloadURL, user, ":@");
std::string pass;
success = success && nextToken(downloadURL, pass, "@/");
std::string filePath;
success = success && nextToken(downloadURL, filePath, "");
if (!success && !user.empty())
{
// no user/pass combo - move the file into it's proper place
filePath = user;
user = ""; // LFeenanEA - Credentials removed as per Security requirements
pass = "";
success = true;
}
std::string fileStr = filePath;
unsigned int slashPos = filePath.find_last_of('/');
std::string fileDir = "patches\\";
std::string fileName = "";
if (slashPos == filePath.npos)
{
fileName = filePath;
}
else
{
fileName = filePath.substr(slashPos+1);
}
fileDir.append(fileName);
DEBUG_LOG(("download URL split: %d [%s] [%s] [%s] [%s] [%s] [%s] [%s]\n",
success, connectionType.c_str(), server.c_str(), user.c_str(), pass.c_str(),
filePath.c_str(), fileName.c_str(), fileDir.c_str()));
if (!success)
return;
q.file = filePath;
q.localFile = fileDir;
q.password = pass;
q.regKey = "";
q.server = server;
q.tryResume = true;
q.userName = user;
std::list<QueuedDownload>::iterator it = queuedDownloads.begin();
while (it != queuedDownloads.end())
{
if (it->localFile == q.localFile)
return; // don't add it if it exists already (because we can check multiple times)
++it;
}
queuedDownloads.push_back(q);
}
///////////////////////////////////////////////////////////////////////////////////////
static GHTTPBool patchCheckCallback( GHTTPRequest request, GHTTPResult result, char * buffer, int bufferLen, void * param )
{
--checksLeft;
DEBUG_ASSERTCRASH(checksLeft>=0, ("Too many callbacks"));
DEBUG_LOG(("Result=%d, buffer=[%s], len=%d\n", result, buffer, bufferLen));
if (result != GHTTPSuccess)
{
cantConnect = true;
if (!checksLeft)
{
startOnline();
}
return GHTTPTrue;
}
std::string message = buffer;
std::string line;
while (nextToken(message, line, "\r\n"))
{
std::string type, req, url;
bool ok = true;
ok = ok && nextToken(line, type, " ");
ok = ok && nextToken(line, req, " ");
ok = ok && nextToken(line, url, " ");
if (ok && type == "patch")
{
DEBUG_LOG(("Saw a patch: %d/[%s]\n", atoi(req.c_str()), url.c_str()));
queuePatch( atoi(req.c_str()), url );
}
else if (ok && type == "server")
{
}
}
if (!checksLeft)
{
startOnline();
}
return GHTTPTrue;
}
///////////////////////////////////////////////////////////////////////////////////////
static void StartPatchCheck( void )
{
checkingForPatch = true;
std::string gameURL, mapURL;
std::string configURL, motdURL;
FormatURLFromRegistry(gameURL, mapURL, configURL, motdURL);
std::string proxy;
if (GetStringFromRegistry("", "Proxy", proxy))
{
if (!proxy.empty())
{
ghttpSetProxy(proxy.c_str());
}
}
// check for a patch first
checksLeft = 2;
cantConnect = false;
ghttpGet(gameURL.c_str(), GHTTPFalse, patchCheckCallback, NULL);
ghttpGet(mapURL.c_str(), GHTTPFalse, patchCheckCallback, NULL);
DEBUG_LOG(("Started looking for patches at '%s' && '%s'\n", gameURL.c_str(), mapURL.c_str()));
}
///////////////////////////////////////////////////////////////////////////////////////
BOOL CALLBACK downloadDialogProc( HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
// HRESULT res;
int cmd = LOWORD(wParam);
switch( uMsg )
{
case WM_COMMAND:
if ( cmd == IDC_DLABORT )
{
char abort[128];
char abortdload[256];
LoadString(Global_instance, TXT_ABORT_DOWNLOAD, abortdload, sizeof(abortdload));
LoadString(Global_instance, TXT_ABORT, abort, sizeof(abort));
if (MessageBox(g_PrimaryWindow,abortdload,abort,MB_YESNO)==IDYES)
{
TheDownloadManager->reset();
EndDialog( hwndDlg, g_Finished );
DestroyWindow(hwndDlg);
}
}
else
{
return FALSE;
}
break;
case WM_INITDIALOG:
//SetupDownload();
SendMessage(hwndDlg, WM_SETICON,(WPARAM)ICON_SMALL,
(LPARAM)LoadIcon(Global_instance, MAKEINTRESOURCE(IDI_ICON1)));
g_DLTimeRem[0]=0;
g_DLBytesLeft[0]=0;
g_DLBPS[0]=0;
//SetDlgItemText( hwndDlg, IDC_DOWNLOADTITLE, g_UpdateString);
//SetWindowText(hwndDlg, g_UpdateString);
SetDlgItemText( hwndDlg, IDC_TIMEREM, g_DLTimeRem);
SetDlgItemText( hwndDlg, IDC_BYTESLEFT, g_DLBytesLeft);
// SetDlgItemText( hwndDlg, IDC_BPS, g_DLBPS );
// Work out the full file name
//char fullpath[_MAX_PATH];
//char localfile[_MAX_PATH];
//sprintf( fullpath, "%s/%s", g_Update->patchpath,g_Update->patchfile);
//sprintf(localfile,"%s\\%s",g_Update->localpath,g_Update->patchfile);
// Create the directory
//CreateDirectory((char *)g_Update->localpath, NULL );
TheDownloadManager->downloadFile(TheDownload.server, TheDownload.userName, TheDownload.password,
TheDownload.file, TheDownload.localFile, TheDownload.regKey, TheDownload.tryResume);
/*
res=pDownload->DownloadFile((char *)g_Update->server, (char *)g_Update->login, (char *)g_Update->password,
fullpath, localfile, APP_REG_KEY);
*/
g_DownloadWindow = hwndDlg;
g_Finished = 0;
SetTimer( hwndDlg, 1, 200, NULL ); // was 50
break;
case WM_TIMER:
DEBUG_LOG(("TIMER\n"));
if( g_Finished == 0 )
{
DEBUG_LOG(("Entering PumpMsgs\n"));
TheDownloadManager->update();
/*
pDownload->PumpMessages();
*/
DEBUG_LOG(("Done with PumpMsgs\n"));
if (strlen(g_DLTimeRem))
SetDlgItemText( hwndDlg, IDC_TIMEREM, g_DLTimeRem );
if (strlen(g_DLBytesLeft))
SetDlgItemText( hwndDlg, IDC_BYTESLEFT, g_DLBytesLeft );
//if (strlen(g_DLBPS))
// SetDlgItemText( hwndDlg, IDC_BPS, g_DLBPS );
}
else
{
DEBUG_LOG(("TIMER: Finished\n"));
EndDialog( hwndDlg, g_Finished );
DestroyWindow( hwndDlg );
}
break;
case WM_DESTROY:
KillTimer( hwndDlg, 1 );
//ClosedownDownload();
//DBGMSG("WM_DESTROY");
break;
case WM_SETFONT:
return TRUE;
default:
return FALSE;
}
return TRUE;
}
DWORD dwChatAdvise;
DWORD dwDownloadAdvise;
//Update *g_Update;
uint32 g_AppVer=-1;
BOOL CALLBACK Download_Dialog_Proc( HWND hwndDlg, UINT uMsg, WPARAM wParam,
LPARAM lParam );
BOOL CALLBACK Simple_Dialog_Proc( HWND hwndDlg, UINT uMsg, WPARAM wParam,
LPARAM lParam );
HWND CreatePrimaryWin(void);
char const * Fetch_String(int id);
//
// Create a primary window
//
HWND CreatePrimaryWin(void)
{
HWND hwnd;
WNDCLASS wc;
char name[256];
sprintf(name,Fetch_String(TXT_TITLE));
//DBGMSG("CreatePrimary: "<<name);
/*
** set up and register window class
*/
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = DefWindowProc;
wc.cbClsExtra = 0; // Don't need any extra class data
wc.cbWndExtra = 0; // No extra win data
wc.hInstance = Global_instance;
wc.hIcon=LoadIcon(Global_instance, MAKEINTRESOURCE(IDI_ICON1));
wc.hCursor = NULL; /////////LoadCursor( NULL, IDC_ARROW );
wc.hbrBackground = NULL;
wc.lpszMenuName = name;
wc.lpszClassName = name;
RegisterClass( &wc );
/*
** create a window
*/
hwnd = CreateWindowEx(
WS_EX_APPWINDOW,
name,
name,
WS_POPUP,
0, 0,
//GetSystemMetrics( SM_CXSCREEN ),
//GetSystemMetrics( SM_CYSCREEN ),
0,0,
NULL,
NULL,
Global_instance,
NULL );
SendMessage(hwnd,WM_SETICON,(WPARAM)ICON_SMALL,
(LPARAM)LoadIcon(Global_instance, MAKEINTRESOURCE(IDI_ICON1)));
ShowWindow(hwnd,SW_SHOWNORMAL);
return(hwnd);
}
//
// Dispatch pending windows events
//
void DispatchEvents(void)
{
MSG msg;
int counter=0;
while(PeekMessage(&msg,NULL,0,0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
counter++;
if (counter==256) // just in case
break;
}
}
//
// Check for patches
//
int main(int argc, char *argv[])
{
InitCommonControls();
/*
g_PrimaryWindow=CreatePrimaryWin(); // Create the main window
DispatchEvents(); // process some win messages
*/
/*
// Check if they've registered before, if not ask them if they want to
bool have_registered=false;
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,REGISTER_REG_KEY,0,KEY_READ,&rKey)==ERROR_SUCCESS)
{
char username[64];
valuesize=sizeof(username);
if (RegQueryValueEx(rKey,"UserName",NULL,&type,(uint8 *)username,&valuesize)==ERROR_SUCCESS)
have_registered=true;
RegCloseKey(rKey);
}
if (!have_registered)
{
if (RegOpenKeyEx(HKEY_CLASSES_ROOT,NICK_REG_KEY,0,KEY_READ,&rKey)==ERROR_SUCCESS)
{
have_registered=true;
RegCloseKey(rKey);
}
}
if (!have_registered)
{
if (MessageBox(NULL,Fetch_String(TXT_REGNOW),Fetch_String(TXT_TITLE),MB_YESNO)==IDNO)
have_registered=true; // pretend they've alredy registered
}
if (!have_registered)
{
// figure out where the registration app is installed & launch it, continue
// after it exits.
if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,REGISTER_REG_APP,0,KEY_READ,&rKey)==ERROR_SUCCESS)
{
char regapp[300];
valuesize=sizeof(regapp);
if ((RegQueryValueEx(rKey,"InstallPath",NULL,&type,(uint8 *)regapp,&valuesize)==ERROR_SUCCESS)&&
(strlen(regapp) > 8))
{
// Launch the process
SHELLEXECUTEINFO info;
memset(&info,0,sizeof(info));
info.cbSize=sizeof(info);
info.fMask=SEE_MASK_NOCLOSEPROCESS;
info.hwnd=g_PrimaryWindow;
info.lpVerb=NULL;
info.lpFile=regapp;
info.lpParameters=NULL;
info.lpDirectory=".";
info.nShow=SW_SHOW;
ShellExecuteEx(&info);
// Can't wait infinite or the other process will never create its window
// Only Bill himself knows why this is happening
while(1) // Wait for completion
{
DispatchEvents();
if (WaitForSingleObject(info.hProcess,500)!=WAIT_TIMEOUT)
break;
}
}
RegCloseKey(rKey);
}
}
// OK, done with that crap go on to the task at hand now....
*/
// Find the game version
g_AppVer = -1;
if (!GetUnsignedIntFromRegistry("", "Version", g_AppVer))
{
MessageBox(g_PrimaryWindow,Fetch_String(TXT_INSTALL_PROBLEM),Fetch_String(TXT_ERROR),MB_OK);
exit(0);
}
// OK, have the current game version now
g_PrimaryWindow=CreatePrimaryWin(); // Create the main window
DispatchEvents(); // process some win messages
// Popup the "contacting" window
g_ContactWindow=CreateDialog(Global_instance,MAKEINTRESOURCE(IDD_CONNECTING),g_PrimaryWindow,Simple_Dialog_Proc);
ShowWindow(g_ContactWindow,SW_SHOWNORMAL);
SetForegroundWindow(g_ContactWindow);
DispatchEvents(); // process some win messages
// Setup the Westwood Online stuff
Startup_Chat();
Update_If_Required();
Shutdown_Chat();
return(0);
}
typedef struct SRecord {
int ID; // ID number of the string resource.
int TimeStamp; // 'Time' that this string was last requested.
char String[2048]; // Copy of string resource.
SRecord(void) : ID(-1), TimeStamp(-1) {}
} SRecord;
/***********************************************************************************************
* Fetch_String -- Fetches a string resource. *
* *
* Fetches a string resource and returns a pointer to its text. *
* *
* INPUT: id -- The ID number of the string resource to fetch. *
* *
* OUTPUT: Returns with a pointer to the actual text of the string resource. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 12/25/1996 JLB : Created. *
*=============================================================================================*/
char const * Fetch_String(int id)
{
static SRecord _buffers[64];
static int _time = 0;
/*
** Determine if the string ID requested is valid. If not then return an empty string pointer.
*/
if (id == -1 || id == TXT_NONE) return("");
/*
** Adjust the 'time stamp' tracking value. This is an artificial value used merely to track
** the relative age of the strings requested.
*/
_time = _time+1;
/*
** Check to see if the requested string has already been fetched into a buffer. If so, then
** return a pointer to that string (update the time stamp as well).
*/
for (int index = 0; index < ARRAY_SIZE(_buffers); index++) {
if (_buffers[index].ID == id) {
_buffers[index].TimeStamp = _time;
return(_buffers[index].String);
}
}
/*
** Find a suitable buffer to hold the string to be fetched. The buffer should either be
** empty or have the oldest fetched string.
*/
int oldest = -1;
int oldtime = -1;
for (int text = 0; text < ARRAY_SIZE(_buffers); text++) {
if (oldest == -1 || oldtime > _buffers[text].TimeStamp) {
oldest = text;
oldtime = _buffers[text].TimeStamp;
if (oldtime == -1 || _buffers[text].ID == -1) break;
}
}
/*
** A suitable buffer has been found so fetch the string resource and then return a pointer
** to the string.
*/
char * stringptr = _buffers[oldest].String;
_buffers[oldest].ID = id;
_buffers[oldest].TimeStamp = _time;
if (LoadString(Global_instance, id, stringptr, sizeof(_buffers[oldest].String)) == 0) {
return("");
}
/******
char resname[32];
sprintf(resname,"#%d",id);
HMODULE hmod=GetModuleHandle(NULL);
HRSRC hrsrc=FindResourceEx(hmod, RT_STRING, MAKEINTRESOURCE(id), LANGID);
if (hrsrc==0)
{
char message_buffer[256];
FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), &message_buffer[0], 256, NULL );
}
HGLOBAL resdata=LoadResource(NULL,hrsrc);
LPVOID vdata=LockResource(resdata);
strcpy(stringptr,(char *)vdata);
*********/
stringptr[sizeof(_buffers[oldest].String)-1] = '\0';
return(stringptr);
}
void LogMsg(char *msg)
{
#ifdef _DEBUG
FILE *out=fopen("register.log","a");
fprintf(out,"%s\n",msg);
fflush(out);
fclose(out);
#endif
}
void Startup_Chat(void)
{
/*
//////CComObject<CChatEventSink>* g_pChatSink;
HRESULT hRes;
g_pChatSink=NULL;
CoCreateInstance(CLSID_Chat, NULL, CLSCTX_INPROC_SERVER,
IID_IChat, (void**)&pChat);
if (pChat==NULL)
{
char error[128];
char apimissing[256];
LoadString(Global_instance, TXT_API_MISSING, apimissing, sizeof(apimissing));
LoadString(Global_instance, TXT_ERROR, error, sizeof(error));
MessageBox(g_PrimaryWindow,apimissing,error,MB_OK);
exit(-5);
}
g_pChatSink=new CChatEventSink;
// Get a connection point from the chat class
IConnectionPoint *pConnectionPoint=NULL;
IConnectionPointContainer *pContainer=NULL;
dwChatAdvise=0;
hRes=pChat->QueryInterface(IID_IConnectionPointContainer,(void**)&pContainer);
_ASSERTE(SUCCEEDED(hRes));
hRes=pContainer->FindConnectionPoint(IID_IChatEvent,&pConnectionPoint);
_ASSERTE(SUCCEEDED(hRes));
hRes=pConnectionPoint->Advise((IChatEvent *)g_pChatSink,&dwChatAdvise);
_ASSERTE(SUCCEEDED(hRes));
pChat->SetAttributeValue("RegPath",APP_REG_KEY);
// ADD pConnectionPoint->Release();
*/
}
void Shutdown_Chat(void)
{
/*
/////AtlUnadvise(pChat, IID_IChatEvent, dwChatAdvise);
IConnectionPoint *pConnectionPoint=NULL;
IConnectionPointContainer *pContainer=NULL;
HRESULT hRes;
hRes=pChat->QueryInterface(IID_IConnectionPointContainer,(void**)&pContainer);
_ASSERTE(SUCCEEDED(hRes));
hRes=pContainer->FindConnectionPoint(IID_IChatEvent,&pConnectionPoint);
_ASSERTE(SUCCEEDED(hRes));
pConnectionPoint->Unadvise(dwChatAdvise);
pChat->Release();
/////delete(g_pChatSink); This appears to be bad....
// ADD g_pChatSink->Release();
// ADD pConnectionPoint->Release();
// ADD pContainer->Release();
*/
}
//
// Download a patch for the registration client if required
// This uses the chat API for ver checking and FTP.
//
void Update_If_Required(void)
{
int retval;
int i;
// Create the events
for (i=0; i<NUM_EVENTS; i++)
Events[i]=CreateEvent(NULL,FALSE,FALSE,NULL);
StartPatchCheck();
while (1)
{
ghttpThink();
MSG msg;
while(PeekMessage(&msg,NULL,0,0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
retval=WaitForMultipleObjectsEx(NUM_EVENTS,Events,FALSE,50,FALSE);
if (retval==WAIT_TIMEOUT)
continue;
//DBGMSG("An event was set");
retval-=WAIT_OBJECT_0;
break;
}
//DBGMSG("Out of the loop")
if (retval==ABORT_EVENT)
{
exit(0);
}
else
{
//DBGMSG("NO update required");
}
//DBGMSG("Shutting down");
// close all the event objects
for (i=0; i<NUM_EVENTS; i++)
CloseHandle(Events[i]);
/*
Startup_Chat();
int retval;
int i;
// Create the events
for (i=0; i<NUM_EVENTS; i++)
Events[i]=CreateEvent(NULL,FALSE,FALSE,NULL);
/// For Testing....
///pChat->RequestServerList(1000,262364,"register","regpas98",15);
///pChat->RequestServerList(1000,300,"register","regpas98",15);
pChat->RequestServerList(g_AppSku,g_AppVer,"register","regpas98",40);
while(1)
{
pChat->PumpMessages();
MSG msg;
while(PeekMessage(&msg,NULL,0,0, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
retval=WaitForMultipleObjectsEx(NUM_EVENTS,Events,FALSE,50,FALSE);
if (retval==WAIT_TIMEOUT)
continue;
//DBGMSG("An event was set");
retval-=WAIT_OBJECT_0;
break;
}
//DBGMSG("Out of the loop")
if (retval==ABORT_EVENT)
{
exit(0);
}
else
{
//DBGMSG("NO update required");
}
//DBGMSG("Shutting down");
// close all the event objects
for (i=0; i<NUM_EVENTS; i++)
CloseHandle(Events[i]);
Shutdown_Chat();
*/
}
/*
CChatEventSink::CChatEventSink()
{
m_cRef=0; // init the refrence count
}
///////////////////////////////////////////////////////////
//
// Interface IUnknown Methods
//
///////////////////////////////////////////////////////////
//
// QueryInterface
//
HRESULT __stdcall
CChatEventSink::QueryInterface(const IID& iid, void** ppv)
{
if ((iid == IID_IUnknown) ||(iid == IID_IChatEvent))
{
*ppv = static_cast<IChatEvent*>(this) ;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
(reinterpret_cast<IUnknown*>(*ppv))->AddRef() ;
return S_OK ;
}
///////////////////////////////////////////////////////////
//
// AddRef
//
ULONG __stdcall
CChatEventSink::AddRef()
{
return InterlockedIncrement(&m_cRef) ;
}
///////////////////////////////////////////////////////////
//
// Release
//
ULONG __stdcall
CChatEventSink::Release()
{
if (InterlockedDecrement(&m_cRef) == 0)
{
delete this ;
return 0 ;
}
return m_cRef;
}
///// DOWNLOAD
CDownloadEventSink::CDownloadEventSink()
{
m_cRef=0; // Ref counter
}
///////////////////////////////////////////////////////////
//
// Interface IUnknown Methods
//
///////////////////////////////////////////////////////////
//
// QueryInterface
//
HRESULT __stdcall
CDownloadEventSink::QueryInterface(const IID& iid, void** ppv)
{
if ((iid == IID_IUnknown) ||(iid == IID_IDownloadEvent))
{
*ppv = static_cast<IDownloadEvent*>(this) ;
}
else
{
*ppv = NULL;
return E_NOINTERFACE;
}
(reinterpret_cast<IUnknown*>(*ppv))->AddRef() ;
return S_OK ;
}
///////////////////////////////////////////////////////////
//
// AddRef
//
ULONG __stdcall
CDownloadEventSink::AddRef()
{
return InterlockedIncrement(&m_cRef) ;
}
///////////////////////////////////////////////////////////
//
// Release
//
ULONG __stdcall
CDownloadEventSink::Release()
{
if (InterlockedDecrement(&m_cRef) == 0)
{
delete this ;
return 0 ;
}
return m_cRef;
}
*/
//// FTP Download stuff
void SetupDownload( void )
{
/*
HRESULT hRes;
g_pDownloadSink=NULL;
CoCreateInstance(CLSID_Download, NULL, CLSCTX_INPROC_SERVER,
IID_IDownload, (void**)&pDownload);
_ASSERTE(pDownload);
g_pDownloadSink=new CDownloadEventSink;
// Get a connection point from the chat class
IConnectionPoint *pConnectionPoint=NULL;
IConnectionPointContainer *pContainer=NULL;
dwDownloadAdvise = 0;
hRes=pDownload->QueryInterface(IID_IConnectionPointContainer,(void**)&pContainer);
_ASSERTE(SUCCEEDED(hRes));
hRes=pContainer->FindConnectionPoint(IID_IDownloadEvent,&pConnectionPoint);
_ASSERTE(SUCCEEDED(hRes));
hRes=pConnectionPoint->Advise((IDownloadEvent *)g_pDownloadSink,&dwDownloadAdvise);
_ASSERTE(SUCCEEDED(hRes));
*/
}
void ClosedownDownload( void )
{
/*
// AtlUnadvise(pDownload, IID_IDownloadEvent, dwDownloadAdvise);
IConnectionPoint *pConnectionPoint=NULL;
IConnectionPointContainer *pContainer=NULL;
HRESULT hRes;
hRes=pDownload->QueryInterface(IID_IConnectionPointContainer,(void**)&pContainer);
_ASSERTE(SUCCEEDED(hRes));
hRes=pContainer->FindConnectionPoint(IID_IDownloadEvent,&pConnectionPoint);
_ASSERTE(SUCCEEDED(hRes));
pConnectionPoint->Unadvise(dwDownloadAdvise);
pDownload->Release();
//////delete(g_pDownloadSink); This appears to be bad....
*/
}
BOOL CALLBACK Download_Dialog_Proc( HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
// char fullpath[ 256 ];
// char localfile[ 256];
// HRESULT res;
switch( uMsg )
{
case WM_COMMAND:
switch( LOWORD( wParam ) )
{
case IDC_DLABORT:
{
char abort[128];
char abortdload[256];
LoadString(Global_instance, TXT_ABORT_DOWNLOAD, abortdload, sizeof(abortdload));
LoadString(Global_instance, TXT_ABORT, abort, sizeof(abort));
if (MessageBox(g_PrimaryWindow,abortdload,abort,MB_YESNO)==IDYES)
{
/*
pDownload->Abort();
*/
EndDialog( hwndDlg, g_Finished );
DestroyWindow(hwndDlg);
}
}
break;
default:
return FALSE;
}
break;
case WM_INITDIALOG:
SetupDownload();
SendMessage(hwndDlg, WM_SETICON,(WPARAM)ICON_SMALL,
(LPARAM)LoadIcon(Global_instance, MAKEINTRESOURCE(IDI_ICON1)));
g_DLTimeRem[0]=0;
g_DLBytesLeft[0]=0;
g_DLBPS[0]=0;
//SetDlgItemText( hwndDlg, IDC_DOWNLOADTITLE, g_UpdateString);
//SetWindowText(hwndDlg, g_UpdateString);
SetDlgItemText( hwndDlg, IDC_TIMEREM, g_DLTimeRem);
SetDlgItemText( hwndDlg, IDC_BYTESLEFT, g_DLBytesLeft);
// SetDlgItemText( hwndDlg, IDC_BPS, g_DLBPS );
/*
// Work out the full file name
sprintf( fullpath, "%s/%s", g_Update->patchpath,g_Update->patchfile);
sprintf(localfile,"%s\\%s",g_Update->localpath,g_Update->patchfile);
// Create the directory
CreateDirectory((char *)g_Update->localpath, NULL );
res=pDownload->DownloadFile((char *)g_Update->server, (char *)g_Update->login, (char *)g_Update->password,
fullpath, localfile, APP_REG_KEY);
*/
g_DownloadWindow = hwndDlg;
g_Finished = 0;
SetTimer( hwndDlg, 1, 200, NULL ); // was 50
break;
case WM_TIMER:
LogMsg("TIMER");
if( g_Finished == 0 )
{
LogMsg("Entering PumpMsgs");
/*
pDownload->PumpMessages();
*/
LogMsg("Done with PumpMsgs");
if (strlen(g_DLTimeRem))
SetDlgItemText( hwndDlg, IDC_TIMEREM, g_DLTimeRem );
if (strlen(g_DLBytesLeft))
SetDlgItemText( hwndDlg, IDC_BYTESLEFT, g_DLBytesLeft );
//if (strlen(g_DLBPS))
// SetDlgItemText( hwndDlg, IDC_BPS, g_DLBPS );
}
else
{
LogMsg("TIMER: Finished");
EndDialog( hwndDlg, g_Finished );
DestroyWindow( hwndDlg );
}
break;
case WM_DESTROY:
KillTimer( hwndDlg, 1 );
ClosedownDownload();
//DBGMSG("WM_DESTROY");
break;
case WM_SETFONT:
return TRUE;
default:
return FALSE;
}
return TRUE;
}
// Whoeee this is an exciting one...
BOOL CALLBACK Simple_Dialog_Proc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
switch( uMsg )
{
case WM_INITDIALOG:
return(TRUE);
break;
case WM_CLOSE:
DestroyWindow(hwnd);
PostQuitMessage(0);
exit(0);
break;
}
return(FALSE);
}
/////////////////////////////////////////////////////////////////////////////
// CDownloadEventSink
//////////////////////////////////////////////////////////////////////////////
/*
STDMETHODIMP CDownloadEventSink::OnEnd(void)
{
LogMsg("Finished!");
g_Finished = 1;
return(S_OK);
}
STDMETHODIMP CDownloadEventSink::OnError(int error)
{
LogMsg("ERROR");
g_Finished = -1;
return(S_OK);
}
STDMETHODIMP CDownloadEventSink::OnProgressUpdate(int bytesread, int totalsize,
int timetaken, int timeleft)
{
SendDlgItemMessage( g_DownloadWindow, IDC_PROGRESS, PBM_SETPOS, (WPARAM)(bytesread * 100) / totalsize, 0 );
char temp[256];
if( timeleft > 0 )
{
//DBGMSG("Bytes read: "<<bytesread<<". Time left: "<<timeleft<<" seconds");
LoadString(Global_instance, TXT_TIME_REMAIN, temp, sizeof(temp));
sprintf(g_DLTimeRem,temp,(timeleft/60),(timeleft%60));
LoadString(Global_instance, TXT_BPS, temp, sizeof(temp));
sprintf(g_DLBPS,temp,bytesread/timetaken);
}
LoadString(Global_instance, TXT_BYTES_READ, temp, sizeof(temp));
sprintf(g_DLBytesLeft,temp,bytesread,totalsize);
return(S_OK);
}
STDMETHODIMP CDownloadEventSink::OnStatusUpdate(int status)
{
switch( status )
{
case DOWNLOADSTATUS_CONNECTING:
{
//LogMsg( "Connecting..." );
SetWindowText(g_DownloadWindow, Fetch_String(TXT_CONNECTING));
}
break;
case DOWNLOADSTATUS_FINDINGFILE:
//LogMsg( "Finding patch..." );
SetWindowText(g_DownloadWindow, g_UpdateString);
break;
case DOWNLOADSTATUS_DOWNLOADING:
//LogMsg( "Downloading patch..." );
SetWindowText(g_DownloadWindow, g_UpdateString);
break;
default:
//LogMsg("Unknown status update!");
break;
}
return(S_OK);
}
//
// Just tell the FTP module to go ahead and resume
//
STDMETHODIMP CDownloadEventSink::OnQueryResume(void)
{
return(DOWNLOADEVENT_RESUME);
}
/////////////////////////////////////////////////////////////////////////////
// CChatEventSink
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CChatEventSink::OnServerList(HRESULT res, Server* servers)
{
// If we get this, then we don't need to patch
// Close that contacting window
DestroyWindow(g_ContactWindow);
g_ContactWindow=NULL;
LogMsg("Server List");
MessageBox(g_PrimaryWindow,Fetch_String(TXT_NO_PATCHES),Fetch_String(TXT_AUTO_UPDATE),MB_OK);
SetEvent(Events[NOUPDATE_EVENT]);
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnServerBannedYou(HRESULT, time_t)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnPageSend(HRESULT)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnPaged(HRESULT, User *, LPCSTR)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnFind(HRESULT, Channel *)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnLogout(HRESULT, User *)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnBusy(HRESULT)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnIdle(HRESULT)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnConnection(HRESULT, LPCSTR)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnUserFlags(HRESULT,LPCSTR,unsigned int, unsigned int)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnChannelCreate(HRESULT, Channel *)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnChannelModify(HRESULT, Channel *)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnChannelJoin(HRESULT, Channel *, User *)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnChannelLeave(HRESULT, Channel *, User *)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnChannelTopic(HRESULT, Channel *, LPCSTR)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnChannelBan(HRESULT, LPCSTR, int)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnGroupList(HRESULT, Group *)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnPublicMessage(HRESULT, Channel *, User *, LPCSTR)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnPrivateMessage(HRESULT, User *,LPCSTR)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnSystemMessage(HRESULT, LPCSTR)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnUserLocale(long, struct User *)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnUserTeam(long, struct User *)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnSetLocale(long, enum Locale)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnSetTeam(long, int)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnNetStatus(HRESULT hr)
{
char string[60];
sprintf(string,"NetStatus %ld",hr);
LogMsg(string);
if ((hr==CHAT_E_CON_NETDOWN)||(hr==CHAT_E_CON_LOOKUP_FAILED)||
(hr==CHAT_E_CON_ERROR)||(hr==CHAT_E_TIMEOUT))
{
char error[128];
char cantconn[256];
LoadString(Global_instance, TXT_CANT_CONTACT, cantconn, sizeof(cantconn));
LoadString(Global_instance, TXT_ERROR, error, sizeof(error));
MessageBox(g_PrimaryWindow,cantconn,error,MB_OK);
exit(-1);
}
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnChannelList(HRESULT, Channel*)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnUserList(HRESULT, Channel*, User*)
{
return(S_OK);
}
//
// We got a list of updates to apply
//
STDMETHODIMP CChatEventSink::OnUpdateList(HRESULT r, Update * updates)
{
Update *tmp;
int numupdates=0;
int i=0;
int retval;
static int alreadyGotOne=0;
LogMsg("Update list");
// Close that contacting window
DestroyWindow(g_ContactWindow);
g_ContactWindow=NULL;
if( FAILED(r) )
{
LogMsg("Failed");
SetEvent(Events[ABORT_EVENT]); // An error occurred, bail out
}
if( updates == NULL ) // shouldn't happen
return S_OK;
if (alreadyGotOne) // Should only get one update list
return(S_OK);
alreadyGotOne=1;
// Count the updates;
tmp = updates;
while( tmp != NULL )
{
tmp = tmp->next;
numupdates++;
}
// Got a list of updates - If an update is required, the user must either
// patch or quit.
tmp = updates;
LogMsg("Found an update");
// We have a required update
char upreq[256];
char title[128];
LoadString(Global_instance, TXT_AN_UPGRADE_AVAILABLE, upreq, sizeof(upreq));
strcat(upreq,"\n");
LoadString(Global_instance, TXT_DOWNLOAD_NOW, upreq+strlen(upreq), sizeof(upreq));
LoadString(Global_instance, TXT_UPGRADE_AVAILABLE, title, sizeof(title));
if( MessageBox(g_PrimaryWindow,upreq,title, MB_YESNO ) == IDNO )
{
// If they don't want to patch now, just exit...
//DBGMSG("Must patch to continue, so exit");
exit(0);
}
// Do the downloads
while( tmp != NULL )
{
g_Update = tmp;
char dloading[256];
LoadString(Global_instance, TXT_DOWNLOADING_FILE, dloading, sizeof(dloading));
sprintf( g_UpdateString, dloading, ++i, numupdates );
LogMsg("Creating Download dialog box");
//if( (retval=DialogBox(Global_instance, MAKEINTRESOURCE(IDD_DOWNLOAD_DIALOG), g_PrimaryWindow,
// (DLGPROC)Download_Dialog_Proc)) != 1 )
retval=DialogBox(Global_instance, MAKEINTRESOURCE(IDD_DOWNLOAD_DIALOG), g_PrimaryWindow,(DLGPROC)Download_Dialog_Proc);
if (g_Finished != 1)
{
// Download failed
//DBGMSG("Download failed: "<<retval);
SetEvent(Events[ABORT_EVENT]);
return(E_FAIL);
}
tmp = tmp->next;
}
// Quit so the launcher can apply the patches
exit(0);
return(S_OK); // make silly compiler happy
}
STDMETHODIMP CChatEventSink::OnServerError(HRESULT, LPCSTR)
{
LogMsg("Server Error");
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnMessageOfTheDay(HRESULT, LPCSTR)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnPrivateAction(HRESULT, User *, LPCSTR)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnPublicAction(HRESULT, Channel *, User *, LPCSTR)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnPrivateGameOptions(HRESULT, User *, LPCSTR)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnPublicGameOptions(HRESULT, Channel *, User *, LPCSTR)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnGameStart(HRESULT, Channel *, User *, int)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnUserKick(HRESULT, Channel *, User *, User *)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnUserIP(HRESULT, User *)
{
return(S_OK);
}
STDMETHODIMP CChatEventSink::OnSquadInfo(HRESULT, unsigned long, Squad *)
{
return(S_OK);
}
*/
Reference in New Issue View Git Blame Copy Permalink