1630 lines
45 KiB
C++
1630 lines
45 KiB
C++
/*
|
|
* Copyright (c) 2001 Microsoft Corporation
|
|
*
|
|
* Module Name:
|
|
*
|
|
* POP3oc.cpp
|
|
*
|
|
* Abstract:
|
|
*
|
|
* This file handles all messages passed by the OC Manager
|
|
*
|
|
* Author:
|
|
*
|
|
* Paolo Raden (paolora) Nov-20-2001
|
|
*
|
|
* Environment:
|
|
*
|
|
* User Mode
|
|
*/
|
|
|
|
#define _POP3OC_CPP_
|
|
#include <windows.h>
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
#include <tchar.h>
|
|
#include <shlobj.h>
|
|
#include <objbase.h>
|
|
#include <shlwapi.h>
|
|
#include <lm.h>
|
|
#include <objidl.h>
|
|
#include <psapi.h>
|
|
#include "pop3oc.h"
|
|
#include "ServiceUtil.h"
|
|
#include "Pop3RegKeysUtil.h"
|
|
#include <isexchng.h>
|
|
#include <p3admin.h>
|
|
#include <Pop3Server.h>
|
|
#define _ASSERT(x) {}
|
|
#include <ServUtil.h>
|
|
|
|
#include <smtpinet.h>
|
|
#pragma hdrstop
|
|
|
|
|
|
// also referred to in pop3oc.h // forward reference
|
|
|
|
DWORD OnPreinitialize();
|
|
DWORD OnInitComponent(LPCTSTR ComponentId, PSETUP_INIT_COMPONENT psc);
|
|
DWORD OnSetLanguage();
|
|
DWORD_PTR OnQueryImage();
|
|
DWORD OnSetupRequestPages(UINT type, PVOID srp);
|
|
DWORD OnQuerySelStateChange(LPCTSTR ComponentId, LPCTSTR SubcomponentId, UINT state, UINT flags);
|
|
DWORD OnCalcDiskSpace(LPCTSTR ComponentId, LPCTSTR SubcomponentId, DWORD addComponent, HDSKSPC dspace);
|
|
DWORD OnQueueFileOps(LPCTSTR ComponentId, LPCTSTR SubcomponentId, HSPFILEQ queue);
|
|
DWORD OnNotificationFromQueue();
|
|
DWORD OnQueryStepCount();
|
|
DWORD OnCompleteInstallation(LPCTSTR ComponentId, LPCTSTR SubcomponentId);
|
|
DWORD OnCleanup();
|
|
DWORD OnQueryState(LPCTSTR ComponentId, LPCTSTR SubcomponentId, UINT state);
|
|
DWORD OnNeedMedia();
|
|
DWORD OnAboutToCommitQueue(LPCTSTR ComponentId, LPCTSTR SubcomponentId);
|
|
DWORD OnQuerySkipPage();
|
|
DWORD OnWizardCreated();
|
|
DWORD OnExtraRoutines(LPCTSTR ComponentId, PEXTRA_ROUTINES per);
|
|
|
|
PPER_COMPONENT_DATA AddNewComponent(LPCTSTR ComponentId);
|
|
PPER_COMPONENT_DATA LocateComponent(LPCTSTR ComponentId);
|
|
VOID RemoveComponent(LPCTSTR ComponentId);
|
|
BOOL StateInfo(PPER_COMPONENT_DATA cd, LPCTSTR SubcomponentId, BOOL *state);
|
|
DWORD RegisterServers(HINF hinf, LPCTSTR component, DWORD state);
|
|
DWORD EnumSections(HINF hinf, const TCHAR *component, const TCHAR *key, DWORD index, INFCONTEXT *pic, TCHAR *name);
|
|
DWORD RegisterServices(PPER_COMPONENT_DATA cd, LPCTSTR component, DWORD state);
|
|
DWORD CleanupNetShares(PPER_COMPONENT_DATA cd, LPCTSTR component, DWORD state);
|
|
DWORD RunExternalProgram(PPER_COMPONENT_DATA cd, LPCTSTR component, DWORD state);
|
|
HRESULT CreateLink( const TCHAR *sourcePath, const TCHAR *linkPath, const TCHAR *args, const TCHAR *sDesc );
|
|
|
|
// POP 3 custom
|
|
DWORD KillPop3Snapins();
|
|
|
|
// for registering dlls
|
|
|
|
typedef HRESULT (__stdcall *pfn)(void);
|
|
|
|
#define KEYWORD_REGSVR TEXT("RegSvr")
|
|
#define KEYWORD_UNREGSVR TEXT("UnregSvr")
|
|
#define KEYWORD_UNINSTALL TEXT("Uninstall")
|
|
#define KEYWORD_SOURCEPATH TEXT("SourcePath")
|
|
#define KEYWORD_DELSHARE TEXT("DelShare")
|
|
#define KEYWORD_ADDSERVICE TEXT("AddService")
|
|
#define KEYWORD_DELSERVICE TEXT("DelService")
|
|
#define KEYWORD_SHARENAME TEXT("Share")
|
|
#define KEYWORD_RUN TEXT("Run")
|
|
#define KEYVAL_SYSTEMSRC TEXT("SystemSrc")
|
|
#define KEYWORD_COMMANDLINE TEXT("CommandLine")
|
|
#define KEYWORD_TICKCOUNT TEXT("TickCount")
|
|
|
|
// Services keywords/options
|
|
#define KEYWORD_SERVICENAME TEXT("ServiceName")
|
|
#define KEYWORD_DISPLAYNAME TEXT("DisplayName")
|
|
#define KEYWORD_SERVICETYPE TEXT("ServiceType")
|
|
#define KEYWORD_STARTTYPE TEXT("StartType")
|
|
#define KEYWORD_ERRORCONTROL TEXT("ErrorControl")
|
|
#define KEYWORD_IMAGEPATH TEXT("BinaryPathName")
|
|
#define KEYWORD_LOADORDER TEXT("LoadOrderGroup")
|
|
#define KEYWORD_DEPENDENCIES TEXT("Dependencies")
|
|
#define KEYWORD_STARTNAME TEXT("ServiceStartName")
|
|
#define KEYWORD_PASSWORD TEXT("Password")
|
|
|
|
#define KEYVAL_ON TEXT("on")
|
|
#define KEYVAL_OFF TEXT("off")
|
|
#define KEYVAL_DEFAULT TEXT("default")
|
|
|
|
const char gszRegisterSvrRoutine[] = "DllRegisterServer";
|
|
const char gszUnregisterSvrRoutine[] = "DllUnregisterServer";
|
|
BOOL g_fRebootNeed = FALSE;
|
|
BOOL g_fExchange = FALSE;
|
|
CServiceUtil *g_pServiceUtil = NULL;
|
|
CServiceUtil *g_pServiceUtilWMI = NULL;
|
|
CPop3RegKeysUtil *g_pPopRegKeys = NULL;
|
|
|
|
PPER_COMPONENT_DATA _cd=NULL;
|
|
|
|
|
|
/*
|
|
* called by CRT when _DllMainCRTStartup is the DLL entry point
|
|
*/
|
|
|
|
BOOL
|
|
WINAPI
|
|
DllMain(
|
|
IN HINSTANCE hinstance,
|
|
IN DWORD reason,
|
|
IN LPVOID reserved
|
|
)
|
|
{
|
|
BOOL b;
|
|
|
|
UNREFERENCED_PARAMETER(reserved);
|
|
|
|
b = true;
|
|
|
|
switch(reason)
|
|
{
|
|
case DLL_PROCESS_ATTACH:
|
|
ghinst = hinstance;
|
|
loginit();
|
|
|
|
// Fall through to process first thread
|
|
|
|
case DLL_THREAD_ATTACH:
|
|
b = true;
|
|
break;
|
|
|
|
case DLL_PROCESS_DETACH:
|
|
break;
|
|
|
|
case DLL_THREAD_DETACH:
|
|
break;
|
|
}
|
|
|
|
return(b);
|
|
}
|
|
|
|
|
|
DWORD_PTR
|
|
OcEntry(
|
|
IN LPCTSTR ComponentId,
|
|
IN LPCTSTR SubcomponentId,
|
|
IN UINT Function,
|
|
IN UINT Param1,
|
|
IN OUT PVOID Param2
|
|
)
|
|
{
|
|
DWORD_PTR rc;
|
|
|
|
DebugTraceOCNotification(Function, ComponentId);
|
|
logOCNotification(Function, ComponentId);
|
|
|
|
switch(Function)
|
|
{
|
|
case OC_PREINITIALIZE:
|
|
rc = OnPreinitialize();
|
|
break;
|
|
|
|
case OC_INIT_COMPONENT:
|
|
rc = OnInitComponent(ComponentId, (PSETUP_INIT_COMPONENT)Param2);
|
|
break;
|
|
|
|
case OC_EXTRA_ROUTINES:
|
|
rc = OnExtraRoutines(ComponentId, (PEXTRA_ROUTINES)Param2);
|
|
break;
|
|
|
|
case OC_SET_LANGUAGE:
|
|
rc = OnSetLanguage();
|
|
break;
|
|
|
|
case OC_QUERY_IMAGE:
|
|
rc = OnQueryImage();
|
|
break;
|
|
|
|
case OC_REQUEST_PAGES:
|
|
rc = OnSetupRequestPages(Param1, Param2);
|
|
break;
|
|
|
|
case OC_QUERY_CHANGE_SEL_STATE:
|
|
rc = OnQuerySelStateChange(ComponentId, SubcomponentId, Param1, (UINT)((UINT_PTR)Param2));
|
|
break;
|
|
|
|
case OC_CALC_DISK_SPACE:
|
|
rc = OnCalcDiskSpace(ComponentId, SubcomponentId, Param1, Param2);
|
|
break;
|
|
|
|
case OC_QUEUE_FILE_OPS:
|
|
rc = OnQueueFileOps(ComponentId, SubcomponentId, (HSPFILEQ)Param2);
|
|
break;
|
|
|
|
case OC_NOTIFICATION_FROM_QUEUE:
|
|
rc = OnNotificationFromQueue();
|
|
break;
|
|
|
|
case OC_QUERY_STEP_COUNT:
|
|
rc = OnQueryStepCount();
|
|
break;
|
|
|
|
case OC_COMPLETE_INSTALLATION:
|
|
rc = OnCompleteInstallation(ComponentId, SubcomponentId);
|
|
break;
|
|
|
|
case OC_CLEANUP:
|
|
rc = OnCleanup();
|
|
break;
|
|
|
|
case OC_QUERY_STATE:
|
|
rc = OnQueryState(ComponentId, SubcomponentId, Param1);
|
|
break;
|
|
|
|
case OC_NEED_MEDIA:
|
|
rc = OnNeedMedia();
|
|
break;
|
|
|
|
case OC_ABOUT_TO_COMMIT_QUEUE:
|
|
rc = OnAboutToCommitQueue(ComponentId,SubcomponentId);
|
|
break;
|
|
|
|
case OC_QUERY_SKIP_PAGE:
|
|
rc = OnQuerySkipPage();
|
|
break;
|
|
|
|
case OC_WIZARD_CREATED:
|
|
rc = OnWizardCreated();
|
|
break;
|
|
|
|
default:
|
|
rc = NO_ERROR;
|
|
break;
|
|
}
|
|
|
|
DebugTrace(1, TEXT("processing completed"));
|
|
logOCNotificationCompletion();
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*-------------------------------------------------------*/
|
|
/*
|
|
* OC Manager message handlers
|
|
*
|
|
*-------------------------------------------------------*/
|
|
|
|
|
|
/* OnPreinitialize()
|
|
*
|
|
* handler for OC_PREINITIALIZE
|
|
*/
|
|
|
|
DWORD
|
|
OnPreinitialize(
|
|
VOID
|
|
)
|
|
{
|
|
#ifdef ANSI
|
|
return OCFLAG_ANSI;
|
|
#else
|
|
return OCFLAG_UNICODE;
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* OnInitComponent()
|
|
*
|
|
* handler for OC_INIT_COMPONENT
|
|
*/
|
|
|
|
DWORD OnInitComponent(LPCTSTR ComponentId, PSETUP_INIT_COMPONENT psc)
|
|
{
|
|
PPER_COMPONENT_DATA cd;
|
|
INFCONTEXT context;
|
|
TCHAR buf[256];
|
|
HINF hinf;
|
|
BOOL rc;
|
|
|
|
// We should only uninstall if exchange is on the box
|
|
g_fExchange = _IsExchangeInstalled();
|
|
|
|
// add component to linked list
|
|
if (!(cd = AddNewComponent(ComponentId)))
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
// store component inf handle
|
|
cd->hinf = (psc->ComponentInfHandle == INVALID_HANDLE_VALUE)
|
|
? NULL
|
|
: psc->ComponentInfHandle;
|
|
|
|
// open the inf
|
|
if (cd->hinf)
|
|
SetupOpenAppendInfFile(NULL, cd->hinf,NULL);
|
|
|
|
// copy helper routines and flags
|
|
cd->HelperRoutines = psc->HelperRoutines;
|
|
cd->Flags = psc->SetupData.OperationFlags;
|
|
cd->SourcePath = NULL;
|
|
|
|
|
|
// play
|
|
srand(GetTickCount());
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*
|
|
* OnExtraRoutines()
|
|
*
|
|
* handler for OC_EXTRA_ROUTINES
|
|
*/
|
|
|
|
DWORD OnExtraRoutines(LPCTSTR ComponentId, PEXTRA_ROUTINES per)
|
|
{
|
|
PPER_COMPONENT_DATA cd;
|
|
|
|
if (!(cd = LocateComponent(ComponentId)))
|
|
return NO_ERROR;
|
|
|
|
memcpy(&cd->ExtraRoutines, per, per->size);
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*
|
|
* OnSetLanguage()
|
|
*
|
|
* handler for OC_SET_LANGUAGE
|
|
*/
|
|
|
|
DWORD OnSetLanguage()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* OnSetLanguage()
|
|
*
|
|
* handler for OC_SET_LANGUAGE
|
|
*/
|
|
|
|
DWORD_PTR OnQueryImage()
|
|
{
|
|
return (DWORD_PTR)LoadBitmap(NULL,MAKEINTRESOURCE(32754)); // OBM_CLOSE
|
|
}
|
|
|
|
/*
|
|
* OnSetupRequestPages
|
|
*
|
|
* Prepares wizard pages and returns them to the OC Manager
|
|
*/
|
|
|
|
DWORD OnSetupRequestPages(UINT type, PVOID srp)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* OnWizardCreated()
|
|
*/
|
|
|
|
DWORD OnWizardCreated()
|
|
{
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*
|
|
* OnQuerySkipPage()
|
|
*
|
|
* don't let the user deselect the sam component
|
|
*/
|
|
|
|
DWORD OnQuerySkipPage()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* OnQuerySelStateChange()
|
|
*
|
|
* don't let the user deselect the sam component
|
|
*/
|
|
|
|
DWORD OnQuerySelStateChange(LPCTSTR ComponentId,
|
|
LPCTSTR SubcomponentId,
|
|
UINT state,
|
|
UINT flags)
|
|
{
|
|
if (g_fExchange && (flags & OCQ_ACTUAL_SELECTION) && state)
|
|
{
|
|
log( TEXT("POP3OC: user tried to install %s while exchange is installed. Not supported."), SubcomponentId);
|
|
MsgBox(NULL, IDS_ERR_EXCHANGE_INSTALLED, MB_OK);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* OnCalcDiskSpace()
|
|
*
|
|
* handler for OC_ON_CALC_DISK_SPACE
|
|
*/
|
|
|
|
DWORD OnCalcDiskSpace(LPCTSTR ComponentId,
|
|
LPCTSTR SubcomponentId,
|
|
DWORD addComponent,
|
|
HDSKSPC dspace)
|
|
{
|
|
DWORD rc = NO_ERROR;
|
|
TCHAR section[S_SIZE];
|
|
PPER_COMPONENT_DATA cd;
|
|
|
|
//
|
|
// Param1 = 0 if for removing component or non-0 if for adding component
|
|
// Param2 = HDSKSPC to operate on
|
|
//
|
|
// Return value is Win32 error code indicating outcome.
|
|
//
|
|
// In our case the private section for this component/subcomponent pair
|
|
// is a simple standard inf install section, so we can use the high-level
|
|
// disk space list api to do what we want.
|
|
//
|
|
|
|
if (!(cd = LocateComponent(ComponentId)))
|
|
return NO_ERROR;
|
|
|
|
_tcscpy(section, SubcomponentId);
|
|
|
|
if (addComponent)
|
|
{
|
|
rc = SetupAddInstallSectionToDiskSpaceList(dspace,
|
|
cd->hinf,
|
|
NULL,
|
|
section,
|
|
0,
|
|
0);
|
|
}
|
|
else
|
|
{
|
|
rc = SetupRemoveInstallSectionFromDiskSpaceList(dspace,
|
|
cd->hinf,
|
|
NULL,
|
|
section,
|
|
0,
|
|
0);
|
|
}
|
|
|
|
if (!rc)
|
|
rc = GetLastError();
|
|
else
|
|
rc = NO_ERROR;
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* OnQueueFileOps()
|
|
*
|
|
* handler for OC_QUEUE_FILE_OPS
|
|
*/
|
|
|
|
DWORD OnQueueFileOps(LPCTSTR ComponentId, LPCTSTR SubcomponentId, HSPFILEQ queue)
|
|
{
|
|
PPER_COMPONENT_DATA cd;
|
|
BOOL state;
|
|
BOOL rc;
|
|
INFCONTEXT context;
|
|
TCHAR section[256];
|
|
TCHAR srcpathbuf[256];
|
|
TCHAR *srcpath;
|
|
|
|
if (!(cd = LocateComponent(ComponentId)))
|
|
return NO_ERROR;
|
|
|
|
if (!SubcomponentId || !*SubcomponentId)
|
|
return NO_ERROR;
|
|
|
|
cd->queue = queue;
|
|
|
|
if (!StateInfo(cd, SubcomponentId, &state))
|
|
return NO_ERROR;
|
|
|
|
wsprintf(section, SubcomponentId);
|
|
|
|
rc = TRUE;
|
|
if (!state) {
|
|
// being uninstalled. Fetch uninstall section name.
|
|
rc = SetupFindFirstLine(cd->hinf,
|
|
SubcomponentId,
|
|
KEYWORD_UNINSTALL,
|
|
&context);
|
|
|
|
if (rc) {
|
|
rc = SetupGetStringField(&context,
|
|
1,
|
|
section,
|
|
sizeof(section) / sizeof(TCHAR),
|
|
NULL);
|
|
}
|
|
|
|
// POP3 Server Custom code goes here
|
|
if (!_wcsicmp( SubcomponentId, L"Pop3Service"))
|
|
{
|
|
// Winpop Init 0
|
|
TCHAR szSource[MAX_PATH+1];
|
|
if (0 != GetSystemDirectory( szSource, MAX_PATH+1 ))
|
|
{
|
|
TCHAR szAppName[MAX_PATH+30];
|
|
TCHAR szCommandLine[MAX_PATH+50];
|
|
_tcscpy( szAppName, szSource );
|
|
_tcscat( szAppName, _T("\\winpop.exe") );
|
|
_tcscpy( szCommandLine, szAppName );
|
|
_tcscat( szCommandLine, _T(" INIT 0") );
|
|
|
|
STARTUPINFO si;
|
|
PROCESS_INFORMATION pi;
|
|
ZeroMemory( &si, sizeof(si) );
|
|
ZeroMemory( &pi, sizeof(pi) );
|
|
|
|
DWORD dwRet;
|
|
if (CreateProcess( szAppName, szCommandLine, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi ))
|
|
do
|
|
{
|
|
dwRet = MsgWaitForMultipleObjects( 1, &pi.hProcess, FALSE, INFINITE, QS_ALLINPUT );
|
|
|
|
if( dwRet == WAIT_OBJECT_0 + 1 )
|
|
{
|
|
MSG msg;
|
|
while( PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) )
|
|
{
|
|
TranslateMessage( &msg );
|
|
DispatchMessage( &msg );
|
|
}
|
|
}
|
|
}
|
|
while( dwRet != WAIT_OBJECT_0 && dwRet != WAIT_FAILED );
|
|
|
|
CloseHandle( pi.hProcess );
|
|
CloseHandle( pi.hThread );
|
|
}
|
|
}
|
|
|
|
// Kill all Pop3 snapins
|
|
KillPop3Snapins();
|
|
// also, unregister the dlls and kill services before deletion
|
|
|
|
SetupInstallServicesFromInfSection(cd->hinf, section, 0);
|
|
SetupInstallFromInfSection(NULL,cd->hinf,section,SPINST_UNREGSVR,NULL,NULL,0,NULL,NULL,NULL,NULL);
|
|
}
|
|
|
|
if (rc) {
|
|
// if uninstalling, don't use version checks
|
|
rc = SetupInstallFilesFromInfSection(cd->hinf,
|
|
NULL,
|
|
queue,
|
|
section,
|
|
cd->SourcePath,
|
|
state ? SP_COPY_NEWER : 0);
|
|
}
|
|
|
|
if (!rc)
|
|
return GetLastError();
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*
|
|
* OnNotificationFromQueue()
|
|
*
|
|
* handler for OC_NOTIFICATION_FROM_QUEUE
|
|
*
|
|
* NOTE: although this notification is defined,
|
|
* it is currently unimplemented in oc manager
|
|
*/
|
|
|
|
DWORD OnNotificationFromQueue()
|
|
{
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*
|
|
* OnQueryStepCount
|
|
*
|
|
* handler forOC_QUERY_STEP_COUNT
|
|
*/
|
|
|
|
DWORD OnQueryStepCount()
|
|
{
|
|
return 2;
|
|
}
|
|
|
|
/*
|
|
* OnCompleteInstallation
|
|
*
|
|
* handler for OC_COMPLETE_INSTALLATION
|
|
*/
|
|
|
|
DWORD OnCompleteInstallation(LPCTSTR ComponentId, LPCTSTR SubcomponentId)
|
|
{
|
|
PPER_COMPONENT_DATA cd;
|
|
INFCONTEXT context;
|
|
TCHAR section[256];
|
|
BOOL state;
|
|
BOOL rc;
|
|
DWORD Error = NO_ERROR;
|
|
|
|
// Do post-installation processing in the cleanup section.
|
|
// This way we know all compoents queued for installation
|
|
// have beein installed before we do our stuff.
|
|
|
|
if (!(cd = LocateComponent(ComponentId)))
|
|
return NO_ERROR;
|
|
|
|
if (!SubcomponentId || !*SubcomponentId)
|
|
return NO_ERROR;
|
|
|
|
if (!StateInfo(cd, SubcomponentId, &state))
|
|
return NO_ERROR;
|
|
|
|
wsprintf(section, SubcomponentId);
|
|
|
|
rc = TRUE;
|
|
if (!state) {
|
|
// being uninstalled. Fetch uninstall section name.
|
|
rc = SetupFindFirstLine(cd->hinf,
|
|
SubcomponentId,
|
|
KEYWORD_UNINSTALL,
|
|
&context);
|
|
|
|
if (rc) {
|
|
rc = SetupGetStringField(&context,
|
|
1,
|
|
section,
|
|
sizeof(section) / sizeof(TCHAR),
|
|
NULL);
|
|
}
|
|
}
|
|
|
|
if (state) {
|
|
//
|
|
// installation
|
|
//
|
|
|
|
if (rc) {
|
|
if ( NULL == g_pPopRegKeys )
|
|
{
|
|
g_pPopRegKeys = new CPop3RegKeysUtil();
|
|
g_pPopRegKeys->Save();
|
|
}
|
|
// process the inf file
|
|
rc = SetupInstallFromInfSection(NULL, // hwndOwner
|
|
cd->hinf, // inf handle
|
|
section, // name of component
|
|
SPINST_ALL & ~SPINST_FILES,
|
|
NULL, // relative key root
|
|
NULL, // source root path
|
|
0, // copy flags
|
|
NULL, // callback routine
|
|
NULL, // callback routine context
|
|
NULL, // device info set
|
|
NULL); // device info struct
|
|
|
|
if (rc) {
|
|
rc = SetupInstallServicesFromInfSection(cd->hinf, section, 0);
|
|
Error = GetLastError();
|
|
|
|
if (!rc && Error == ERROR_SECTION_NOT_FOUND) {
|
|
rc = TRUE;
|
|
Error = NO_ERROR;
|
|
}
|
|
|
|
if (rc) {
|
|
if (Error == ERROR_SUCCESS_REBOOT_REQUIRED) {
|
|
cd->HelperRoutines.SetReboot(cd->HelperRoutines.OcManagerContext,TRUE);
|
|
}
|
|
Error = NO_ERROR;
|
|
rc = RunExternalProgram(cd, section, state);
|
|
}
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// uninstallation
|
|
//
|
|
|
|
if (rc)
|
|
{
|
|
|
|
rc = RunExternalProgram(cd, section, state);
|
|
|
|
}
|
|
if (rc) {
|
|
|
|
rc = CleanupNetShares(cd, section, state);
|
|
|
|
}
|
|
}
|
|
|
|
HRESULT hr = CoInitialize( NULL );
|
|
// POP3 Server Custom code goes here
|
|
if (!_wcsicmp( SubcomponentId, L"Pop3Service"))
|
|
{
|
|
// installing
|
|
TCHAR szSnapinName[64];
|
|
int iLen=LoadString(ghinst, IDS_SNAPIN_NAME, szSnapinName, sizeof(szSnapinName)/sizeof(TCHAR));
|
|
if(0==iLen)
|
|
{
|
|
_tcscpy(szSnapinName, _T("POP3 Service"));
|
|
}
|
|
|
|
if (state)
|
|
{
|
|
// Tooltip
|
|
TCHAR szTooltip[INFOTIPSIZE];
|
|
ZeroMemory( szTooltip, sizeof(szTooltip)/sizeof(TCHAR) );
|
|
LoadString(ghinst, IDS_SHORTCUT_TOOLTIP, szTooltip, sizeof(szTooltip)/sizeof(TCHAR) );
|
|
|
|
// Create the shortcut
|
|
TCHAR szDest[MAX_PATH+70];
|
|
if (TRUE == SHGetSpecialFolderPath( 0, szDest, CSIDL_COMMON_ADMINTOOLS, FALSE ))
|
|
{
|
|
TCHAR szSource[MAX_PATH+1];
|
|
if (0 != GetSystemDirectory( szSource, MAX_PATH+1 ))
|
|
{
|
|
_tcscat( szSource, _T("\\p3server.msc") );
|
|
_tcscat( szDest, _T("\\") );
|
|
_tcscat( szDest, szSnapinName);
|
|
_tcscat( szDest, _T(".lnk") );
|
|
CreateLink( szSource, szDest, 0, szTooltip );
|
|
}
|
|
}
|
|
|
|
// Winpop Init 1
|
|
TCHAR szSource[MAX_PATH+1];
|
|
if (0 != GetSystemDirectory( szSource, MAX_PATH+1 ))
|
|
{
|
|
TCHAR szAppName[MAX_PATH+30];
|
|
TCHAR szCommandLine[MAX_PATH+50];
|
|
_tcscpy( szAppName, szSource );
|
|
_tcscat( szAppName, _T("\\winpop.exe") );
|
|
_tcscpy( szCommandLine, szAppName );
|
|
_tcscat( szCommandLine, _T(" INIT 1") );
|
|
|
|
STARTUPINFO si;
|
|
PROCESS_INFORMATION pi;
|
|
ZeroMemory( &si, sizeof(si) );
|
|
ZeroMemory( &pi, sizeof(pi) );
|
|
|
|
DWORD dwRet;
|
|
if (CreateProcess( szAppName, szCommandLine, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi ))
|
|
do
|
|
{
|
|
dwRet = MsgWaitForMultipleObjects( 1, &pi.hProcess, FALSE, INFINITE, QS_ALLINPUT );
|
|
|
|
if( dwRet == WAIT_OBJECT_0 + 1 )
|
|
{
|
|
MSG msg;
|
|
while( PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) )
|
|
{
|
|
TranslateMessage( &msg );
|
|
DispatchMessage( &msg );
|
|
}
|
|
}
|
|
}
|
|
while( dwRet != WAIT_OBJECT_0 && dwRet != WAIT_FAILED );
|
|
|
|
CloseHandle( pi.hProcess );
|
|
CloseHandle( pi.hThread );
|
|
}
|
|
|
|
// Add perf counters
|
|
if (0 != GetSystemDirectory( szSource, MAX_PATH+1 ))
|
|
{
|
|
TCHAR szAppName[MAX_PATH+30];
|
|
TCHAR szCommandLine[MAX_PATH*2+50];
|
|
_tcscpy( szAppName, szSource );
|
|
_tcscat( szAppName, _T("\\lodctr.exe") );
|
|
_tcscpy( szCommandLine, szAppName );
|
|
_tcscat( szCommandLine, _T(" ") );
|
|
_tcscat( szCommandLine, szSource );
|
|
_tcscat( szCommandLine, _T("\\POP3Server\\pop3perf.ini") );
|
|
|
|
STARTUPINFO si;
|
|
PROCESS_INFORMATION pi;
|
|
ZeroMemory( &si, sizeof(si) );
|
|
ZeroMemory( &pi, sizeof(pi) );
|
|
|
|
DWORD dwRet;
|
|
if (CreateProcess( szAppName, szCommandLine, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi ))
|
|
do
|
|
{
|
|
dwRet = MsgWaitForMultipleObjects( 1, &pi.hProcess, FALSE, INFINITE, QS_ALLINPUT );
|
|
|
|
if( dwRet == WAIT_OBJECT_0 + 1 )
|
|
{
|
|
MSG msg;
|
|
while( PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) )
|
|
{
|
|
TranslateMessage( &msg );
|
|
DispatchMessage( &msg );
|
|
}
|
|
}
|
|
}
|
|
while( dwRet != WAIT_OBJECT_0 && dwRet != WAIT_FAILED );
|
|
|
|
CloseHandle( pi.hProcess );
|
|
CloseHandle( pi.hThread );
|
|
}
|
|
|
|
// Restore the regkeys to their original state for uninstall
|
|
if ( NULL != g_pPopRegKeys )
|
|
{
|
|
g_pPopRegKeys->Restore();
|
|
g_pPopRegKeys = NULL;
|
|
}
|
|
}
|
|
// removing
|
|
else
|
|
{
|
|
// delete the shortcut
|
|
TCHAR szPath[MAX_PATH+70];
|
|
if (TRUE == SHGetSpecialFolderPath( 0, szPath, CSIDL_COMMON_ADMINTOOLS, FALSE ))
|
|
{
|
|
_tcscat( szPath, _T("\\") );
|
|
_tcscat( szPath, szSnapinName);
|
|
_tcscat( szPath, _T(".lnk") );
|
|
DeleteFile( szPath );
|
|
}
|
|
|
|
TCHAR szSource[MAX_PATH+1];
|
|
TCHAR szStoreDllName[MAX_PATH+30];
|
|
// Remove perf counters
|
|
if (0 != GetSystemDirectory( szSource, MAX_PATH+1 ))
|
|
{
|
|
TCHAR szAppName[MAX_PATH+30];
|
|
TCHAR szCommandLine[MAX_PATH*2+50];
|
|
_tcscpy( szAppName, szSource );
|
|
_tcscat( szAppName, _T("\\unlodctr.exe") );
|
|
_tcscpy( szCommandLine, szAppName );
|
|
_tcscat( szCommandLine, _T(" pop3svc") );
|
|
_tcscpy( szStoreDllName, szSource);
|
|
_tcscat( szStoreDllName, _T("\\POP3Server\\P3Store.dll"));
|
|
|
|
STARTUPINFO si;
|
|
PROCESS_INFORMATION pi;
|
|
ZeroMemory( &si, sizeof(si) );
|
|
ZeroMemory( &pi, sizeof(pi) );
|
|
|
|
DWORD dwRet;
|
|
if (CreateProcess( szAppName, szCommandLine, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi ))
|
|
do
|
|
{
|
|
dwRet = MsgWaitForMultipleObjects( 1, &pi.hProcess, FALSE, INFINITE, QS_ALLINPUT );
|
|
|
|
if( dwRet == WAIT_OBJECT_0 + 1 )
|
|
{
|
|
MSG msg;
|
|
while( PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) )
|
|
{
|
|
TranslateMessage( &msg );
|
|
DispatchMessage( &msg );
|
|
}
|
|
}
|
|
}
|
|
while( dwRet != WAIT_OBJECT_0 && dwRet != WAIT_FAILED );
|
|
|
|
CloseHandle( pi.hProcess );
|
|
CloseHandle( pi.hThread );
|
|
}
|
|
//Before we restore the service, wait max of 30 seconds for p3store.dll to be deleted
|
|
int iCountDown=15;
|
|
while( ( INVALID_FILE_ATTRIBUTES != GetFileAttributes(szStoreDllName) ) &&
|
|
( iCountDown >0 ) )
|
|
{
|
|
Sleep(2000);
|
|
iCountDown--;
|
|
}
|
|
|
|
if ( NULL != g_pServiceUtil )
|
|
{
|
|
g_pServiceUtil->RestoreServiceState( IISADMIN_SERVICE_NAME );
|
|
delete g_pServiceUtil;
|
|
g_pServiceUtil = NULL;
|
|
}
|
|
if ( NULL != g_pServiceUtilWMI )
|
|
{
|
|
g_pServiceUtilWMI->RestoreServiceState( WMI_SERVICE_NAME );
|
|
delete g_pServiceUtilWMI;
|
|
g_pServiceUtilWMI = NULL;
|
|
}
|
|
// Remove Dirs for files
|
|
if (0 != GetSystemDirectory( szPath, MAX_PATH+1 ))
|
|
{
|
|
_tcscat( szPath, _T("\\POP3Server") );
|
|
RemoveDirectory( szPath );
|
|
}
|
|
}
|
|
}
|
|
// POP3 Admin
|
|
else if (!_wcsicmp( SubcomponentId, L"Pop3Admin" ))
|
|
{
|
|
// installing
|
|
if (state)
|
|
{
|
|
}
|
|
// removing
|
|
else
|
|
{
|
|
TCHAR szPath[MAX_PATH+1];
|
|
if (0 != GetSystemDirectory( szPath, MAX_PATH+1 ))
|
|
{
|
|
_tcscat( szPath, _T("\\ServerAppliance\\Web\\Mail") );
|
|
RemoveDirectory( szPath );
|
|
}
|
|
|
|
}
|
|
// stop the elementmgr service
|
|
if ( _IsServiceRunning( _T("elementmgr")))
|
|
{
|
|
hr = _StopService( _T("elementmgr"), FALSE );
|
|
if ( S_OK != hr )
|
|
log( _T("POP3OC:OnCompleteInstallation: Unable to stop elementmgr.\r\n") );
|
|
}
|
|
}
|
|
|
|
CoUninitialize();
|
|
|
|
if (!rc && (Error == NO_ERROR) ) {
|
|
Error = GetLastError( );
|
|
}
|
|
|
|
return Error;
|
|
}
|
|
|
|
/*
|
|
* OnCleanup()
|
|
*
|
|
* handler for OC_CLEANUP
|
|
*/
|
|
|
|
DWORD OnCleanup()
|
|
{
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*
|
|
* OnQueryState()
|
|
*
|
|
* handler for OC_QUERY_STATE
|
|
*/
|
|
|
|
DWORD OnQueryState(LPCTSTR ComponentId,
|
|
LPCTSTR SubcomponentId,
|
|
UINT state)
|
|
{
|
|
return SubcompUseOcManagerDefault;
|
|
}
|
|
|
|
/*
|
|
* OnNeedMedia()
|
|
*
|
|
* handler for OC_NEED_MEDIA
|
|
*/
|
|
|
|
DWORD OnNeedMedia()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* OnAboutToCommitQueue()
|
|
*
|
|
* handler for OC_ABOUT_TO_COMMIT_QUEUE
|
|
*/
|
|
|
|
DWORD OnAboutToCommitQueue(LPCTSTR ComponentId, LPCTSTR SubcomponentId)
|
|
{
|
|
PPER_COMPONENT_DATA cd;
|
|
BOOL state;
|
|
BOOL rc;
|
|
INFCONTEXT context;
|
|
TCHAR section[256];
|
|
TCHAR srcpathbuf[256];
|
|
TCHAR *srcpath;
|
|
|
|
if (!(cd = LocateComponent(ComponentId)))
|
|
return NO_ERROR;
|
|
|
|
if (!SubcomponentId || !*SubcomponentId)
|
|
return NO_ERROR;
|
|
|
|
if (!StateInfo(cd, SubcomponentId, &state))
|
|
return NO_ERROR;
|
|
|
|
//
|
|
// only do stuff on uninstall
|
|
//
|
|
if (state) {
|
|
return NO_ERROR;
|
|
}
|
|
|
|
// Fetch uninstall section name.
|
|
rc = SetupFindFirstLine(
|
|
cd->hinf,
|
|
SubcomponentId,
|
|
KEYWORD_UNINSTALL,
|
|
&context);
|
|
|
|
if (rc) {
|
|
rc = SetupGetStringField(
|
|
&context,
|
|
1,
|
|
section,
|
|
sizeof(section) / sizeof(TCHAR),
|
|
NULL);
|
|
}
|
|
|
|
// POP3 Server Custom code goes here
|
|
if (rc)
|
|
{
|
|
if (!_wcsicmp( SubcomponentId, L"Pop3Service"))
|
|
{ // Stop IISAdmin so that we can complete uninstall
|
|
if ( NULL == g_pServiceUtil )
|
|
{
|
|
g_pServiceUtil = new CServiceUtil();
|
|
if ( NULL != g_pServiceUtil )
|
|
{
|
|
g_pServiceUtil->StopService( IISADMIN_SERVICE_NAME );
|
|
}
|
|
}
|
|
}
|
|
// Stop WMI so that we can complete uninstall
|
|
if ( NULL == g_pServiceUtilWMI )
|
|
{
|
|
g_pServiceUtilWMI = new CServiceUtil();
|
|
if ( NULL != g_pServiceUtilWMI )
|
|
{
|
|
g_pServiceUtilWMI->StopService( WMI_SERVICE_NAME );
|
|
}
|
|
}
|
|
}
|
|
// Move Migration stuff to Mailroot
|
|
// We will not fail uninstall if something fails in this section
|
|
HKEY hKey;
|
|
DWORD dwType = REG_SZ, dwSize;
|
|
UINT uiRC;
|
|
long lRC;
|
|
TCHAR sCopyFrom[MAX_PATH+1], sCopyTo[MAX_PATH+1];
|
|
|
|
// Get the mail root
|
|
lRC = RegOpenKeyEx( HKEY_LOCAL_MACHINE, POP3SERVER_SOFTWARE_SUBKEY, 0, KEY_QUERY_VALUE, &hKey );
|
|
if ( ERROR_SUCCESS == lRC )
|
|
{
|
|
dwSize = sizeof( sCopyTo )/sizeof(TCHAR);
|
|
lRC = RegQueryValueEx( hKey, VALUENAME_MAILROOT, 0, &dwType, reinterpret_cast<LPBYTE>( sCopyTo ), &dwSize );
|
|
RegCloseKey( hKey );
|
|
}
|
|
// Get the current location
|
|
if ( ERROR_SUCCESS == lRC )
|
|
{
|
|
dwSize = sizeof( sCopyFrom )/sizeof(TCHAR);
|
|
uiRC = GetSystemDirectory( sCopyFrom, dwSize );
|
|
if ( 0 != uiRC && dwSize > uiRC )
|
|
lRC = ERROR_SUCCESS;
|
|
else
|
|
lRC = GetLastError();
|
|
}
|
|
|
|
if (rc)
|
|
rc = SetupInstallServicesFromInfSection(cd->hinf, section, 0);
|
|
|
|
if (rc) {
|
|
rc = SetupInstallFromInfSection(
|
|
NULL,
|
|
cd->hinf,
|
|
section,
|
|
SPINST_ALL & ~SPINST_FILES,
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL);
|
|
}
|
|
|
|
if (rc) {
|
|
SetLastError(NO_ERROR);
|
|
}
|
|
return GetLastError();
|
|
|
|
}
|
|
|
|
/*
|
|
* AddNewComponent()
|
|
*
|
|
* add new compononent to the top of the component list
|
|
*/
|
|
|
|
PPER_COMPONENT_DATA AddNewComponent(LPCTSTR ComponentId)
|
|
{
|
|
PPER_COMPONENT_DATA data;
|
|
|
|
data = (PPER_COMPONENT_DATA)LocalAlloc(LPTR,sizeof(PER_COMPONENT_DATA));
|
|
if (!data)
|
|
return data;
|
|
|
|
data->ComponentId = (TCHAR *)LocalAlloc(LMEM_FIXED,
|
|
(_tcslen(ComponentId) + 1) * sizeof(TCHAR));
|
|
|
|
if(data->ComponentId)
|
|
{
|
|
_tcscpy((TCHAR *)data->ComponentId, ComponentId);
|
|
|
|
// Stick at head of list
|
|
data->Next = gcd;
|
|
gcd = data;
|
|
}
|
|
else
|
|
{
|
|
LocalFree((HLOCAL)data);
|
|
data = NULL;
|
|
}
|
|
|
|
return(data);
|
|
}
|
|
|
|
/*
|
|
* LocateComponent()
|
|
*
|
|
* returns a compoent struct that matches the
|
|
* passed component id.
|
|
*/
|
|
|
|
PPER_COMPONENT_DATA LocateComponent(LPCTSTR ComponentId)
|
|
{
|
|
PPER_COMPONENT_DATA p;
|
|
|
|
for (p = gcd; p; p=p->Next)
|
|
{
|
|
if (!_tcsicmp(p->ComponentId, ComponentId))
|
|
return p;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* RemoveComponent()
|
|
*
|
|
* yanks a component from our linked list of components
|
|
*/
|
|
|
|
VOID RemoveComponent(LPCTSTR ComponentId)
|
|
{
|
|
PPER_COMPONENT_DATA p, prev;
|
|
|
|
for (prev = NULL, p = gcd; p; prev = p, p = p->Next)
|
|
{
|
|
if (!_tcsicmp(p->ComponentId, ComponentId))
|
|
{
|
|
LocalFree((HLOCAL)p->ComponentId);
|
|
|
|
if (p->SourcePath)
|
|
LocalFree((HLOCAL)p->SourcePath);
|
|
|
|
if (prev)
|
|
prev->Next = p->Next;
|
|
else
|
|
gcd = p->Next;
|
|
|
|
LocalFree((HLOCAL)p);
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// loads current selection state info into "state" and
|
|
// returns whether the selection state was changed
|
|
|
|
BOOL
|
|
StateInfo(
|
|
PPER_COMPONENT_DATA cd,
|
|
LPCTSTR SubcomponentId,
|
|
BOOL *state
|
|
)
|
|
{
|
|
BOOL rc = TRUE;
|
|
|
|
assert(state);
|
|
|
|
// otherwise, check for a change in installation state
|
|
|
|
*state = cd->HelperRoutines.QuerySelectionState(cd->HelperRoutines.OcManagerContext,
|
|
SubcomponentId,
|
|
OCSELSTATETYPE_CURRENT);
|
|
|
|
if (*state == cd->HelperRoutines.QuerySelectionState(cd->HelperRoutines.OcManagerContext,
|
|
SubcomponentId,
|
|
OCSELSTATETYPE_ORIGINAL))
|
|
{
|
|
// no change
|
|
rc = FALSE;
|
|
}
|
|
|
|
// if this is gui mode setup, presume the state has changed to force
|
|
// an installation (or uninstallation)
|
|
|
|
if (!(cd->Flags & SETUPOP_STANDALONE) && *state)
|
|
rc = TRUE;
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* EnumSections()
|
|
*
|
|
* finds the name of a section for a specified keyword
|
|
*/
|
|
|
|
DWORD
|
|
EnumSections(
|
|
HINF hinf,
|
|
const TCHAR *component,
|
|
const TCHAR *key,
|
|
DWORD index,
|
|
INFCONTEXT *pic,
|
|
TCHAR *name
|
|
)
|
|
{
|
|
TCHAR section[S_SIZE];
|
|
|
|
if (!SetupFindFirstLine(hinf, component, NULL, pic))
|
|
return 0;
|
|
|
|
if (!SetupFindNextMatchLine(pic, key, pic))
|
|
return 0;
|
|
|
|
if (index > SetupGetFieldCount(pic))
|
|
return 0;
|
|
|
|
if (!SetupGetStringField(pic, index, section, sizeof(section)/sizeof(TCHAR), NULL))
|
|
return 0;
|
|
|
|
if (name)
|
|
_tcscpy(name, section);
|
|
|
|
return SetupFindFirstLine(hinf, section, NULL, pic);
|
|
}
|
|
|
|
|
|
DWORD
|
|
OcLog(
|
|
LPCTSTR ComponentId,
|
|
UINT level,
|
|
LPCTSTR sz
|
|
)
|
|
{
|
|
TCHAR fmt[5000];
|
|
PPER_COMPONENT_DATA cd;
|
|
|
|
if (!(cd = LocateComponent(ComponentId)))
|
|
return NO_ERROR;
|
|
|
|
assert(cd->ExtraRoutines.LogError);
|
|
assert(level);
|
|
assert(sz);
|
|
|
|
_tcscpy(fmt, TEXT("%s: %s"));
|
|
|
|
return cd->ExtraRoutines.LogError(cd->HelperRoutines.OcManagerContext,
|
|
level,
|
|
fmt,
|
|
ComponentId,
|
|
sz);
|
|
}
|
|
|
|
DWORD
|
|
CleanupNetShares(
|
|
PPER_COMPONENT_DATA cd,
|
|
LPCTSTR component,
|
|
DWORD state)
|
|
{
|
|
INFCONTEXT ic;
|
|
TCHAR sname[S_SIZE];
|
|
DWORD section;
|
|
TCHAR *keyword;
|
|
|
|
if (state) {
|
|
return NO_ERROR;
|
|
} else {
|
|
keyword = KEYWORD_DELSHARE;
|
|
}
|
|
|
|
for (section = 1;
|
|
EnumSections(cd->hinf, component, keyword, section, &ic, sname);
|
|
section++)
|
|
{
|
|
INFCONTEXT sic;
|
|
NET_API_STATUS netStat;
|
|
|
|
CHAR Temp[SBUF_SIZE];
|
|
TCHAR ShareName[ SBUF_SIZE ];
|
|
|
|
if (!SetupFindFirstLine(cd->hinf, sname, KEYWORD_SHARENAME, &sic))
|
|
{
|
|
log( TEXT("POP3OC: %s INF error - unable to find %s\r\n"), keyword, KEYWORD_SHARENAME );
|
|
continue;
|
|
}
|
|
|
|
if (!SetupGetStringField(&sic, 1, ShareName, SBUF_SIZE, NULL))
|
|
{
|
|
log( TEXT("POP3OC: %s INF error - incorrect %s line\r\n"), keyword, KEYWORD_SHARENAME );
|
|
continue;
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
netStat = NetShareDel( NULL, ShareName, 0 );
|
|
#else // UNICODE
|
|
WCHAR ShareNameW[ SBUF_SIZE ];
|
|
mbstowcs( ShareNameW, ShareName, lstrlen(ShareName));
|
|
netStat = NetShareDel( NULL, ShareNameW, 0 );
|
|
#endif // UNICODE
|
|
if ( netStat != NERR_Success )
|
|
{
|
|
log( TEXT("POP3OC: Failed to remove %s share. Error 0x%08x\r\n"), ShareName, netStat );
|
|
continue;
|
|
}
|
|
|
|
log( TEXT("POP3OC: %s share removed successfully.\r\n"), ShareName );
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
DWORD
|
|
RunExternalProgram(
|
|
PPER_COMPONENT_DATA cd,
|
|
LPCTSTR component,
|
|
DWORD state)
|
|
{
|
|
INFCONTEXT ic;
|
|
TCHAR sname[S_SIZE];
|
|
DWORD section;
|
|
TCHAR *keyword;
|
|
|
|
keyword = KEYWORD_RUN;
|
|
|
|
for (section = 1;
|
|
EnumSections(cd->hinf, component, keyword, section, &ic, sname);
|
|
section++)
|
|
{
|
|
INFCONTEXT sic;
|
|
TCHAR CommandLine[ SBUF_SIZE ];
|
|
CHAR szTickCount[ SBUF_SIZE ];
|
|
ULONG TickCount;
|
|
BOOL b;
|
|
STARTUPINFO startupinfo;
|
|
PROCESS_INFORMATION process_information;
|
|
DWORD dwErr;
|
|
|
|
if (!SetupFindFirstLine(cd->hinf, sname, KEYWORD_COMMANDLINE , &sic))
|
|
{
|
|
log( TEXT("POP3OC: %s INF error - unable to find %s\r\n"), keyword, KEYWORD_COMMANDLINE );
|
|
continue;
|
|
}
|
|
|
|
if (!SetupGetStringField(&sic, 1, CommandLine, SBUF_SIZE, NULL))
|
|
{
|
|
log( TEXT("POP3OC: %s INF error - incorrect %s line\r\n"), keyword, KEYWORD_COMMANDLINE );
|
|
continue;
|
|
}
|
|
|
|
if (!SetupFindFirstLine(cd->hinf, sname, KEYWORD_TICKCOUNT, &sic))
|
|
{
|
|
log( TEXT("POP3OC: %s INF error - unable to find %s\r\n"), keyword, KEYWORD_TICKCOUNT );
|
|
continue;
|
|
}
|
|
|
|
if (!SetupGetStringFieldA(&sic, 1, szTickCount, SBUF_SIZE, NULL))
|
|
{
|
|
log( TEXT("POP3OC: %s INF error - incorrect %s line\r\n"), keyword, KEYWORD_TICKCOUNT );
|
|
continue;
|
|
}
|
|
|
|
TickCount = atoi( szTickCount );
|
|
|
|
ZeroMemory( &startupinfo, sizeof(startupinfo) );
|
|
startupinfo.cb = sizeof(startupinfo);
|
|
startupinfo.dwFlags = STARTF_USESHOWWINDOW;
|
|
startupinfo.wShowWindow = SW_HIDE | SW_SHOWMINNOACTIVE;
|
|
|
|
b = CreateProcess( NULL,
|
|
CommandLine,
|
|
NULL,
|
|
NULL,
|
|
FALSE,
|
|
CREATE_DEFAULT_ERROR_MODE,
|
|
NULL,
|
|
NULL,
|
|
&startupinfo,
|
|
&process_information );
|
|
if ( !b )
|
|
{
|
|
log( TEXT("POP3OC: failed to spawn %s process.\r\n"), CommandLine );
|
|
continue;
|
|
}
|
|
|
|
dwErr = WaitForSingleObject( process_information.hProcess, TickCount * 1000 );
|
|
if ( dwErr != NO_ERROR )
|
|
{
|
|
log( TEXT("POP3OC: WaitForSingleObject() failed. Error 0x%08x\r\n"), dwErr );
|
|
TerminateProcess( process_information.hProcess, -1 );
|
|
CloseHandle( process_information.hProcess );
|
|
CloseHandle( process_information.hThread );
|
|
continue;
|
|
}
|
|
|
|
CloseHandle( process_information.hProcess );
|
|
CloseHandle( process_information.hThread );
|
|
|
|
log( TEXT("POP3OC: %s successfully completed within %u seconds.\r\n"), CommandLine, TickCount );
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
HRESULT CreateLink( const TCHAR *sourcePath, const TCHAR *linkPath, const TCHAR *args, const TCHAR *sDesc )
|
|
{
|
|
CoInitialize( NULL );
|
|
IShellLink* pShellLink = NULL;
|
|
HRESULT hr = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
|
|
IID_IShellLink, reinterpret_cast<void**>(&pShellLink));
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = pShellLink->SetPath(sourcePath);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = pShellLink->SetArguments(args);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
hr = pShellLink->SetDescription(sDesc);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
IPersistFile* pPersistFile = NULL;
|
|
hr = pShellLink->QueryInterface(IID_IPersistFile, reinterpret_cast<void**>(&pPersistFile));
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
TCHAR* szTemp = new TCHAR[(sizeof(TCHAR) * _tcslen(linkPath)) + sizeof(TCHAR)];
|
|
if (!szTemp)
|
|
return E_OUTOFMEMORY;
|
|
|
|
_tcscpy( szTemp, linkPath );
|
|
hr = pPersistFile->Save(szTemp, TRUE);
|
|
if (FAILED(hr))
|
|
return hr;
|
|
|
|
|
|
pPersistFile->Release();
|
|
pShellLink->Release();
|
|
|
|
CoUninitialize();
|
|
delete [] szTemp;
|
|
return S_OK;
|
|
}
|
|
|
|
//Get a complete
|
|
int GetProcesses (DWORD ** lplp)
|
|
{
|
|
*lplp = NULL;
|
|
|
|
// according to docs (and other places), there's no scheme to tell,
|
|
// a priori, how many procs there are. So use loop below:
|
|
|
|
DWORD * lpids = NULL;
|
|
DWORD dwcb = sizeof(DWORD), dwcbNeeded;
|
|
do {
|
|
// alloc based on current dwcb.
|
|
lpids = (DWORD *)malloc (dwcb);
|
|
if (!lpids)
|
|
return 0;
|
|
|
|
dwcbNeeded = 0;
|
|
BOOL b = EnumProcesses (lpids, dwcb, &dwcbNeeded);
|
|
if ((b == FALSE) || (dwcbNeeded == 0)) {
|
|
// error!
|
|
free (lpids);
|
|
return 0;
|
|
}
|
|
if (dwcbNeeded == dwcb) {
|
|
free (lpids);
|
|
dwcb *= 2;
|
|
continue;
|
|
}
|
|
|
|
// if we got here, we have a complete list of procs
|
|
break;
|
|
} while (1);
|
|
|
|
*lplp = lpids;
|
|
return dwcbNeeded/sizeof(DWORD);
|
|
}
|
|
|
|
int GetModules (HANDLE hProcess, HMODULE ** lplp)
|
|
{
|
|
*lplp = NULL;
|
|
|
|
HMODULE * lpMods = NULL;
|
|
DWORD dwcb = sizeof(HMODULE), dwcbNeeded;
|
|
do {
|
|
// alloc based on current dwcb.
|
|
lpMods = (HMODULE *)malloc (dwcb);
|
|
if (!lpMods)
|
|
return 0;
|
|
|
|
dwcbNeeded = 0;
|
|
BOOL b = EnumProcessModules (hProcess, lpMods, dwcb, &dwcbNeeded);
|
|
if ((b == FALSE) || (dwcbNeeded == 0)) {
|
|
// error!
|
|
free (lpMods);
|
|
return 0;
|
|
}
|
|
// unlike calls to EnumProcesses, the last param of EnumProcessModules
|
|
// is actually useful: so, use it.
|
|
if (dwcbNeeded > dwcb) {
|
|
free (lpMods);
|
|
dwcb = dwcbNeeded;
|
|
continue;
|
|
}
|
|
|
|
// if we got here, we have a complete list of modules
|
|
break;
|
|
} while (1);
|
|
|
|
*lplp = lpMods;
|
|
return dwcbNeeded/sizeof(HMODULE);
|
|
}
|
|
DWORD KillPop3Snapins()
|
|
{
|
|
DWORD * lpProcs = NULL;
|
|
int iProcs = GetProcesses (&lpProcs);
|
|
if (!lpProcs)
|
|
return false;
|
|
|
|
bool b = false;
|
|
HANDLE hProcess;
|
|
HMODULE hModule;
|
|
DWORD cbReturned;
|
|
TCHAR szName[MAX_PATH];
|
|
HMODULE *lpMods;
|
|
int iMods;
|
|
|
|
// for each proc, get its name, and see if it's MMC
|
|
for (int i=0; i<iProcs; i++)
|
|
{
|
|
hProcess = OpenProcess (PROCESS_ALL_ACCESS, FALSE, lpProcs[i]);
|
|
if (hProcess != NULL)
|
|
{ // first module is the .exe....
|
|
hModule = NULL;
|
|
cbReturned = 0;
|
|
if ( EnumProcessModules (hProcess, &hModule, sizeof(hModule), &cbReturned ))
|
|
{ // get .exe name
|
|
szName[0] = 0;
|
|
GetModuleBaseName (hProcess, hModule, szName, MAX_PATH);
|
|
if ( 0 == _tcsicmp (szName, _T("mmc.exe")))
|
|
{ // get all modules (.dlls)
|
|
lpMods = NULL;
|
|
iMods = GetModules (hProcess, &lpMods);
|
|
if (lpMods != NULL)
|
|
{
|
|
for (int j=1; !b && j<iMods; j++)
|
|
{
|
|
GetModuleBaseName (hProcess, lpMods[j], szName, MAX_PATH);
|
|
if (!_tcsicmp( szName, _T("Pop3Snap.dll") ) )
|
|
{
|
|
b = true;
|
|
}
|
|
}
|
|
}
|
|
free (lpMods);
|
|
}
|
|
}
|
|
if(b)
|
|
{
|
|
//This is mmc.exe with pop3snap.dll
|
|
TerminateProcess(hProcess, 0 );
|
|
b=FALSE;
|
|
}
|
|
CloseHandle( hProcess);
|
|
}
|
|
}
|
|
free (lpProcs);
|
|
|
|
return b;
|
|
|
|
}
|
|
|