//
// Copyright 1997 Nicholas J. Irias. All rights reserved.
//
//
// Class CP4Command - an async wrapper for P4 commands
#include "stdafx.h"
#define TRACE_HERE
#include "P4Win.h"
#include "p4command.h"
#include "getpwddlg.h"
#include "mainfrm.h"
#include "GuiClientUser.h"
#include "Cmd_Login.h"
#include "md5.h"
#include <process.h>
const CString g_fPassword = _T("-P ");
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
// MultiProcessorSleep reg setting: 0==off; ODD == GUI sleep; > EVEN == worker sleep
static int m_MultiProcessorSleep = 0;
// Prototype for taskthread
//
UINT TaskThread( LPVOID pParam );
int P4KeepAlive::IsAlive()
{
if (global_cancel)
{
global_cancel = 0;
return 0;
}
else
return 1;
}
IMPLEMENT_DYNCREATE(CP4Command, CObject)
CP4Command::CP4Command(CGuiClient *client /* =NULL */) : m_pClient(client)
{
m_pStrListIn= NULL;
m_UsedTagged=FALSE;
m_RanInit=FALSE;
m_ClosedConn=TRUE;
m_PWD_DlgCancelled=FALSE;
m_ServerKey=0;
m_HaveServerLock = FALSE;
m_HitMaxFileSeeks= FALSE;
m_RedoOpenedFilter=FALSE;
m_FatalError = m_FatalErrorCleared = m_TriggerError = m_IgnorePermissionErrs = FALSE;
if(m_pClient != NULL)
{
m_IsChildTask=TRUE;
}
else
{
// There is no longer any need to call enviro.Reload(); enviro is no longer a global variable
m_IsChildTask=FALSE;
m_pClient = new CGuiClient();
ASSERT ( m_pClient );
}
// set the array to grow by MAX_P4ARGS, but don't actually set size
m_args.SetSize(0, MAX_P4ARGS);
m_argsA.SetSize(0, MAX_P4ARGS);
m_TaskName=_T("Command base class");
m_Function=_T("Function unassigned");
m_pTaskThread = NULL;
m_ReplyWnd=NULL;
m_MultiProcessorSleep = GET_P4REGPTR()->GetMultiProcessorSleep();
if (m_MultiProcessorSleep & 0x01)
m_MultiProcessorSleep = 0 - m_MultiProcessorSleep;
}
CP4Command::~CP4Command()
{
Error e;
CloseConn(&e);
// delete ANSI arg strings
for(int i = 0; i < m_argsA.GetSize(); i++)
delete m_argsA.GetAt(i);
// Make sure the caption bar gets updated if the user
// changed a setting
if( m_Asynchronous )
{
// can't use MainFrame()-> construct
// because mainfram might have closed.
CMainFrame * mainWnd = MainFrame();
if (mainWnd)
mainWnd->UpdateCaption(!(m_FatalError || m_FatalErrorCleared));
}
}
void CP4Command::CloseConn(Error *e)
{
if(!m_ClosedConn)
{
// we're through with the clientuser, let it point back to parent command, if any
m_pClient->PopCommandPtr(this);
if(!m_IsChildTask)
{
if( m_RanInit )
{
try
{
m_pClient->Final(e);
if (e->Test())
{
CString msg= FormatError(e);
if (e->IsFatal())
{
if (msg.Find(_T("TCP receive interrupted by client")) != -1)
{
m_FatalError = TRUE;
msg = LoadStringResource(IDS_INTERRUPTEDBYCLIENT);
}
TheApp()->StatusAdd(msg, SV_ERROR);
}
XTRACE(msg);
}
}
catch(...)
{
// Probably called Final for a client
// that never was connected
ASSERT(0);
}
}
delete m_pClient;
m_pClient = 0;
}
m_ClosedConn=TRUE;
}
else if (!m_IsChildTask && m_pClient)
delete m_pClient;
XTRACE(_T("Task %s Connection Closed\n"), GetTaskName( ));
}
BOOL CP4Command::Init(HWND replyWnd, BOOL asynch, BOOL holdLock/*=FALSE*/, int key/*=0*/)
{
// We need a reply window
ASSERT( m_pClient != NULL || IsWindow(replyWnd) );
m_ReplyWnd= replyWnd;
m_Asynchronous= asynch;
if( key != 0 )
{
m_ServerKey= key;
m_HaveServerLock= TRUE;
}
m_HoldServerLock=holdLock;
XTRACE(_T("Task %s Initialized\n"), GetTaskName( ));
return TRUE;
}
BOOL CP4Command::Run()
{
if(!m_IsChildTask)
{
// In general, no command can start unless SERVER_BUSY() is false
// or the command carries the key in m_pSingleLock. The exception is:
//
// IsQueueable() and we are are running with m_Asynchronous
// This means the command is capable of carrying all relevant context
// information and can afford to sit in a queue after a task thread
// is spawned.
if( !m_HaveServerLock && SERVER_BUSY() )
{
if( !( IsQueueable() && m_Asynchronous ) )
{
XTRACE(_T("Run() bailing out: %s\n"), m_TaskName);
return FALSE;
}
}
}
if(m_Asynchronous)
{
ASSERT(!m_IsChildTask);
if( !IsQueueable() && SERVER_BUSY() && !m_HaveServerLock )
{
ASSERT(0);
CString bloodInUrine;
bloodInUrine.FormatMessage( IDS_P4WIN_UNRECOVERABLE_ERROR__COMMAND_IS_s,
m_TaskName);
AfxMessageBox( bloodInUrine, MB_ICONSTOP );
// this is not excessive, since we will likely GPF if we try
// to continue, and we'll never know why we gpf'd
ExitProcess(1);
}
if( m_HaveServerLock )
AsyncExecCommand();
else
{
XTRACE(_T("Queuing Task: %s\n"), GetTaskName( ));
QUEUE_COMMAND(this);
}
}
else
{
// Dont try to lock the server. If its the primary thread,
// we wont be starting any other commands. If we are a
// child command under another async command, it already
// took out a lock
XTRACE(_T("Task %s Running Synchronous\n"), GetTaskName( ));
ExecCommand();
XTRACE(_T("Task %s Completed Synchronous\n"), GetTaskName( ));
}
return TRUE;
}
////////////////////////////////////////////////////////
// P4 argument collection
int CP4Command::AddArg( LPCTSTR arg )
{
ASSERT(arg != NULL);
ASSERT( m_args.GetSize() < MAX_P4ARGS );
m_args.Add(arg);
return m_args.GetSize();
}
int CP4Command::AddArg( int arg )
{
ASSERT( m_args.GetSize() < MAX_P4ARGS );
CString sArg;
sArg.Format(_T("%d"),arg);
m_args.Add(sArg);
return m_args.GetSize();
}
void CP4Command::ClearArgs( int baseArgs)
{
if(m_args.GetSize() > baseArgs)
m_args.RemoveAt(baseArgs, m_args.GetSize() - baseArgs);
}
BOOL CP4Command::NextListArgs()
{
ClearArgs(m_BaseArgs); // Clear all but the base args
ASSERT(m_posStrListIn != NULL);
// Pull another 10 files off the list
for(int i=0; m_posStrListIn != NULL && i<20; i++)
AddArg(m_pStrListIn->GetNext(m_posStrListIn));
// Caller knows not to call again when the list is empty
if(m_posStrListIn == NULL)
m_pStrListIn->RemoveAll();
return FALSE; // if we returned TRUE, it would immediately terminate command
}
/*
_________________________________________________________________
It takes no less than three functions to neatly run commands asynchronously:
1) AsyncExecCommand() spawns the worker thread and returns immediately
2) TaskThread(), a non-member function, launders the execution to member
function ExecCommand(). This intermediate step is required because the
"this" pointer gets in the way of sending a member function pointer
to AfxBeginThread()
3) ExecCommand() actually does the work, under an independent thread, but
with full member function access to class property
_________________________________________________________________
*/
void CP4Command::AsyncExecCommand()
{
// Set priority below normal to avoid gui freeze up
m_pTaskThread=AfxBeginThread(TaskThread, (LPVOID) this,
THREAD_PRIORITY_NORMAL, 0, CREATE_SUSPENDED, NULL);
m_pTaskThread->m_bAutoDelete=TRUE; // Tinker w/ priority here if reqd
m_pTaskThread->ResumeThread();
if (m_MultiProcessorSleep < 0)
Sleep(0 - m_MultiProcessorSleep);
}
BOOL CP4Command::InitConnection()
{
XTRACE(_T("Task %s Initializing Connection\n"), GetTaskName( ));
ASSERT(m_ClosedConn == TRUE);
m_pClient->PushCommandPtr(this);
m_ClosedConn=FALSE;
if(m_IsChildTask)
{
m_pClient->SetVersion(((CP4winApp *) AfxGetApp())->m_version);
m_pClient->SetVar( "prog", "P4Win");
return TRUE;
}
else
{
Error e;
e.Clear();
if(m_UsedTagged)
m_pClient->UseTaggedProtocol();
else
m_pClient->UseSpecdefsProtocol();
m_pClient->Init(&e);
if(!e.Test())
{
m_RanInit=TRUE;
// Allow the user to Cancel the command if desired
global_cancel = 0; // don't want a stale value!
m_pClient->SetBreak( &m_cb );
// Notify that we are p4win
m_pClient->SetVersion(((CP4winApp *) AfxGetApp())->m_version);
m_pClient->SetVar( "prog", "P4Win");
// Record the permanent client if we havent already, then
// set the client to the active client
//
CString client= m_pClient->GetClient().Text();
if( client.Compare( GET_P4REGPTR()->GetP4Client(TRUE)) != 0)
GET_P4REGPTR()->SetP4Client( client, FALSE, TRUE, FALSE );
client= GET_P4REGPTR()->GetP4Client();
m_pClient->SetClient( client);
// Record the permanent user if we havent already, then
// set the user to the active user
// note: user must be set before calling m_pClient->GetPassword().Text();
//
CString user= CharToCString(m_pClient->GetUser().Text());
if( user.Compare( GET_P4REGPTR()->GetP4User(TRUE)) != 0)
GET_P4REGPTR()->SetP4User( user, FALSE, TRUE, FALSE );
user= GET_P4REGPTR()->GetP4User();
m_pClient->SetUser(user);
// Record the permanent password if we havent already, then
// set the password to the active password
//
CString password = m_pClient->GetPassword().Text();
if( password.Compare( GET_P4REGPTR()->GetP4UserPassword(TRUE)) != 0)
{ // Note that a Perm password is actually set only if it has not yet been set
// this is because we no longer write passwords to the Registry (3rd arg).
GET_P4REGPTR()->SetP4Password( password, FALSE, TRUE, FALSE ); // set Perm
}
int lev;
if ((lev = GET_SERVERLEVEL()) >= 18)
{
m_pClient->SetPassword( _T("") ); // use the ticket for 2004.2 and later
}
else if (!lev) // must be a new port
{
GET_P4REGPTR()->SetP4Password( password, TRUE, FALSE, FALSE ); // also set Temp
}
else
{
password= GET_P4REGPTR()->GetP4UserPassword();
m_pClient->SetPassword( password );
}
// Record the hostname
CString hostname= m_pClient->GetHost().Text();
GET_P4REGPTR()->SetHostname(hostname);
}
else
{
m_ErrorTxt= RemoveTabs( FormatError(&e) );
m_FatalError=TRUE;
// Sometimes a blatantly wrong port results in the error msg being fired
// back too fast for cmainframe to receive it, so pause for a few millisecs
Sleep(500);
}
return !e.Test();
}
}
void CP4Command::ExecCommand()
{
BOOL done=FALSE;
m_FatalError=FALSE;
// Initialize connection
if(!InitConnection())
{
TheApp()->StatusAdd(m_ErrorTxt, SV_ERROR);
done=TRUE;
}
// Prerequisite commands run here
if(!done)
PreProcess(done);
// Loop to enable list processing
while(!done)
{
// Check for possible abort request
if(APP_ABORTING())
{
ReleaseServerLock();
ExitThread(0);
}
// Clear any error
m_ErrorTxt.Empty();
m_FatalError=m_SyntaxError=FALSE;
{
// a bit of ugliness in order to provide SetArgv with
// 8-bit strings...
int i;
for(i = 0; i < m_argsA.GetSize(); i++)
{
delete m_argsA.GetAt(i);
}
m_argsA.SetSize(m_args.GetSize());
for(i = 0; i < m_args.GetSize(); i++)
{
CharString cs = CharFromCString(m_args[i]);
char *argA = new char[strlen(cs)+1];
strcpy(argA, cs);
m_argsA.SetAt(i, argA);
}
}
m_Function = m_args[0];
// Show the command in the output pane if the user wants it
if ( GET_P4REGPTR()->ShowCommandTrace( ) )
TheApp()->StatusAdd( CString ( "Executing " ) + GetP4Command( ) );
// Run the command - run it in a loop so it is restartable
BOOL restart; // if true, we need to loop back and try again
do
{
restart = m_RetryUnicodeMode = false;
m_pClient->SetArgv( m_args.GetSize() - 1, m_argsA.GetData() + 1 );
m_pClient->Run( CharFromCString(m_Function) );
#ifdef UNICODE
if(m_RetryUnicodeMode)
{
m_pClient->SetTrans();
restart = true;
}
else
#endif
if (PWDRequired() && (GET_PWD_ERROR()
|| GET_NOPWD_SET() || GET_PWDNOTALLOW())) // Password Error?
{
CString password;
BOOL permanent = FALSE;
BOOL need2login= FALSE;
if (GET_PWD_ERROR())
{
while (!MainFrameCWnd) // wait until MainFrame is intitialzed
Sleep(100);
CGetPwdDlg dlg(MainFrameCWnd); // force Pswd dialog to be a child of MainFrame
if(dlg.DoModal( ) == IDCANCEL) // popup the Password dialog
{
m_PWD_DlgCancelled = TRUE; // they canceled
// Clear the error so we don't ask unnecessarily if they switch users next
SET_PWD_ERROR(FALSE);
break; // break out of the loop
}
password = dlg.GetPassword(); // get the clear-text password
if (GET_SECURITYLEVEL() >= 2) // if high security, forget any password
{
GET_P4REGPTR()->SetP4Password(_T(""), TRUE, TRUE, TRUE);
SetEnvironmentVariable(_T("P4PASSWD"), NULL);
}
else
{
permanent = dlg.IsWriteToRegistry();
// if not perm & is a 2004.2+ server, we have to clear any reg entry
if (!permanent && GET_SERVERLEVEL() >= 18)
{
GET_P4REGPTR()->SetP4Password(_T(""), TRUE, TRUE, TRUE);
SetEnvironmentVariable(_T("P4PASSWD"), NULL);
}
}
}
else if (GET_PWDNOTALLOW())
{
SET_PWDNOTALLOW(FALSE);
password = GET_P4REGPTR()->GetP4UserPassword();
if (GET_SECURITYLEVEL() >= 2) // if high security, forget any password
GET_P4REGPTR()->SetP4Password(_T(""), TRUE, FALSE, FALSE);
}
else // we need to login using the password they set
{
SET_NOPWD_SET(FALSE); // clear the error
password = GET_P4REGPTR()->GetP4UserPassword();
need2login = TRUE;
if (GET_SECURITYLEVEL() >= 2) // if high security, forget the password
GET_P4REGPTR()->SetP4Password(_T(""), TRUE, FALSE, FALSE);
}
int err = 0;
if (need2login || GET_SERVERLEVEL() >= 18) // 2004.1 server or later?
{
BOOL b = false;
CCmd_Login *pCmd = new CCmd_Login; // run p4 login
CString portStr = m_pClient->GetPort().Text(); // get current port
pCmd->GetClient()->SetPort(portStr); // run login against cur port
CString userStr = m_pClient->GetUser().Text(); // get current user
pCmd->GetClient()->SetUser(userStr); // run login against cur user
// In certain cases we have to temporialy 'unbusy' the server
if (!m_ServerKey && !m_Asynchronous && SERVER_BUSY())
{
((CP4winApp *) AfxGetApp())->m_CS.ClearServerBusy();
b = true; // remeber we 'unbusied' the server
}
pCmd->Init(NULL, RUN_SYNC, (m_ServerKey ? HOLD_LOCK : LOSE_LOCK), m_ServerKey);
pCmd->Run(password); // run the login command
err = pCmd->GetError();
delete pCmd;
if (b) // if we 'unbusied' the server, mark it busy again
((CP4winApp *) AfxGetApp())->m_CS.SetServerBusy();
m_pClient->SetPassword(_T("")); // clear any old ticket or password
}
else // 2003.2 server or earlier
{
MD5 md5; // hash the clear-text
StrBuf foo;
foo.Set(CharFromCString(password));
StrPtr *sptr;
sptr = &foo;
md5.Update(*sptr);
md5.Final(foo);
password = CharToCString(foo.Text());
GET_P4REGPTR()->SetP4Password( password, TRUE, permanent, permanent );
m_pClient->SetPassword(password); // finally add the pswd to the client obj
}
if (!err) // were there any problems (i.e. did p4 login run ok?)
{
SET_PWD_ERROR(FALSE); // clear the error indicators
SET_NOPWD_SET(FALSE);
SET_PWDNOTALLOW(FALSE);
m_FatalError = false;
restart = true; // and restart the original command
if ( GET_P4REGPTR()->ShowCommandTrace( ) )
TheApp()->StatusAdd( CString ( "Re-executing " ) + GetP4Command( ) );
}
}
} while(restart);
if( m_FatalError )
done = TRUE;
else
ProcessResults(done);
}
// Follow-up commands run here
if(!m_FatalError)
PostProcess();
// Make sure server status gets cleared BEFORE the interface thread
// can act on a completion message
if(!m_IsChildTask)
{
Error e;
// Clear server busy status
if(m_Asynchronous && !m_HoldServerLock)
ReleaseServerLock();
// Clear any password error if the PWD worked
if(!m_FatalError && PWDRequired())
{
SET_PWD_ERROR(FALSE);
SET_NOPWD_SET(FALSE);
SET_PWDNOTALLOW(FALSE);
if (GET_SERVERLEVEL() >= 18) // 2004.1 server or later?
{ // clear password to force ticket use
GET_P4REGPTR()->SetP4Password( _T(""), FALSE, TRUE, FALSE ); // set Prem
GET_P4REGPTR()->SetP4Password( _T(""), TRUE, FALSE, FALSE ); // also set Temp
}
}
// Make sure the connection closed, or NT3.51 will bite it when
// next command is init'ed
CloseConn(&e);
if (e.Test() && !e.IsFatal()) // Fatals are taken care of in CloseConn
{
CString msg = FormatError(&e);
if (msg.Find(_T("WSAECONNRESET")) != -1) // WSAECONNRESETs are fatal
m_FatalError = TRUE;
TheApp()->StatusAdd(msg, m_FatalError ? SV_ERROR : SV_WARNING);
}
// Finally, post back to ui thread
if(m_ReplyWnd != NULL)
::PostMessage( m_ReplyWnd, m_ReplyMsg, (WPARAM) this, 0);
}
}
/*
_________________________________________________________________
At this point, the command is ready to run, so blast ahead. The
control over what command can run or be queued is in the Run()
member function. See CP4CommandStatus for queue management. At
present, only 3 commands are queueable (and have IsQueueable() override
functions). Those commands can sit in queue for some time, and
should not encounter errors upon return. All relevant context
information is carried by a queueable command.
For a command sequence that must not be interruptible, call the
first command's Init() with HOLD_LOCK. When that command returns,
use GetServerKey() to grab the key, and pass that key into the
next command in the sequence via Init(). The last command should
be run with LOSE_KEY in its Init(), or alternatively ReleaseServerLock()
can be called to drop the lock and re-enable the queue.
_________________________________________________________________
*/
UINT TaskThread( LPVOID pParam )
{
CP4Command *pCmd = ( CP4Command * ) pParam;
{
// pCmd may be deleted by the time ExecCommand returns
// so we can't be using it afterwards.
#ifdef _DEBUG
// to aid in debugging prematurely deleted commands
// this string must be cleaned up before calling AfxEndThread
// or a memory leak will result, hence the extra curly braces.
CString taskName(pCmd->GetTaskName());
XTRACE(_T("Async Task: %s Beginning\n"), taskName);
#endif
if (m_MultiProcessorSleep > 0)
Sleep(m_MultiProcessorSleep);
pCmd->ExecCommand( );
#ifdef _DEBUG
XTRACE(_T("Async Task: %s Complete\n"), taskName);
#endif
}
AfxEndThread( 0 );
return 0;
}
///////////////////////////////////////
// Default handlers for server output
void CP4Command::OnOutputInfo(char level, LPCTSTR data, LPCTSTR msg)
{
// Check for possible abort request
if(APP_ABORTING() && m_Asynchronous)
{
ReleaseServerLock();
ExitThread(0);
}
TheApp()->StatusAdd(msg, SV_WARNING);
}
void CP4Command::OnOutputStat( StrDict *varList )
{
// Only specific commands use this function
ASSERT(0);
}
void CP4Command::OnOutputText(LPCTSTR data, int length)
{
// Only specific commands use this function
ASSERT(0);
}
void CP4Command::OnOutputError(char level, LPCTSTR errBuf, LPCTSTR errMsg)
{
if(APP_ABORTING() && m_Asynchronous)
{
ReleaseServerLock();
ExitThread(0);
}
// Most if not all "errors" returned here are info messages
// P4_OPENED "//depot/... - file(s) not opened anywhere."
//
CString txt( errBuf );
CString msg( errMsg );
if (( txt.Find( _T("Perforce password") ) > -1 )
|| ( txt.Find( _T("please login") ) > -1 ))
{
SET_PWD_ERROR(TRUE);
TheApp()->StatusAdd( msg, SV_WARNING );
m_ErrorTxt= LoadStringResource(IDS_OPERATION_CANNOT_COMPLETED_BECAUSE_BAD_PASSWORD);
m_FatalError=TRUE;
return;
}
if ( txt.Find( _T("Password not allowed at this server security level") ) > -1 )
{
SET_PWDNOTALLOW(TRUE);
m_ErrorTxt= msg;
m_FatalError=TRUE;
return;
}
if ((txt.Find(_T("Password must be set ")) > -1)
|| (txt.Find(_T("server requires the password to be reset")) > -1))
{
m_FatalError=TRUE;
HWND hWnd= AfxGetMainWnd()->GetSafeHwnd();
if( hWnd != NULL )
{
TheApp()->StatusAdd( m_ErrorTxt = msg, SV_WARNING );
BOOL b = false;
// In certain cases we have to temporialy 'unbusy' the server
if (!m_ServerKey && !m_Asynchronous && SERVER_BUSY())
{
((CP4winApp *) AfxGetApp())->m_CS.ClearServerBusy();
b = true; // remeber we 'unbusied' the server
}
if (IDOK == ::SendMessage(hWnd, WM_USERPSWDDLG, (WPARAM)TRUE, (LPARAM)m_ServerKey))
{
m_pClient->SetPassword(GET_P4REGPTR()->GetP4UserPassword());
SET_NOPWD_SET(TRUE);
}
if (b) // if we 'unbusied' the server, mark it busy again
((CP4winApp *) AfxGetApp())->m_CS.SetServerBusy();
return;
}
}
#ifdef UNICODE
if (txt.Find(_T("Unicode clients require a unicode enabled server.") ) > -1 )
{
SET_UNICODE(FALSE);
m_RetryUnicodeMode = TRUE;
return;
}
else if (txt.Find(_T("Unicode server permits only unicode enabled clients.") ) > -1 )
{
SET_UNICODE(TRUE);
CString charset= GET_P4REGPTR()->GetP4Charset();
if(charset.IsEmpty())
{
m_ErrorTxt= _T("Unicode server permits only unicode enabled clients. You must set P4CHARSET to use this server");
m_FatalError=TRUE;
TheApp()->StatusAdd( m_ErrorTxt, SV_WARNING );
return;
}
m_RetryUnicodeMode = TRUE;
return;
}
#endif
if( txt.Find( _T("Request too large") ) > -1 && txt.Find(_T("maxresults")) > -1 )
{
if (txt != msg)
TheApp()->StatusAdd( msg, SV_WARNING );
int semicolon= txt.Find(_T(";"));
if( semicolon > -1 )
txt= txt.Left( semicolon );
txt+= LoadStringResource(IDS_TO_FULLY_REFRESH_THE_DISPLAY_YOU_NEED_TO_ADJUST_MAXRESULTS);
txt+= GET_P4REGPTR()->GetP4User();
txt+= LoadStringResource(IDS_quote_nl_SEE_P4WIN_HELP_FOR_INFO_REGARDING_MAXRESULTS);
TheApp()->StatusAdd( txt, SV_ERROR );
m_FatalError=TRUE;
return;
}
if (( txt.Find( _T("You don't have permission") ) > -1 )
|| ( txt.Find( _T("no permission for operation") ) > -1 ))
{
if (m_IgnorePermissionErrs)
return;
TheApp()->StatusAdd( msg, SV_WARNING );
m_FatalError=TRUE;
return;
}
if(txt.Find(_T(" - over license quota")) != -1)
{
m_ErrorTxt=txt; // save off the error message first
int i = msg.Find('\n');
int j = msg.Find('\n', i+1);
if (i < j && i != -1)
{
txt = msg.Left(i+1) + msg.Mid(j);
msg = txt; // have to use a temp variable
}
TheApp()->StatusAdd(msg, SV_WARNING );
m_FatalError=TRUE;
return;
}
if(txt.Find(_T("Client template (-t) only allowed for new client")) != -1)
{
TheApp()->StatusAdd(LoadStringResource(IDS_CREATE_CLIENT_FROM_TEMPLATE_ONLY_ALLOWED_FOR_NEW_CLIENT), SV_WARNING );
m_FatalError=TRUE;
return;
}
if( txt.Find( _T("Must create client ")) != -1 ||
txt.Find( _T(" - use 'client' command to create it.") ) != -1 )
{
PostClientError();
m_FatalError = TRUE;
return;
}
else if ((TheApp()->m_RunClientWizOnly)
&& (txt.Find(_T(" not opened on this client")) == -1)
&& (txt.Find(_T(" not in client view")) == -1))
{
HWND hWnd= AfxGetMainWnd()->m_hWnd;
if( hWnd != NULL )
::PostMessage(hWnd, WM_COMMAND, ID_APP_EXIT, 0);
}
if( GET_SERVERLEVEL() > 0 && GET_SERVERLEVEL() < 3 )
{
TheApp()->StatusAdd( LoadStringResource(IDS_ERROR_P4WIN_REQUIRES_PERFORCE_SERVER_97_3_OR_NEWER), SV_ERROR );
m_FatalError = TRUE;
return;
}
if ( txt.Find( _T("Purely numeric name not allowed") ) > -1 )
m_FatalErrorCleared=TRUE;
// Subclasses of CP4Command should call HandledCmdSpecificError
//
// If a known error was not encountered, we still report the
// problem to the status window, but not with the SV_ERROR
// display code. Otherwise, if the error/warning occurrs
// a few hundred times, the user has to click 'OK' a few too
// many times for comfort. We also don't set m_FatalError,
// because there on occasion is a message sent to OutputError
// that is not fatal..
//
CString sErrBuf(errBuf);
CString sErrMsg(errMsg);
if( !HandledCmdSpecificError( sErrBuf, sErrMsg ))
{
TheApp()->StatusAdd( errMsg, SV_WARNING );
}
}
BOOL CP4Command::HandledCmdSpecificError(LPCTSTR errBuf, LPCTSTR errMsg)
{
return FALSE;
}
void CP4Command::OnErrorPause(LPCTSTR errBuf, Error *e)
{
// Check for possible abort request
if(APP_ABORTING() && m_Asynchronous)
{
ReleaseServerLock();
ExitThread(0);
}
TheApp()->StatusAdd(errBuf, SV_ERROR);
}
void CP4Command::ProcessResults(BOOL& done)
{
// Note: for commands without input lists, this default will
// do absolutely nothing
if(m_pStrListIn == NULL || m_pStrListIn->IsEmpty())
done = TRUE;
else if(!done)
done = NextListArgs();
}
void CP4Command::PreProcess(BOOL& done)
{
// Do nothing by default
}
void CP4Command::PostProcess()
{
// Do nothing by default
}
void CP4Command::DeleteResults()
{
// Do nothing by default
}
void CP4Command::OnInputData(StrBuf *strBuf, Error *e)
{
// object violently by default
ASSERT(0);
}
int CP4Command::OnResolve( ClientMerge *m, Error *e )
{
// object violently by default
ASSERT(0);
return CMS_QUIT;
}
void CP4Command::OnPrompt( const StrPtr &msg, StrBuf &rsp, int noEcho, Error *e )
{
ASSERT(0);
}
/*
_________________________________________________________________
put the client commands in the status pane, so we can debug.
since the users can see them, substitute asterisks for the password
if there is one.
hey! sometimes the command is blank, and the args are 0.
like for ostat.
_________________________________________________________________
*/
CString CP4Command::GetP4Command( )
{
CString msg ;
BOOL debug= FALSE;
#ifdef _DEBUG
debug=TRUE;
#endif
if( !debug && m_TaskName == _T("Password") )
msg= _T("p4 passwd");
else
{
int args = m_args.GetSize() ;
while ( args-- )
msg = CString ( _T(" ") ) + m_args[ args ] + msg;
msg = _T("p4") + msg;
}
return msg;
}
void CP4Command::SetServerKey(int lock)
{
ASSERT(lock);
m_ServerKey= lock;
m_HaveServerLock=TRUE;
}
int CP4Command::GetServerKey()
{
ASSERT(m_HaveServerLock);
return m_ServerKey;
}
BOOL CP4Command::GetServerLock(DWORD timeout)
{
ASSERT(!m_HaveServerLock);
if(m_Asynchronous)
{
XTRACE(_T("Async Task: %s Attempting lock...\n"), GetTaskName());
m_HaveServerLock=GET_SERVER_LOCK( m_ServerKey );
#ifdef _DEBUG
if(m_HaveServerLock)
XTRACE(_T("Async Task: %s Got lock...\n"), GetTaskName());
else
XTRACE(_T("Async Task: %s Failed to lock...\n"), GetTaskName());
#endif
}
else
// What is a syncro task doing getting a lock?
ASSERT(0);
return m_HaveServerLock;
}
void CP4Command::ReleaseServerLock()
{
if(m_Asynchronous)
{
ASSERT(m_HaveServerLock);
XTRACE(_T("Async Task: %s Releasing lock\n"), GetTaskName());
RELEASE_SERVER_LOCK( m_ServerKey);
m_HaveServerLock=FALSE;
m_ServerKey=0;
}
// else
// What is a syncro task doing releasing a lock?
// ASSERT(0);
// since ReleaseServerLock is called by command clients that
// can't determine if the command is syncro, can't faile here
}
void CP4Command::PostClientError()
{
// Attempt to activate the clients pane, and let the UI know that the
// error was due to a bad client
HWND hWnd= AfxGetMainWnd()->m_hWnd;
if( hWnd != NULL )
::PostMessage(hWnd, WM_CLIENTERROR, 0, 0);
}