able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/sdktools/debuggers/excepmon/emshell/emshellview.cpp

3773 lines
103 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
// emshellView.cpp : implementation of the CEmshellView class
//
#include "stdafx.h"
#include "emshell.h"
#include "ConnectionDlg.h"
#include "comdef.h"
#include "AutomaticSessDlg.h"
#include "RemoteSessDlg.h"
#include "PropPageGeneral.h"
#include "PropPageDumpFiles.h"
#include "PropPageLogFiles.h"
#include "PropPageGenLogDump.h"
#include "ReadLogsDlg.h"
#include "EmOptions.h"
#include "MSInfoDlg.h"
#include "emshellDoc.h"
#include "emshellView.h"
#include "afxdlgs.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#define ISTREAM_BUFFER_SIZE 0X10000
extern const TCHAR* gtcNone;
const TCHAR* gtcEmChm = _T("\\em.chm");
/////////////////////////////////////////////////////////////////////////////
// CEmshellView
IMPLEMENT_DYNCREATE(CEmshellView, CFormView)
BEGIN_MESSAGE_MAP(CEmshellView, CFormView)
//{{AFX_MSG_MAP(CEmshellView)
ON_WM_SIZE()
ON_WM_DESTROY()
ON_WM_TIMER()
ON_UPDATE_COMMAND_UI(ID_VIEW_REFRESH, OnUpdateViewRefresh)
ON_COMMAND(ID_REFRESH, OnViewRefresh)
ON_UPDATE_COMMAND_UI(ID_PROCESSPOPUP_STOPSESSION, OnUpdateProcesspopupStopDebugSession)
ON_COMMAND(ID_PROCESSPOPUP_STOPSESSION, OnProcesspopupStopDebugSession)
ON_COMMAND(ID_PROCESSPOPUP_GENERATEMINIDUMP, OnProcesspopupGenerateminidump)
ON_UPDATE_COMMAND_UI(ID_PROCESSPOPUP_GENERATEMINIDUMP, OnUpdateProcesspopupGenerateminidump)
ON_COMMAND(ID_PROCESSPOPUP_GENERATEUSERDUMP, OnProcesspopupGenerateuserdump)
ON_UPDATE_COMMAND_UI(ID_PROCESSPOPUP_GENERATEUSERDUMP, OnUpdateProcesspopupGenerateuserdump)
ON_COMMAND(ID_PROCESSPOPUP_AUTOMATICSESSION, OnProcesspopupAutomaticsession)
ON_UPDATE_COMMAND_UI(ID_PROCESSPOPUP_AUTOMATICSESSION, OnUpdateProcesspopupAutomaticsession)
ON_UPDATE_COMMAND_UI(ID_PROCESSPOPUP_PROPERTIES, OnUpdateProcesspopupProperties)
ON_COMMAND(ID_PROCESSPOPUP_PROPERTIES, OnProcesspopupProperties)
ON_UPDATE_COMMAND_UI(ID_PROCESSPOPUP_MANUALSESSION, OnUpdateProcesspopupManualsession)
ON_COMMAND(ID_PROCESSPOPUP_MANUALSESSION, OnProcesspopupManualsession)
ON_COMMAND(ID_PROCESSPOPUP_REFRESH, OnProcesspopupRefresh)
ON_UPDATE_COMMAND_UI(ID_PROCESSPOPUP_REFRESH, OnUpdateProcesspopupRefresh)
ON_COMMAND(ID_VIEW_SERVICESANDAPPLICATIONS, OnViewServicesandapplications)
ON_UPDATE_COMMAND_UI(ID_VIEW_SERVICESANDAPPLICATIONS, OnUpdateViewServicesandapplications)
ON_COMMAND(ID_VIEW_LOGFILES, OnViewLogfiles)
ON_UPDATE_COMMAND_UI(ID_VIEW_LOGFILES, OnUpdateViewLogfiles)
ON_COMMAND(ID_VIEW_DUMPFILES, OnViewDumpfiles)
ON_UPDATE_COMMAND_UI(ID_VIEW_DUMPFILES, OnUpdateViewDumpfiles)
ON_UPDATE_COMMAND_UI(ID_LOGPOPUP_OPEN, OnUpdateLogpopupOpen)
ON_COMMAND(ID_LOGPOPUP_OPEN, OnLogpopupOpen)
ON_UPDATE_COMMAND_UI(ID_LOGPOPUP_PROPERTIES, OnUpdateLogpopupProperties)
ON_COMMAND(ID_LOGPOPUP_PROPERTIES, OnLogpopupProperties)
ON_COMMAND(ID_VIEW_APPLICATIONS, OnViewApplications)
ON_UPDATE_COMMAND_UI(ID_VIEW_APPLICATIONS, OnUpdateViewApplications)
ON_COMMAND(ID_VIEW_COMPLETEDSESSIONS, OnViewCompletedsessions)
ON_UPDATE_COMMAND_UI(ID_VIEW_COMPLETEDSESSIONS, OnUpdateViewCompletedsessions)
ON_COMMAND(ID_VIEW_SERVICES, OnViewServices)
ON_UPDATE_COMMAND_UI(ID_VIEW_SERVICES, OnUpdateViewServices)
ON_COMMAND(ID_PROCESSPOPUP_DELETESESSION, OnProcesspopupDeleteSession)
ON_UPDATE_COMMAND_UI(ID_PROCESSPOPUP_DELETESESSION, OnUpdateProcesspopupDeleteSession)
ON_COMMAND(IDM_TOOLS_OPTOINS, OnToolsOptions)
ON_UPDATE_COMMAND_UI(IDM_TOOLS_OPTOINS, OnUpdateToolsOptoins)
ON_COMMAND(ID_PROCESSPOPUP_CANCELSESSION, OnProcesspopupCancelDebugSession)
ON_UPDATE_COMMAND_UI(ID_PROCESSPOPUP_CANCELSESSION, OnUpdateProcesspopupCancelDebugSession)
ON_COMMAND(ID_LOGPOPUP_DELETE, OnLogpopupDelete)
ON_UPDATE_COMMAND_UI(ID_LOGPOPUP_DELETE, OnUpdateLogpopupDelete)
ON_COMMAND(ID_ACTION_GENERATENFOFILE, OnActionGenerateMSInfoFile)
ON_UPDATE_COMMAND_UI(ID_ACTION_GENERATENFOFILE, OnUpdateActionGenerateMSInfoFile)
ON_COMMAND(ID_VIEW_MSINFOFILES, OnViewMSInfoFiles)
ON_UPDATE_COMMAND_UI(ID_VIEW_MSINFOFILES, OnUpdateViewMSInfoFiles)
ON_COMMAND(ID_LOGPOPUP_EXPORT, OnLogpopupExport)
ON_UPDATE_COMMAND_UI(ID_LOGPOPUP_EXPORT, OnUpdateLogpopupExport)
ON_COMMAND(ID_VIEW_REFRESH, OnViewRefresh)
ON_COMMAND(ID_HELP_CONTENTS, OnHelpContents)
//}}AFX_MSG_MAP
// Standard printing commands
ON_COMMAND(ID_FILE_PRINT, CFormView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_DIRECT, CFormView::OnFilePrint)
ON_COMMAND(ID_FILE_PRINT_PREVIEW, CFormView::OnFilePrintPreview)
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CEmshellView construction/destruction
CEmshellView::CEmshellView()
: CFormView(CEmshellView::IDD),
m_mainListControl(this)
{
//{{AFX_DATA_INIT(CEmshellView)
// NOTE: the ClassWizard will add member initialization here
//}}AFX_DATA_INIT
memset ( &m_lastSelectedEmObj, 0, sizeof ( EmObject ) );
}
CEmshellView::~CEmshellView()
{
}
void CEmshellView::DoDataExchange(CDataExchange* pDX)
{
CFormView::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CEmshellView)
DDX_Control(pDX, IDC_LST_MAINLISTCTRL, m_mainListControl);
//}}AFX_DATA_MAP
}
BOOL CEmshellView::PreCreateWindow(CREATESTRUCT& cs)
{
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs
return CFormView::PreCreateWindow(cs);
}
void CEmshellView::OnInitialUpdate()
{
CFormView::OnInitialUpdate();
SetShellState(SHELLVIEW_ALL);
GetParentFrame()->RecalcLayout();
ResizeParentToFit();
}
/////////////////////////////////////////////////////////////////////////////
// CEmshellView diagnostics
#ifdef _DEBUG
void CEmshellView::AssertValid() const
{
CFormView::AssertValid();
}
void CEmshellView::Dump(CDumpContext& dc) const
{
CFormView::Dump(dc);
}
CEmshellDoc* CEmshellView::GetDocument() // non-debug version is inline
{
ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CEmshellDoc)));
return (CEmshellDoc*)m_pDocument;
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CEmshellView message handlers
BSTR
CopyBSTR
(
LPBYTE pb,
ULONG cb
)
{
return ::SysAllocStringByteLen ((LPCSTR)pb, cb);
}
void CEmshellView::OnSize(UINT nType, int cx, int cy)
{
CFormView::OnSize(nType, cx, cy);
if (m_mainListControl.GetSafeHwnd()) {
UINT delta = 0;
// m_mainListControl.ResizeColumnsWithRatio();
m_mainListControl.MoveWindow(delta, delta, cx - (delta*2), cy- (delta*2));
}
SetScrollSizes(MM_TEXT, CSize(cx, cy));
}
PEmObject GetEmObj(BSTR bstrEmObj)
{
//Do a simple cast from a BSTR to an EmObject
return ((PEmObject)bstrEmObj);
}
HRESULT CEmshellView::DisplayLogData(PEmObject pEmObject)
{
_ASSERTE(pEmObject != NULL);
HRESULT hr = E_FAIL;
CString strFileSize;
CString strStartDate;
LONG lRow = 0L;
int nImage = 0;
int nImageOffset = 0;
do
{
if( pEmObject == NULL ){
hr = E_INVALIDARG;
break;
}
strFileSize.Format(_T("%d"), pEmObject->dwBucket1);
lRow = m_mainListControl.SetItemText(-1, 0, pEmObject->szName);
if(lRow == -1L){
hr = E_FAIL;
break;
}
//Set the itemData
m_mainListControl.SetItemData(lRow, (ULONG_PTR) pEmObject);
//Get the correct offset into the bitmap for the current status
nImageOffset = GetImageOffsetFromStatus((EmSessionStatus)pEmObject->nStatus);
//Call SetItem() with the index and image to show based on the state of pEmObject
m_mainListControl.SetItem(lRow, 0, LVIF_IMAGE, NULL, nImageOffset, 0, 0, 0);
lRow = m_mainListControl.SetItemText(lRow, 1, strFileSize);
if(lRow == -1L){
hr = E_FAIL;
break;
}
//
// a-mando
//
if( pEmObject->dateStart ) {
COleDateTime oleDtTm( pEmObject->dateStart );
strStartDate = oleDtTm.Format(_T("%c"));
lRow = m_mainListControl.SetItemText(lRow, 2, strStartDate);
if(lRow == -1L){
hr = E_FAIL;
break;
}
}
// a-mando
hr = S_OK;
}
while( false );
return hr;
}
HRESULT CEmshellView::DisplayMSInfoData(PEmObject pEmObject)
{
return DisplayDumpData(pEmObject);
}
HRESULT CEmshellView::DisplayDumpData(PEmObject pEmObject)
{
_ASSERTE(pEmObject != NULL);
HRESULT hr = E_FAIL;
CString strFileSize;
CString strStartDate;
LONG lRow = 0L;
int nImage = 0;
int nImageOffset = 0;
do
{
if( pEmObject == NULL ){
hr = E_INVALIDARG;
break;
}
strFileSize.Format(_T("%d"), pEmObject->dwBucket1);
lRow = m_mainListControl.SetItemText(-1, 0, pEmObject->szName);
if(lRow == -1L){
hr = E_FAIL;
break;
}
//Set the itemData
m_mainListControl.SetItemData(lRow, (ULONG_PTR) pEmObject);
//Get the correct offset into the bitmap for the current status
nImageOffset = GetImageOffsetFromStatus((EmSessionStatus)pEmObject->nStatus);
//Call SetItem() with the index and image to show based on the state of pEmObject
m_mainListControl.SetItem(lRow, 0, LVIF_IMAGE, NULL, nImageOffset, 0, 0, 0);
lRow = m_mainListControl.SetItemText(lRow, 1, strFileSize);
if(lRow == -1L){
hr = E_FAIL;
break;
}
//
// a-mando
//
if( pEmObject->dateStart ) {
COleDateTime oleDtTm( pEmObject->dateStart );
strStartDate = oleDtTm.Format(_T("%c"));
lRow = m_mainListControl.SetItemText(lRow, 2, strStartDate);
if(lRow == -1L){
hr = E_FAIL;
break;
}
}
// a-mando
hr = S_OK;
}
while( false );
return hr;
}
HRESULT CEmshellView::DisplayServiceData(PEmObject pEmObject)
{
_ASSERTE(pEmObject != NULL);
HRESULT hr = E_FAIL;
TCHAR szPid[20] = {0};
LONG lRow = 0L;
int nImage = 0;
CString csPROCStatus;
int nImageOffset = 0;
do
{
if( pEmObject == NULL ){
hr = E_INVALIDARG;
break;
}
_ltot(pEmObject->nId, szPid, 10);
lRow = m_mainListControl.SetItemText(-1, 0, pEmObject->szName);
if(lRow == -1L){
hr = E_FAIL;
break;
}
//Set the itemData
m_mainListControl.SetItemData(lRow, (ULONG_PTR) pEmObject);
//Get the correct offset into the bitmap for the current status
nImageOffset = GetImageOffsetFromStatus((EmSessionStatus)pEmObject->nStatus);
//Call SetItem() with the index and image to show based on the state of pEmObject
m_mainListControl.SetItem(lRow, 0, LVIF_IMAGE, NULL, nImageOffset, 0, 0, 0);
lRow = m_mainListControl.SetItemText(lRow, 1, pEmObject->szSecName);
if(lRow == -1L){
hr = E_FAIL;
break;
}
lRow = m_mainListControl.SetItemText(lRow, 2, pEmObject->szBucket1);
if(lRow == -1L){
hr = E_FAIL;
break;
}
lRow = m_mainListControl.SetItemText(lRow, 3, szPid);
if(lRow == -1L){
hr = E_FAIL;
break;
}
//
// a-mando
//
if( pEmObject->dateStart != 0L ) {
COleDateTime oleDtTm(pEmObject->dateStart);
CString strStartDate = oleDtTm.Format(_T("%c"));
lRow = m_mainListControl.SetItemText(lRow, 4, strStartDate );
if(lRow == -1L){
hr = E_FAIL;
break;
}
}
if( pEmObject->dateEnd != 0L ) {
COleDateTime oleDtTm(pEmObject->dateEnd);
CString strEndDate = oleDtTm.Format(_T("%c"));
lRow = m_mainListControl.SetItemText(lRow, 5, strEndDate );
if(lRow == -1L){
hr = E_FAIL;
break;
}
}
// a-mando
((CEmshellApp*)AfxGetApp())->GetStatusString(pEmObject->nStatus, csPROCStatus);
lRow = m_mainListControl.SetItemText(lRow, 6, csPROCStatus);
if(lRow == -1L){
hr = E_FAIL;
break;
}
hr = S_OK;
}
while( false );
return hr;
}
HRESULT CEmshellView::DisplayProcessData(PEmObject pEmObject)
{
_ASSERTE(pEmObject != NULL);
HRESULT hr = E_FAIL;
TCHAR szPid[20] = {0};
LONG lRow = 0L;
int nImage = 0;
CString csPROCStatus;
int nImageOffset = 0;
do
{
if( pEmObject == NULL ){
hr = E_INVALIDARG;
break;
}
_ltot(pEmObject->nId, szPid, 10);
lRow = m_mainListControl.SetItemText(-1, 0, pEmObject->szName);
if(lRow == -1L){
hr = E_FAIL;
break;
}
//Set the itemData
m_mainListControl.SetItemData(lRow, (ULONG_PTR) pEmObject);
//Get the correct offset into the bitmap for the current status
nImageOffset = GetImageOffsetFromStatus((EmSessionStatus)pEmObject->nStatus);
//Call SetItem() with the index and image to show based on the state of pEmObject
m_mainListControl.SetItem(lRow, 0, LVIF_IMAGE, NULL, nImageOffset, 0, 0, 0);
lRow = m_mainListControl.SetItemText(lRow, 1, szPid);
if(lRow == -1L){
hr = E_FAIL;
break;
}
//
// a-mando
//
if( pEmObject->dateStart != 0L ) {
COleDateTime oleDtTm(pEmObject->dateStart);
CString strStartDate = oleDtTm.Format(_T("%c"));
lRow = m_mainListControl.SetItemText(lRow, 2, strStartDate );
if(lRow == -1L){
hr = E_FAIL;
break;
}
}
if( pEmObject->dateEnd != 0L ) {
COleDateTime oleDtTm(pEmObject->dateEnd);
CString strEndDate = oleDtTm.Format(_T("%c"));
lRow = m_mainListControl.SetItemText(lRow, 3, strEndDate );
if(lRow == -1L){
hr = E_FAIL;
break;
}
}
// a-mando
((CEmshellApp*)AfxGetApp())->GetStatusString(pEmObject->nStatus, csPROCStatus);
lRow = m_mainListControl.SetItemText(lRow, 4, csPROCStatus);
if(lRow == -1L){
hr = E_FAIL;
break;
}
hr = S_OK;
}
while( false );
return hr;
}
HRESULT CEmshellView::DisplayStoppedSessionData(PEmObject pEmObject)
{
_ASSERTE(pEmObject != NULL);
return DisplayServiceData(pEmObject);
}
void CEmshellView::OnDestroy()
{
CFormView::OnDestroy();
//If we have sessions still open, there is a big problem
ASSERT(m_SessionTable.GetSize() == 0);
// m_ShellImageList.DeleteImageList();
}
CPtrArray* CEmshellView::GetSessionTable()
{
return &m_SessionTable;
}
void CEmshellView::ClearSessionTable()
{
//Iterate through the collection removing all the elements and calling release on all the
//session pointers. Also, call StopDebugSession CloseActiveSession and RemoveActiveSession
//on all the active sessions
IEmDebugSession* dsValue = NULL;
INT_PTR nUpperBound = 0;
PActiveSession pActiveSession = NULL;
HRESULT hr = S_OK;
do {
//Get the size of the array, start at the end, and remove each element
nUpperBound = m_SessionTable.GetUpperBound();
if( nUpperBound == -1 ) break;
for ( ; nUpperBound >= 0; nUpperBound-- ) {
pActiveSession = ( PActiveSession ) m_SessionTable.GetAt( nUpperBound );
if ( pActiveSession == NULL ) {
hr = E_FAIL;
break;
}
/* memcpy((void*)&emObject.guidstream, (void*)&pActiveSession->guid, sizeof( GUID ));
//Call StopDebug on this active session if we're the master.
if (pActiveSession->bMaster) {
hr = pActiveSession->pIDebugSession->StopDebug();
//So what are we supposed to do if it fails? We should still remove it from the active
//session table.
}
//Create bstr's for the journey ahead, and break if we can't
bstrEmObj = CopyBSTR ( (LPBYTE)&emObject, sizeof( EmObject ) );
if( bstrEmObj == NULL ){
hr = E_OUTOFMEMORY;
break;
}
//Call CloseSession on the pEmObject
hr = GetDocument()->GetEmManager()->CloseSession(bstrEmObj);
if (FAILED(hr)) {
CString strErrorMsg;
strErrorMsg.LoadString(IDS_ERROR_FAILEDCLOSESESSION);
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromString(strErrorMsg);
//We've handled the error, so set hr back to S_OK for the next time round
hr = S_OK;
}
*/
//Delete the pActiveSession. This will release the interface too
DeAllocActiveSession( pActiveSession );
//Remove the item from the array
m_SessionTable.RemoveAt( nUpperBound );
}
} while ( FALSE );
if ( FAILED( hr ) ) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR( hr );
}
}
HRESULT CEmshellView::StartManualDebugSession(EmObject* pEmObject)
{
IEmDebugSession* pIEmDebugSession = NULL;
HRESULT hr = E_FAIL;
BOOL bRetVal = FALSE;
CString strMessage;
INT_PTR nResult = 0;
BSTR bstrPath = NULL;
BSTR bstrEmObj = NULL;
BSTR bstrECXEmObject = NULL;
_variant_t varUsername;
_variant_t varPort;
_variant_t varPassword;
_variant_t varAltSymPath;
EmObject EmObjectFilter;
PEmObject pEmObjectTmp = NULL;
_variant_t var; //This will create and initialize the var variant
LONG lParam = 0;
do {
//Create bstr's for the journey ahead, and break if we can't
bstrEmObj = CopyBSTR ( (LPBYTE)pEmObject, sizeof( EmObject ) );
if( bstrEmObj == NULL ){
hr = E_OUTOFMEMORY;
break;
}
memcpy(&EmObjectFilter, pEmObject, sizeof( EmObject ) );
EmObjectFilter.type = EMOBJ_CMDSET;
bstrECXEmObject = CopyBSTR ( (LPBYTE)&EmObjectFilter, sizeof( EmObject ) );
//Start a debug session with OpenSession()
hr = GetDocument()->GetEmManager()->OpenSession(bstrEmObj, &pIEmDebugSession);
if ( hr == S_OK ) {
//Get the EnumObjects for the ECX list control so we can pass it to the dlg
hr = GetDocument()->GetEmManager()->EnumObjectsEx(bstrECXEmObject, &var);
if ( FAILED(hr) ) break;
PSessionSettings pSessionSettings = &((CEmshellApp*)AfxGetApp())->m_SessionSettings;
//Create the Automatic Session Dialog
CRemoteSessDlg dlg(pSessionSettings, &var);
nResult = dlg.DoModal();
if ( nResult == IDOK ) {
//Check if the user wanted to save the settings, if so, call UpdateSessionDlgData(FALSE)
if ( dlg.m_bRememberSettings ) {
((CEmshellApp*)AfxGetApp())->UpdateSessionData( TRUE );
}
if ( !dlg.m_strSelectedCommandSet.IsEmpty() && dlg.m_strSelectedCommandSet != gtcNone) {
bstrPath = dlg.m_strSelectedCommandSet.AllocSysString();
if( bstrPath == NULL ){
hr = E_OUTOFMEMORY;
break;
}
} else {
bstrPath = ::SysAllocString( _T("") );
}
varUsername = pSessionSettings->strUsername.AllocSysString();
varPassword = pSessionSettings->strPassword.AllocSysString();
varPort.ChangeType(VT_I4);
varPort.lVal = _ttoi(pSessionSettings->strPort);
varAltSymPath = pSessionSettings->strAltSymbolPath.AllocSysString();
//Init the var to nothing
var.Clear();
//Time to call DebugEx(), get ready for the ride!
hr = pIEmDebugSession->DebugEx(bstrEmObj,
SessType_Manual,
bstrPath,
lParam,
varUsername,
varPassword,
varPort,
var,
varAltSymPath);
//We don't need the bstr's, release them.
SysFreeString ( bstrPath );
if ( FAILED(hr) ) break;
//Convert the bstrEmObj to an PEmObject and memcopy it into the itemdata's PEmObject
pEmObjectTmp = GetEmObj(bstrEmObj);
if( pEmObject == NULL ){
hr = E_FAIL;
break;
}
memcpy(pEmObject, pEmObjectTmp, sizeof( EmObject ) );
AddActiveSession(pEmObject, pIEmDebugSession, TRUE);
/* TCHAR szClientConnectString[_MAX_PATH] = {0};
//Start the local cdb session
GetClientConnectString(szClientConnectString, _MAX_PATH, pEmObject, varPort.lVal);
hr = StartCDBClient(szClientConnectString);
if ( FAILED(hr) ) break;
*/
}
else {
//release the debugsession pointer, the user decided to cancel
if ( pIEmDebugSession != NULL )
//If we got here, we shouldn't have created an active session, so just release the
//debug interface
SAFE_RELEASEIX(pIEmDebugSession);
}
}
else if ( hr == S_FALSE ) {
//We were not able to open a master session, ask the user if they
//would like to be the owner if this is an orphan
if ( pEmObject->nStatus & STAT_ORPHAN ) {
if ( CommenceOrphanCustodyBattle( pIEmDebugSession ) ) {
//Get the status of the EmObject
hr = pIEmDebugSession->GetStatus( bstrEmObj );
if ( FAILED( hr ) ) break;
//Convert the bstrEmObj to an PEmObject and memcopy it into the itemdata's PEmObject
pEmObjectTmp = GetEmObj(bstrEmObj);
if (pEmObjectTmp == NULL) break;
memcpy(pEmObject, pEmObjectTmp, sizeof( EmObject ) );
AddActiveSession(pEmObject, pIEmDebugSession, TRUE);
break;
}
}
//We were not able to open a master session, ask the user if they
//would like to spectate
strMessage.LoadString( IDS_DEBUG_ERROR );
if ( ( (CEmshellApp*) AfxGetApp() )->DisplayErrMsgFromString( strMessage, MB_YESNO ) == IDYES ) {
//Convert the bstrEmObj to an PEmObject and memcopy it into the itemdata's PEmObject
pEmObjectTmp = GetEmObj(bstrEmObj);
if (pEmObjectTmp == NULL) break;
memcpy(pEmObject, pEmObjectTmp, sizeof( EmObject ) );
AddActiveSession(pEmObject, pIEmDebugSession, FALSE);
break;
}
else {
//Release the debug interface, we never created an activesession.
SAFE_RELEASEIX(pIEmDebugSession);
}
}
} while (FALSE);
if (FAILED(hr)) {
if ( pIEmDebugSession != NULL )
//If we got here, we shouldn't have created an active session, so just release the
//debug interface
SAFE_RELEASEIX(pIEmDebugSession);
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR(hr);
}
SysFreeString ( bstrPath );
SysFreeString ( bstrEmObj );
SysFreeString ( bstrECXEmObject );
//Update the status of the EmObjects ListElement to reflect it's new status
UpdateListElement(pEmObject);
return hr;
}
HRESULT CEmshellView::StartAutomaticDebugSession(PEmObject pEmObject)
{
IEmDebugSession* pIEmDebugSession = NULL;
HRESULT hr = E_FAIL;
BOOL bRetVal = FALSE;
CString strMessage;
INT_PTR nResult = 0;
BSTR bstrPath = NULL;
BSTR bstrEmObj = NULL;
BSTR bstrECXEmObject = NULL;
_variant_t varAdminName;
_variant_t varAltSymPath;
PEmObject pEmObjectTmp = NULL;
EmObject EmObjectFilter;
_variant_t var; //This will create and initialize the var variant
LONG lParam = 0;
do {
//Create bstr's for the journey ahead, and break if we can't
bstrEmObj = CopyBSTR ( (LPBYTE)pEmObject, sizeof( EmObject ) );
memcpy(&EmObjectFilter, pEmObject, sizeof( EmObject ) );
EmObjectFilter.type = EMOBJ_CMDSET;
bstrECXEmObject = CopyBSTR ( (LPBYTE)&EmObjectFilter, sizeof( EmObject ) );
if( bstrEmObj == NULL ){
hr = E_OUTOFMEMORY;
break;
}
//Start a debug session with OpenSession()
hr = GetDocument()->GetEmManager()->OpenSession(bstrEmObj, &pIEmDebugSession);
if ( hr == S_OK ) {
//Get the EnumObjects for the ECX list control so we can pass it to the dlg
hr = GetDocument()->GetEmManager()->EnumObjectsEx(bstrECXEmObject, &var);
if ( FAILED(hr) ) break;
PSessionSettings pSessionSettings = &((CEmshellApp*)AfxGetApp())->m_SessionSettings;
//Create the Automatic Session Dialog
CAutomaticSessDlg dlg(pSessionSettings, &var, (EmObjectType)pEmObject->type);
nResult = dlg.DoModal();
if ( nResult == IDOK ) {
//Check if the user wanted to save the settings, if so, call UpdateRegistry()
if ( dlg.m_bRememberSettings ) {
((CEmshellApp*)AfxGetApp())->UpdateSessionData( TRUE );
}
bstrPath = dlg.m_strSelectedCommandSet.AllocSysString();
if( bstrPath == NULL ){
hr = E_OUTOFMEMORY;
break;
}
varAdminName = pSessionSettings->strAdminName.AllocSysString();
varAltSymPath = pSessionSettings->strAltSymbolPath.AllocSysString();
//Init the var to nothing
var.Clear();
if ( dlg.m_bRecursiveMode ) lParam = lParam | RECURSIVE_MODE;
if ( dlg.m_bMiniDump ) lParam = lParam | PRODUCE_MINI_DUMP;
if ( dlg.m_bUserDump ) lParam = lParam | PRODUCE_USER_DUMP;
//Set the cursor to a wait cursor
CWaitCursor wait;
//Time to call DebugEx(), get ready for the ride!
hr = pIEmDebugSession->DebugEx(bstrEmObj,
SessType_Automatic,
bstrPath,
lParam,
var,
var,
var,
varAdminName,
varAltSymPath);
//We don't need the bstr's, release them.
SysFreeString ( bstrPath );
if ( FAILED(hr) ) break;
//Convert the bstrEmObj to an PEmObject and memcopy it into the itemdata's PEmObject
pEmObjectTmp = GetEmObj(bstrEmObj);
if( pEmObject == NULL ){
hr = E_FAIL;
break;
}
memcpy(pEmObject, pEmObjectTmp, sizeof( EmObject ) );
AddActiveSession(pEmObject, pIEmDebugSession, TRUE);
}
else {
//release the debugsession pointer, the user decided to cancel
if ( pIEmDebugSession != NULL )
//If we got here, we shouldn't have created an active session, so just release the
//debug interface
SAFE_RELEASEIX(pIEmDebugSession);
}
}
else if ( hr == S_FALSE ) {
//We were not able to open a master session, ask the user if they
//would like to be the owner if this is an orphan
if ( pEmObject->nStatus & STAT_ORPHAN ) {
if ( CommenceOrphanCustodyBattle( pIEmDebugSession ) ) {
//Get the status of the EmObject
hr = pIEmDebugSession->GetStatus( bstrEmObj );
if ( FAILED( hr ) ) break;
//Convert the bstrEmObj to an PEmObject and memcopy it into the itemdata's PEmObject
pEmObjectTmp = GetEmObj(bstrEmObj);
if (pEmObjectTmp == NULL) break;
memcpy(pEmObject, pEmObjectTmp, sizeof( EmObject ) );
AddActiveSession(pEmObject, pIEmDebugSession, TRUE);
break;
}
}
//We were not able to open a master session, ask the user if they
//would like to spectate
strMessage.LoadString( IDS_DEBUG_ERROR );
if (((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromString(strMessage, MB_YESNO) == IDYES) {
//Convert the bstrEmObj to an PEmObject and memcopy it into the itemdata's PEmObject
pEmObjectTmp = GetEmObj(bstrEmObj);
if (pEmObjectTmp == NULL) break;
memcpy(pEmObject, pEmObjectTmp, sizeof( EmObject ) );
AddActiveSession(pEmObject, pIEmDebugSession, FALSE);
break;
}
else {
//Release the debug interface, we never created an activesession.
SAFE_RELEASEIX(pIEmDebugSession);
}
}
} while (FALSE);
if (FAILED(hr)) {
if ( pIEmDebugSession != NULL )
//If we got here, we shouldn't have created an active session, so just release the
//debug interface
SAFE_RELEASEIX(pIEmDebugSession);
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR(hr);
}
SysFreeString ( bstrPath );
SysFreeString ( bstrEmObj );
SysFreeString ( bstrECXEmObject );
//Update the status of the EmObjects ListElement to reflect it's new status
UpdateListElement(pEmObject);
return hr;
}
void CEmshellView::DeAllocActiveSession(PActiveSession pActiveSession)
{
//Release the DebugSession
SAFE_RELEASEIX(pActiveSession->pIDebugSession);
if (pActiveSession != NULL)
delete pActiveSession;
else ((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR(E_FAIL);
}
PActiveSession CEmshellView::AllocActiveSession(PEmObject pEmObject, IEmDebugSession* pIDebugSession)
{
HRESULT hr = E_FAIL;
PActiveSession pActiveSession = NULL;
do {
//Allocate an ActiveSession object, initialize it, and return it
pActiveSession = new ActiveSession;
if (pActiveSession == NULL) {
hr = E_OUTOFMEMORY;
break;
}
//Initialize the members
pActiveSession->pEmObject = pEmObject;
pActiveSession->pIDebugSession = pIDebugSession;
pActiveSession->bMaster = FALSE;
memcpy((void*)&pActiveSession->guid, (void*)pEmObject->guidstream, sizeof( GUID ));
hr = S_OK;
} while (FALSE);
if (FAILED(hr)) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR(hr);
}
return pActiveSession;
}
void CEmshellView::OnTimer(UINT nIDEvent)
{
INT_PTR nUpperBound = 0;
PActiveSession pActiveSession = NULL;
HRESULT hr = S_OK;
PEmObject pEmObject = NULL;
BSTR bstrEmObj = NULL;
PEmObject pEmObjectTmp = NULL;
if ( m_SessionTable.GetSize() > 0 ) {
//Step through all the elements in the session table updating the status if it has a valid pEmObject
for ( nUpperBound = m_SessionTable.GetUpperBound(); nUpperBound >= 0; nUpperBound-- ) {
pActiveSession = ( PActiveSession ) m_SessionTable.GetAt( nUpperBound );
if ( pActiveSession == NULL ) {
hr = E_FAIL;
break;
}
pEmObject = pActiveSession->pEmObject;
//If we don't have an EmObject to refresh, we don't need to handle this one.
if( pEmObject == NULL ) {
continue;
}
//Create bstr's for the journey ahead, and break if we can't
bstrEmObj = CopyBSTR ( ( LPBYTE )pEmObject, sizeof( EmObject ) );
if( bstrEmObj == NULL ){
hr = E_OUTOFMEMORY;
break;
}
hr = pActiveSession->pIDebugSession->GetStatus( bstrEmObj );
//If we failed to get the status on this session, don't stop, just continue to the next session
if (FAILED( hr )) {
hr = S_OK;
continue;
}
//Convert the bstrEmObj to an PEmObject and memcopy it into the itemdata's PEmObject
pEmObjectTmp = GetEmObj( bstrEmObj );
if ( pEmObjectTmp == NULL ) {
hr = E_FAIL;
break;
}
SysFreeString( bstrEmObj );
memcpy( pEmObject, pEmObjectTmp, sizeof( EmObject ) );
//Update the ListCtl with the new info
UpdateListElement( pEmObject );
}
}
if ( FAILED( hr ) ) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR( hr );
}
SysFreeString ( bstrEmObj );
CFormView::OnTimer( nIDEvent );
}
HRESULT CEmshellView::RemoveActiveSession( PEmObject pEmObject )
{
INT_PTR nUpperBound = 0;
PActiveSession pActiveSession = NULL;
//Search the session table looking for pEmObject->guidstream, if found close it
//We don't call FindActiveSession() because we don't get the position of the element,
//so do our own search...again :/
for ( nUpperBound = m_SessionTable.GetUpperBound(); nUpperBound >= 0; nUpperBound-- ) {
pActiveSession = ( PActiveSession ) m_SessionTable.GetAt( nUpperBound );
if ( pActiveSession == NULL ) {
break;
}
if( memcmp( ( void * ) &pActiveSession->guid, ( void * ) pEmObject->guidstream, sizeof( GUID ) ) == 0 ) {
//Delete the pActiveSession. This will release the interface
DeAllocActiveSession( pActiveSession );
//Remove the item from the array
m_SessionTable.RemoveAt( nUpperBound );
//We have found the element, stop the search
break;
}
}
return S_OK;
}
HRESULT CEmshellView::DeleteDebugSession( PEmObject pEmObject )
{
HRESULT hr = E_FAIL;
BSTR bstrEmObj = NULL;
do {
//Set the cursor to a wait cursor
CWaitCursor wait;
//Create bstr's for the journey ahead, and break if we can't
bstrEmObj = CopyBSTR ( (LPBYTE)pEmObject, sizeof( EmObject ) );
if( bstrEmObj == NULL ){
hr = E_OUTOFMEMORY;
break;
}
//Close the active session
hr = GetDocument()->GetEmManager()->DeleteSession( bstrEmObj );
if ( FAILED( hr ) ) {
break;
}
} while ( FALSE );
if ( FAILED( hr ) ) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR( hr );
}
SysFreeString ( bstrEmObj );
return hr;
}
void CEmshellView::CancelDebugSession( PEmObject pEmObject )
{
PActiveSession pActiveSession = NULL;
HRESULT hr = S_OK;
BSTR bstrEmObj = NULL;
PEmObject pEmObjectTmp = NULL;
IEmDebugSession* pTempDebugSession = NULL;
do {
pActiveSession = FindActiveSession( pEmObject );
if ( pActiveSession == NULL ) {
//Create bstr's for the journey ahead, and break if we can't
bstrEmObj = CopyBSTR ( ( LPBYTE ) pEmObject, sizeof( EmObject ) );
if( bstrEmObj == NULL ) {
hr = E_OUTOFMEMORY;
break;
}
//We don't have a session open, so open a temporary session
hr = GetDocument()->GetEmManager()->OpenSession( bstrEmObj, &pTempDebugSession );
//If we can't get an S_OK, then it's not an orphan, just release the interface.
if ( FAILED( hr ) ) {
if ( pTempDebugSession ) {
//Release the pTempDebugSession pointer
SAFE_RELEASEIX( pTempDebugSession );
}
break;
}
//If it's an orphan, ask the user if they want to take control, and if so, add it to our session table
if ( CommenceOrphanCustodyBattle( pTempDebugSession ) ) {
pActiveSession = AddActiveSession( pEmObject, pTempDebugSession, TRUE );
if ( !pActiveSession ) {
if ( pTempDebugSession ) {
//Release the pTempDebugSession pointer
SAFE_RELEASEIX( pTempDebugSession );
}
break;
}
}
else {
if ( pTempDebugSession ) {
//Release the pTempDebugSession pointer
SAFE_RELEASEIX( pTempDebugSession );
}
break;
}
}
else if ( !pActiveSession->bMaster ) {
//We're not the master, so try to become one
hr = pActiveSession->pIDebugSession->AdoptOrphan();
if ( SUCCEEDED( hr ) ) {
//We're now the master, so update the bMaster flag and continue
pActiveSession->bMaster = TRUE;
}
else {
//We couldn't get ownership of the session, abort with a message.
break;
}
}
//Set the cursor to a wait cursor
CWaitCursor wait;
//Stop the debug session
hr = pActiveSession->pIDebugSession->CancelDebug( TRUE );
if ( FAILED( hr ) ) {
break;
}
//Create bstr's for the journey ahead, and break if we can't
bstrEmObj = CopyBSTR ( ( LPBYTE ) pEmObject, sizeof( EmObject ) );
if( bstrEmObj == NULL ) {
hr = E_OUTOFMEMORY;
break;
}
//Get the status of the EmObject
hr = pActiveSession->pIDebugSession->GetStatus( bstrEmObj );
if ( FAILED( hr ) ) break;
//Convert the bstrEmObj to an PEmObject and memcopy it into the itemdata's PEmObject
pEmObjectTmp = GetEmObj(bstrEmObj);
if (pEmObjectTmp == NULL) {
hr = E_FAIL;
break;
}
SysFreeString( bstrEmObj );
//Remove the session from the active session table
RemoveActiveSession( pEmObject );
//Update the ListCtl with the new info. The status should read Debug Completed or some such
memcpy(pEmObject, pEmObjectTmp, sizeof( EmObject ) );
UpdateListElement( pEmObject );
} while( FALSE );
if ( FAILED( hr ) ) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR( hr );
}
SysFreeString ( bstrEmObj );
}
BOOL CEmshellView::CommenceOrphanCustodyBattle( IEmDebugSession* pIEmDebugSession )
{
HRESULT hr;
CString strMessage;
BOOL bRetVal = FALSE;
strMessage.LoadString( IDS_ORPHANCUSTODYCONFIRM );
//Ask the user if they want custody of the orphan
if (((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromString( strMessage, MB_YESNO ) == IDYES) {
//Take control and exit
hr = pIEmDebugSession->AdoptOrphan();
if ( SUCCEEDED( hr ) ) {
bRetVal = TRUE;
}
else {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR( hr );
}
}
return bRetVal;
}
void CEmshellView::StopDebugSession( PEmObject pEmObject )
{
PActiveSession pActiveSession = NULL;
HRESULT hr = S_OK;
BSTR bstrEmObj = NULL;
PEmObject pEmObjectTmp = NULL;
IEmDebugSession* pTempDebugSession = NULL;
do {
pActiveSession = FindActiveSession( pEmObject );
if ( pActiveSession == NULL ) {
//Create bstr's for the journey ahead, and break if we can't
bstrEmObj = CopyBSTR ( ( LPBYTE ) pEmObject, sizeof( EmObject ) );
if( bstrEmObj == NULL ) {
hr = E_OUTOFMEMORY;
break;
}
//We don't have a session open, so open a temporary session
hr = GetDocument()->GetEmManager()->OpenSession( bstrEmObj, &pTempDebugSession );
//Convert the bstrEmObj to an PEmObject and memcopy it into the itemdata's PEmObject
pEmObjectTmp = GetEmObj(bstrEmObj);
if (pEmObjectTmp == NULL) {
hr = E_FAIL;
break;
}
SysFreeString( bstrEmObj );
//If we can't get an S_OK, then it's not an orphan, just release the interface.
if ( FAILED( hr ) ) {
if ( pTempDebugSession ) {
//Release the pTempDebugSession pointer
SAFE_RELEASEIX( pTempDebugSession );
}
break;
}
//If it's an orphan, ask the user if they want to take control, and if successfull,
//add it to our session table
if ( pEmObject->nStatus & STAT_ORPHAN && CommenceOrphanCustodyBattle( pTempDebugSession ) ) {
pActiveSession = AddActiveSession( pEmObject, pTempDebugSession, TRUE );
if ( !pActiveSession ) {
if ( pTempDebugSession ) {
//Release the pTempDebugSession pointer
SAFE_RELEASEIX( pTempDebugSession );
break;
}
}
}
else {
if ( pTempDebugSession ) {
//Release the pTempDebugSession pointer
SAFE_RELEASEIX( pTempDebugSession );
}
break;
}
}
else if ( !pActiveSession->bMaster ) {
//We're not the master, so try to become one
hr = pActiveSession->pIDebugSession->AdoptOrphan();
if ( SUCCEEDED( hr ) ) {
//We're now the master, so update the bMaster flag and continue
pActiveSession->bMaster = TRUE;
}
else {
//We couldn't get ownership of the session, just remove the session from the active session table.
//Remove the session from the active session table
RemoveActiveSession( pEmObject );
hr = S_OK;
break;
}
}
//Set the cursor to a wait cursor
CWaitCursor wait;
//Stop the debug session
hr = pActiveSession->pIDebugSession->StopDebug( TRUE );
if ( FAILED( hr ) ) {
break;
}
//Create bstr's for the journey ahead, and break if we can't
bstrEmObj = CopyBSTR ( ( LPBYTE ) pEmObject, sizeof( EmObject ) );
if( bstrEmObj == NULL ) {
hr = E_OUTOFMEMORY;
break;
}
//Get the status of the EmObject
hr = pActiveSession->pIDebugSession->GetStatus( bstrEmObj );
if ( FAILED( hr ) ) break;
//Convert the bstrEmObj to an PEmObject and memcopy it into the itemdata's PEmObject
pEmObjectTmp = GetEmObj(bstrEmObj);
if (pEmObjectTmp == NULL) {
hr = E_FAIL;
break;
}
SysFreeString( bstrEmObj );
//Remove the session from the active session table
// RemoveActiveSession( pEmObject );
//Update the ListCtl with the new info. The status should read Debug Completed or some such
memcpy(pEmObject, pEmObjectTmp, sizeof( EmObject ) );
UpdateListElement( pEmObject );
} while( FALSE );
if ( FAILED( hr ) ) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR( hr );
}
SysFreeString ( bstrEmObj );
}
PActiveSession CEmshellView::AddActiveSession(PEmObject pEmObject, IEmDebugSession* pIEmDebugSession, BOOL bMaster)
{
PActiveSession pActiveSession = NULL;
do {
pActiveSession = AllocActiveSession(pEmObject, pIEmDebugSession);
if (pActiveSession == NULL) break;
//Initialize the bMaster flag of the active session object
pActiveSession->bMaster = bMaster;
//Set the session type
pActiveSession->nSessionType = (SessionType) pEmObject->type2;
//Set the object type
pActiveSession->emObjType = (EmObjectType) pEmObject->type;
//Add the pDebugSession to the session table if we succeeded in opening a debug session
m_SessionTable.Add((void*&)pActiveSession);
} while ( FALSE );
return pActiveSession;
}
void CEmshellView::UpdateListElement(PEmObject pEmObject)
{
switch (m_enumShellViewState) {
case SHELLVIEW_ALL:
RefreshAllViewElement(pEmObject);
break;
case SHELLVIEW_APPLICATIONS:
RefreshProcessViewElement(pEmObject);
break;
case SHELLVIEW_SERVICES:
RefreshServiceViewElement(pEmObject);
break;
case SHELLVIEW_COMPLETEDSESSIONS:
RefreshCompletedSessionViewElement(pEmObject);
break;
case SHELLVIEW_LOGFILES:
RefreshLogViewElement(pEmObject);
break;
case SHELLVIEW_DUMPFILES:
RefreshDumpViewElement(pEmObject);
break;
case SHELLVIEW_NONE:
default:
break;
}
}
void CEmshellView::RefreshProcessViewElement(PEmObject pEmObject)
{
CString strTempString = _T("");
int nImageOffset = 0;
//Given an PEmObject, find the element in the ListCtl, update it's image
//and call UpdateData on the ListControl
PEmObject pListEmObject = NULL;
//Step through every item in the list control searching for pEmObject
int nCount = m_mainListControl.GetItemCount();
for (int i = 0;i < nCount; i++) {
pListEmObject = (PEmObject)m_mainListControl.GetItemData(i);
if (pListEmObject == NULL) break;
if (memcmp((void *)pListEmObject->guidstream, (void *)pEmObject->guidstream, sizeof( GUID ) ) == 0) {
//Get the correct offset into the bitmap for the current status
nImageOffset = GetImageOffsetFromStatus((EmSessionStatus)pEmObject->nStatus);
//We have found the item, update its image based on its state
m_mainListControl.SetItem(i, 0, LVIF_IMAGE, NULL, nImageOffset, 0, 0, 0);
//Image Name
strTempString.Format(_T("%s"), pListEmObject->szName);
m_mainListControl.SetItemText(i, 0, strTempString);
//PID
strTempString.Format(_T("%d"), pListEmObject->nId);
m_mainListControl.SetItemText(i, 1, strTempString);
//
// a-mando
//
// Start Date
if( pEmObject->dateStart != 0L ) {
COleDateTime oleDtTm(pListEmObject->dateStart);
CString strStartDate = oleDtTm.Format(_T("%c"));
m_mainListControl.SetItemText(i, 2, strStartDate );
}
// End Date
if( pEmObject->dateEnd != 0L ) {
COleDateTime oleDtTm(pListEmObject->dateEnd);
CString strEndDate = oleDtTm.Format(_T("%c"));
m_mainListControl.SetItemText(i, 3, strEndDate );
}
// a-mando
//Status
((CEmshellApp*)AfxGetApp())->GetStatusString(pListEmObject->nStatus, strTempString);
m_mainListControl.SetItemText(i, 4, strTempString);
m_mainListControl.Update(i);
//We have found the element, stop the search
break;
}
}
}
void CEmshellView::RefreshServiceViewElement(PEmObject pEmObject)
{
CString strTempString = _T("");
int nImageOffset = 0;
//Given an PEmObject, find the element in the ListCtl, update it's image
//and call UpdateData on the ListControl
PEmObject pListEmObject = NULL;
//Step through every item in the list control searching for pEmObject
int nCount = m_mainListControl.GetItemCount();
for (int i = 0;i < nCount; i++) {
pListEmObject = (PEmObject)m_mainListControl.GetItemData(i);
if (pListEmObject == NULL) break;
if (memcmp((void *)pListEmObject->guidstream, (void *)pEmObject->guidstream, sizeof( GUID ) ) == 0) {
//Get the correct offset into the bitmap for the current status
nImageOffset = GetImageOffsetFromStatus((EmSessionStatus)pEmObject->nStatus);
//We have found the item, update its image based on its state
m_mainListControl.SetItem(i, 0, LVIF_IMAGE, NULL, nImageOffset, 0, 0, 0);
//Image Name
strTempString.Format(_T("%s"), pListEmObject->szName);
m_mainListControl.SetItemText(i, 0, strTempString);
//Short Name
strTempString.Format(_T("%s"), pListEmObject->szSecName);
m_mainListControl.SetItemText(i, 1, strTempString);
//Description Name
strTempString.Format(_T("%s"), pListEmObject->szBucket1);
m_mainListControl.SetItemText(i, 2, strTempString);
//PID
strTempString.Format(_T("%d"), pListEmObject->nId);
m_mainListControl.SetItemText(i, 3, strTempString);
//
// a-mando
//
if( pEmObject->dateStart != 0L ) {
COleDateTime oleDtTm(pListEmObject->dateStart);
CString strStartDate = oleDtTm.Format(_T("%c"));
m_mainListControl.SetItemText(i, 4, strStartDate );
}
if( pEmObject->dateEnd != 0L ) {
COleDateTime oleDtTm(pListEmObject->dateEnd);
CString strEndDate = oleDtTm.Format(_T("%c"));
m_mainListControl.SetItemText(i, 5, strEndDate );
}
// a-mando
//Status
((CEmshellApp*)AfxGetApp())->GetStatusString(pListEmObject->nStatus, strTempString);
m_mainListControl.SetItemText(i, 6, strTempString);
m_mainListControl.Update(i);
//We have found the element, stop the search
break;
}
}
}
void CEmshellView::RefreshCompletedSessionViewElement(PEmObject pEmObject)
{
RefreshServiceViewElement(pEmObject);
}
void CEmshellView::RefreshAllViewElement(PEmObject pEmObject)
{
RefreshServiceViewElement(pEmObject);
}
void CEmshellView::RefreshLogViewElement(PEmObject pEmObject)
{
CString strTempString = _T("");
int nImageOffset = 0;
int nImage = 0;
//Given an PEmObject, find the element in the ListCtl, update it's image
//and call UpdateData on the ListControl
PEmObject pListEmObject = NULL;
//Step through every item in the list control searching for pEmObject
int nCount = m_mainListControl.GetItemCount();
for (int i = 0;i < nCount; i++) {
pListEmObject = (PEmObject)m_mainListControl.GetItemData(i);
if (pListEmObject == NULL) break;
if (memcmp((void *)pListEmObject->guidstream, (void *)pEmObject->guidstream, sizeof( GUID ) ) == 0) {
//Get the correct offset into the bitmap for the current status
nImageOffset = GetImageOffsetFromStatus((EmSessionStatus)pEmObject->nStatus);
//We have found the item, update its image based on its state
m_mainListControl.SetItem(i, 0, LVIF_IMAGE, NULL, nImageOffset, 0, 0, 0);
//Image Name
strTempString.Format(_T("%d bytes"), pListEmObject->szName);
m_mainListControl.SetItemText(i, 0, strTempString);
//File Size
strTempString.Format(_T("%d"), pListEmObject->dwBucket1);
m_mainListControl.SetItemText(i, 1, strTempString);
m_mainListControl.Update(i);
//We have found the element, stop the search
break;
}
}
}
void CEmshellView::RefreshDumpViewElement(PEmObject pEmObject)
{
RefreshLogViewElement(pEmObject);
}
void CEmshellView::ReSynchApplications()
{
//iterate through all the sessions and find the corrisponding GUID in the ListCtrl
//Clear the list control
PEmObject pEmObject = NULL;
INT_PTR nUpperBound = 0;
PActiveSession pActiveSession = NULL;
HRESULT hr = S_OK;
BOOL bFound = FALSE;
do {
nUpperBound = m_SessionTable.GetUpperBound();
if (nUpperBound == -1) break;
//Get the GUID and look it up in the session table
//If found, map the pEmObject to the session, else remove it.
for (; nUpperBound >= 0; nUpperBound--) {
pActiveSession = (PActiveSession) m_SessionTable.GetAt(nUpperBound);
if (pActiveSession == NULL) {
hr = E_FAIL;
break;
}
//If the pActiveSession is not process, continue
if ( pActiveSession->emObjType != EMOBJ_PROCESS ) continue;
//Step through every item in the list control
int nCount = m_mainListControl.GetItemCount();
for (int i = 0;i < nCount; i++) {
pEmObject = (PEmObject)m_mainListControl.GetItemData(i);
if (pEmObject == NULL) {
hr = E_FAIL;
break;
}
if(memcmp((void *)&pActiveSession->guid, (void *)pEmObject->guidstream, sizeof( GUID ) ) == 0) {
//Assign the pEmObject to the pActiveSession
pActiveSession->pEmObject = pEmObject;
//We have found the element, stop the search
bFound = TRUE;
break;
}
}
if (!bFound) {
//We have a session table element that does not map to a list element
//Notify the error of the anomoly and remove it from the session table
CString strMessage;
strMessage.LoadString(IDS_SESSIONLISTANOMOLY);
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromString(strMessage);
//Delete the pActiveSession. This will release the interface too
DeAllocActiveSession(pActiveSession);
//Remove the item from the session table
m_SessionTable.RemoveAt(nUpperBound);
break;
}
}
} while (FALSE);
if (FAILED(hr)) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR(hr);
}
}
void CEmshellView::ReSynchServices()
{
//iterate through all the sessions and find the corrisponding GUID in the ListCtrl
//Clear the list control
PEmObject pEmObject = NULL;
INT_PTR nUpperBound = 0;
PActiveSession pActiveSession = NULL;
HRESULT hr = S_OK;
BOOL bFound = FALSE;
do {
nUpperBound = m_SessionTable.GetUpperBound();
if (nUpperBound == -1) break;
//Get the GUID and look it up in the session table
//If found, map the pEmObject to the session, else remove it.
for (; nUpperBound >= 0; nUpperBound--) {
pActiveSession = (PActiveSession) m_SessionTable.GetAt(nUpperBound);
if (pActiveSession == NULL) {
hr = E_FAIL;
break;
}
//If the pActiveSession is not service, continue
if ( pActiveSession->emObjType != EMOBJ_SERVICE ) continue;
//Step through every item in the list control
int nCount = m_mainListControl.GetItemCount();
for (int i = 0;i < nCount; i++) {
pEmObject = (PEmObject)m_mainListControl.GetItemData(i);
if (pEmObject == NULL) {
hr = E_FAIL;
break;
}
if(memcmp((void *)&pActiveSession->guid, (void *)pEmObject->guidstream, sizeof( GUID ) ) == 0) {
//Assign the pEmObject to the pActiveSession
pActiveSession->pEmObject = pEmObject;
//We have found the element, stop the search
bFound = TRUE;
break;
}
}
if (!bFound) {
//We have a session table element that does not map to a list element
//Notify the error of the anomoly and remove it from the session table
CString strMessage;
strMessage.LoadString(IDS_SESSIONLISTANOMOLY);
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromString(strMessage);
//Delete the pActiveSession. This will release the interface too
DeAllocActiveSession(pActiveSession);
//Remove the item from the session table
m_SessionTable.RemoveAt(nUpperBound);
break;
}
}
} while (FALSE);
if (FAILED(hr)) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR(hr);
}
}
void CEmshellView::ReSynchStoppedSessions()
{
//iterate through all the sessions and find the corrisponding GUID in the ListCtrl
//Clear the list control
PEmObject pEmObject = NULL;
INT_PTR nUpperBound = 0;
PActiveSession pActiveSession = NULL;
HRESULT hr = S_OK;
BOOL bFound = FALSE;
do {
nUpperBound = m_SessionTable.GetUpperBound();
if (nUpperBound == -1) break;
//Get the GUID and look it up in the session table
//If found, map the pEmObject to the session, else remove it.
for (; nUpperBound >= 0; nUpperBound--) {
pActiveSession = (PActiveSession) m_SessionTable.GetAt(nUpperBound);
if (pActiveSession == NULL) {
hr = E_FAIL;
break;
}
//Step through every item in the list control
int nCount = m_mainListControl.GetItemCount();
for (int i = 0;i < nCount; i++) {
pEmObject = (PEmObject)m_mainListControl.GetItemData(i);
if (pEmObject == NULL) {
hr = E_FAIL;
break;
}
if(memcmp((void *)&pActiveSession->guid, (void *)pEmObject->guidstream, sizeof( GUID ) ) == 0) {
//Assign the pEmObject to the pActiveSession
pActiveSession->pEmObject = pEmObject;
//We have found the element, stop the search
bFound = TRUE;
break;
}
}
}
} while (FALSE);
if (FAILED(hr)) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR(hr);
}
}
void CEmshellView::GenerateDump(PEmObject pEmObject, BOOL bMiniDump)
{
INT_PTR nUpperBound = 0;
PActiveSession pActiveSession = NULL;
HRESULT hr = E_FAIL;
BSTR bstrEmObj = NULL;
IEmDebugSession* pTempDebugSession = NULL;
BOOL bTempSession = FALSE;
PEmObject pEmObjectTmp = NULL;
//Set the cursor to a wait cursor
CWaitCursor wait;
do {
//Find the element in the session table
pActiveSession = FindActiveSession( pEmObject );
//Create bstr's for the journey ahead, and break if we can't
bstrEmObj = CopyBSTR ( (LPBYTE)pEmObject, sizeof( EmObject ) );
if( bstrEmObj == NULL ){
hr = E_OUTOFMEMORY;
break;
}
if (pActiveSession == NULL) {
//Get a temporary IDebugSession*
hr = GetDocument()->GetEmManager()->OpenSession(bstrEmObj, &pTempDebugSession);
if (FAILED(hr)) break;
bTempSession = TRUE;
}
else {
//Generate the dumpfile
pTempDebugSession = pActiveSession->pIDebugSession;
if ( pTempDebugSession == NULL ) break;
}
//Generate the dumpfile
hr = pTempDebugSession->GenerateDumpFile(bMiniDump);
if (FAILED(hr)) break;
hr = pTempDebugSession->GetStatus(bstrEmObj);
if (FAILED(hr)) break;
//Convert the bstrEmObj to an PEmObject and memcopy it into the itemdata's PEmObject
pEmObjectTmp = GetEmObj(bstrEmObj);
if (pEmObjectTmp == NULL) break;
SysFreeString( bstrEmObj );
memcpy(pEmObject, pEmObjectTmp, sizeof( EmObject ) );
//Update the ListCtl with the new info
UpdateListElement(pEmObject);
} while (FALSE);
if (FAILED(hr)) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR(hr);
}
SysFreeString( bstrEmObj );
if ( bTempSession && pTempDebugSession ) {
//Release the pTempDebugSession pointer
SAFE_RELEASEIX( pTempDebugSession );
}
}
void CEmshellView::OnViewRefresh()
{
RefreshListCtl();
}
void CEmshellView::RefreshListCtl()
{
//refresh the list control based on it's contents
if ( GetDocument()->GetConnectedToServerState() ) {
//Refresh everything. Rebuild the list.
ListCtrlClear();
//Pass in the current view
ListCtrlPopulate(m_enumShellViewState);
m_mainListControl.RefreshList();
}
}
//******** Right click popup menu item updateUI handlers ***********//
//*********************************************************//
void CEmshellView::OnUpdateProcesspopupStopDebugSession( CCmdUI* pCmdUI )
{
PEmObject pEmObject = NULL;
BOOL bEnable = FALSE;
PActiveSession pActiveSession = NULL;
do {
if ( !GetDocument()->GetConnectedToServerState() ) break;
if ( m_enumShellViewState != SHELLVIEW_ALL &&
m_enumShellViewState != SHELLVIEW_APPLICATIONS &&
m_enumShellViewState != SHELLVIEW_SERVICES &&
m_enumShellViewState != SHELLVIEW_COMPLETEDSESSIONS ) break;
// Update the state of this button based on the state of the currently selected item
//Get the currently selected emObject
pEmObject = GetSelectedEmObject();
if ( pEmObject == NULL ) break;
pActiveSession = FindActiveSession( pEmObject );
//Determine if the status of pActiveSession and enable this appropriately
if ( pEmObject->nStatus & STAT_SESS_DEBUG_IN_PROGRESS &&
( pEmObject->nStatus & STAT_ORPHAN || pActiveSession ) )
bEnable = TRUE;
}while ( FALSE );
pCmdUI->Enable( bEnable);
}
void CEmshellView::OnUpdateProcesspopupCancelDebugSession( CCmdUI* pCmdUI )
{
PEmObject pEmObject = NULL;
BOOL bEnable = FALSE;
PActiveSession pActiveSession = NULL;
do {
if ( !GetDocument()->GetConnectedToServerState() ) break;
if ( m_enumShellViewState != SHELLVIEW_ALL &&
m_enumShellViewState != SHELLVIEW_APPLICATIONS &&
m_enumShellViewState != SHELLVIEW_SERVICES &&
m_enumShellViewState != SHELLVIEW_COMPLETEDSESSIONS ) break;
// Update the state of this button based on the state of the currently selected item
//Get the currently selected emObject
pEmObject = GetSelectedEmObject();
if ( pEmObject == NULL ) break;
pActiveSession = FindActiveSession( pEmObject );
//Determine if the status of pActiveSession and enable this apprpriately
if ( pEmObject->nStatus & STAT_SESS_DEBUG_IN_PROGRESS &&
( pEmObject->nStatus & STAT_ORPHAN || ( pActiveSession && pActiveSession->bMaster ) ) )
bEnable = TRUE;
}while (FALSE);
pCmdUI->Enable( bEnable);
}
void CEmshellView::OnUpdateViewRefresh(CCmdUI* pCmdUI)
{
//We get this call everytime the menu is about to be shown
pCmdUI->Enable ( GetDocument()->GetConnectedToServerState() );
}
void CEmshellView::OnUpdateProcesspopupGenerateminidump(CCmdUI* pCmdUI)
{
PEmObject pEmObject = NULL;
BOOL bEnable = FALSE;
do {
if ( !GetDocument()->GetConnectedToServerState() ) break;
if ( m_enumShellViewState != SHELLVIEW_ALL &&
m_enumShellViewState != SHELLVIEW_APPLICATIONS &&
m_enumShellViewState != SHELLVIEW_SERVICES &&
m_enumShellViewState != SHELLVIEW_COMPLETEDSESSIONS ) break;
// Update the state of this button based on the state of the currently selected item
// If we are the master, then we can stop this session
//Get the currently selected emObject
pEmObject = GetSelectedEmObject();
if ( pEmObject == NULL ) break;
if ( !( pEmObject->nStatus & STAT_NOTRUNNING ) &&
!( pEmObject->nStatus & STAT_SESS_STOPPED ) &&
( pEmObject->type & EMOBJ_PROCESS ||
pEmObject->type & EMOBJ_SERVICE ) ) {
bEnable = TRUE;
}
}while (FALSE);
pCmdUI->Enable( bEnable);
}
void CEmshellView::OnUpdateProcesspopupGenerateuserdump(CCmdUI* pCmdUI)
{
PEmObject pEmObject = NULL;
BOOL bEnable = FALSE;
do {
if ( !GetDocument()->GetConnectedToServerState() ) break;
if ( m_enumShellViewState != SHELLVIEW_ALL &&
m_enumShellViewState != SHELLVIEW_APPLICATIONS &&
m_enumShellViewState != SHELLVIEW_SERVICES &&
m_enumShellViewState != SHELLVIEW_COMPLETEDSESSIONS ) break;
// Update the state of this button based on the state of the currently selected item
// If we are the master, then we can stop this session
//Get the currently selected emObject
pEmObject = GetSelectedEmObject();
if ( pEmObject == NULL ) break;
if ( !( pEmObject->nStatus & STAT_NOTRUNNING ) &&
!( pEmObject->nStatus & STAT_SESS_STOPPED ) &&
( pEmObject->type & EMOBJ_PROCESS ||
pEmObject->type & EMOBJ_SERVICE ) ) {
bEnable = TRUE;
}
}while (FALSE);
pCmdUI->Enable( bEnable);
}
void CEmshellView::OnUpdateProcesspopupAutomaticsession(CCmdUI* pCmdUI)
{
PEmObject pEmObject = NULL;
BOOL bEnable = FALSE;
PActiveSession pActiveSession = NULL;
// Allow if this isn't being debugged
do {
if ( !GetDocument()->GetConnectedToServerState() ) break;
if ( m_enumShellViewState != SHELLVIEW_ALL &&
m_enumShellViewState != SHELLVIEW_APPLICATIONS &&
m_enumShellViewState != SHELLVIEW_SERVICES &&
m_enumShellViewState != SHELLVIEW_COMPLETEDSESSIONS ) break;
// Update the state of this button based on the state of the currently selected item
//Get the currently selected emObject
pEmObject = GetSelectedEmObject();
if ( pEmObject == NULL ) break;
//Find the element in the session table
pActiveSession = FindActiveSession( pEmObject );
//Determine the status of pActiveSession and enable this apprpriately
if ( !pActiveSession && (pEmObject->nStatus & STAT_SESS_NOT_STARTED) ||
( pEmObject->type2 == SessType_Automatic && pEmObject->nStatus & STAT_ORPHAN ) ) {
bEnable = TRUE;
}
}while (FALSE);
pCmdUI->Enable( bEnable);
}
void CEmshellView::OnUpdateProcesspopupManualsession(CCmdUI* pCmdUI)
{
PEmObject pEmObject = NULL;
BOOL bEnable = FALSE;
PActiveSession pActiveSession = NULL;
// Allow if this isn't being debugged
do {
if ( !GetDocument()->GetConnectedToServerState() ) break;
if ( m_enumShellViewState != SHELLVIEW_ALL &&
m_enumShellViewState != SHELLVIEW_APPLICATIONS &&
m_enumShellViewState != SHELLVIEW_SERVICES &&
m_enumShellViewState != SHELLVIEW_COMPLETEDSESSIONS ) break;
// Update the state of this button based on the state of the currently selected item
// If we are the master, then we can stop this session
//Get the currently selected emObject
pEmObject = GetSelectedEmObject();
if ( pEmObject == NULL ) break;
//Find the element in the session table
pActiveSession = FindActiveSession( pEmObject );
//Determine if the status of pActiveSession and enable this apprpriately
// if ( pEmObject->nStatus & STAT_SESS_NOT_STARTED ) {
if ( !pActiveSession && (pEmObject->nStatus & STAT_SESS_NOT_STARTED) ||
( pEmObject->type2 == SessType_Manual && pEmObject->nStatus & STAT_ORPHAN ) ) {
bEnable = TRUE;
}
}while (FALSE);
pCmdUI->Enable( bEnable);
}
void CEmshellView::OnUpdateProcesspopupProperties(CCmdUI* pCmdUI)
{
BOOL bEnable = FALSE;
do {
if ( !GetDocument()->GetConnectedToServerState() ) break;
if ( GetSelectedEmObject() == NULL ) break;
bEnable = TRUE;
} while ( FALSE );
// Always allow properties
pCmdUI->Enable( bEnable );
}
void CEmshellView::OnUpdateProcesspopupRefresh(CCmdUI* pCmdUI)
{
// Only allow refresh if the current item is in our session table
PEmObject pEmObject = NULL;
BOOL bEnable = FALSE;
do {
if ( !GetDocument()->GetConnectedToServerState() ) break;
if ( m_enumShellViewState != SHELLVIEW_ALL &&
m_enumShellViewState != SHELLVIEW_APPLICATIONS &&
m_enumShellViewState != SHELLVIEW_SERVICES &&
m_enumShellViewState != SHELLVIEW_COMPLETEDSESSIONS ) break;
// Update the state of this button based on the state of the currently selected item
// If we are the master, then we can stop this session
//Get the currently selected emObject
pEmObject = GetSelectedEmObject();
if ( pEmObject == NULL ) break;
bEnable = TRUE;
}while (FALSE);
pCmdUI->Enable( bEnable);
}
//******** Right click popup menu item handlers ***********//
//*********************************************************//
void CEmshellView::OnProcesspopupStopDebugSession()
{
//Stop the session for the current item selected
PEmObject pEmObject = NULL;
HRESULT hr = E_FAIL;
do {
pEmObject = GetSelectedEmObject();
if ( pEmObject == NULL ) break;
//Stop and remove the session
StopDebugSession( pEmObject );
hr = S_OK;
} while ( FALSE );
if ( FAILED( hr ) ) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR( hr );
}
}
void CEmshellView::OnProcesspopupGenerateminidump()
{
PEmObject pEmObject = NULL;
HRESULT hr = E_FAIL;
do {
pEmObject = GetSelectedEmObject();
if (pEmObject == NULL) break;
//Generate the MiniDump file
GenerateDump(pEmObject, TRUE);
hr = S_OK;
} while (FALSE);
if (FAILED(hr)) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR(hr);
}
}
void CEmshellView::OnProcesspopupGenerateuserdump()
{
PEmObject pEmObject = NULL;
HRESULT hr = E_FAIL;
do {
pEmObject = GetSelectedEmObject();
if (pEmObject == NULL) break;
//Generate the UserDump file
GenerateDump(pEmObject, FALSE);
hr = S_OK;
} while(FALSE);
if (FAILED(hr)) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR(hr);
}
}
void CEmshellView::OnProcesspopupAutomaticsession()
{
PEmObject pEmObject = NULL;
HRESULT hr = E_FAIL;
do {
pEmObject = GetSelectedEmObject();
if ( pEmObject == NULL ) break;
//Start the automatic session
hr = StartAutomaticDebugSession(pEmObject);
} while (FALSE);
}
void CEmshellView::OnProcesspopupManualsession()
{
// Start a manual session with the server
PEmObject pEmObject = NULL;
HRESULT hr = E_FAIL;
do {
pEmObject = GetSelectedEmObject();
if (pEmObject == NULL) break;
//Start the manual session
hr = StartManualDebugSession(pEmObject);
} while (FALSE);
if (FAILED(hr)) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR(hr);
}
}
void CEmshellView::OnProcesspopupProperties()
{
PEmObject pEmObject = NULL;
IEmDebugSession* pIDebugSession = NULL;
do {
pEmObject = GetSelectedEmObject();
if ( pEmObject == NULL ) break;
if ( pEmObject ) {
//Get the current view state from the shell
switch ( GetViewState() ) {
case SHELLVIEW_LOGFILES:
case SHELLVIEW_DUMPFILES:
case SHELLVIEW_MSINFOFILES:
ShowProperties( pEmObject );
break;
default:
DoModalPropertySheet( pEmObject );
}
}
} while (FALSE);
}
void CEmshellView::OnProcesspopupRefresh()
{
// Refresh the currently selected item
// Get the currently selected EmObject
PEmObject pEmObject = NULL;
HRESULT hr = E_FAIL;
PActiveSession pActiveSession = NULL;
BSTR bstrEmObj = NULL;
PEmObject pEmObjectTmp = NULL;
IEmDebugSession* pTempDebugSession = NULL;
BOOL bTempSession = FALSE;
do {
pEmObject = GetSelectedEmObject();
if (pEmObject == NULL) break;
//Find the element in the session table
pActiveSession = FindActiveSession( pEmObject );
//Create bstr's for the journey ahead, and break if we can't
bstrEmObj = CopyBSTR ( (LPBYTE)pEmObject, sizeof( EmObject ) );
if( bstrEmObj == NULL ){
hr = E_OUTOFMEMORY;
break;
}
if ( pActiveSession == NULL ) {
hr = GetDocument()->GetEmManager()->OpenSession(bstrEmObj, &pTempDebugSession);
if (FAILED(hr)) break;
bTempSession = TRUE;
hr = pTempDebugSession->GetStatus(bstrEmObj);
if (FAILED(hr)) break;
}
else {
hr = pActiveSession->pIDebugSession->GetStatus(bstrEmObj);
if (FAILED(hr)) break;
}
//Convert the bstrEmObj to an PEmObject and memcopy it into the itemdata's PEmObject
pEmObjectTmp = GetEmObj(bstrEmObj);
if (pEmObjectTmp == NULL) break;
SysFreeString( bstrEmObj );
memcpy(pEmObject, pEmObjectTmp, sizeof( EmObject ) );
//Update the element
UpdateListElement(pEmObject);
hr = S_OK;
} while (FALSE);
if (FAILED(hr)) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR(hr);
}
SysFreeString ( bstrEmObj );
if ( pTempDebugSession ) {
//Release the pTempDebugSession pointer
SAFE_RELEASEIX( pTempDebugSession );
}
}
PEmObject CEmshellView::GetSelectedEmObject()
{
PEmObject pEmObject = NULL;
int nIndex = -1;
do {
nIndex = GetSelectedItemIndex();
if (nIndex == -1) break;
pEmObject = (PEmObject) m_mainListControl.GetItemData(nIndex);
} while (FALSE);
return pEmObject;
}
int CEmshellView::GetSelectedItemIndex()
{
POSITION pos = 0;
int nIndex = -1;
do {
pos = m_mainListControl.GetFirstSelectedItemPosition();
if(pos == NULL) break;
//Get the nIndex for the currently selected item
nIndex = m_mainListControl.GetNextSelectedItem(pos);
} while (FALSE);
return nIndex;
}
PActiveSession CEmshellView::FindActiveSession(PEmObject pEmObject)
{
//iterate through all the sessions and find the corrisponding pEmObject
INT_PTR nUpperBound = 0;
PActiveSession pActiveSession = NULL;
BOOL bFound = FALSE;
PActiveSession pRetVal = NULL;
do {
nUpperBound = m_SessionTable.GetUpperBound();
if ( nUpperBound == -1 ) break;
if ( pEmObject == NULL ) break;
//look up the pEmObject in the session table
//If found, map the pEmObject to the session, else remove it.
for (; nUpperBound >= 0; nUpperBound--) {
pActiveSession = (PActiveSession) m_SessionTable.GetAt(nUpperBound);
if ( pActiveSession == NULL ) break;
if( memcmp( ( void * ) &pActiveSession->guid, ( void * ) pEmObject->guidstream, sizeof( GUID ) ) == 0 ) {
pRetVal = pActiveSession;
}
}
} while ( FALSE );
return pRetVal;
}
int CEmshellView::GetImageOffsetFromStatus(EmSessionStatus em)
{
int retVal = 0;
//Use a switch/case statement to determine the correct offset into the bitmap
switch (em) {
case STAT_SESS_NONE_STAT_NONE:
retVal = 0;
break;
case STAT_SESS_NOT_STARTED_NOTRUNNING:
retVal = 1;
break;
case STAT_SESS_NOT_STARTED_RUNNING:
retVal = 2;
break;
case STAT_SESS_NOT_STARTED_FILECREATED_SUCCESSFULLY:
retVal = 3;
break;
case STAT_SESS_NOT_STARTED_FILECREATION_FAILED:
retVal = 4;
break;
case STAT_SESS_DEBUG_IN_PROGRESS_NONE:
retVal = 5;
break;
case STAT_SESS_DEBUG_IN_PROGRESS_FILECREATED_SUCESSFULLY:
retVal = 6;
break;
case STAT_SESS_DEBUG_IN_PROGRESS_FILECREATION_FAILED:
retVal = 7;
break;
case STAT_SESS_DEBUG_IN_PROGRESS_ORPHAN_NONE:
retVal = 8;
break;
case STAT_SESS_DEBUG_IN_PROGRESS_ORPHAN_FILECREATED_SUCESSFULLY:
retVal = 9;
break;
case STAT_SESS_DEBUG_IN_PROGRESS_ORPHAN_FILECREATION_FAILED:
retVal = 10;
break;
case STAT_SESS_STOPPED_SUCCESS:
retVal = 11;
break;
case STAT_SESS_STOPPED_FAILED:
retVal = 12;
break;
case STAT_SESS_STOPPED_ORPHAN_SUCCESS:
retVal = 13;
break;
case STAT_SESS_STOPPED_ORPHAN_FAILED:
retVal = 14;
break;
case STAT_SESS_STOPPED_DEBUGGEE_KILLED:
retVal = 15;
break;
case STAT_SESS_STOPPED_DEBUGGEE_EXITED:
retVal = 16;
break;
case STAT_SESS_STOPPED_EXCEPTION_OCCURED:
retVal = 17;
break;
case STAT_SESS_STOPPED_ORPHAN_DEBUGGEE_KILLED:
retVal = 18;
break;
case STAT_SESS_STOPPED_ORPHAN_DEBUGGEE_EXITED:
retVal = 19;
break;
case STAT_SESS_STOPPED_ORPHAN_EXCEPTION_OCCURED:
retVal = 20;
break;
case STAT_SESS_STOPPED_ACCESSVIOLATION_OCCURED:
retVal = 21;
break;
case STAT_SESS_STOPPED_ORPHAN_ACCESSVIOLATION_OCCURED:
retVal = 22;
break;
}
return retVal;
}
void CEmshellView::InitializeAllView()
{
InitializeServiceView();
}
void CEmshellView::InitializeCompletedSessionsView()
{
InitializeServiceView();
}
void CEmshellView::InitializeProcessView()
{
//This gets called only when the user is first starting the app or when
//the user is changing views.
//Reset the list control
m_mainListControl.ResetListCtrl();
//Load the string resources for the CListCtrl columns
CString strImageName, strPID, strStatus, strStartDate, strEndDate;
strImageName.LoadString(IDS_LC_IMAGENAME);
strPID.LoadString(IDS_LC_PID);
strStatus.LoadString(IDS_LC_STATUS);
strStartDate.LoadString(IDS_LC_STARTDATE);
strEndDate.LoadString(IDS_LC_ENDDATE);
//Unload the last image resources, if there are any
m_ShellImageList.DeleteImageList();
//Load the image resources for the CListCtrl items
m_ShellImageList.Create(IDB_STATUS_BITMAP, 16, 1, CLR_NONE);
m_mainListControl.SetImageList(&m_ShellImageList, LVSIL_SMALL);
//Add the columns to the list control
m_mainListControl.BeginSetColumn(5);
m_mainListControl.AddColumn(strImageName);
m_mainListControl.AddColumn(strPID, VT_I4);
m_mainListControl.AddColumn(strStartDate);
m_mainListControl.AddColumn(strEndDate);
m_mainListControl.AddColumn(strStatus);
m_mainListControl.EndSetColumn();
m_mainListControl.ResizeColumnsFitScreen();
m_mainListControl.SetExtendedStyle(LVS_EX_FULLROWSELECT);
}
void CEmshellView::InitializeServiceView()
{
//This gets called only when the user is first starting the app or when
//the user is changing views.
//Reset the list control
m_mainListControl.ResetListCtrl();
//Load the string resources for the CListCtrl columns
CString strImageName, strPID, strStatus, strShortName, strDescription,
strStartDate, strEndDate;
strImageName.LoadString(IDS_LC_IMAGENAME);
strPID.LoadString(IDS_LC_PID);
strStatus.LoadString(IDS_LC_STATUS);
strShortName.LoadString(IDS_LC_SHORTNAME);
strDescription.LoadString(IDS_LC_DESCRIPTION);
strStartDate.LoadString(IDS_LC_STARTDATE);
strEndDate.LoadString(IDS_LC_ENDDATE);
//Unload the last image resources, if there are any
m_ShellImageList.DeleteImageList();
//Load the image resources for the CListCtrl items
m_ShellImageList.Create(IDB_STATUS_BITMAP, 16, 1, CLR_NONE);
m_mainListControl.SetImageList(&m_ShellImageList, LVSIL_SMALL);
//Add the columns to the list control
m_mainListControl.BeginSetColumn(7);
m_mainListControl.AddColumn(strImageName);
m_mainListControl.AddColumn(strShortName);
m_mainListControl.AddColumn(strDescription);
m_mainListControl.AddColumn(strPID, VT_I4);
m_mainListControl.AddColumn(strStartDate);
m_mainListControl.AddColumn(strEndDate);
m_mainListControl.AddColumn(strStatus);
m_mainListControl.EndSetColumn();
m_mainListControl.ResizeColumnsFitScreen();
m_mainListControl.SetExtendedStyle(LVS_EX_FULLROWSELECT);
}
void CEmshellView::InitializeLogView()
{
//Reset the list control
m_mainListControl.ResetListCtrl();
//Load the string resources for the CListCtrl columns
CString strFileName, strSize, strTime; //, strProc;
strFileName.LoadString(IDS_LC_FILENAME);
strSize.LoadString(IDS_LC_FILESIZE);
strTime.LoadString(IDS_LC_FILETIME);
// strProc.LoadString(IDS_LC_FILEPROCESS);
//Unload the last image resources, if there are any
m_ShellImageList.DeleteImageList();
//Load the image resources for the CListCtrl items
m_ShellImageList.Create(IDB_STATUS_BITMAP, 16, 1, CLR_NONE);
m_mainListControl.SetImageList(&m_ShellImageList, LVSIL_SMALL);
//Add the columns to the list control
m_mainListControl.BeginSetColumn(3);
m_mainListControl.AddColumn(strFileName);
m_mainListControl.AddColumn(strSize, VT_I4);
m_mainListControl.AddColumn(strTime);
// m_mainListControl.AddColumn(strProc);
m_mainListControl.EndSetColumn();
m_mainListControl.ResizeColumnsFitScreen();
m_mainListControl.SetExtendedStyle(LVS_EX_FULLROWSELECT);
}
void CEmshellView::InitializeDumpView()
{
InitializeLogView();
}
void CEmshellView::PopulateProcessType()
{
_variant_t var; //This will create and initialize the var variant
HRESULT hr = E_FAIL;
LONG lLBound = 0;
LONG lUBound = 0;
BSTR bstrEmObj = NULL;
BSTR bstrEmObjectFilter = NULL;
PEmObject pCurrentObj = NULL;
EmObject EmObjectFilter;
memset(&EmObjectFilter, 0, sizeof( EmObject ));
do {
EmObjectFilter.type = EMOBJ_PROCESS;
bstrEmObjectFilter = CopyBSTR ( (LPBYTE)&EmObjectFilter, sizeof( EmObject ) );
//Populate the list control based on the EmObjectType
//Enumerate all the objects and stick them in the variant
//hr = GetDocument()->GetEmManager()->EnumObjectsEx(bstrEmObjectFilter, &var);
hr = GetDocument()->GetEmManager()->EnumObjects(EMOBJ_PROCESS, &var );
if(FAILED(hr)) break;
//Get the lower and upper bounds of the variant array
hr = SafeArrayGetLBound(var.parray, 1, &lLBound);
if(FAILED(hr)) break;
hr = SafeArrayGetUBound(var.parray, 1, &lUBound);
if(FAILED(hr)) break;
//There are elements at both the lower bound and upper bound, so include them
for(; lLBound <= lUBound; lLBound++)
{
//Get a BSTR object from the safe array
hr = SafeArrayGetElement(var.parray, &lLBound, &bstrEmObj);
if (FAILED(hr)) break;
//Create a local copy of the EmObject (there aren't any pointers in
//EmObject structure, so don't worry about doing a deep copy
pCurrentObj = ((CEmshellApp*)AfxGetApp())->AllocEmObject();
if ( pCurrentObj != NULL ) {
*pCurrentObj = *GetEmObj( bstrEmObj );
}
SysFreeString( bstrEmObj );
//Unallocate the EmObject if it has an hr of E_FAIL
if (FAILED(pCurrentObj->hr)) {
((CEmshellApp*)AfxGetApp())->DeAllocEmObject( pCurrentObj );
continue;
}
if ( !( (CEmshellApp*)AfxGetApp() )->CanDisplayProcess( pCurrentObj->szName ) ){
((CEmshellApp*)AfxGetApp())->DeAllocEmObject( pCurrentObj );
continue;
}
//Depending on the current view, use the correct DisplayData routine
if ( m_enumShellViewState == SHELLVIEW_APPLICATIONS ) {
//Convert the BSTR object to an EmObject and pass it to DisplayData
DisplayProcessData( pCurrentObj );
} else {
DisplayServiceData( pCurrentObj );
}
}
} while (FALSE);
SafeArrayDestroyData(var.parray);
SysFreeString ( bstrEmObjectFilter );
SysFreeString ( bstrEmObj );
if (FAILED(hr)) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR(hr);
}
}
void CEmshellView::PopulateServiceType()
{
_variant_t var; //This will create and initialize the var variant
HRESULT hr = E_FAIL;
LONG lLBound = 0;
LONG lUBound = 0;
BSTR bstrEmObj = NULL;
BSTR bstrEmObjectFilter = NULL;
PEmObject pCurrentObj = NULL;
EmObject EmObjectFilter;
memset(&EmObjectFilter, 0, sizeof( EmObject ));
do {
EmObjectFilter.type = EMOBJ_SERVICE;
bstrEmObjectFilter = CopyBSTR ( (LPBYTE)&EmObjectFilter, sizeof( EmObject ) );
//Populate the list control based on the EmObjectType
//Enumerate all the objects and stick them in the variant
//hr = GetDocument()->GetEmManager()->EnumObjectsEx(bstrEmObjectFilter, &var);
hr = GetDocument()->GetEmManager()->EnumObjects(EMOBJ_SERVICE, &var );
if(FAILED(hr)) break;
//Get the lower and upper bounds of the variant array
hr = SafeArrayGetLBound(var.parray, 1, &lLBound);
if(FAILED(hr)) break;
hr = SafeArrayGetUBound(var.parray, 1, &lUBound);
if(FAILED(hr)) break;
//There are elements at both the lower bound and upper bound, so include them
for(; lLBound <= lUBound; lLBound++)
{
//Get a BSTR object from the safe array
hr = SafeArrayGetElement(var.parray, &lLBound, &bstrEmObj);
if (FAILED(hr)) break;
//Create a local copy of the EmObject (there aren't any pointers in
//EmObject structure, so don't worry about doing a deep copy
pCurrentObj = ((CEmshellApp*)AfxGetApp())->AllocEmObject();
if (pCurrentObj == NULL) {
hr = E_FAIL;
break;
}
*pCurrentObj = *GetEmObj( bstrEmObj );
SysFreeString( bstrEmObj );
//Unallocate the EmObject if it has an hr of E_FAIL
if ( (_tcscmp(pCurrentObj->szName, _T("")) == 0) && FAILED(pCurrentObj->hr)) {
((CEmshellApp*)AfxGetApp())->DeAllocEmObject( pCurrentObj );
continue;
}
if ( !( (CEmshellApp*)AfxGetApp() )->CanDisplayService( pCurrentObj->szName, pCurrentObj->szSecName ) ){
((CEmshellApp*)AfxGetApp())->DeAllocEmObject( pCurrentObj );
continue;
}
//Convert the BSTR object to an EmObject and pass it to DisplayData
DisplayServiceData( pCurrentObj );
}
} while (FALSE);
SafeArrayDestroyData(var.parray);
SysFreeString ( bstrEmObjectFilter );
SysFreeString ( bstrEmObj );
if (FAILED(hr)) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR(hr);
}
}
void CEmshellView::PopulateDumpType()
{
_variant_t var; //This will create and initialize the var variant
HRESULT hr = E_FAIL;
LONG lLBound = 0;
LONG lUBound = 0;
BSTR bstrEmObj = NULL;
BSTR bstrEmObjectFilter = NULL;
EmObject *pCurrentObj = NULL;
EmObject EmObjectFilter;
memset(&EmObjectFilter, 0, sizeof( EmObject ) );
do {
EmObjectFilter.type = EMOBJ_MINIDUMP;
bstrEmObjectFilter = CopyBSTR ( (LPBYTE)&EmObjectFilter, sizeof( EmObject ) );
//Populate the list control based on the EmObjectType
//Enumerate all the objects and stick them in the variant
hr = GetDocument()->GetEmManager()->EnumObjectsEx(bstrEmObjectFilter, &var);
if(FAILED(hr)) break;
//Get the lower and upper bounds of the variant array
hr = SafeArrayGetLBound(var.parray, 1, &lLBound);
if(FAILED(hr)) break;
hr = SafeArrayGetUBound(var.parray, 1, &lUBound);
if(FAILED(hr)) break;
//There are elements at both the lower bound and upper bound, so include them
for(; lLBound <= lUBound; lLBound++)
{
//Get a BSTR object from the safe array
hr = SafeArrayGetElement(var.parray, &lLBound, &bstrEmObj);
if (FAILED(hr)) break;
//Create a local copy of the EmObject (there aren't any pointers in
//EmObject structure, so don't worry about doing a deep copy
pCurrentObj = ((CEmshellApp*)AfxGetApp())->AllocEmObject();
if (pCurrentObj != NULL) {
*pCurrentObj = *GetEmObj( bstrEmObj );
}
SysFreeString( bstrEmObj );
//Unallocate the EmObject if it has an hr of E_FAIL
if (FAILED(pCurrentObj->hr)) {
((CEmshellApp*)AfxGetApp())->DeAllocEmObject( pCurrentObj );
continue;
}
//Convert the BSTR object to an EmObject and pass it to DisplayData
DisplayDumpData( pCurrentObj );
}
} while (FALSE);
SafeArrayDestroyData(var.parray);
SysFreeString ( bstrEmObjectFilter );
SysFreeString ( bstrEmObj );
if (FAILED(hr)) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR(hr);
}
}
void CEmshellView::PopulateCompletedSessionsType()
{
_variant_t var; //This will create and initialize the var variant
HRESULT hr = E_FAIL;
LONG lLBound = 0;
LONG lUBound = 0;
BSTR bstrEmObj = NULL;
BSTR bstrEmObjectFilter = NULL;
EmObject *pCurrentObj = NULL;
EmObject EmObjectFilter;
memset(&EmObjectFilter, 0, sizeof( EmObject ) );
do {
EmObjectFilter.type = EMOBJ_PROCESS;
EmObjectFilter.nStatus = STAT_SESS_STOPPED; // only the HIWORD is the filter.
bstrEmObjectFilter = CopyBSTR ( (LPBYTE)&EmObjectFilter, sizeof( EmObject ) );
//Populate the list control based on the EmObjectType
//Enumerate all the objects and stick them in the variant
hr = GetDocument()->GetEmManager()->EnumObjectsEx(bstrEmObjectFilter, &var);
if(hr != S_OK) break;
//Get the lower and upper bounds of the variant array
hr = SafeArrayGetLBound(var.parray, 1, &lLBound);
if(FAILED(hr)) break;
hr = SafeArrayGetUBound(var.parray, 1, &lUBound);
if(FAILED(hr)) break;
//There are elements at both the lower bound and upper bound, so include them
for(; lLBound <= lUBound; lLBound++)
{
//Get a BSTR object from the safe array
hr = SafeArrayGetElement(var.parray, &lLBound, &bstrEmObj);
if (FAILED(hr)) break;
//Create a local copy of the EmObject (there aren't any pointers in
//EmObject structure, so don't worry about doing a deep copy
pCurrentObj = ((CEmshellApp*)AfxGetApp())->AllocEmObject();
if (pCurrentObj != NULL) {
*pCurrentObj = *GetEmObj( bstrEmObj );
}
SysFreeString( bstrEmObj );
//Unallocate the EmObject if it has an hr of E_FAIL
if (FAILED(pCurrentObj->hr)) {
((CEmshellApp*)AfxGetApp())->DeAllocEmObject( pCurrentObj );
continue;
}
//Convert the BSTR object to an EmObject and pass it to DisplayData
DisplayStoppedSessionData( pCurrentObj );
}
} while (FALSE);
SafeArrayDestroyData(var.parray);
SysFreeString ( bstrEmObjectFilter );
SysFreeString ( bstrEmObj );
if (FAILED(hr)) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR(hr);
}
}
void CEmshellView::PopulateLogType()
{
_variant_t var; //This will create and initialize the var variant
HRESULT hr = E_FAIL;
LONG lLBound = 0;
LONG lUBound = 0;
BSTR bstrEmObj = NULL;
BSTR bstrEmObjectFilter = NULL;
EmObject *pCurrentObj = NULL;
EmObject EmObjectFilter;
memset(&EmObjectFilter, 0, sizeof( EmObject ) );
do {
EmObjectFilter.type = EMOBJ_LOGFILE;
bstrEmObjectFilter = CopyBSTR ( (LPBYTE)&EmObjectFilter, sizeof( EmObject ) );
//Populate the list control based on the EmObjectType
//Enumerate all the objects and stick them in the variant
hr = GetDocument()->GetEmManager()->EnumObjectsEx(bstrEmObjectFilter, &var);
if(FAILED(hr)) break;
//Get the lower and upper bounds of the variant array
hr = SafeArrayGetLBound(var.parray, 1, &lLBound);
if(FAILED(hr)) break;
hr = SafeArrayGetUBound(var.parray, 1, &lUBound);
if(FAILED(hr)) break;
//There are elements at both the lower bound and upper bound, so include them
for(; lLBound <= lUBound; lLBound++)
{
//Get a BSTR object from the safe array
hr = SafeArrayGetElement(var.parray, &lLBound, &bstrEmObj);
if (FAILED(hr)) break;
//Create a local copy of the EmObject (there aren't any pointers in
//EmObject structure, so don't worry about doing a deep copy
pCurrentObj = ((CEmshellApp*)AfxGetApp())->AllocEmObject();
if (pCurrentObj != NULL) {
*pCurrentObj = *GetEmObj( bstrEmObj );
}
SysFreeString( bstrEmObj );
//Unallocate the EmObject if it has an hr of E_FAIL
if (FAILED(pCurrentObj->hr)) {
((CEmshellApp*)AfxGetApp())->DeAllocEmObject( pCurrentObj );
continue;
}
//Convert the BSTR object to an EmObject and pass it to DisplayData
DisplayLogData( pCurrentObj );
}
} while (FALSE);
SafeArrayDestroyData(var.parray);
SysFreeString ( bstrEmObjectFilter );
SysFreeString ( bstrEmObj );
if (FAILED(hr)) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR(hr);
}
}
void CEmshellView::StoreOffSelectedEmObject()
{
PEmObject pEmObject = NULL;
//Get the currently selected emObject
pEmObject = GetSelectedEmObject();
if ( pEmObject != NULL ) {
//store off it's name
m_lastSelectedEmObj = *pEmObject;
}
else {
memset ( &m_lastSelectedEmObj, 0, sizeof ( EmObject ) );
}
}
void CEmshellView::SetShellState(EMShellViewState eState)
{
StoreOffSelectedEmObject();
//Clear the current view
ListCtrlClear();
//Set the view style to the appropriate enum view state
m_enumShellViewState = eState;
//Initialize the new view state
ListCtrlInitialize(m_enumShellViewState);
}
void CEmshellView::ListCtrlInitialize(EMShellViewState eShellViewState)
{
switch (eShellViewState) {
case SHELLVIEW_ALL:
InitializeAllView();
break;
case SHELLVIEW_APPLICATIONS:
InitializeProcessView();
break;
case SHELLVIEW_COMPLETEDSESSIONS:
InitializeCompletedSessionsView();
break;
case SHELLVIEW_SERVICES:
InitializeServiceView();
break;
case SHELLVIEW_LOGFILES:
InitializeLogView();
break;
case SHELLVIEW_DUMPFILES:
InitializeDumpView();
break;
case SHELLVIEW_MSINFOFILES:
InitializeMSInfoView();
break;
case SHELLVIEW_NONE:
break;
}
}
void CEmshellView::SelectItemBySZNAME(TCHAR* pszName, int nId)
{
//Search through the list selecting the item whose itemdata.szname matches pszName
//Given a pszName, find the element in the ListCtl
PEmObject pListEmObject = NULL;
BOOL bFound = FALSE;
int nFirstMatch = -1;
//Step through every item in the list control searching for pEmObject
int nCount = m_mainListControl.GetItemCount();
for (int i = 0;i < nCount; i++) {
pListEmObject = (PEmObject) m_mainListControl.GetItemData(i);
if (pListEmObject == NULL) break;
if (wcscmp(pListEmObject->szName, pszName) == 0 ) {
if (nFirstMatch == -1 )
nFirstMatch = i;
if (pListEmObject->nId == nId) {
m_mainListControl.SelectItem(i);
bFound = TRUE;
//We have found the element, stop the search
break;
}
}
}
//If the we didn't find a perfect match, select the first near match
//And if we didn't find any, select the first item in the list
if ( !bFound ) {
if (nFirstMatch == -1) {
m_mainListControl.SelectItem(0);
}
else {
m_mainListControl.SelectItem(nFirstMatch);
}
}
}
void CEmshellView::ListCtrlPopulate(EMShellViewState eShellViewState)
{
DWORD dwPollSessionsFreq = 30L; // default is 30 secs
((CEmshellApp*)AfxGetApp())->GetEmShellRegOptions( TRUE, &dwPollSessionsFreq );
switch (eShellViewState) {
case SHELLVIEW_ALL:
PopulateProcessType();
PopulateServiceType();
ReSynchServices();
ReSynchApplications();
SetTimer( 1, dwPollSessionsFreq*1000, 0);
break;
case SHELLVIEW_APPLICATIONS:
PopulateProcessType();
ReSynchApplications();
SetTimer( 1, dwPollSessionsFreq*1000, 0);
break;
case SHELLVIEW_SERVICES:
PopulateServiceType();
ReSynchServices();
SetTimer( 1, dwPollSessionsFreq*1000, 0);
break;
case SHELLVIEW_COMPLETEDSESSIONS:
PopulateCompletedSessionsType();
ReSynchStoppedSessions();
break;
case SHELLVIEW_LOGFILES:
PopulateLogType();
break;
case SHELLVIEW_DUMPFILES:
PopulateDumpType();
break;
case SHELLVIEW_MSINFOFILES:
PopulateMSInfoType();
break;
case SHELLVIEW_NONE:
break;
}
//Select the last selected item
//Try to select the last emobject name selected. If not, select the first item in the view.
SelectItemBySZNAME( m_lastSelectedEmObj.szName, m_lastSelectedEmObj.nId );
}
/*void CEmshellView::CloseAllSessions()
{
}
*/
void CEmshellView::ListCtrlClear()
{
INT_PTR nUpperBound = 0;
PActiveSession pActiveSession = NULL;
HRESULT hr = E_FAIL;
PEmObject pEmObject = NULL;
INT_PTR nCount = m_mainListControl.GetItemCount();
//We need to make sure the timer doesn't get through when the list is empty
//Destroy the timer first
KillTimer(1);
//Step through every item in the list control and delete the pEmObjects
//and the item.
for (int i = 0;i < nCount; i++) {
pEmObject = (PEmObject)m_mainListControl.GetItemData(i);
//Cast dwData to a EmObject and call delete on it
((CEmshellApp*)AfxGetApp())->DeAllocEmObject(pEmObject);
}
//Remove all the items from the list control
i = m_mainListControl.DeleteAllItems();
ASSERT(m_mainListControl.GetItemCount() == 0);
//Set all the pEmObjects to NULL
for (nUpperBound = m_SessionTable.GetUpperBound(); nUpperBound >= 0; nUpperBound--) {
pActiveSession = (PActiveSession) m_SessionTable.GetAt(nUpperBound);
ASSERT(pActiveSession != NULL);
pActiveSession->pEmObject = NULL;
}
}
void CEmshellView::OnViewServicesandapplications()
{
if ( m_enumShellViewState == SHELLVIEW_ALL ) return;
SetShellState(SHELLVIEW_ALL);
ListCtrlPopulate(SHELLVIEW_ALL);
}
void CEmshellView::OnUpdateViewServicesandapplications(CCmdUI* pCmdUI)
{
BOOL bEnable = FALSE;
BOOL bChecked = FALSE;
if ( GetDocument()->GetConnectedToServerState() == TRUE ) {
bEnable = TRUE;
if ( m_enumShellViewState == SHELLVIEW_ALL ) {
bChecked = TRUE;
}
}
pCmdUI->Enable ( bEnable );
pCmdUI->SetCheck( bChecked );
}
void CEmshellView::OnViewLogfiles()
{
if ( m_enumShellViewState == SHELLVIEW_LOGFILES ) return;
SetShellState(SHELLVIEW_LOGFILES);
ListCtrlPopulate(SHELLVIEW_LOGFILES);
}
void CEmshellView::OnUpdateViewLogfiles(CCmdUI* pCmdUI)
{
BOOL bEnable = FALSE;
BOOL bChecked = FALSE;
if ( GetDocument()->GetConnectedToServerState() == TRUE ) {
bEnable = TRUE;
if ( m_enumShellViewState == SHELLVIEW_LOGFILES )
bChecked = TRUE;
}
pCmdUI->Enable ( bEnable );
pCmdUI->SetCheck( bChecked );
}
void CEmshellView::OnViewDumpfiles()
{
if ( m_enumShellViewState == SHELLVIEW_DUMPFILES ) return;
SetShellState(SHELLVIEW_DUMPFILES);
ListCtrlPopulate(SHELLVIEW_DUMPFILES);
}
void CEmshellView::OnUpdateViewDumpfiles(CCmdUI* pCmdUI)
{
BOOL bEnable = FALSE;
BOOL bChecked = FALSE;
if ( GetDocument()->GetConnectedToServerState() == TRUE ) {
bEnable = TRUE;
if ( m_enumShellViewState == SHELLVIEW_DUMPFILES )
bChecked = TRUE;
}
pCmdUI->Enable ( bEnable );
pCmdUI->SetCheck( bChecked );
}
void CEmshellView::OnUpdateLogpopupOpen(CCmdUI* pCmdUI)
{
BOOL bEnable = FALSE;
//TODO: Enable the button when display a log file is supported
pCmdUI->Enable ( m_enumShellViewState == SHELLVIEW_LOGFILES );
}
void CEmshellView::OnLogpopupOpen()
{
// TODO: Add your command handler code here
PEmObject pEmObject = NULL;
pEmObject = GetSelectedEmObject();
if ( pEmObject == NULL ) return;
CReadLogsDlg ReadLogDlg(pEmObject, GetDocument()->GetEmManager());
ReadLogDlg.DoModal();
}
void CEmshellView::OnUpdateLogpopupProperties(CCmdUI* pCmdUI)
{
BOOL bEnable = FALSE;
//TODO: Enable the button when properties of a log file is supported
pCmdUI->Enable ( TRUE );
}
void CEmshellView::OnLogpopupProperties()
{
// TODO: Add your command handler code here
PEmObject pEmObject = GetSelectedEmObject();
if ( pEmObject ) {
ShowProperties( pEmObject );
}
}
void CEmshellView::ShowProperties( PEmObject pEmObject )
{
CPropertySheet propsheet;
CPropPageGenLogDump genLogDumpPropPage;
genLogDumpPropPage.m_pEmObj = pEmObject;
genLogDumpPropPage.m_pParentPropSheet = &propsheet;
propsheet.AddPage(&genLogDumpPropPage);
propsheet.SetTitle( pEmObject->szName, PSH_PROPTITLE );
propsheet.DoModal();
if( genLogDumpPropPage.m_bDeleteFile ) {
OnLogpopupDelete();
}
}
EMShellViewState CEmshellView::GetViewState()
{
return m_enumShellViewState;
}
HRESULT CEmshellView::StartCDBClient(IN LPTSTR lpszConnectString)
{
STARTUPINFO sp;
PROCESS_INFORMATION pi;
ZeroMemory(&sp, sizeof( sp ) );
ZeroMemory(&pi, sizeof( pi ) );
BOOL bCdbCreated = CreateProcess(// This has to be obtained from the registry...
_T("C:\\Debuggers\\cdb.exe"),
lpszConnectString,
NULL,
NULL,
FALSE,
CREATE_NEW_PROCESS_GROUP | CREATE_NEW_CONSOLE,
NULL,
NULL,
&sp,
&pi
);
//
// Wait till CDB does some initializations..
// Don't know how long to wait.. have to figure out a way..
//
Sleep(2000);
if(bCdbCreated == FALSE){
return HRESULT_FROM_WIN32(GetLastError());
}
return S_OK;
}
HRESULT CEmshellView::GetClientConnectString(IN OUT LPTSTR pszConnectString, IN DWORD dwBuffSize, PEmObject pEmSessObj, int nPort)
{
_ASSERTE(pszConnectString != NULL);
_ASSERTE(dwBuffSize > 0L);
HRESULT hr = E_FAIL;
DWORD dwBuff = MAX_COMPUTERNAME_LENGTH;
do
{
if( pszConnectString == NULL ||
dwBuffSize <= 0L ) break;
if( nPort != 0 ){
_stprintf(pszConnectString, _T(" -remote tcp:server=%s,port=%d"), GetDocument()->GetServerName(), nPort);
}
else {
_stprintf(pszConnectString, _T(" -remote npipe:server=%s,pipe=EM_%d"), GetDocument()->GetServerName(), pEmSessObj->nId);
}
hr = S_OK;
}
while( false );
return hr;
}
void CEmshellView::DoModalPropertySheet(PEmObject pEmObject)
{
CPropertySheet propsheet;
CPropPageGeneral generalPropPage;
CPropPageLogFiles logFilesPropPage;
CPropPageDumpFiles dumpFilesPropPage;
BOOL bInActiveSessionTable = FALSE;
generalPropPage.m_pEmObject = pEmObject;
logFilesPropPage.m_pEmObject = pEmObject;
logFilesPropPage.m_pIEmManager = GetDocument()->GetEmManager();
dumpFilesPropPage.m_pEmObject = pEmObject;
dumpFilesPropPage.m_pIEmManager = GetDocument()->GetEmManager();
propsheet.AddPage(&generalPropPage);
propsheet.AddPage(&logFilesPropPage);
propsheet.AddPage(&dumpFilesPropPage);
//
// a-mando
//
propsheet.SetTitle( pEmObject->szName, PSH_PROPTITLE );
propsheet.DoModal();
}
void CEmshellView::OnViewApplications()
{
if ( m_enumShellViewState == SHELLVIEW_APPLICATIONS ) return;
SetShellState(SHELLVIEW_APPLICATIONS);
ListCtrlPopulate(SHELLVIEW_APPLICATIONS);
}
void CEmshellView::OnUpdateViewApplications(CCmdUI* pCmdUI)
{
BOOL bEnable = FALSE;
BOOL bChecked = FALSE;
if ( GetDocument()->GetConnectedToServerState() == TRUE ) {
bEnable = TRUE;
if ( m_enumShellViewState == SHELLVIEW_APPLICATIONS )
bChecked = TRUE;
}
pCmdUI->Enable ( bEnable );
pCmdUI->SetCheck( bChecked );
}
void CEmshellView::OnViewCompletedsessions()
{
if ( m_enumShellViewState == SHELLVIEW_COMPLETEDSESSIONS ) return;
SetShellState(SHELLVIEW_COMPLETEDSESSIONS);
ListCtrlPopulate(SHELLVIEW_COMPLETEDSESSIONS);
}
void CEmshellView::OnUpdateViewCompletedsessions(CCmdUI* pCmdUI)
{
BOOL bEnable = FALSE;
BOOL bChecked = FALSE;
if ( GetDocument()->GetConnectedToServerState() == TRUE ) {
bEnable = TRUE;
if ( m_enumShellViewState == SHELLVIEW_COMPLETEDSESSIONS )
bChecked = TRUE;
}
pCmdUI->Enable ( bEnable );
pCmdUI->SetCheck( bChecked );
}
void CEmshellView::OnViewServices()
{
if ( m_enumShellViewState == SHELLVIEW_SERVICES ) return;
SetShellState(SHELLVIEW_SERVICES);
ListCtrlPopulate(SHELLVIEW_SERVICES);
}
void CEmshellView::OnUpdateViewServices(CCmdUI* pCmdUI)
{
BOOL bEnable = FALSE;
BOOL bChecked = FALSE;
if ( GetDocument()->GetConnectedToServerState() == TRUE ) {
bEnable = TRUE;
if ( m_enumShellViewState == SHELLVIEW_SERVICES )
bChecked = TRUE;
}
pCmdUI->Enable ( bEnable );
pCmdUI->SetCheck( bChecked );
}
void CEmshellView::OnProcesspopupDeleteSession()
{
//Delete the session for the current item selected
PEmObject pEmObject = NULL;
HRESULT hr = E_FAIL;
int nIndex = -1;
PActiveSession pActiveSession = NULL;
IEmDebugSession* pTempDebugSession = NULL;
BSTR bstrEmObj = NULL;
do {
nIndex = GetSelectedItemIndex();
if ( nIndex == -1 ) break;
pEmObject = ( PEmObject ) m_mainListControl.GetItemData( nIndex );
if ( pEmObject == NULL ) break;
//Find the element in the session table
pActiveSession = FindActiveSession( pEmObject );
if ( pActiveSession == NULL ) {
//Create bstr's for the journey ahead, and break if we can't
bstrEmObj = CopyBSTR ( (LPBYTE)pEmObject, sizeof( EmObject ) );
if( bstrEmObj == NULL ){
hr = E_OUTOFMEMORY;
break;
}
//We don't have a session open, so open a temporary session
hr = GetDocument()->GetEmManager()->OpenSession( bstrEmObj, &pTempDebugSession );
if (FAILED(hr)) break;
SysFreeString( bstrEmObj );
if ( hr == S_OK ) {
//We are the master now... Delete the debug session
hr = DeleteDebugSession( pEmObject );
if ( FAILED( hr ) ) break;
}
else if ( hr == S_FALSE ) {
//Adopt the orphan if the user wants
if ( CommenceOrphanCustodyBattle( pTempDebugSession ) ) {
hr = DeleteDebugSession( pEmObject );
if ( FAILED( hr ) ) break;
} else break;
}
else if ( hr == E_FAIL ) {
//Notify the user that the process currently belongs to someone else
break;
}
}
else {
//Close and remove the currently selected session
hr = DeleteDebugSession( pEmObject );
if ( FAILED( hr ) ) break;
hr = RemoveActiveSession( pEmObject );
if ( FAILED( hr ) ) break;
}
//Cast dwData to a EmObject and call delete on it
((CEmshellApp*)AfxGetApp())->DeAllocEmObject(pEmObject);
//Remove the item from the list control
m_mainListControl.DeleteItem( nIndex );
} while ( FALSE );
if ( FAILED( hr ) ) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR( hr );
}
if ( pTempDebugSession ) {
//Release the pTempDebugSession pointer
SAFE_RELEASEIX( pTempDebugSession );
}
SysFreeString ( bstrEmObj );
}
void CEmshellView::OnUpdateProcesspopupDeleteSession( CCmdUI* pCmdUI )
{
PEmObject pEmObject = NULL;
PActiveSession pActiveSession = NULL;
BOOL bEnable = FALSE;
do {
if ( !GetDocument()->GetConnectedToServerState() ) break;
// Update the state of this button based on the state of the currently selected item
//Get the currently selected emObject
pEmObject = GetSelectedEmObject();
if ( pEmObject == NULL ) break;
pActiveSession = FindActiveSession( pEmObject );
//Determine if the status of pActiveSession and enable this apprpriately
//If it's status is stopped && (it's an orphan || it's in our session table)
if ( pEmObject->nStatus & STAT_SESS_STOPPED &&
( pEmObject->nStatus & STAT_ORPHAN || pActiveSession ) ) {
bEnable = TRUE;
}
}while ( FALSE );
pCmdUI->Enable( bEnable );
}
void CEmshellView::OnToolsOptions()
{
// TODO: Add your command handler code here
CEmOptions EmOpts;
DWORD dwPollSessionsFreq = 30L; // default
if( EmOpts.DoModal() == IDOK ) {
((CEmshellApp*)AfxGetApp())->GetEmShellRegOptions( FALSE, &dwPollSessionsFreq );
KillTimer( 1 );
SetTimer( 1, dwPollSessionsFreq*1000, 0);
}
}
void CEmshellView::OnUpdateToolsOptoins(CCmdUI* pCmdUI)
{
// TODO: Add your command update UI handler code here
}
void CEmshellView::OnProcesspopupCancelDebugSession()
{
//Stop the session for the current item selected
PEmObject pEmObject = NULL;
HRESULT hr = E_FAIL;
do {
pEmObject = GetSelectedEmObject();
if ( pEmObject == NULL ) break;
//Stop and remove the session
CancelDebugSession( pEmObject );
hr = S_OK;
} while ( FALSE );
if ( FAILED( hr ) ) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR( hr );
}
}
//
// a-mando
//
void CEmshellView::OnLogpopupDelete()
{
//Stop the session for the current item selected
PEmObject pEmObject = NULL;
HRESULT hr = E_FAIL;
BSTR bstrEmObj = NULL;
UINT nIndex = -1;
do {
nIndex = GetSelectedItemIndex();
if ( nIndex == -1 ) break;
pEmObject = GetSelectedEmObject();
if ( pEmObject == NULL ) break;
bstrEmObj = CopyBSTR ( (LPBYTE)pEmObject, sizeof( EmObject ) );
if( bstrEmObj == NULL ){
hr = E_OUTOFMEMORY;
break;
}
hr = GetDocument()->GetEmManager()->DeleteFile( bstrEmObj );
if( FAILED(hr) ) break;
//Remove the item from the list control
m_mainListControl.DeleteItem( nIndex );
if( !m_mainListControl.SelectItem( nIndex ) ) {
m_mainListControl.SelectItem( nIndex-1 );
}
} while ( FALSE );
if ( FAILED( hr ) ) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR( hr );
}
}
void CEmshellView::OnUpdateLogpopupDelete(CCmdUI* pCmdUI)
{
// TODO: Add your command update UI handler code here
}
// a-mando
void CEmshellView::OnActionGenerateMSInfoFile()
{
// TODO: Add your command handler code here
CMSInfoDlg DlgMsInfo;
BSTR bstrCategories = NULL;
HRESULT hr = S_OK;
CWaitCursor wait;
// we won't show this dialog if the user doesn't want it.
if( !((CEmshellApp*)AfxGetApp())->m_dwShowMSInfoDlg || DlgMsInfo.DoModal() == IDOK ) {
((CEmshellApp*)AfxGetApp())->m_dwShowMSInfoDlg = !DlgMsInfo.m_bDlgNoShow;
bstrCategories = DlgMsInfo.m_csCategories.AllocSysString();
hr = GetDocument()->GetEmManager()->MakeNFO( NULL, NULL, bstrCategories );
}
SysFreeString( bstrCategories );
if ( FAILED( hr ) ) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR( hr );
}
}
void CEmshellView::OnUpdateActionGenerateMSInfoFile(CCmdUI* pCmdUI)
{
// TODO: Add your command update UI handler code here
pCmdUI->Enable( GetDocument()->GetConnectedToServerState() );
}
void CEmshellView::OnViewMSInfoFiles()
{
if ( m_enumShellViewState == SHELLVIEW_MSINFOFILES ) return;
SetShellState(SHELLVIEW_MSINFOFILES);
ListCtrlPopulate(SHELLVIEW_MSINFOFILES);
}
void CEmshellView::OnUpdateViewMSInfoFiles(CCmdUI* pCmdUI)
{
BOOL bEnable = FALSE;
BOOL bChecked = FALSE;
if ( GetDocument()->GetConnectedToServerState() == TRUE ) {
bEnable = TRUE;
if ( m_enumShellViewState == SHELLVIEW_MSINFOFILES )
bChecked = TRUE;
}
pCmdUI->Enable ( bEnable );
pCmdUI->SetCheck( bChecked );
}
void CEmshellView::PopulateMSInfoType()
{
_variant_t var; //This will create and initialize the var variant
HRESULT hr = E_FAIL;
LONG lLBound = 0;
LONG lUBound = 0;
BSTR bstrEmObj = NULL;
BSTR bstrEmObjectFilter = NULL;
EmObject *pCurrentObj = NULL;
EmObject EmObjectFilter;
memset(&EmObjectFilter, 0, sizeof( EmObject ) );
do {
EmObjectFilter.type = EMOBJ_MSINFO;
bstrEmObjectFilter = CopyBSTR ( (LPBYTE)&EmObjectFilter, sizeof( EmObject ) );
//Populate the list control based on the EmObjectType
//Enumerate all the objects and stick them in the variant
hr = GetDocument()->GetEmManager()->EnumObjectsEx(bstrEmObjectFilter, &var);
if(FAILED(hr)) break;
//Get the lower and upper bounds of the variant array
hr = SafeArrayGetLBound(var.parray, 1, &lLBound);
if(FAILED(hr)) break;
hr = SafeArrayGetUBound(var.parray, 1, &lUBound);
if(FAILED(hr)) break;
//There are elements at both the lower bound and upper bound, so include them
for(; lLBound <= lUBound; lLBound++)
{
//Get a BSTR object from the safe array
hr = SafeArrayGetElement(var.parray, &lLBound, &bstrEmObj);
if (FAILED(hr)) break;
//Create a local copy of the EmObject (there aren't any pointers in
//EmObject structure, so don't worry about doing a deep copy
pCurrentObj = ((CEmshellApp*)AfxGetApp())->AllocEmObject();
if (pCurrentObj != NULL) {
*pCurrentObj = *GetEmObj( bstrEmObj );
}
SysFreeString( bstrEmObj );
//Unallocate the EmObject if it has an hr of E_FAIL
if (FAILED(pCurrentObj->hr)) {
((CEmshellApp*)AfxGetApp())->DeAllocEmObject( pCurrentObj );
continue;
}
//Convert the BSTR object to an EmObject and pass it to DisplayData
DisplayMSInfoData( pCurrentObj );
}
} while (FALSE);
SafeArrayDestroyData(var.parray);
SysFreeString ( bstrEmObjectFilter );
SysFreeString( bstrEmObj );
if (FAILED(hr)) {
((CEmshellApp*)AfxGetApp())->DisplayErrMsgFromHR(hr);
}
}
void CEmshellView::InitializeMSInfoView()
{
InitializeLogView();
}
void CEmshellView::OnLogpopupExport()
{
PEmObject pEmObject = NULL;
CString strDirPath;
do {
pEmObject = GetSelectedEmObject();
if ( pEmObject == NULL ) break;
//Get the path
if ( ( (CEmshellApp*) AfxGetApp() )->AskForPath( strDirPath ) ) {
//Export the file
((CEmshellApp*)AfxGetApp())->ExportLog( pEmObject, strDirPath, GetDocument()->GetEmManager() );
}
} while ( FALSE );
}
void CEmshellView::OnUpdateLogpopupExport(CCmdUI* pCmdUI)
{
// TODO: Add your command update UI handler code here
}
void CEmshellView::OnHelpContents()
{
// TODO: Add your command handler code here
HWND hwnd = HtmlHelp( ::GetDesktopWindow(), ((CEmshellApp*)AfxGetApp())->m_strApplicationPath + gtcEmChm, HH_DISPLAY_TOPIC, NULL );
}
Reference in a new issue Copy permalink