able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/fs/remotefs/dfs/setup/setupsvc.cxx

1204 lines
35 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+------------------------------------------------------------------
//
// File: SETUPSVC.CXX
//
// Contents:
//
// Synoposis:
//
// Classes: CService
//
// Functions:
//
// History: May 19, 1993 AlokS Created
//
//-------------------------------------------------------------------
#include <windows.h>
#include <ole2.h>
#include <windowsx.h>
#include <shlobj.h>
#include <registry.hxx>
#include <setupsvc.hxx>
#include "resource.h"
#include "messages.h"
#define ARRAYLEN(x) (sizeof(x) / sizeof((x)[0]))
extern HINSTANCE g_hInstance;
//+-------------------------------------------------------------------------
//
// Function: MyFormatMessageText
//
// Synopsis: Given a resource IDs, load strings from given instance
// and format the string into a buffer
//
// History: 11-Aug-93 WilliamW Created.
//
//--------------------------------------------------------------------------
VOID
MyFormatMessageText(
IN HRESULT dwMsgId,
IN PWSTR pszBuffer,
IN DWORD dwBufferSize,
IN va_list * parglist
)
{
//
// get message from system or app msg file.
//
DWORD dwReturn = FormatMessage(
FORMAT_MESSAGE_FROM_HMODULE,
g_hInstance,
dwMsgId,
LANG_USER_DEFAULT,
pszBuffer,
dwBufferSize,
parglist);
if (0 == dwReturn) // couldn't find message
{
WCHAR szText[200];
LoadString(g_hInstance, IDS_APP_MSG_NOT_FOUND, szText, ARRAYLEN(szText));
wsprintf(pszBuffer,szText,dwMsgId);
}
}
VOID
MyFormatMessage(
IN HRESULT dwMsgId,
IN PWSTR pszBuffer,
IN DWORD dwBufferSize,
...
)
{
va_list arglist;
va_start(arglist, dwBufferSize);
MyFormatMessageText(dwMsgId, pszBuffer, dwBufferSize, &arglist);
va_end(arglist);
}
//+------------------------------------------------------------------
//
// Class: CService
//
// Purpose: Helper class for dealing with Service Controller
//
// Interface: CService::CService() = Constructor
// CService::~CService() = Destructor
// CService::Init() = Initializes the class
// CService::_CreateService() = Install a Win32 Service
// CService::_OpenService() = Open an existing service
// CService::_QueryServiceStatus() = Query servcie status.
// CService::_CloseService() = Close all resources associated with
// the service
// CService::_DeleteService() = Remove a Win32 Service
// CService::_DisableService() = Disables a Win32 Service
// CService::_StartService() = Start an existing service
// CService::_StopService() = Stop an existing, running service
// CService::_ConfigService() = Combo operation. Create if
// not present else reconfigure it
//
// History: May 20, 1993 AlokS Created
//
// Notes: This is a smart wrapper class for Service APIs. But it is not
// multi-thread safe.
//
//-------------------------------------------------------------------
//+------------------------------------------------------------------
//
// Member: CService::CService
//
// Synopsis: Create an instance
//
// Effects: Instantiates the class
//
// Arguments: -none-
//
// Returns : None.
//
// History: May 20, 1993 AlokS Created
//
// Notes: The class allows only one handle to service per instance of this
// class. Plus, it is not written to close handles before opening
// new service. However, it does guarantee to close handles
// (SC database and one Service handle) at destruction time.
//
//-------------------------------------------------------------------
CService::CService():
_schSCManager(NULL),
_scHandle(NULL)
{
;
}
//+------------------------------------------------------------------
//
// Member: CService::Init
//
// Synopsis: Open handle to Service Controller
//
// Effects: -do-
//
// Arguments: -none-
//
// Returns : 0 on success else error from opening SC.
//
// History: Nov 4, 1993 AlokS Created
//
// Notes: The class allows only one handle to service per instance of this
// class. Plus, it is not written to close handles before opening
// new service. However, it does guarantee to close handles
// (SC database and one Service handle) at destruction time.
//
//-------------------------------------------------------------------
DWORD CService::Init()
{
DWORD dwStatus = 0;
// Open the local SC database
_schSCManager = OpenSCManager(NULL, // Machine Name
NULL, // Database Name
SC_MANAGER_CREATE_SERVICE|
SC_MANAGER_LOCK
);
if (_schSCManager == NULL)
{
dwStatus = GetLastError();
DSSCDebugOut(( DEB_IERROR, "Error: %lx in opening SCManager", dwStatus));
}
return(dwStatus);
}
//+------------------------------------------------------------------
//
// Member: CService::~CService
//
// Synopsis: Release all resources
//
// Effects: Closes SC database handle as well as any service handle
//
// Arguments: none
//
// History: May 20, 1993 AlokS Created
//
// Notes: Remember that we have only 1 service handle per instance.
//
//-------------------------------------------------------------------
CService::~CService()
{
if (_schSCManager != NULL)
CloseServiceHandle (_schSCManager);
if (_scHandle != NULL)
CloseServiceHandle (_scHandle);
}
//+------------------------------------------------------------------
//
// Member: CService::_CreateService
//
// Synopsis: This method is used to install a new Win32 Service or driver
//
// Effects: Creates a service.
//
// Arguments: all [in] parameters. See CreateService() API documentation
//
// Returns: 0 on success
//
// History: May 20, 1993 AlokS Created
//
// Notes: The handle of newly created service is remembered and closed by
// destructor
//
//-------------------------------------------------------------------
DWORD CService::_CreateService(const LPWSTR lpwszServiceName,
const LPWSTR lpwszDisplayName,
DWORD fdwDesiredAccess,
DWORD fdwServiceType,
DWORD fdwStartType,
DWORD fdwErrorControl,
const LPWSTR lpwszBinaryPathName,
const LPWSTR lpwszLoadOrderGroup,
const LPDWORD lpdwTagID,
const LPWSTR lpwszDependencies,
const LPWSTR lpwszServiceStartName,
const LPWSTR lpwszPassword)
{
if (_schSCManager==NULL)
{
return(ERROR_INVALID_HANDLE);
}
DWORD dwStatus =0;
_scHandle = CreateService(_schSCManager,
lpwszServiceName,
lpwszDisplayName,
fdwDesiredAccess,
fdwServiceType,
fdwStartType,
fdwErrorControl,
lpwszBinaryPathName,
lpwszLoadOrderGroup,
lpdwTagID,
lpwszDependencies,
lpwszServiceStartName,
lpwszPassword
);
if (_scHandle==NULL)
{
dwStatus = GetLastError();
DSSCDebugOut(( DEB_IERROR,
"Error: %lx in CreateService: %ws\n",
dwStatus,
lpwszServiceName));
}
return dwStatus;
}
//+------------------------------------------------------------------
//
// Member: CService::_OpenService
//
// Synopsis: Opens the service if caller has specified proper access
//
// Effects: Opens a service, if one exists
//
// Arguments: [in] lpwszServiceName = Name of the service
// [in] fdwDesiredAccess = Open Access mode bits
//
// Returns: 0 on success
//
// History: May 20, 1993 AlokS Created
//
// Notes: The handle of opened service is remembered and closed by
// destructor
//
//-------------------------------------------------------------------
DWORD CService::_OpenService( const LPWSTR lpwszServiceName,
DWORD fdwDesiredAccess
)
{
if (_schSCManager==NULL)
{
return(ERROR_INVALID_HANDLE);
}
DWORD dwStatus =0;
_scHandle = OpenService ( _schSCManager,
lpwszServiceName,
fdwDesiredAccess
);
if (_scHandle==NULL)
{
dwStatus = GetLastError();
DSSCDebugOut(( DEB_IERROR,
"Error: %lx in OpeningService: %ws\n",
dwStatus,
lpwszServiceName
));
}
return dwStatus;
}
//+------------------------------------------------------------------
//
// Member: CService::_StartService
//
// Synopsis: Start the named service
//
// Effects: Opens a service, if one exists
//
// Arguments: [in] lpwszServiceName = Name of the service to start
//
// Returns: 0 on success
//
// History: May 20, 1993 AlokS Created
//
// Notes: The handle of opened service is remembered and closed by
// destructor
//
//-------------------------------------------------------------------
DWORD CService::_StartService( const LPWSTR lpwszServiceName
)
{
if (_schSCManager==NULL)
{
return(ERROR_INVALID_HANDLE);
}
DWORD dwStatus =0;
if (_scHandle)
_CloseService();
_scHandle = OpenService ( _schSCManager,
lpwszServiceName,
SERVICE_START|SERVICE_QUERY_STATUS
);
if (_scHandle==NULL)
{
dwStatus = GetLastError();
DSSCDebugOut(( DEB_IERROR,
"Error: %lx in Opening Service: %ws\n",
dwStatus,
lpwszServiceName
));
}
else if (!StartService(_scHandle, NULL, NULL))
{
dwStatus = GetLastError();
DSSCDebugOut(( DEB_IERROR,
"Error: %lx in Starting Service: %ws\n",
dwStatus,
lpwszServiceName
));
}
return dwStatus;
}
//+------------------------------------------------------------------
//
// Member: CService::_StopService
//
// Synopsis: Stop the named service
//
// Effects: Opens a service, if one exists
//
// Arguments: [in] lpwszServiceName = Name of the service to stop
//
// Returns: 0 on success
//
// History: May 9, 1994 DaveStr Created
//
// Notes: The handle of opened service is remembered and closed by
// destructor
//
//-------------------------------------------------------------------
DWORD CService::_StopService( const LPWSTR lpwszServiceName
)
{
SERVICE_STATUS ss;
if (_schSCManager==NULL)
{
return(ERROR_INVALID_HANDLE);
}
DWORD dwStatus =0;
if (_scHandle)
_CloseService();
_scHandle = OpenService ( _schSCManager,
lpwszServiceName,
SERVICE_STOP|SERVICE_QUERY_STATUS
);
if (_scHandle==NULL)
{
dwStatus = GetLastError();
DSSCDebugOut(( DEB_IERROR,
"Error: %lx in Opening Service: %ws\n",
dwStatus,
lpwszServiceName
));
}
else if (!ControlService(_scHandle, SERVICE_CONTROL_STOP, &ss))
{
dwStatus = GetLastError();
DSSCDebugOut(( DEB_IERROR,
"Error: %lx in Controlling (stopping) Service: %ws\n",
dwStatus,
lpwszServiceName
));
}
return dwStatus;
}
//+------------------------------------------------------------------
//
// Member: CService::_DeleteService
//
// Synopsis: Remove the named service
//
// Effects: Deletes a service, if one exists
//
// Arguments: [in] lpwszServiceName = Name of the service to remove
//
// Returns: 0 on success
//
// History: May 20, 1993 AlokS Created
//
// Notes:
//
//
//-------------------------------------------------------------------
DWORD CService::_DeleteService( const LPWSTR lpwszServiceName )
{
DWORD dwStatus;
// Open the service
dwStatus = _OpenService(lpwszServiceName,
SERVICE_CHANGE_CONFIG|
DELETE
);
if (!dwStatus)
{
// We have a handle to the existing service. So, delete it.
if (!DeleteService ( _scHandle))
{
dwStatus = GetLastError();
DSSCDebugOut(( DEB_IERROR,
"Error: %lx in DeleteService: %ws\n",
dwStatus,
lpwszServiceName
));
_CloseService();
}
}
return dwStatus;
}
//+------------------------------------------------------------------
//
// Member: CService::_DisableService
//
// Synopsis: Disable the named service
//
// Effects: Disables a service, if one exists
//
// Arguments: [in] lpwszServiceName = Name of the service to disable
//
// Returns: 0 on success
//
// History: Dec 8, 1993 AlokS Created
//
// Notes:
//
//
//-------------------------------------------------------------------
DWORD CService::_DisableService( const LPWSTR lpwszServiceName )
{
DWORD dwStatus;
// Open the service
dwStatus = _OpenService(lpwszServiceName,
SERVICE_CHANGE_CONFIG
);
if (!dwStatus)
{
// We have a handle to the existing service. So, delete it.
if (!ChangeServiceConfig ( _scHandle, // Handle
SERVICE_NO_CHANGE, // Type
SERVICE_DISABLED, // Start
SERVICE_NO_CHANGE, // Error
NULL, // Path
NULL, // Load order
NULL, // Tag
NULL, // Depend
NULL, // Start name
NULL, // Password
NULL // Display Name
))
{
dwStatus = GetLastError();
DSSCDebugOut(( DEB_IERROR,
"Error: %lx in ChangeService: %ws\n",
dwStatus,
lpwszServiceName
));
_CloseService();
}
}
return dwStatus;
}
//+------------------------------------------------------------------
//
// Member: CService::_CloseService
//
// Synopsis: Close a service for which we have an open handle
//
// Effects: Close service handle, if opened previously
//
// Arguments: -none-
//
// Returns: 0 on success
//
// History: May 20, 1993 AlokS Created
//
// Notes:
//
//
//-------------------------------------------------------------------
void CService::_CloseService( )
{
if (_scHandle != NULL)
CloseServiceHandle ( _scHandle);
_scHandle = NULL;
}
//+------------------------------------------------------------------
//
// Member: CService::_QueryServiceStatus
//
// Synopsis: query current service status
//
// Effects: none
//
// Arguments: service_status - service status structure.
//
// Returns: 0 on success
//
// History: May 20, 1993 AlokS Created
//
// Notes:
//
//
//-------------------------------------------------------------------
DWORD CService::_QueryServiceStatus(LPSERVICE_STATUS ss)
{
if (_scHandle != NULL) {
if (!QueryServiceStatus(_scHandle, ss))
return(GetLastError());
return(0);
}
return(ERROR_INVALID_HANDLE);
}
//+------------------------------------------------------------------
//
// Member: CService::ConfigService
//
// Synopsis: Create else Open/Change the named Service
//
// Effects: It first tries to create a service. If one exists already,
// it changes the configuration to new configuration.
//
// Arguments: Lots of them. See documentation on CreateService() API.
//
// Returns: 0 on success
//
// History: May 20, 1993 AlokS Created
//
// Notes: Most people should use this method only for setting up services
//
// MAJOR NOTE: It is essential that all the keys being asked to change
// be actually present before they can be changed
//
//
//
//-------------------------------------------------------------------
WCHAR MsgBuf[0x1000];
DWORD CService::_ConfigService( DWORD fdwServiceType,
DWORD fdwStartType,
DWORD fdwErrorControl,
const LPWSTR lpwszBinaryPathName,
const LPWSTR lpwszLoadOrderGroup,
const LPWSTR lpwszDependencies,
const LPWSTR lpwszServiceStartName,
const LPWSTR lpwszPassword,
const LPWSTR lpwszDisplayName,
const LPWSTR lpwszServiceName
)
{
if (_schSCManager==NULL)
{
return(ERROR_INVALID_HANDLE);
}
DWORD dwStatus = ERROR_SERVICE_DATABASE_LOCKED;
SC_LOCK scLock;
//
// Let us lock the database. There could be a problem here
// because the service controller also locks the database when
// starting a service so it reads the startup parameters properly.
// If this is the case, and the database is locked, we just try
// up to 5 times to lock it ourselves before we fail.
//
for ( ULONG tries = 0;
(tries < 5) && (dwStatus == ERROR_SERVICE_DATABASE_LOCKED);
tries++ )
{
scLock = LockServiceDatabase (_schSCManager);
if ( scLock == NULL )
{
dwStatus = GetLastError();
DSSCDebugOut((DEB_ERROR, "LockServiceDatabase(try %d) == %#0x\n",
tries, dwStatus));
if ( dwStatus == ERROR_SERVICE_DATABASE_LOCKED )
{
Sleep ( 2 * 1000 );
}
}
else
{
dwStatus = 0;
}
}
if ( dwStatus != 0 )
{
return dwStatus;
}
// First, we try to create the service.
dwStatus = _CreateService(
lpwszServiceName,
lpwszDisplayName,
GENERIC_WRITE, // Access
fdwServiceType,
fdwStartType,
fdwErrorControl,
lpwszBinaryPathName,
lpwszLoadOrderGroup,
NULL, // Tag ID
lpwszDependencies,
lpwszServiceStartName,
lpwszPassword
);
// It is possible that service exists
if ((dwStatus == ERROR_SERVICE_EXISTS) ||
(dwStatus == ERROR_DUP_NAME))
{
// Open the service
dwStatus = _OpenService(lpwszServiceName,
SERVICE_CHANGE_CONFIG|DELETE);
if (!dwStatus) {
if (!ChangeServiceConfig(_scHandle,
fdwServiceType,
fdwStartType,
fdwErrorControl,
lpwszBinaryPathName,
lpwszLoadOrderGroup,
NULL,
lpwszDependencies,
lpwszServiceStartName,
lpwszPassword,
lpwszDisplayName
)) {
//
// Change didn't work, lets try to delete and recreate this
// service.
//
dwStatus = 0;
if (!DeleteService ( _scHandle)) {
// This is hopeless. Let us give up now
dwStatus = GetLastError();
DSSCDebugOut(( DEB_IERROR,
"Error: %lx in DeleteService: %ws\n",
dwStatus,
lpwszServiceName));
}
_CloseService();
if (!dwStatus) {
// last attempt to create
dwStatus = _CreateService(
lpwszServiceName,
lpwszDisplayName,
GENERIC_WRITE, // Access
fdwServiceType,
fdwStartType,
fdwErrorControl,
lpwszBinaryPathName,
lpwszLoadOrderGroup,
NULL, // Tag ID
lpwszDependencies,
lpwszServiceStartName,
lpwszPassword
);
DSSCDebugOut(( DEB_IERROR,
"This is hopeless. Recreating failed!!\n"));
}
}
} // OpenService
} // CreateService
//
// Set description
//
if (dwStatus == ERROR_SUCCESS) {
SERVICE_DESCRIPTION ServiceDescription;
// Open the service if the above did not
if (_scHandle == NULL) {
dwStatus = _OpenService(
lpwszServiceName,
SERVICE_CHANGE_CONFIG);
}
if (dwStatus == ERROR_SUCCESS) {
ULONG i;
MyFormatMessage(MSG_DFS_DESCRIPTION, MsgBuf, sizeof(MsgBuf));
for (i = 0; MsgBuf[i] != UNICODE_NULL && i < (sizeof(MsgBuf)/sizeof(WCHAR)); i++) {
if (MsgBuf[i] == L'\r')
MsgBuf[i] = UNICODE_NULL;
else if (MsgBuf[i] == L'\n')
MsgBuf[i] = UNICODE_NULL;
}
ServiceDescription.lpDescription = MsgBuf;
dwStatus = ChangeServiceConfig2(
_scHandle,
SERVICE_CONFIG_DESCRIPTION, // InfoLevel
&ServiceDescription);
dwStatus = (dwStatus != 0) ? ERROR_SUCCESS : GetLastError();
}
}
_CloseService();
UnlockServiceDatabase ( scLock);
return dwStatus;
}
//+------------------------------------------------------------------
//
// Function: _StartService
//
// Synopsis:
//
// Effects: Starts the Service and any other
// service dependent on it. It also ensures that the
// service has started befor returning.
//
// Arguments: [pwsz] -- name of the service to be started
//
// Returns: 0 on success
//
// History: Nov 12, 1993 AlokS Created
//
// Notes: This code was borrowed from the original StartDfs code
// written by Aloks and parameterized to allow other
// services to be started. An interesting question is
// whether this should be made a method of CDSSvc class.
// (TBD by AlokS)
//
//-------------------------------------------------------------------
DWORD _SynchStartService(WCHAR *pwszServiceName)
{
DWORD dwRc;
// Open Service Controller
CService cSvc;
if ((dwRc = cSvc.Init())== ERROR_SUCCESS)
{
// Start the Service
dwRc = cSvc._StartService(pwszServiceName);
if (dwRc == ERROR_SERVICE_ALREADY_RUNNING)
{
// We are done!
return ( ERROR_SUCCESS );
}
}
if (dwRc)
{
DSSCDebugOut((DEB_IERROR, "Error starting: %ws\n",pwszServiceName));
return(dwRc);
}
// Wait for the service to start running
SERVICE_STATUS scStatus;
DWORD MaxTries = 0;
do
{
if (!QueryServiceStatus(cSvc.QueryService(),
&scStatus
))
{
dwRc = GetLastError();
DSSCDebugOut((DEB_IERROR, "Error Querying service\n"));
break;
}
else if (scStatus.dwCurrentState != SERVICE_RUNNING)
{
Sleep(SERVICE_WAIT_TIME);
MaxTries++;
}
} while ( scStatus.dwCurrentState != SERVICE_RUNNING && MaxTries < MAX_SERVICE_WAIT_RETRIES);
if (MaxTries == MAX_SERVICE_WAIT_RETRIES)
{
dwRc = ERROR_SERVICE_REQUEST_TIMEOUT;
}
return(dwRc);
}
//+------------------------------------------------------------------
//
// Function: ConfigDfs
//
// Synopsis:
//
// Effects: Configures DFS File System Driver
//
// Arguments: -none-
//
// Returns: 0 on success
//
// History: May 20, 1993 AlokS Created
//
// Notes:
//
//-------------------------------------------------------------------
DWORD ConfigDfs()
{
DWORD dwErr = ERROR_SUCCESS;
// Open Service Controller
CService cSvc;
if (dwErr = cSvc.Init())
return dwErr;
// Create DFS (Driver)
dwErr = cSvc._ConfigService(
SERVICE_FILE_SYSTEM_DRIVER, // Service Type
SERVICE_BOOT_START, // Start Type
SERVICE_ERROR_NORMAL, // Error Control
// service file
L"\\SystemRoot\\system32\\drivers\\Dfs.sys",
L"filter", // Load order group
NULL, // Dependency
NULL, // Service start name
NULL, // password
L"DfsDriver", // display name
L"DfsDriver" // Service Name
);
if (dwErr)
return dwErr;
//
// Registry Changes
//
//
// Fix up the NetworkProvider order level - delete the Dfs provider
// if one has been inserted there
//
if (dwErr == ERROR_SUCCESS) {
CRegKey cregNP( HKEY_LOCAL_MACHINE,
L"System\\CurrentControlSet\\Control\\NetworkProvider\\Order",
KEY_READ | KEY_WRITE,
NULL,
REG_OPTION_NON_VOLATILE);
dwErr = cregNP.QueryErrorStatus();
if (dwErr == ERROR_SUCCESS) {
CRegSZ cregOrder( cregNP, L"ProviderOrder" );
dwErr = cregOrder.QueryErrorStatus();
if (dwErr == ERROR_SUCCESS) {
WCHAR wszProviders[128];
WCHAR *pwszProviders = wszProviders;
PWCHAR pwszDfs;
ULONG cbProviders = sizeof(wszProviders);
dwErr = cregOrder.GetString( pwszProviders, &cbProviders );
if (dwErr == ERROR_MORE_DATA) {
pwszProviders = new WCHAR[ cbProviders / sizeof(WCHAR) ];
if (pwszProviders == NULL) {
dwErr = ERROR_OUTOFMEMORY;
} else {
dwErr = cregOrder.GetString( pwszProviders, &cbProviders );
}
}
if (dwErr == ERROR_SUCCESS) {
//
// Delete Dfs only if its not already there.
//
pwszDfs = wcsstr(pwszProviders, L"Dfs,");
if (pwszDfs != NULL) {
*pwszDfs = UNICODE_NULL;
wcscat( pwszProviders, pwszDfs + 4);
dwErr = cregOrder.SetString( pwszProviders );
}
}
if (pwszProviders != wszProviders && pwszProviders != NULL) {
delete [] pwszProviders;
}
}
}
}
return dwErr;
}
//+------------------------------------------------------------------
//
// Function: StartDfs
//
// Synopsis:
//
// Effects: Starts out the DFS Service.
//
// Arguments: -none-
//
// Returns: 0 on success
//
// History: Nov 12, 1993 AlokS Created
//
// Notes:
//
//-------------------------------------------------------------------
DWORD StartDfs (
GUID *pguidDomain,
PWSTR pwszDomain
)
{
DWORD dwRc;
//
// We load the dfs driver and then call FindDomainController. This
// call to FindDomainController is expected to seed the Dfs driver
// with domain info.
//
dwRc = _SynchStartService(L"Dfs");
return(dwRc);
}
//+------------------------------------------------------------------
//
// Function: RemoveDfs
//
// Synopsis:
//
// Effects: Remove DFS driver
//
//-------------------------------------------------------------------
DWORD
RemoveDfs(void)
{
//DbgCommonApiTrace(RemoveDfs);
DWORD dwErr = ERROR_SUCCESS;
// Open Service Controller
CService cSvc;
if (!(dwErr = cSvc.Init()))
{
// Disable DFS driver
dwErr = cSvc._DisableService(L"Dfs");
}
if (dwErr)
{
return(dwErr);
}
/*
* Registry Changes
*/
// Now, we remove entries under DFS entry in registry
//
// Remove Dfs from the NetworkProvider list
//
if (dwErr == ERROR_SUCCESS) {
CRegKey cregNP( HKEY_LOCAL_MACHINE,
L"System\\CurrentControlSet\\Control\\NetworkProvider\\Order",
KEY_READ | KEY_WRITE,
NULL,
REG_OPTION_NON_VOLATILE);
dwErr = cregNP.QueryErrorStatus();
if (dwErr == ERROR_SUCCESS) {
CRegSZ cregOrder( cregNP, L"ProviderOrder" );
dwErr = cregOrder.QueryErrorStatus();
if (dwErr == ERROR_SUCCESS) {
WCHAR wszProviders[128];
WCHAR *pwszProviders = wszProviders;
WCHAR *pwszDfs, *pwszAfterDfs;
ULONG cbProviders = sizeof(wszProviders);
dwErr = cregOrder.GetString( pwszProviders, &cbProviders );
if (dwErr == ERROR_MORE_DATA) {
pwszProviders = new WCHAR[ cbProviders / sizeof(WCHAR) ];
if (pwszProviders == NULL) {
dwErr = ERROR_OUTOFMEMORY;
} else {
dwErr = cregOrder.GetString( pwszProviders, &cbProviders );
}
}
if (dwErr == ERROR_SUCCESS) {
//
// Delete Dfs only if its there.
//
pwszDfs = wcsstr(pwszProviders, L"Dfs,");
if (pwszDfs != NULL) {
pwszAfterDfs = pwszDfs + wcslen(L"Dfs,");
memmove(
(PVOID) pwszDfs,
(PVOID) pwszAfterDfs,
(wcslen( pwszAfterDfs ) + 1) * sizeof(WCHAR));
dwErr = cregOrder.SetString( pwszProviders );
}
}
if (pwszProviders != wszProviders && pwszProviders != NULL) {
delete [] pwszProviders;
}
}
}
}
return dwErr ;
}
//+------------------------------------------------------------------
//
// Function: ConfigDfsService
//
// Synopsis:
//
// Effects: Configures Dfs Service
//
//-------------------------------------------------------------------
DWORD
ConfigDfsService()
{
DWORD dwErr = 0;
ULONG i;
// Open Service Controller
CService cSvc;
if (dwErr = cSvc.Init())
return dwErr;
//
// Get localizable name of service
//
MyFormatMessage(MSG_DFS_COMPONENT_NAME, MsgBuf, sizeof(MsgBuf));
for (i = 0; MsgBuf[i] != UNICODE_NULL && i < (sizeof(MsgBuf)/sizeof(WCHAR)); i++) {
if (MsgBuf[i] == L'\r')
MsgBuf[i] = UNICODE_NULL;
else if (MsgBuf[i] == L'\n')
MsgBuf[i] = UNICODE_NULL;
}
// Create entry for Dfs Manager
dwErr = cSvc._ConfigService(
SERVICE_WIN32_OWN_PROCESS, // Service Type
SERVICE_AUTO_START, // Start Type
SERVICE_ERROR_NORMAL, // Error Control
L"%SystemRoot%\\system32\\Dfssvc.exe", // service binary
L"Dfs", // Load order group
L"LanmanWorkstation\0LanmanServer\0DfsDriver\0Mup\0", // Dependency
NULL, // Logon Name
NULL, // Logon Password
MsgBuf, // display name
L"Dfs" // Service Name
);
if (dwErr == ERROR_SUCCESS) {
CRegKey cregDfs( HKEY_LOCAL_MACHINE,
&dwErr,
L"System\\CurrentControlSet\\Services\\Dfs"
);
if (dwErr == ERROR_SUCCESS) {
CRegDWORD DfsVer ((const CRegKey &)cregDfs, L"DfsVersion",
DFS_VERSION_NUMBER);
dwErr = DfsVer.QueryErrorStatus();
}
}
return dwErr ;
}
//+------------------------------------------------------------------
//
// Function: RemoveDfsService
//
// Synopsis:
//
// Effects: Remove Dfs Service
//
// Arguments: -none-
//
// Returns: 0 on success
//
//
// History: May 20, 1993 AlokS Created
//
// Notes:
//
//
//-------------------------------------------------------------------
DWORD RemoveDfsService( )
{
DWORD dwErr = 0;
// Open Service Controller
CService cSvc;
if (!(dwErr = cSvc.Init()))
{
// Delete DFSManager Service
dwErr = cSvc._DeleteService(L"DfsService");
}
return dwErr ;
}
Reference in a new issue Copy permalink