precomp.h File Reference

#include <windef.h>
#include <winbase.h>
#include <winerror.h>
#include <wingdi.h>
#include <winsvc.h>
#include <wincon.h>
#include <shlobj.h>
#include <commdlg.h>
#include <strsafe.h>
#include <process.h>
#include "resource.h"

Include dependency graph for precomp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_MAIN_WND_INFO
struct	_MENU_HINT
struct	_SERVICEPROPSHEET
struct	_DEPENDDATA

Macros
#define	WIN32_NO_STATUS
#define	_INC_WINDOWS
#define	COM_NO_WINDOWS_H
#define	NO_ITEM_SELECTED   -1
#define	MAX_KEY_LENGTH   256
#define	LVNAME   0
#define	LVDESC   1
#define	LVSTATUS   2
#define	LVSTARTUP   3
#define	LVLOGONAS   4
#define	LVMAX   5
#define	IMAGE_UNKNOWN   0
#define	IMAGE_SERVICE   1
#define	IMAGE_DRIVER   2
#define	ACTION_START   1
#define	ACTION_STOP   2
#define	ACTION_PAUSE   3
#define	ACTION_RESUME   4
#define	ACTION_RESTART   5
#define	ORD_ASCENDING   1
#define	ORD_DESCENDING   -1
#define	DEFAULT_STEP   0

Typedefs
typedef struct _MAIN_WND_INFO	MAIN_WND_INFO
typedef struct _MAIN_WND_INFO *	PMAIN_WND_INFO
typedef struct _MENU_HINT	MENU_HINT
typedef struct _MENU_HINT *	PMENU_HINT
typedef struct _SERVICEPROPSHEET	SERVICEPROPSHEET
typedef struct _SERVICEPROPSHEET *	PSERVICEPROPSHEET
typedef struct _DEPENDDATA	DEPENDDATA
typedef struct _DEPENDDATA *	PDEPENDDATA

Functions
INT_PTR CALLBACK	AboutDialogProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK	CreateDialogProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK	DeleteDialogProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK	ProgressDialogProc (HWND hDlg, UINT Message, WPARAM wParam, LPARAM lParam)
VOID	SetMenuAndButtonStates (PMAIN_WND_INFO Info)
VOID	UpdateServiceCount (PMAIN_WND_INFO Info)
VOID	ChangeListViewText (PMAIN_WND_INFO Info, ENUM_SERVICE_STATUS_PROCESS *pService, UINT Column)
BOOL	InitMainWindowImpl (VOID)
VOID	UninitMainWindowImpl (VOID)
HWND	CreateMainWindow (LPCTSTR lpCaption, int nCmdShow)
VOID	SetListViewStyle (HWND hListView, DWORD View)
VOID	ListViewSelectionChanged (PMAIN_WND_INFO Info, LPNMLISTVIEW pnmv)
BOOL	CreateListView (PMAIN_WND_INFO Info)
DWORD	DoStartService (LPWSTR ServiceName, HANDLE hProgress, LPWSTR lpStartParams)
DWORD	DoStopService (LPWSTR ServiceName, HANDLE hProgress)
DWORD	DoControlService (LPWSTR ServiceName, HWND hProgress, DWORD Control)
BOOL	RunActionWithProgress (HWND hParent, LPWSTR ServiceName, LPWSTR DisplayName, UINT Action, PVOID Param)
VOID	IncrementProgressBar (HANDLE hProgress, UINT NewPos)
VOID	CompleteProgressBar (HANDLE hProgress)
ENUM_SERVICE_STATUS_PROCESS *	GetSelectedService (PMAIN_WND_INFO Info)
LPQUERY_SERVICE_CONFIG	GetServiceConfig (LPWSTR lpServiceName)
BOOL	SetServiceConfig (LPQUERY_SERVICE_CONFIG pServiceConfig, LPWSTR lpServiceName, LPWSTR lpPassword)
LPWSTR	GetServiceDescription (LPWSTR lpServiceName)
BOOL	SetServiceDescription (LPWSTR lpServiceName, LPWSTR lpDescription)
LPWSTR	GetExecutablePath (LPWSTR lpServiceName)
VOID	FreeServiceList (PMAIN_WND_INFO Info)
BOOL	RefreshServiceList (PMAIN_WND_INFO Info)
BOOL	UpdateServiceStatus (ENUM_SERVICE_STATUS_PROCESS *pService)
BOOL	GetServiceList (PMAIN_WND_INFO Info)
HTREEITEM	AddItemToTreeView (HWND hTreeView, HTREEITEM hRoot, LPWSTR lpDisplayName, LPWSTR lpServiceName, ULONG serviceType, BOOL bHasChildren)
INT_PTR CALLBACK	StopDependsDialogProc (HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
LPWSTR	GetListOfServicesToStop (LPWSTR lpServiceName)
BOOL	CreateStopDependsDialog (HWND hParent, LPWSTR ServiceName, LPWSTR DisplayName, LPWSTR ServiceList)
BOOL	TV1_Initialize (PDEPENDDATA pDependData, LPWSTR lpServiceName)
VOID	TV1_AddDependantsToTree (PDEPENDDATA pDependData, HTREEITEM hParent, LPWSTR lpServiceName)
BOOL	TV2_Initialize (PDEPENDDATA pDependData, LPWSTR lpServiceName)
VOID	TV2_AddDependantsToTree (PDEPENDDATA pDependData, HTREEITEM hParent, LPWSTR lpServiceName)
BOOL	TV2_HasDependantServices (LPWSTR lpServiceName)
LPENUM_SERVICE_STATUS	TV2_GetDependants (LPWSTR lpServiceName, LPDWORD lpdwCount)
VOID	OpenPropSheet (PMAIN_WND_INFO Info)
INT_PTR CALLBACK	DependenciesPageProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK	GeneralPageProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK	LogonPageProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
INT_PTR CALLBACK	RecoveryPageProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
VOID	ExportFile (PMAIN_WND_INFO Info)
INT	AllocAndLoadString (OUT LPWSTR *lpTarget, IN HINSTANCE hInst, IN UINT uID)
DWORD	LoadAndFormatString (IN HINSTANCE hInstance, IN UINT uID, OUT LPWSTR *lpTarget,...)
BOOL	StatusBarLoadAndFormatString (IN HWND hStatusBar, IN INT PartId, IN HINSTANCE hInstance, IN UINT uID,...)
BOOL	StatusBarLoadString (IN HWND hStatusBar, IN INT PartId, IN HINSTANCE hInstance, IN UINT uID)
INT	GetTextFromEdit (OUT LPWSTR lpString, IN HWND hDlg, IN UINT Res)
VOID	GetError (VOID)
VOID	DisplayString (PWCHAR)
HIMAGELIST	InitImageList (UINT StartResource, UINT EndResource, UINT Width, UINT Height, ULONG type)
VOID	ResourceMessageBox (HINSTANCE hInstance, HWND hwnd, UINT uType, UINT uCaptionId, UINT uMessageId)

Variables
HINSTANCE	hInstance
HANDLE	ProcessHeap

Macro Definition Documentation

_INC_WINDOWS

#define _INC_WINDOWS

Definition at line 5 of file precomp.h.

ACTION_PAUSE

#define ACTION_PAUSE   3

Definition at line 42 of file precomp.h.

ACTION_RESTART

#define ACTION_RESTART   5

Definition at line 44 of file precomp.h.

ACTION_RESUME

#define ACTION_RESUME   4

Definition at line 43 of file precomp.h.

ACTION_START

#define ACTION_START   1

Definition at line 40 of file precomp.h.

ACTION_STOP

#define ACTION_STOP   2

Definition at line 41 of file precomp.h.

COM_NO_WINDOWS_H

#define COM_NO_WINDOWS_H

Definition at line 6 of file precomp.h.

DEFAULT_STEP

#define DEFAULT_STEP   0

Definition at line 111 of file precomp.h.

IMAGE_DRIVER

#define IMAGE_DRIVER   2

Definition at line 38 of file precomp.h.

IMAGE_SERVICE

#define IMAGE_SERVICE   1

Definition at line 37 of file precomp.h.

IMAGE_UNKNOWN

#define IMAGE_UNKNOWN   0

Definition at line 36 of file precomp.h.

LVDESC

#define LVDESC   1

Definition at line 30 of file precomp.h.

LVLOGONAS

#define LVLOGONAS   4

Definition at line 33 of file precomp.h.

LVMAX

#define LVMAX   5

Definition at line 34 of file precomp.h.

LVNAME

#define LVNAME   0

Definition at line 29 of file precomp.h.

LVSTARTUP

#define LVSTARTUP   3

Definition at line 32 of file precomp.h.

LVSTATUS

#define LVSTATUS   2

Definition at line 31 of file precomp.h.

MAX_KEY_LENGTH

#define MAX_KEY_LENGTH   256

Definition at line 27 of file precomp.h.

NO_ITEM_SELECTED

#define NO_ITEM_SELECTED   -1

Definition at line 26 of file precomp.h.

ORD_ASCENDING

#define ORD_ASCENDING   1

Definition at line 46 of file precomp.h.

ORD_DESCENDING

#define ORD_DESCENDING   -1

Definition at line 47 of file precomp.h.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 4 of file precomp.h.

Typedef Documentation

DEPENDDATA

typedef struct _DEPENDDATA DEPENDDATA

MAIN_WND_INFO

typedef struct _MAIN_WND_INFO MAIN_WND_INFO

MENU_HINT

typedef struct _MENU_HINT MENU_HINT

PDEPENDDATA

typedef struct _DEPENDDATA * PDEPENDDATA

PMAIN_WND_INFO

typedef struct _MAIN_WND_INFO * PMAIN_WND_INFO

PMENU_HINT

typedef struct _MENU_HINT * PMENU_HINT

PSERVICEPROPSHEET

typedef struct _SERVICEPROPSHEET * PSERVICEPROPSHEET

SERVICEPROPSHEET

typedef struct _SERVICEPROPSHEET SERVICEPROPSHEET

Function Documentation

AboutDialogProc()

INT_PTR CALLBACK AboutDialogProc	(	HWND	hDlg,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 4 of file about.c.

{
    HWND  hLicenseEditWnd;
    HICON hIcon = NULL;
    TCHAR strLicense[700];
 
    switch (message)
    {
    case WM_INITDIALOG:
 
        hIcon = LoadImage(hInstance,
                          MAKEINTRESOURCE(IDI_ICON),
                          IMAGE_ICON,
                          16,
                          16,
                          0);
 
        SendMessage(hDlg,
                    WM_SETICON,
                    ICON_SMALL,
                    (LPARAM)hIcon);
 
        hLicenseEditWnd = GetDlgItem(hDlg,
                                     IDC_LICENSE_EDIT);
 
        LoadString(hInstance,
                   IDS_LICENSE,
                   strLicense,
                   sizeof(strLicense) / sizeof(TCHAR));
 
        SetWindowText(hLicenseEditWnd,
                      strLicense);
        return TRUE;
 
    case WM_COMMAND:
        if ((LOWORD(wParam) == IDOK) || (LOWORD(wParam) == IDCANCEL))
        {
            DestroyIcon(hIcon);
            EndDialog(hDlg,
                      LOWORD(wParam));
            return TRUE;
        }
 
        break;
    }
 
    return FALSE;
}

AddItemToTreeView()

HTREEITEM AddItemToTreeView	(	HWND	hTreeView,
		HTREEITEM	hRoot,
		LPWSTR	lpDisplayName,
		LPWSTR	lpServiceName,
		ULONG	serviceType,
		BOOL	bHasChildren
	)

Definition at line 13 of file propsheet_depends.c.

{
    TV_ITEM tvi;
    TV_INSERTSTRUCT tvins;
    LPWSTR lpName;
    DWORD dwSize;
 
    ZeroMemory(&tvi, sizeof(tvi));
    ZeroMemory(&tvins, sizeof(tvins));
 
    tvi.mask = TVIF_TEXT | TVIF_PARAM | TVIF_SELECTEDIMAGE | TVIF_IMAGE | TVIF_CHILDREN;
    tvi.pszText = lpDisplayName;
    tvi.cchTextMax = wcslen(lpDisplayName);
    tvi.cChildren = bHasChildren;
 
    /* Select the image for this service */
    switch (ServiceType)
    {
        case SERVICE_WIN32_OWN_PROCESS:
        case SERVICE_WIN32_SHARE_PROCESS:
            tvi.iImage = IMAGE_SERVICE;
            tvi.iSelectedImage = IMAGE_SERVICE;
            break;
 
        case SERVICE_KERNEL_DRIVER:
        case SERVICE_FILE_SYSTEM_DRIVER:
            tvi.iImage = IMAGE_DRIVER;
            tvi.iSelectedImage = IMAGE_DRIVER;
            break;
 
        default:
            tvi.iImage = IMAGE_UNKNOWN;
            tvi.iSelectedImage = IMAGE_UNKNOWN;
            break;
    }
 
    if (lpServiceName)
    {
        dwSize = wcslen(lpServiceName) + 1;
        /* Attach the service name */
        lpName = (LPWSTR)HeapAlloc(GetProcessHeap(),
                                   0,
                                   dwSize * sizeof(WCHAR));
        if (lpName)
        {
            StringCchCopyW(lpName, dwSize, lpServiceName);
            tvi.lParam = (LPARAM)lpName;
        }
    }
 
    tvins.item = tvi;
    tvins.hParent = hParent;
 
    return TreeView_InsertItem(hTreeView, &tvins);
}

Referenced by TV1_AddDependantsToTree(), and TV2_AddDependantsToTree().

AllocAndLoadString()

INT AllocAndLoadString	(	OUT LPWSTR *	lpTarget,
		IN HINSTANCE	hInst,
		IN UINT	uID
	)

Definition at line 50 of file misc.c.

{
    INT ln;
 
    ln = LengthOfStrResource(hInst,
                             uID);
    if (ln++ > 0)
    {
        (*lpTarget) = (LPWSTR)LocalAlloc(LMEM_FIXED,
                                         ln * sizeof(WCHAR));
        if ((*lpTarget) != NULL)
        {
            INT Ret;
            if (!(Ret = LoadStringW(hInst, uID, *lpTarget, ln)))
            {
                LocalFree((HLOCAL)(*lpTarget));
            }
            return Ret;
        }
    }
    return 0;
}

ChangeListViewText()

VOID ChangeListViewText	(	PMAIN_WND_INFO	Info,
		ENUM_SERVICE_STATUS_PROCESS *	pService,
		UINT	Column
	)

Definition at line 105 of file listview.c.

{
    LVFINDINFO lvfi;
    LVITEM lvItem;
    INT index;
 
    lvfi.flags = LVFI_PARAM;
    lvfi.lParam = (LPARAM)pService;
    index = ListView_FindItem(Info->hListView,
                              -1,
                              &lvfi);
    if (index != -1)
    {
        lvItem.iItem = index;
        lvItem.iSubItem = Column;
 
        switch (Column)
        {
            case LVNAME:
            {
                LPQUERY_SERVICE_CONFIG lpServiceConfig;
 
                lpServiceConfig = GetServiceConfig(pService->lpServiceName);
                if (lpServiceConfig)
                {
                    lvItem.pszText = lpServiceConfig->lpDisplayName;
                    SendMessage(Info->hListView,
                                LVM_SETITEMTEXT,
                                lvItem.iItem,
                                (LPARAM)&lvItem);
 
                    HeapFree(ProcessHeap,
                             0,
                             lpServiceConfig);
                }
            }
            break;
 
            case LVDESC:
            {
                LPWSTR lpDescription;
 
                lpDescription = GetServiceDescription(pService->lpServiceName);
 
                lvItem.pszText = lpDescription;
                SendMessage(Info->hListView,
                            LVM_SETITEMTEXTW,
                            lvItem.iItem,
                            (LPARAM) &lvItem);
 
                HeapFree(ProcessHeap,
                         0,
                         lpDescription);
            }
            break;
 
            case LVSTATUS:
            {
                WCHAR szStatus[64];
 
                if (pService->ServiceStatusProcess.dwCurrentState == SERVICE_RUNNING)
                {
                    LoadStringW(hInstance,
                                IDS_SERVICES_STARTED,
                                szStatus,
                                sizeof(szStatus) / sizeof(WCHAR));
                }
                else
                {
                    szStatus[0] = 0;
                }
 
                lvItem.pszText = szStatus;
                SendMessageW(Info->hListView,
                             LVM_SETITEMTEXT,
                             lvItem.iItem,
                             (LPARAM) &lvItem);
            }
            break;
 
            case LVSTARTUP:
            {
                LPQUERY_SERVICE_CONFIGW lpServiceConfig;
                LPWSTR lpStartup = NULL;
                DWORD StringId = 0;
 
                lpServiceConfig = GetServiceConfig(pService->lpServiceName);
 
                if (lpServiceConfig)
                {
                    switch (lpServiceConfig->dwStartType)
                    {
                        case 2: StringId = IDS_SERVICES_AUTO; break;
                        case 3: StringId = IDS_SERVICES_MAN; break;
                        case 4: StringId = IDS_SERVICES_DIS; break;
                    }
                }
 
                if (StringId)
                    AllocAndLoadString(&lpStartup,
                                       hInstance,
                                       StringId);
 
                lvItem.pszText = lpStartup;
                SendMessageW(Info->hListView,
                             LVM_SETITEMTEXTW,
                             lvItem.iItem,
                             (LPARAM)&lvItem);
 
                LocalFree(lpStartup);
                HeapFree(ProcessHeap,
                         0,
                         lpServiceConfig);
            }
            break;
 
            case LVLOGONAS:
            {
                LPQUERY_SERVICE_CONFIG lpServiceConfig;
 
                lpServiceConfig = GetServiceConfig(pService->lpServiceName);
                if (lpServiceConfig)
                {
                    lvItem.pszText = lpServiceConfig->lpServiceStartName;
                    SendMessageW(Info->hListView,
                                 LVM_SETITEMTEXT,
                                 lvItem.iItem,
                                 (LPARAM)&lvItem);
 
                    HeapFree(ProcessHeap,
                             0,
                             lpServiceConfig);
                }
            }
            break;
        }
    }
}

Referenced by GeneralPageProc(), MainWndCommand(), RefreshServiceList(), and SaveDlgInfo().

CompleteProgressBar()

VOID CompleteProgressBar

(

HANDLE

hProgress

)

Definition at line 311 of file progress.c.

{
    HWND hProgBar = (HWND)hProgress;
    UINT Pos = 0;
 
    /* Get the current position */
    Pos = SendMessageW(hProgBar,
                       PBM_GETPOS,
                       0,
                       0);
 
    /* Loop until we hit the max */
    while (Pos <= PROGRESS_RANGE)
    {
        /* Increment the progress bar */
        SendMessageW(hProgBar,
                     PBM_DELTAPOS,
                     Pos,
                     0);
 
        /* Wait for 15ms to give it a smooth feel */
        Sleep(15);
        Pos++;
    }
}

Referenced by ActionThread().

CreateDialogProc()

INT_PTR CALLBACK CreateDialogProc	(	HWND	hDlg,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 218 of file create.c.

{
    HICON hIcon = NULL;
 
    switch (message)
    {
        case WM_INITDIALOG:
        {
            hIcon = (HICON)LoadImage(hInstance,
                                     MAKEINTRESOURCE(IDI_SM_ICON),
                                     IMAGE_ICON,
                                     16,
                                     16,
                                     0);
            if (hIcon)
            {
                SendMessage(hDlg,
                            WM_SETICON,
                            ICON_SMALL,
                            (LPARAM)hIcon);
                DestroyIcon(hIcon);
            }
 
            return TRUE;
        }
 
        case WM_COMMAND:
        {
            switch (LOWORD(wParam))
            {
                case IDOK:
                {
                    PCREATE_DATA Data;
 
                    Data = (PCREATE_DATA)HeapAlloc(ProcessHeap,
                                                   HEAP_ZERO_MEMORY,
                                                   sizeof(CREATE_DATA));
                    if (Data)
                    {
                        Data->hSelf = hDlg;
 
                        if (GetDataFromDialog(Data))
                        {
                            DoCreate(Data);
                        }
                        else
                        {
                            /* Something went wrong, leave the dialog
                             * open so they can try again */
                            FreeMemory(Data);
                            break;
                        }
 
                        FreeMemory(Data);
                    }
 
                    EndDialog(hDlg,
                              LOWORD(wParam));
                    return TRUE;
                }
 
                case IDCANCEL:
                {
                    EndDialog(hDlg,
                              LOWORD(wParam));
                    return TRUE;
                }
 
                case ID_CREATE_HELP:
                {
                    HWND hHelp;
 
                    if (! bHelpOpen)
                    {
                        hHelp = CreateDialog(hInstance,
                                             MAKEINTRESOURCE(IDD_DLG_HELP_OPTIONS),
                                             hDlg,
                                             CreateHelpDialogProc);
                        if(hHelp != NULL)
                        {
                            bHelpOpen = TRUE;
                        }
                    }
                }
                break;
            }
        }
    }
 
    return FALSE;
}

Referenced by MainWndCommand().

CreateListView()

BOOL CreateListView

(

PMAIN_WND_INFO

Info

)

Definition at line 355 of file listview.c.

{
    LVCOLUMNW lvc = { 0 };
    WCHAR szTemp[256];
    HDITEM hdi;
    int i, n;
 
    Info->hListView = CreateWindowExW(WS_EX_CLIENTEDGE,
                                      WC_LISTVIEWW,
                                      NULL,
                                      WS_CHILD | WS_VISIBLE | LVS_REPORT | WS_BORDER |
                                         LBS_NOTIFY | LVS_SORTASCENDING | LBS_NOREDRAW,
                                      0, 0, 0, 0,
                                      Info->hMainWnd,
                                      (HMENU) IDC_SERVLIST,
                                      hInstance,
                                      NULL);
    if (Info->hListView == NULL)
    {
        MessageBoxW(Info->hMainWnd,
                    L"Could not create List View.",
                    L"Error",
                    MB_OK | MB_ICONERROR);
        return FALSE;
    }
 
    Info->hHeader = ListView_GetHeader(Info->hListView);
 
    (void)ListView_SetExtendedListViewStyle(Info->hListView,
                                            LVS_EX_FULLROWSELECT | LVS_EX_HEADERDRAGDROP);/*LVS_EX_GRIDLINES |*/
 
    lvc.mask = LVCF_TEXT | LVCF_SUBITEM | LVCF_WIDTH  | LVCF_FMT;
    lvc.fmt  = LVCFMT_LEFT;
    lvc.pszText = szTemp;
 
    /* Add columns to the list-view */
    for (n = 0; n < sizeof(Columns) / sizeof(Columns[0]); n++)
    {
        lvc.iSubItem = Columns[n].iSubItem;
        lvc.cx = Columns[n].cx;
 
        LoadStringW(hInstance,
                    Columns[n].idsText,
                    szTemp,
                    sizeof(szTemp) / sizeof(szTemp[0]));
 
        i = ListView_InsertColumn(Info->hListView, Columns[n].iSubItem, &lvc);
 
        hdi.mask = HDI_LPARAM;
        hdi.lParam = ORD_ASCENDING;
        (void)Header_SetItem(Info->hHeader, i, &hdi);
    }
 
    InitListViewImage(Info);
 
    /* check the details view menu item */
    CheckMenuRadioItem(GetMenu(Info->hMainWnd),
                       ID_VIEW_LARGE,
                       ID_VIEW_DETAILS,
                       ID_VIEW_DETAILS,
                       MF_BYCOMMAND);
 
    return TRUE;
}

Referenced by ChildWndProc(), and InitMainWnd().

CreateMainWindow()

HWND CreateMainWindow	(	LPCTSTR	lpCaption,
		int	nCmdShow
	)

Definition at line 923 of file mainwnd.c.

{
    PMAIN_WND_INFO Info;
    HWND hMainWnd = NULL;
 
    Info = (MAIN_WND_INFO*) HeapAlloc(ProcessHeap,
                     HEAP_ZERO_MEMORY,
                     sizeof(MAIN_WND_INFO));
 
    if (Info != NULL)
    {
        Info->nCmdShow = nCmdShow;
 
        hMainWnd = CreateWindowEx(WS_EX_WINDOWEDGE,
                                  szMainWndClass,
                                  lpCaption,
                                  WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
                                  CW_USEDEFAULT,
                                  CW_USEDEFAULT,
                                  680,
                                  450,
                                  NULL,
                                  NULL,
                                  hInstance,
                                  Info);
        if (hMainWnd == NULL)
        {
            //int ret;
            //ret = GetLastError();
            GetError();
            HeapFree(ProcessHeap,
                     0,
                     Info);
        }
    }
 
    return hMainWnd;
}

CreateStopDependsDialog()

BOOL CreateStopDependsDialog	(	HWND	hParent,
		LPWSTR	ServiceName,
		LPWSTR	DisplayName,
		LPWSTR	ServiceList
	)

Definition at line 293 of file stop_dependencies.c.

{
    STOP_DATA StopData;
    INT_PTR Result;
 
    StopData.ServiceName = ServiceName;
    StopData.DisplayName = DisplayName;
    StopData.ServiceList = ServiceList;
 
    Result = DialogBoxParamW(hInstance,
                             MAKEINTRESOURCEW(IDD_DLG_DEPEND_STOP),
                             hParent,
                             StopDependsDialogProc,
                             (LPARAM)&StopData);
    if (Result == IDOK)
        return TRUE;
 
    return FALSE;
}

Referenced by RunActionWithProgress().

DeleteDialogProc()

INT_PTR CALLBACK DeleteDialogProc	(	HWND	hDlg,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 57 of file delete.c.

{
    PMAIN_WND_INFO Info = NULL;
    HICON hIcon = NULL;
 
    /* Get the window context */
    Info = (PMAIN_WND_INFO)GetWindowLongPtr(hDlg,
                                            GWLP_USERDATA);
    if (Info == NULL && message != WM_INITDIALOG)
    {
        return FALSE;
    }
 
    switch (message)
    {
        case WM_INITDIALOG:
        {
            LPWSTR lpDescription;
 
            Info = (PMAIN_WND_INFO)lParam;
            if (Info != NULL)
            {
                SetWindowLongPtrW(hDlg,
                                  GWLP_USERDATA,
                                  (LONG_PTR)Info);
 
                hIcon = (HICON)LoadImageW(hInstance,
                                          MAKEINTRESOURCE(IDI_SM_ICON),
                                          IMAGE_ICON,
                                          16,
                                          16,
                                          0);
                if (hIcon)
                {
                    SendMessageW(hDlg,
                                 WM_SETICON,
                                 ICON_SMALL,
                                 (LPARAM)hIcon);
                    DestroyIcon(hIcon);
                }
 
                SendDlgItemMessageW(hDlg,
                                    IDC_DEL_NAME,
                                    WM_SETTEXT,
                                    0,
                                    (LPARAM)Info->pCurrentService->lpDisplayName);
 
                lpDescription = GetServiceDescription(Info->pCurrentService->lpServiceName);
                if (lpDescription)
                {
                    SendDlgItemMessageW(hDlg,
                                        IDC_DEL_DESC,
                                        WM_SETTEXT,
                                        0,
                                        (LPARAM)lpDescription);
                    HeapFree(ProcessHeap,
                             0,
                             lpDescription);
                }
 
                return TRUE;
            }
 
            return FALSE;
        }
 
        case WM_COMMAND:
        {
            switch (LOWORD(wParam))
            {
                case IDOK:
                {
                    if (DoDeleteService(Info, hDlg))
                    {
                        (void)ListView_DeleteItem(Info->hListView,
                                                  Info->SelectedItem);
                        UpdateServiceCount(Info);
                    }
                    EndDialog(hDlg,
                              LOWORD(wParam));
                    return TRUE;
                }
 
                case IDCANCEL:
                {
                    EndDialog(hDlg,
                              LOWORD(wParam));
                    return TRUE;
                }
            }
        }
    }
 
    return FALSE;
}

Referenced by MainWndCommand().

DependenciesPageProc()

INT_PTR CALLBACK DependenciesPageProc	(	HWND	hwndDlg,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 183 of file propsheet_depends.c.

{
    PDEPENDDATA pDependData;
 
    /* Get the window context */
    pDependData = (PDEPENDDATA)GetWindowLongPtr(hwndDlg,
                                                GWLP_USERDATA);
    if (pDependData == NULL && uMsg != WM_INITDIALOG)
    {
        return FALSE;
    }
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
        {
            pDependData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DEPENDDATA));
            if (pDependData != NULL)
            {
                SetWindowLongPtr(hwndDlg,
                                 GWLP_USERDATA,
                                 (LONG_PTR)pDependData);
 
                pDependData->pDlgInfo = (PSERVICEPROPSHEET)(((LPPROPSHEETPAGE)lParam)->lParam);
                pDependData->hDependsWnd = hwndDlg;
 
                InitDependPage(pDependData);
            }
        }
        break;
 
        case WM_NOTIFY:
        {
            switch (((LPNMHDR)lParam)->code)
            {
                case TVN_ITEMEXPANDING:
                {
                    LPNMTREEVIEW lpnmtv = (LPNMTREEVIEW)lParam;
 
                    if (lpnmtv->action == TVE_EXPAND)
                    {
                        if (lpnmtv->hdr.idFrom == IDC_DEPEND_TREE1)
                        {
                            /* Has this node been expanded before */
                            if (!TreeView_GetChild(pDependData->hDependsTreeView1, lpnmtv->itemNew.hItem))
                            {
                                /* It's not, add the children */
                                TV1_AddDependantsToTree(pDependData, lpnmtv->itemNew.hItem, (LPWSTR)lpnmtv->itemNew.lParam);
                            }
                        }
                        else if (lpnmtv->hdr.idFrom == IDC_DEPEND_TREE2)
                        {
                            /* Has this node been expanded before */
                            if (!TreeView_GetChild(pDependData->hDependsTreeView2, lpnmtv->itemNew.hItem))
                            {
                                /* It's not, add the children */
                                TV2_AddDependantsToTree(pDependData, lpnmtv->itemNew.hItem, (LPWSTR)lpnmtv->itemNew.lParam);
                            }
                        }
                    }
                    break;
                }
            }
            break;
        }
 
        case WM_COMMAND:
            switch(LOWORD(wParam))
            {
 
            }
            break;
 
        case WM_DESTROY:
            DestroyTreeView(pDependData->hDependsTreeView1);
            DestroyTreeView(pDependData->hDependsTreeView2);
 
            if (pDependData->hDependsImageList)
                ImageList_Destroy(pDependData->hDependsImageList);
 
            HeapFree(GetProcessHeap(), 0, pDependData);
    }
 
    return FALSE;
}

Referenced by PropSheetThread().

DisplayString()

VOID DisplayString

(

PWCHAR

)

DoControlService()

DWORD DoControlService	(	LPWSTR	ServiceName,
		HWND	hProgress,
		DWORD	Control
	)

Definition at line 18 of file control.c.

{
    SC_HANDLE hSCManager;
    SC_HANDLE hService;
    SERVICE_STATUS_PROCESS ServiceStatus = {0};
    SERVICE_STATUS Status;
    DWORD BytesNeeded = 0;
    DWORD StartTickCount;
    DWORD OldCheckPoint;
    DWORD WaitTime;
    DWORD MaxWait;
    DWORD ReqState, i;
    BOOL Result;
    DWORD dwResult = ERROR_SUCCESS;
 
    /* Set the state we're interested in */
    switch (Control)
    {
        case SERVICE_CONTROL_PAUSE:
            ReqState = SERVICE_PAUSED;
            break;
        case SERVICE_CONTROL_CONTINUE:
            ReqState = SERVICE_RUNNING;
            break;
        default:
            /* Unhandled control code */
            DPRINT1("Unknown control command: 0x%X\n", Control);
            return ERROR_INVALID_SERVICE_CONTROL;
    }
 
    hSCManager = OpenSCManagerW(NULL,
                                NULL,
                                SC_MANAGER_CONNECT);
    if (!hSCManager) return GetLastError();
 
    hService = OpenServiceW(hSCManager,
                            ServiceName,
                            SERVICE_PAUSE_CONTINUE | SERVICE_INTERROGATE | SERVICE_QUERY_STATUS);
    if (!hService)
    {
        dwResult = GetLastError();
        CloseServiceHandle(hSCManager);
        return dwResult;
    }
 
        /* Send the control message to the service */
    Result = ControlService(hService,
                            Control,
                            &Status);
    if (Result)
    {
        if (hProgress)
        {
            /* Increment the progress bar */
            IncrementProgressBar(hProgress, DEFAULT_STEP);
        }
 
        /* Get the service status */
        Result = QueryServiceStatusEx(hService,
                                      SC_STATUS_PROCESS_INFO,
                                      (LPBYTE)&ServiceStatus,
                                      sizeof(SERVICE_STATUS_PROCESS),
                                      &BytesNeeded);
        if (Result)
        {
            Result = FALSE;
            MaxWait = MAX_WAIT_TIME;
            OldCheckPoint = ServiceStatus.dwCheckPoint;
            StartTickCount = GetTickCount();
 
            /* Loop until it's at the correct state */
            while (ServiceStatus.dwCurrentState != ReqState)
            {
                /* Fixup the wait time */
                WaitTime = ServiceStatus.dwWaitHint / 10;
 
                if (WaitTime < 1000) WaitTime = 1000;
                else if (WaitTime > 10000) WaitTime = 10000;
 
                /* We don't wanna wait for up to 10 secs without incrementing */
                for (i = WaitTime / 1000; i > 0; i--)
                {
                    Sleep(1000);
                    if (hProgress)
                    {
                        /* Increment the progress bar */
                        IncrementProgressBar(hProgress, DEFAULT_STEP);
                    }
                }
 
                /* Get the latest status info */
                if (!QueryServiceStatusEx(hService,
                                            SC_STATUS_PROCESS_INFO,
                                            (LPBYTE)&ServiceStatus,
                                            sizeof(SERVICE_STATUS_PROCESS),
                                            &BytesNeeded))
                {
                    /* Something went wrong... */
                    dwResult = GetLastError();
                    DPRINT1("QueryServiceStatusEx failed: %d\n", dwResult);
                    break;
                }
 
                /* Is the service making progress? */
                if (ServiceStatus.dwCheckPoint > OldCheckPoint)
                {
                    /* It is, get the latest tickcount to reset the max wait time */
                    StartTickCount = GetTickCount();
                    OldCheckPoint = ServiceStatus.dwCheckPoint;
                    IncrementProgressBar(hProgress, DEFAULT_STEP);
                }
                else
                {
                    /* It's not, make sure we haven't exceeded our wait time */
                    if (GetTickCount() >= StartTickCount + MaxWait)
                    {
                        /* We have, give up */
                        DPRINT1("Timeout\n");
                        dwResult = ERROR_SERVICE_REQUEST_TIMEOUT;
                        break;
                    }
                }
            }
        }
        else
        {
            dwResult = GetLastError();
        }
 
        if (ServiceStatus.dwCurrentState == ReqState)
        {
            dwResult = ERROR_SUCCESS;
        }
    }
    else
    {
        dwResult = GetLastError();
    }
 
    CloseServiceHandle(hService);
    CloseServiceHandle(hSCManager);
 
    return dwResult;
}

Referenced by ActionThread().

DoStartService()

DWORD DoStartService	(	LPWSTR	ServiceName,
		HANDLE	hProgress,
		LPWSTR	lpStartParams
	)

Definition at line 18 of file start.c.

{
    SC_HANDLE hSCManager;
    SC_HANDLE hService;
    SERVICE_STATUS_PROCESS ServiceStatus;
    DWORD BytesNeeded = 0;
    DWORD StartTickCount;
    DWORD OldCheckPoint;
    DWORD WaitTime;
    DWORD MaxWait;
    BOOL Result = FALSE;
 
    BOOL bWhiteSpace = TRUE;
    LPWSTR lpChar;
    DWORD dwArgsCount = 0;
    DWORD dwResult = ERROR_SUCCESS;
    LPCWSTR *lpArgsVector = NULL;
 
    if (lpStartParams != NULL)
    {
        /* Count the number of arguments */
        lpChar = lpStartParams;
        while (*lpChar != 0)
        {
            if (iswspace(*lpChar))
            {
                bWhiteSpace = TRUE;
            }
            else
            {
                if (bWhiteSpace != FALSE)
                {
                    dwArgsCount++;
                    bWhiteSpace = FALSE;
                }
            }
 
            lpChar++;
        }
 
        /*
         * Allocate the arguments vector.
         * Do not add the service name here because services.exe does it for us!
         */
        lpArgsVector = LocalAlloc(LMEM_FIXED, dwArgsCount * sizeof(LPCWSTR));
        if (!lpArgsVector)
            return GetLastError();
 
        /* Fill the arguments vector */
        dwArgsCount = 0;
        bWhiteSpace = TRUE;
        lpChar = lpStartParams;
        while (*lpChar != 0)
        {
            if (iswspace(*lpChar))
            {
                *lpChar = 0;
                bWhiteSpace = TRUE;
            }
            else
            {
                if (bWhiteSpace != FALSE)
                {
                    lpArgsVector[dwArgsCount] = lpChar;
                    dwArgsCount++;
                    bWhiteSpace = FALSE;
                }
            }
 
            lpChar++;
        }
    }
 
    hSCManager = OpenSCManagerW(NULL,
                                NULL,
                                SC_MANAGER_CONNECT);
    if (!hSCManager)
    {
        dwResult = GetLastError();
        if (lpArgsVector)
            LocalFree((LPVOID)lpArgsVector);
        return dwResult;
    }
 
    hService = OpenServiceW(hSCManager,
                            ServiceName,
                            SERVICE_START | SERVICE_QUERY_STATUS);
    if (!hService)
    {
        dwResult = GetLastError();
        CloseServiceHandle(hSCManager);
        if (lpArgsVector)
            LocalFree((LPVOID)lpArgsVector);
        return dwResult;
    }
 
    /* Start the service */
    Result = StartServiceW(hService,
                            dwArgsCount,
                            lpArgsVector);
    if (!Result && GetLastError() == ERROR_SERVICE_ALREADY_RUNNING)
    {
        /* If it's already running, just return TRUE */
        Result = TRUE;
    }
    else if (Result)
    {
        if (hProgress)
        {
            /* Increment the progress bar */
            IncrementProgressBar(hProgress, DEFAULT_STEP);
        }
 
        /* Get the service status to check if it's running */
        Result = QueryServiceStatusEx(hService,
                                        SC_STATUS_PROCESS_INFO,
                                        (LPBYTE)&ServiceStatus,
                                        sizeof(SERVICE_STATUS_PROCESS),
                                        &BytesNeeded);
        if (Result)
        {
            Result = FALSE;
            MaxWait = MAX_WAIT_TIME;
            OldCheckPoint = ServiceStatus.dwCheckPoint;
            StartTickCount = GetTickCount();
 
            /* Loop until it's running */
            while (ServiceStatus.dwCurrentState != SERVICE_RUNNING)
            {
                int i;
                /* Fixup the wait time */
                WaitTime = ServiceStatus.dwWaitHint / 10;
 
                if (WaitTime < 1000) WaitTime = 1000;
                else if (WaitTime > 10000) WaitTime = 10000;
 
                /* We don't wanna wait for up to 10 secs without incrementing */
                for (i = WaitTime / 1000; i > 0; i--)
                {
                    Sleep(1000);
                    if (hProgress)
                    {
                        /* Increment the progress bar */
                        IncrementProgressBar(hProgress, DEFAULT_STEP);
                    }
                }
 
 
                /* Get the latest status info */
                if (!QueryServiceStatusEx(hService,
                                            SC_STATUS_PROCESS_INFO,
                                            (LPBYTE)&ServiceStatus,
                                            sizeof(SERVICE_STATUS_PROCESS),
                                            &BytesNeeded))
                {
                    /* Something went wrong... */
                    dwResult = GetLastError();
                    DPRINT1("QueryServiceStatusEx failed: %d\n", dwResult);
                    break;
                }
 
                /* Is the service making progress? */
                if (ServiceStatus.dwCheckPoint > OldCheckPoint)
                {
                    /* It is, get the latest tickcount to reset the max wait time */
                    StartTickCount = GetTickCount();
                    OldCheckPoint = ServiceStatus.dwCheckPoint;
                }
                else
                {
                    /* It's not, make sure we haven't exceeded our wait time */
                    if (GetTickCount() >= StartTickCount + MaxWait)
                    {
                        /* We have, give up */
                        DPRINT1("Timeout\n");
                        dwResult = ERROR_SERVICE_REQUEST_TIMEOUT;
                        break;
                    }
                }
            }
        }
        else
        {
            dwResult = GetLastError();
        }
 
        if (ServiceStatus.dwCurrentState == SERVICE_RUNNING)
        {
            dwResult = ERROR_SUCCESS;
        }
    }
 
    CloseServiceHandle(hService);
    CloseServiceHandle(hSCManager);
 
    if (lpArgsVector)
        LocalFree((LPVOID)lpArgsVector);
 
    return dwResult;
}

Referenced by ActionThread().

DoStopService()

DWORD DoStopService	(	LPWSTR	ServiceName,
		HANDLE	hProgress
	)

Referenced by ActionThread().

ExportFile()

VOID ExportFile

(

PMAIN_WND_INFO

Info

)

Definition at line 108 of file export.c.

{
    OPENFILENAMEW ofn;
    WCHAR szFileName[MAX_PATH];
 
    ZeroMemory(&ofn, sizeof(ofn));
    szFileName[0] = UNICODE_NULL;
 
    ofn.lStructSize = sizeof(OPENFILENAME);
    ofn.hwndOwner = Info->hMainWnd;
    ofn.lpstrFilter = L"Text (Tab Delimited)(*.txt)\0*.txt\0Text (Comma Delimited)(*.csv)\0*.csv\0";
    ofn.lpstrFile = szFileName;
    ofn.nMaxFile = MAX_PATH;
    ofn.lpstrDefExt = L"txt";
    ofn.Flags = OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;
 
    if(GetSaveFileName(&ofn))
    {
        if (SaveServicesToFile(Info, szFileName, ofn.nFilterIndex))
            return;
    }
 
    if (CommDlgExtendedError() != CDERR_GENERALCODES)
        MessageBoxW(NULL, L"Export to file failed", NULL, 0);
}

Referenced by MainWndCommand().

FreeServiceList()

VOID FreeServiceList

(

PMAIN_WND_INFO

Info

)

Definition at line 257 of file query.c.

{
    DWORD i;
 
    if (Info->pAllServices != NULL)
    {
        for (i = 0; i < Info->NumServices; i++)
        {
            if (Info->pAllServices[i].lpServiceName)
                HeapFree(ProcessHeap, 0, Info->pAllServices[i].lpServiceName);
 
            if (Info->pAllServices[i].lpDisplayName)
                HeapFree(ProcessHeap, 0, Info->pAllServices[i].lpDisplayName);
        }
 
        HeapFree(ProcessHeap, 0, Info->pAllServices);
        Info->pAllServices = NULL;
        Info->NumServices = 0;
    }
}

Referenced by GetServiceList(), and MainWndProc().

GeneralPageProc()

INT_PTR CALLBACK GeneralPageProc	(	HWND	hwndDlg,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 327 of file propsheet_general.c.

{
    PPAGEDATA pPageData;
 
    /* Get the window context */
    pPageData = (PPAGEDATA)GetWindowLongPtr(hwndDlg,
                                            GWLP_USERDATA);
    if (pPageData == NULL && uMsg != WM_INITDIALOG)
    {
        return FALSE;
    }
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
            pPageData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PAGEDATA));
            if (pPageData != NULL)
            {
                SetWindowLongPtr(hwndDlg,
                                 GWLP_USERDATA,
                                 (LONG_PTR)pPageData);
 
                pPageData->dlgInfo = (PSERVICEPROPSHEET)(((LPPROPSHEETPAGE)lParam)->lParam);
                if (pPageData->dlgInfo != NULL)
                {
                    InitGeneralPage(pPageData->dlgInfo, hwndDlg);
                    SetButtonStates(pPageData->dlgInfo, hwndDlg);
                }
            }
            break;
 
        case WM_DESTROY:
            HeapFree(GetProcessHeap(), 0, pPageData);
            break;
 
        case WM_COMMAND:
            switch(LOWORD(wParam))
            {
                case IDC_START_TYPE:
                    if (HIWORD(wParam) == CBN_SELCHANGE)
                    {
                        pPageData->bStartTypeChanged = TRUE;
                        PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
                    }
                    break;
 
                case IDC_DISP_NAME:
                    if (HIWORD(wParam) == EN_CHANGE)
                    {
                        pPageData->bDisplayNameChanged = TRUE;
                        PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
                    }
                    break;
 
                case IDC_DESCRIPTION:
                    if (HIWORD(wParam) == EN_CHANGE)
                    {
                        pPageData->bDescriptionChanged = TRUE;
                        PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
                    }
                    break;
 
                case IDC_EXEPATH:
                    if (HIWORD(wParam) == EN_CHANGE)
                    {
                        pPageData->bBinaryPathChanged = TRUE;
                        PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
                    }
                    break;
 
                case IDC_START:
                {
                    WCHAR szStartParams[256];
                    LPWSTR lpStartParams = NULL;
 
                    if (GetDlgItemText(hwndDlg, IDC_START_PARAM, szStartParams, 256) > 0)
                        lpStartParams = szStartParams;
 
                    EnableWindow(GetDlgItem(hwndDlg, IDC_START_PARAM), FALSE);
 
                    RunActionWithProgress(hwndDlg,
                                          pPageData->dlgInfo->pService->lpServiceName,
                                          pPageData->dlgInfo->pService->lpDisplayName,
                                          ACTION_START,
                                          lpStartParams);
 
                    UpdateServiceStatus(pPageData->dlgInfo->pService);
                    ChangeListViewText(pPageData->dlgInfo->Info, pPageData->dlgInfo->pService, LVSTATUS);
                    SetButtonStates(pPageData->dlgInfo, hwndDlg);
                    SetServiceStatusText(pPageData->dlgInfo, hwndDlg);
                    break;
                }
 
                case IDC_STOP:
                    RunActionWithProgress(hwndDlg,
                                          pPageData->dlgInfo->pService->lpServiceName,
                                          pPageData->dlgInfo->pService->lpDisplayName,
                                          ACTION_STOP,
                                          NULL);
 
                    UpdateServiceStatus(pPageData->dlgInfo->pService);
                    ChangeListViewText(pPageData->dlgInfo->Info, pPageData->dlgInfo->pService, LVSTATUS);
                    SetButtonStates(pPageData->dlgInfo, hwndDlg);
                    SetServiceStatusText(pPageData->dlgInfo, hwndDlg);
                    break;
 
                case IDC_PAUSE:
                    RunActionWithProgress(hwndDlg,
                                          pPageData->dlgInfo->pService->lpServiceName,
                                          pPageData->dlgInfo->pService->lpDisplayName,
                                          ACTION_PAUSE,
                                          NULL);
 
                    UpdateServiceStatus(pPageData->dlgInfo->pService);
                    ChangeListViewText(pPageData->dlgInfo->Info, pPageData->dlgInfo->pService, LVSTATUS);
                    SetButtonStates(pPageData->dlgInfo, hwndDlg);
                    SetServiceStatusText(pPageData->dlgInfo, hwndDlg);
                    break;
 
                case IDC_RESUME:
                    RunActionWithProgress(hwndDlg,
                                          pPageData->dlgInfo->pService->lpServiceName,
                                          pPageData->dlgInfo->pService->lpDisplayName,
                                          ACTION_RESUME,
                                          NULL);
 
                    UpdateServiceStatus(pPageData->dlgInfo->pService);
                    ChangeListViewText(pPageData->dlgInfo->Info, pPageData->dlgInfo->pService, LVSTATUS);
                    SetButtonStates(pPageData->dlgInfo, hwndDlg);
                    SetServiceStatusText(pPageData->dlgInfo, hwndDlg);
                    break;
 
                case IDC_EDIT:
                    SendDlgItemMessage(hwndDlg, IDC_DISP_NAME, EM_SETREADONLY, FALSE, 0);
                    SendDlgItemMessage(hwndDlg, IDC_DESCRIPTION, EM_SETREADONLY, FALSE, 0);
                    SendDlgItemMessage(hwndDlg, IDC_EXEPATH, EM_SETREADONLY, FALSE, 0);
                    EnableWindow(GetDlgItem(hwndDlg, IDC_EDIT), FALSE);
                    break;
            }
            break;
 
        case WM_NOTIFY:
            switch (((LPNMHDR)lParam)->code)
            {
                case PSN_APPLY:
                    if (pPageData->bDisplayNameChanged ||
                        pPageData->bDescriptionChanged ||
                        pPageData->bBinaryPathChanged ||
                        pPageData->bStartTypeChanged)
                    {
                        SaveDlgInfo(pPageData, hwndDlg);
                        SetButtonStates(pPageData->dlgInfo, hwndDlg);
                        pPageData->bDisplayNameChanged = FALSE;
                        pPageData->bDescriptionChanged = FALSE;
                        pPageData->bBinaryPathChanged = FALSE;
                        pPageData->bStartTypeChanged = FALSE;
                    }
                    break;
            }
            break;
    }
 
    return FALSE;
}

Referenced by Applet(), AppletInit(), PropSheetThread(), and SystemApplet().

GetError()

VOID GetError

(

VOID

)

Definition at line 192 of file misc.c.

{
    LPWSTR lpMsgBuf = NULL;
 
    FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                   FORMAT_MESSAGE_FROM_SYSTEM |
                   FORMAT_MESSAGE_IGNORE_INSERTS,
                   NULL,
                   GetLastError(),
                   MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                   (VOID*)&lpMsgBuf,
                   0,
                   NULL );
 
    MessageBoxW(NULL, lpMsgBuf, L"Error!", MB_OK | MB_ICONERROR);
 
    LocalFree(lpMsgBuf);
}

Referenced by CreateMainWindow(), GetServiceDescription(), InitEditWnd(), SetServiceAccount(), SetServiceConfig(), and SetServiceDescription().

GetExecutablePath()

LPWSTR GetExecutablePath

(

LPWSTR

lpServiceName

)

GetListOfServicesToStop()

LPWSTR GetListOfServicesToStop

(

LPWSTR

lpServiceName

)

Definition at line 126 of file stop_dependencies.c.

{
    LPWSTR lpServiceList = NULL;
 
    /* Call recursive function to get our list */
    if (BuildListOfServicesToStop(&lpServiceList, lpServiceName))
        return lpServiceList;
    else
        return NULL;
}

Referenced by RunActionWithProgress().

GetSelectedService()

ENUM_SERVICE_STATUS_PROCESS * GetSelectedService

(

PMAIN_WND_INFO

Info

)

Definition at line 13 of file query.c.

{
    LVITEM lvItem;
 
    lvItem.mask = LVIF_PARAM;
    lvItem.iItem = Info->SelectedItem;
    SendMessage(Info->hListView,
                LVM_GETITEM,
                0,
                (LPARAM)&lvItem);
 
    /* return pointer to selected service */
    return (ENUM_SERVICE_STATUS_PROCESS *)lvItem.lParam;
}

Referenced by ListViewSelectionChanged().

GetServiceConfig()

LPQUERY_SERVICE_CONFIG GetServiceConfig

(

LPWSTR

lpServiceName

)

Definition at line 29 of file query.c.

{
    LPQUERY_SERVICE_CONFIGW lpServiceConfig = NULL;
    SC_HANDLE hSCManager;
    SC_HANDLE hService;
    DWORD dwBytesNeeded;
 
    hSCManager = OpenSCManagerW(NULL,
                                NULL,
                                SC_MANAGER_CONNECT);
    if (hSCManager)
    {
        hService = OpenServiceW(hSCManager,
                                lpServiceName,
                                SERVICE_QUERY_CONFIG);
        if (hService)
        {
            if (!QueryServiceConfigW(hService,
                                     NULL,
                                     0,
                                     &dwBytesNeeded))
            {
                if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
                {
                    lpServiceConfig = (LPQUERY_SERVICE_CONFIG)HeapAlloc(GetProcessHeap(),
                                                                        0,
                                                                        dwBytesNeeded);
                    if (lpServiceConfig)
                    {
                        if (!QueryServiceConfigW(hService,
                                                lpServiceConfig,
                                                dwBytesNeeded,
                                                &dwBytesNeeded))
                        {
                            HeapFree(GetProcessHeap(),
                                     0,
                                     lpServiceConfig);
                            lpServiceConfig = NULL;
                        }
                    }
                }
            }
 
            CloseServiceHandle(hService);
        }
 
        CloseServiceHandle(hSCManager);
    }
 
    return lpServiceConfig;
}

Referenced by AddServiceNamesToStop(), ChangeListViewText(), InitGeneralPage(), LogonPageProc(), SetButtonStates(), SetMenuAndButtonStates(), SetStartupType(), and TV1_AddDependantsToTree().

GetServiceDescription()

LPWSTR GetServiceDescription

(

LPWSTR

lpServiceName

)

Definition at line 135 of file query.c.

{
    SC_HANDLE hSCManager = NULL;
    SC_HANDLE hSc = NULL;
    SERVICE_DESCRIPTIONW *pServiceDescription = NULL;
    LPWSTR lpDescription = NULL;
    DWORD BytesNeeded = 0;
    DWORD dwSize;
 
    hSCManager = OpenSCManagerW(NULL,
                                NULL,
                                SC_MANAGER_ENUMERATE_SERVICE);
    if (hSCManager == NULL)
    {
        GetError();
        return NULL;
    }
 
    hSc = OpenServiceW(hSCManager,
                       lpServiceName,
                       SERVICE_QUERY_CONFIG);
    if (hSc)
    {
        if (!QueryServiceConfig2W(hSc,
                                  SERVICE_CONFIG_DESCRIPTION,
                                  NULL,
                                  0,
                                  &BytesNeeded))
        {
            if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
            {
                pServiceDescription = (SERVICE_DESCRIPTION *) HeapAlloc(ProcessHeap,
                                                                        0,
                                                                        BytesNeeded);
                if (pServiceDescription == NULL)
                    goto cleanup;
 
                if (QueryServiceConfig2W(hSc,
                                         SERVICE_CONFIG_DESCRIPTION,
                                         (LPBYTE)pServiceDescription,
                                         BytesNeeded,
                                         &BytesNeeded))
                {
                    if (pServiceDescription->lpDescription)
                    {
                        dwSize = wcslen(pServiceDescription->lpDescription) + 1;
                        lpDescription = HeapAlloc(ProcessHeap,
                                                  0,
                                                  dwSize * sizeof(WCHAR));
                        if (lpDescription)
                        {
                            StringCchCopyW(lpDescription,
                                           dwSize,
                                           pServiceDescription->lpDescription);
                        }
                    }
                }
            }
        }
    }
 
cleanup:
    if (pServiceDescription)
        HeapFree(ProcessHeap,
                 0,
                 pServiceDescription);
    if (hSCManager != NULL)
        CloseServiceHandle(hSCManager);
    if (hSc != NULL)
        CloseServiceHandle(hSc);
 
    return lpDescription;
}

Referenced by ChangeListViewText(), DeleteDialogProc(), and InitGeneralPage().

GetServiceList()

BOOL GetServiceList

(

PMAIN_WND_INFO

Info

)

Definition at line 279 of file query.c.

{
    ENUM_SERVICE_STATUS_PROCESS *pServices = NULL;
    SC_HANDLE ScHandle;
    BOOL bRet = FALSE;
 
    DWORD BytesNeeded = 0;
    DWORD ResumeHandle = 0;
    DWORD NumServices = 0;
    DWORD i;
 
    FreeServiceList(Info);
 
    ScHandle = OpenSCManagerW(NULL,
                              NULL,
                              SC_MANAGER_ENUMERATE_SERVICE);
    if (ScHandle != NULL)
    {
        if (!EnumServicesStatusEx(ScHandle,
                                  SC_ENUM_PROCESS_INFO,
                                  SERVICE_WIN32,
                                  SERVICE_STATE_ALL,
                                  NULL,
                                  0,
                                  &BytesNeeded,
                                  &NumServices,
                                  &ResumeHandle,
                                  0))
        {
            /* Call function again if required size was returned */
            if (GetLastError() == ERROR_MORE_DATA)
            {
                /* reserve memory for service info array */
                pServices = (ENUM_SERVICE_STATUS_PROCESS *)HeapAlloc(ProcessHeap,
                                                                     0,
                                                                     BytesNeeded);
                if (pServices)
                {
                    /* fill array with service info */
                    if (EnumServicesStatusEx(ScHandle,
                                             SC_ENUM_PROCESS_INFO,
                                             SERVICE_WIN32,
                                             SERVICE_STATE_ALL,
                                             (LPBYTE)pServices,
                                             BytesNeeded,
                                             &BytesNeeded,
                                             &NumServices,
                                             &ResumeHandle,
                                             0))
                    {
                        bRet = TRUE;
                    }
                }
            }
        }
    }
 
    if (ScHandle)
        CloseServiceHandle(ScHandle);
 
    Info->pAllServices = (ENUM_SERVICE_STATUS_PROCESS *)HeapAlloc(ProcessHeap,
                                                                  HEAP_ZERO_MEMORY,
                                                                  NumServices * sizeof(ENUM_SERVICE_STATUS_PROCESS));
    if (Info->pAllServices != NULL)
    {
        Info->NumServices = NumServices;
 
        for (i = 0; i < NumServices; i++)
        {
            Info->pAllServices[i].lpServiceName = HeapAlloc(ProcessHeap,
                                                            HEAP_ZERO_MEMORY,
                                                            (wcslen(pServices[i].lpServiceName) + 1) * sizeof(WCHAR));
            if (Info->pAllServices[i].lpServiceName)
                wcscpy(Info->pAllServices[i].lpServiceName, pServices[i].lpServiceName);
 
            Info->pAllServices[i].lpDisplayName = HeapAlloc(ProcessHeap,
                                                            HEAP_ZERO_MEMORY,
                                                            (wcslen(pServices[i].lpDisplayName) + 1) * sizeof(WCHAR));
            if (Info->pAllServices[i].lpDisplayName)
                wcscpy(Info->pAllServices[i].lpDisplayName, pServices[i].lpDisplayName);
 
            CopyMemory(&Info->pAllServices[i].ServiceStatusProcess,
                       &pServices[i].ServiceStatusProcess,
                       sizeof(SERVICE_STATUS_PROCESS));
        }
    }
 
    if (pServices)
        HeapFree(ProcessHeap, 0, pServices);
 
    return bRet;
}

Referenced by RefreshServiceList().

GetTextFromEdit()

INT GetTextFromEdit	(	OUT LPWSTR	lpString,
		IN HWND	hDlg,
		IN UINT	Res
	)

Definition at line 174 of file misc.c.

{
    INT len = GetWindowTextLengthW(GetDlgItem(hDlg, Res));
    if(len > 0)
    {
        GetDlgItemTextW(hDlg,
                        Res,
                        lpString,
                        len + 1);
    }
    else
        lpString = NULL;
 
    return len;
}

IncrementProgressBar()

VOID IncrementProgressBar	(	HANDLE	hProgress,
		UINT	NewPos
	)

Definition at line 338 of file progress.c.

{
    HWND hProgBar = (HWND)hProgress;
    UINT Position;
 
    /* Don't allow the progress to reach to complete*/
    Position = SendMessageW(hProgBar,
                            PBM_GETPOS,
                            0,
                            0);
    if (Position < PROGRESS_STEP_MAX)
    {
        /* Do we want to increment the default amount? */
        if (Step == DEFAULT_STEP)
        {
            /* Use the step value we set on create */
            SendMessageW(hProgBar,
                         PBM_STEPIT,
                         0,
                         0);
        }
        else
        {
            /* Use the value passed */
            SendMessageW(hProgBar,
                         PBM_SETPOS,
                         Step,
                         0);
        }
    }
}

Referenced by DoControlService(), DoStartService(), and DoStopService().

InitImageList()

HIMAGELIST InitImageList	(	UINT	StartResource,
		UINT	EndResource,
		UINT	Width,
		UINT	Height,
		ULONG	type
	)

Definition at line 219 of file misc.c.

{
    HANDLE hImage;
    HIMAGELIST himl;
    UINT i;
    INT ret;
 
    /* Create the toolbar icon image list */
    himl = ImageList_Create(Width,
                            Height,
                            ILC_MASK | ILC_COLOR32,
                            EndResource - StartResource,
                            0);
    if (himl == NULL)
        return NULL;
 
    ret = 0;
    for (i = StartResource; i <= EndResource && ret != -1; i++)
    {
        hImage = LoadImageW(hInstance,
                            MAKEINTRESOURCEW(i),
                            type,
                            Width,
                            Height,
                            LR_LOADTRANSPARENT);
        if (hImage == NULL)
        {
            ret = -1;
            break;
        }
 
        if (type == IMAGE_BITMAP)
        {
            ret = ImageList_AddMasked(himl,
                                      hImage,
                                      RGB(255, 0, 128));
        }
        else if (type == IMAGE_ICON)
        {
            ret = ImageList_AddIcon(himl,
                                    hImage);
        }
 
        DeleteObject(hImage);
    }
 
    if (ret == -1)
    {
        ImageList_Destroy(himl);
        himl = NULL;
    }
 
    return himl;
}

Referenced by InitDependPage(), pCreateToolbar(), PopulateTreeView(), and SoundsDlgProc().

InitMainWindowImpl()

BOOL InitMainWindowImpl

(

VOID

)

Definition at line 964 of file mainwnd.c.

{
    WNDCLASSEX wc = {0};
 
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.lpfnWndProc = MainWndProc;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon(hInstance,
                        MAKEINTRESOURCE(IDI_SM_ICON));
    wc.hCursor = LoadCursor(NULL,
                            IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
    wc.lpszMenuName = MAKEINTRESOURCE(IDR_MAINMENU);
    wc.lpszClassName = szMainWndClass;
    wc.hIconSm = (HICON)LoadImage(hInstance,
                                  MAKEINTRESOURCE(IDI_SM_ICON),
                                  IMAGE_ICON,
                                  16,
                                  16,
                                  LR_SHARED);
 
    return RegisterClassEx(&wc) != (ATOM)0;
}

ListViewSelectionChanged()

VOID ListViewSelectionChanged	(	PMAIN_WND_INFO	Info,
		LPNMLISTVIEW	pnmv
	)

Definition at line 48 of file listview.c.

{
    HMENU hMainMenu;
 
    /* get handle to menu */
    hMainMenu = GetMenu(Info->hMainWnd);
 
    /* activate properties menu item, if not already */
    if (GetMenuState(hMainMenu,
                     ID_PROP,
                     MF_BYCOMMAND) != MF_ENABLED)
    {
        EnableMenuItem(hMainMenu,
                       ID_PROP,
                       MF_ENABLED);
        EnableMenuItem(GetSubMenu(Info->hShortcutMenu, 0),
                       ID_PROP,
                       MF_ENABLED);
        SetMenuDefaultItem(GetSubMenu(Info->hShortcutMenu, 0),
                           ID_PROP,
                           MF_BYCOMMAND);
    }
 
    /* activate delete menu item, if not already */
    if (GetMenuState(hMainMenu,
                     ID_DELETE,
                     MF_BYCOMMAND) != MF_ENABLED)
    {
        EnableMenuItem(hMainMenu,
                       ID_DELETE,
                       MF_ENABLED);
        EnableMenuItem(GetSubMenu(Info->hShortcutMenu, 0),
                       ID_DELETE,
                       MF_ENABLED);
    }
 
    /* set selected service */
    Info->SelectedItem = pnmv->iItem;
 
    /* get pointer to selected service */
    Info->pCurrentService = GetSelectedService(Info);
 
    /* set current selected service in the status bar */
    SendMessage(Info->hStatus,
                SB_SETTEXT,
                1,
                (LPARAM)Info->pCurrentService->lpDisplayName);
 
    /* show the properties button */
    SendMessage(Info->hTool,
                TB_SETSTATE,
                ID_PROP,
                (LPARAM)MAKELONG(TBSTATE_ENABLED, 0));
}

Referenced by MainWndProc().

LoadAndFormatString()

DWORD LoadAndFormatString	(	IN HINSTANCE	hInstance,
		IN UINT	uID,
		OUT LPWSTR *	lpTarget,
			...
	)

Definition at line 76 of file misc.c.

{
    DWORD Ret = 0;
    LPWSTR lpFormat;
    va_list lArgs;
 
    if (AllocAndLoadString(&lpFormat,
                           hInstance,
                           uID) > 0)
    {
        va_start(lArgs, lpTarget);
        /* let's use Format to format it because it has the ability to allocate
           memory automatically */
        Ret = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
                             lpFormat,
                             0,
                             0,
                             (LPWSTR)lpTarget,
                             0,
                             &lArgs);
        va_end(lArgs);
 
        LocalFree((HLOCAL)lpFormat);
    }
 
    return Ret;
}

LogonPageProc()

INT_PTR CALLBACK LogonPageProc	(	HWND	hwndDlg,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 221 of file propsheet_logon.c.

{
    PLOGONDATA pLogonData;
 
    /* Get the window context */
    pLogonData = (PLOGONDATA)GetWindowLongPtr(hwndDlg,
                                              GWLP_USERDATA);
    if (pLogonData == NULL && uMsg != WM_INITDIALOG)
    {
        return FALSE;
    }
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
            pLogonData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LOGONDATA));
            if (pLogonData != NULL)
            {
                SetWindowLongPtr(hwndDlg,
                                 GWLP_USERDATA,
                                 (LONG_PTR)pLogonData);
 
                pLogonData->bInitialized = FALSE;
                pLogonData->pService = ((PSERVICEPROPSHEET)(((LPPROPSHEETPAGE)lParam)->lParam))->pService;
 
                pLogonData->pServiceConfig = GetServiceConfig(pLogonData->pService->lpServiceName);
                if (pLogonData->pServiceConfig != NULL)
                {
                    wcscpy(pLogonData->szPassword1, DEFAULT_PASSWORD);
                    wcscpy(pLogonData->szPassword2, DEFAULT_PASSWORD);
 
                    if (pLogonData->pServiceConfig->lpServiceStartName == NULL ||
                        _wcsicmp(pLogonData->pServiceConfig->lpServiceStartName, L"LocalSystem") == 0)
                    {
                        SendDlgItemMessageW(hwndDlg, IDC_LOGON_SYSTEMACCOUNT, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
                        if (pLogonData->pServiceConfig->dwServiceType & SERVICE_INTERACTIVE_PROCESS) {
                            pLogonData->nInteractive = BST_CHECKED;
                            SendDlgItemMessageW(hwndDlg, IDC_LOGON_INTERACTIVE, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
                        }
                        SetControlStates(hwndDlg, pLogonData, TRUE);
                    }
                    else
                    {
                        wcscpy(pLogonData->szAccountName, pLogonData->pServiceConfig->lpServiceStartName);
                        SendDlgItemMessageW(hwndDlg, IDC_LOGON_THISACCOUNT, BM_SETCHECK, (WPARAM)BST_CHECKED, 0);
                        SetControlStates(hwndDlg, pLogonData, FALSE);
                    }
                }
 
                pLogonData->bInitialized = TRUE;
            }
 
            EnableWindow(GetDlgItem(hwndDlg, IDC_LOGON_HWPROFILE), FALSE);
            break;
 
        case WM_DESTROY:
            if (pLogonData->pServiceConfig)
                HeapFree(GetProcessHeap(), 0, pLogonData->pServiceConfig);
 
            HeapFree(GetProcessHeap(), 0, pLogonData);
            break;
 
        case WM_COMMAND:
            switch(LOWORD(wParam))
            {
                case IDC_LOGON_SYSTEMACCOUNT:
                    if (HIWORD(wParam) == BN_CLICKED)
                    {
                        if (pLogonData->bInitialized)
                        {
                            pLogonData->bAccountChanged = TRUE;
                            PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
                        }
                        SetControlStates(hwndDlg, pLogonData, TRUE);
                    }
                    break;
 
                case IDC_LOGON_THISACCOUNT:
                    if (HIWORD(wParam) == BN_CLICKED)
                    {
                        if (pLogonData->bInitialized)
                        {
                            pLogonData->bAccountChanged = TRUE;
                            PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
                        }
                        SetControlStates(hwndDlg, pLogonData, FALSE);
                    }
                    break;
 
                case IDC_LOGON_INTERACTIVE:
                    if (HIWORD(wParam) == BN_CLICKED)
                    {
                        if (pLogonData->bInitialized)
                        {
                            pLogonData->bAccountChanged = TRUE;
                            PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
                        }
                    }
                    break;
 
                case IDC_LOGON_ACCOUNTNAME:
                case IDC_LOGON_PASSWORD1:
                case IDC_LOGON_PASSWORD2:
                    if (HIWORD(wParam) == EN_CHANGE && pLogonData->bInitialized)
                    {
                        pLogonData->bAccountChanged = TRUE;
                        PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
                    }
                    break;
            }
            break;
 
        case WM_NOTIFY:
            switch (((LPNMHDR)lParam)->code)
            {
                case PSN_QUERYINITIALFOCUS:
                    return OnQueryInitialFocus(hwndDlg, pLogonData);
 
                case PSN_APPLY:
                    return OnApply(hwndDlg, pLogonData);
            }
            break;
    }
 
    return FALSE;
}

Referenced by PropSheetThread().

OpenPropSheet()

VOID OpenPropSheet

(

PMAIN_WND_INFO

Info

)

Definition at line 30 of file propsheet.c.

{
    PSERVICEPROPSHEET pServicePropSheet;
    HANDLE hThread;
 
    pServicePropSheet = HeapAlloc(ProcessHeap,
                                  0,
                                  sizeof(*pServicePropSheet));
    if (!pServicePropSheet) return;
 
    /* Set the current service in this calling thread to avoid
     * it being updated before the thread is up */
    pServicePropSheet->pService = Info->pCurrentService;
    pServicePropSheet->Info = Info;
 
    hThread = (HANDLE)_beginthreadex(NULL, 0, &PropSheetThread, pServicePropSheet, 0, NULL);
    if (hThread)
    {
        CloseHandle(hThread);
    }
}

Referenced by MainWndCommand().

ProgressDialogProc()

INT_PTR CALLBACK ProgressDialogProc	(	HWND	hDlg,
		UINT	Message,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 281 of file progress.c.

{
    switch(Message)
    {
        case WM_INITDIALOG:
        {
            return InitProgressDialog(hDlg, Message, wParam, lParam);
        }
 
        case WM_COMMAND:
            switch(LOWORD(wParam))
            {
                case IDOK:
                    EndDialog(hDlg, wParam);
                    break;
 
            }
            break;
 
        default:
            return FALSE;
    }
 
    return TRUE;
}

Referenced by RunActionWithProgress().

RecoveryPageProc()

INT_PTR CALLBACK RecoveryPageProc	(	HWND	hwndDlg,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 441 of file propsheet_recovery.c.

{
    PRECOVERYDATA pRecoveryData;
 
    /* Get the window context */
    pRecoveryData = (PRECOVERYDATA)GetWindowLongPtr(hwndDlg,
                                                    GWLP_USERDATA);
    if (pRecoveryData == NULL && uMsg != WM_INITDIALOG)
        return FALSE;
 
    switch (uMsg)
    {
        case WM_INITDIALOG:
            pRecoveryData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RECOVERYDATA));
            if (pRecoveryData != NULL)
            {
                SetWindowLongPtr(hwndDlg,
                                 GWLP_USERDATA,
                                 (LONG_PTR)pRecoveryData);
 
                pRecoveryData->pService = ((PSERVICEPROPSHEET)(((LPPROPSHEETPAGE)lParam)->lParam))->pService;
 
                InitRecoveryPage(hwndDlg);
 
                if (GetServiceFailure(pRecoveryData))
                {
                    ShowFailureActions(hwndDlg, pRecoveryData);
                }
            }
            break;
 
        case WM_DESTROY:
            if (pRecoveryData != NULL)
            {
                if (pRecoveryData->pServiceFailure != NULL)
                    HeapFree(GetProcessHeap(), 0, pRecoveryData->pServiceFailure);
 
                HeapFree(GetProcessHeap(), 0, pRecoveryData);
            }
            break;
 
        case WM_COMMAND:
            switch(LOWORD(wParam))
            {
                case IDC_FIRST_FAILURE:
                case IDC_SECOND_FAILURE:
                case IDC_SUBSEQUENT_FAILURES:
                    if (HIWORD(wParam) == CBN_SELCHANGE)
                    {
                        UpdateFailureActions(hwndDlg, pRecoveryData);
                        pRecoveryData->bChanged = TRUE;
                        PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
                    }
                    break;
 
                case IDC_RESET_TIME:
                case IDC_RESTART_TIME:
                case IDC_PROGRAM:
                case IDC_PARAMETERS:
                    if (HIWORD(wParam) == EN_CHANGE)
                    {
                        pRecoveryData->bChanged = TRUE;
                        PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
                    }
                    break;
 
                case IDC_ADD_FAILCOUNT:
                    if (HIWORD(wParam) == BN_CLICKED)
                    {
                        pRecoveryData->bChanged = TRUE;
                        PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
                    }
                    break;
 
                case IDC_BROWSE_PROGRAM:
                    BrowseFile(hwndDlg);
                    break;
 
                case IDC_RESTART_OPTIONS:
                    break;
            }
            break;
 
        case WM_NOTIFY:
            switch (((LPNMHDR)lParam)->code)
            {
                case PSN_APPLY:
                    if (pRecoveryData->bChanged)
                    {
                        SetFailureActions(hwndDlg);
                        pRecoveryData->bChanged = FALSE;
                    }
                    break;
            }
            break;
    }
 
    return FALSE;
}

Referenced by PropSheetThread().

RefreshServiceList()

BOOL RefreshServiceList

(

PMAIN_WND_INFO

Info

)

Definition at line 247 of file listview.c.

{
    ENUM_SERVICE_STATUS_PROCESS *pService;
    LVITEMW lvItem;
    DWORD Index;
 
    SendMessage (Info->hListView,
                 WM_SETREDRAW,
                 FALSE,
                 0);
 
    (void)ListView_DeleteAllItems(Info->hListView);
 
    if (GetServiceList(Info))
    {
        for (Index = 0; Index < Info->NumServices; Index++)
        {
            INT i;
 
            pService = &Info->pAllServices[Index];
 
            /* set the display name */
            ZeroMemory(&lvItem, sizeof(LVITEMW));
            lvItem.mask = LVIF_TEXT | LVIF_PARAM;
            lvItem.pszText = pService->lpDisplayName;
 
            /* Add the service pointer */
            lvItem.lParam = (LPARAM)pService;
 
            /* add it to the listview */
            lvItem.iItem = ListView_InsertItem(Info->hListView, &lvItem);
 
            /* fill out all the column data */
            for (i = LVDESC; i <= LVLOGONAS; i++)
            {
                ChangeListViewText(Info, pService, i);
            }
        }
 
        UpdateServiceCount(Info);
    }
 
    /* turn redraw flag on. */
    SendMessageW(Info->hListView,
                 WM_SETREDRAW,
                 TRUE,
                 0);
 
    return TRUE;
}

Referenced by MainWndCommand(), and MainWndProc().

ResourceMessageBox()

VOID ResourceMessageBox	(	HINSTANCE	hInstance,
		HWND	hwnd,
		UINT	uType,
		UINT	uCaptionId,
		UINT	uMessageId
	)

Definition at line 282 of file misc.c.

{
    WCHAR szErrorText[BUFFERSIZE];
    WCHAR szErrorCaption[BUFFERSIZE];
 
    LoadStringW(hInstance, uMessageId, szErrorText, sizeof(szErrorText) / sizeof(WCHAR));
    LoadStringW(hInstance, uCaptionId, szErrorCaption, sizeof(szErrorCaption) / sizeof(WCHAR));
 
    MessageBoxW(hwnd, szErrorText, szErrorCaption, uType);
}

Referenced by AdvancedPageProc(), CopyProfileDlgProc(), DeleteHardwareProfile(), DeleteUserProfile(), EditVariableDlgProc(), OnApply(), OnSet(), OnVirtMemDialogOk(), and RenameProfileDlgProc().

RunActionWithProgress()

BOOL RunActionWithProgress	(	HWND	hParent,
		LPWSTR	ServiceName,
		LPWSTR	DisplayName,
		UINT	Action,
		PVOID	Param
	)

Definition at line 372 of file progress.c.

{
    PROGRESS_DATA ProgressData;
    LPWSTR ServiceList;
    BOOL StopDepends;
    INT_PTR Result;
 
    StopDepends = FALSE;
    ServiceList = NULL;
 
 
    /* Check if we'll be stopping the service */
    if (Action == ACTION_STOP || Action == ACTION_RESTART)
    {
        /* Does the service have any dependent services which need stopping first */
        ServiceList = GetListOfServicesToStop(ServiceName);
        if (ServiceList)
        {
            /* Ask the user if they want to stop the dependants */
            StopDepends = CreateStopDependsDialog(hParent,
                                                  ServiceName,
                                                  DisplayName,
                                                  ServiceList);
 
            /* Exit early if the user decided not to stop the dependants */
            if (StopDepends == FALSE)
            {
                HeapFree(GetProcessHeap(), 0, ServiceList);
                return FALSE;
            }
        }
    }
 
    ProgressData.hDlg = NULL;
    ProgressData.ServiceName = ServiceName;
    ProgressData.Action = Action;
    ProgressData.StopDepends = StopDepends;
    ProgressData.ServiceList = ServiceList;
    ProgressData.Param = Param;
 
    Result = DialogBoxParamW(hInstance,
                             MAKEINTRESOURCEW(IDD_DLG_PROGRESS),
                             hParent,
                             ProgressDialogProc,
                             (LPARAM)&ProgressData);
 
    if (ServiceList)
        HeapFree(GetProcessHeap(), 0, ServiceList);
 
    return (Result == IDOK);
}

Referenced by GeneralPageProc(), and MainWndCommand().

SetListViewStyle()

VOID SetListViewStyle	(	HWND	hListView,
		DWORD	View
	)

Definition at line 34 of file listview.c.

{
    DWORD Style = GetWindowLongPtr(hListView, GWL_STYLE);
 
    if ((Style & LVS_TYPEMASK) != View)
    {
        SetWindowLongPtr(hListView,
                         GWL_STYLE,
                         (Style & ~LVS_TYPEMASK) | View);
    }
}

Referenced by MainWndCommand().

SetMenuAndButtonStates()

VOID SetMenuAndButtonStates

(

PMAIN_WND_INFO

Info

)

Definition at line 152 of file mainwnd.c.

{
    HMENU hMainMenu;
    UINT i;
 
    /* get handle to menu */
    hMainMenu = GetMenu(Info->hMainWnd);
 
    /* set all to greyed */
    for (i = ID_START; i <= ID_RESTART; i++)
    {
        EnableMenuItem(hMainMenu, i, MF_GRAYED);
        EnableMenuItem(GetSubMenu(Info->hShortcutMenu, 0), i, MF_GRAYED);
        SendMessage(Info->hTool, TB_SETSTATE, i,
                    (LPARAM)MAKELONG(TBSTATE_INDETERMINATE, 0));
    }
 
    if (Info->SelectedItem != NO_ITEM_SELECTED)
    {
        LPQUERY_SERVICE_CONFIG lpServiceConfig = NULL;
        DWORD Flags, State;
 
        /* allow user to delete service */
        if (Info->bIsUserAnAdmin)
        {
            SendMessage(Info->hTool, TB_SETSTATE, ID_DELETE,
                       (LPARAM)MAKELONG(TBSTATE_ENABLED, 0));
            EnableMenuItem(hMainMenu, ID_DELETE, MF_ENABLED);
            EnableMenuItem(GetSubMenu(Info->hShortcutMenu, 0), ID_DELETE, MF_ENABLED);
        }
 
        Flags = Info->pCurrentService->ServiceStatusProcess.dwControlsAccepted;
        State = Info->pCurrentService->ServiceStatusProcess.dwCurrentState;
 
        lpServiceConfig = GetServiceConfig(Info->pCurrentService->lpServiceName);
 
        if (lpServiceConfig && lpServiceConfig->dwStartType != SERVICE_DISABLED)
        {
            if (State == SERVICE_STOPPED)
            {
                EnableMenuItem(hMainMenu, ID_START, MF_ENABLED);
                EnableMenuItem(GetSubMenu(Info->hShortcutMenu, 0), ID_START, MF_ENABLED);
                SendMessage(Info->hTool, TB_SETSTATE, ID_START,
                       (LPARAM)MAKELONG(TBSTATE_ENABLED, 0));
            }
 
            if ( (Flags & SERVICE_ACCEPT_STOP) && (State == SERVICE_RUNNING) )
            {
                EnableMenuItem(hMainMenu, ID_RESTART, MF_ENABLED);
                EnableMenuItem(GetSubMenu(Info->hShortcutMenu, 0), ID_RESTART, MF_ENABLED);
                SendMessage(Info->hTool, TB_SETSTATE, ID_RESTART,
                       (LPARAM)MAKELONG(TBSTATE_ENABLED, 0));
            }
        }
 
        if(lpServiceConfig)
            HeapFree(GetProcessHeap(), 0, lpServiceConfig);
 
        if ( (Flags & SERVICE_ACCEPT_STOP) && (State == SERVICE_RUNNING) )
        {
            EnableMenuItem(hMainMenu, ID_STOP, MF_ENABLED);
            EnableMenuItem(GetSubMenu(Info->hShortcutMenu, 0), ID_STOP, MF_ENABLED);
            SendMessage(Info->hTool, TB_SETSTATE, ID_STOP,
                   (LPARAM)MAKELONG(TBSTATE_ENABLED, 0));
        }
 
        if ( (Flags & SERVICE_ACCEPT_PAUSE_CONTINUE) && (State == SERVICE_RUNNING) )
        {
            EnableMenuItem(hMainMenu, ID_PAUSE, MF_ENABLED);
            EnableMenuItem(GetSubMenu(Info->hShortcutMenu, 0), ID_PAUSE, MF_ENABLED);
            SendMessage(Info->hTool, TB_SETSTATE, ID_PAUSE,
                   (LPARAM)MAKELONG(TBSTATE_ENABLED, 0));
        }
    }
    else
    {
        /* disable tools which rely on a selected service */
        EnableMenuItem(hMainMenu, ID_PROP, MF_GRAYED);
        EnableMenuItem(hMainMenu, ID_DELETE, MF_GRAYED);
        EnableMenuItem(GetSubMenu(Info->hShortcutMenu, 0), ID_PROP, MF_GRAYED);
        EnableMenuItem(GetSubMenu(Info->hShortcutMenu, 0), ID_DELETE, MF_GRAYED);
        SendMessage(Info->hTool, TB_SETSTATE, ID_PROP,
                   (LPARAM)MAKELONG(TBSTATE_INDETERMINATE, 0));
        SendMessage(Info->hTool, TB_SETSTATE, ID_DELETE,
                   (LPARAM)MAKELONG(TBSTATE_INDETERMINATE, 0));
    }
 
}

Referenced by MainWndCommand(), MainWndProc(), and SetButtonStates().

SetServiceConfig()

BOOL SetServiceConfig	(	LPQUERY_SERVICE_CONFIG	pServiceConfig,
		LPWSTR	lpServiceName,
		LPWSTR	lpPassword
	)

Definition at line 82 of file query.c.

{
    SC_HANDLE hSCManager;
    SC_HANDLE hSc;
    SC_LOCK scLock;
    BOOL bRet = FALSE;
 
    hSCManager = OpenSCManagerW(NULL,
                                NULL,
                                SC_MANAGER_LOCK);
    if (hSCManager)
    {
        scLock = LockServiceDatabase(hSCManager);
        if (scLock)
        {
            hSc = OpenServiceW(hSCManager,
                               lpServiceName,
                               SERVICE_CHANGE_CONFIG);
            if (hSc)
            {
                if (ChangeServiceConfigW(hSc,
                                         pServiceConfig->dwServiceType,
                                         pServiceConfig->dwStartType,
                                         pServiceConfig->dwErrorControl,
                                         pServiceConfig->lpBinaryPathName,
                                         pServiceConfig->lpLoadOrderGroup,
                                         pServiceConfig->dwTagId ? &pServiceConfig->dwTagId : NULL,
                                         pServiceConfig->lpDependencies,
                                         pServiceConfig->lpServiceStartName,
                                         lpPassword,
                                         pServiceConfig->lpDisplayName))
                {
                    bRet = TRUE;
                }
 
                CloseServiceHandle(hSc);
            }
 
            UnlockServiceDatabase(scLock);
        }
 
        CloseServiceHandle(hSCManager);
    }
 
    if (!bRet)
        GetError();
 
    return bRet;
}

Referenced by SaveDlgInfo().

SetServiceDescription()

BOOL SetServiceDescription	(	LPWSTR	lpServiceName,
		LPWSTR	lpDescription
	)

Definition at line 210 of file query.c.

{
    SC_HANDLE hSCManager;
    SC_HANDLE hSc;
    SC_LOCK scLock;
    SERVICE_DESCRIPTION ServiceDescription;
    BOOL bRet = FALSE;
 
    hSCManager = OpenSCManagerW(NULL,
                                NULL,
                                SC_MANAGER_LOCK);
    if (hSCManager)
    {
        scLock = LockServiceDatabase(hSCManager);
        if (scLock)
        {
            hSc = OpenServiceW(hSCManager,
                               lpServiceName,
                               SERVICE_CHANGE_CONFIG);
            if (hSc)
            {
                ServiceDescription.lpDescription = lpDescription;
 
                if (ChangeServiceConfig2W(hSc,
                                          SERVICE_CONFIG_DESCRIPTION,
                                          &ServiceDescription))
                {
                    bRet = TRUE;
                }
 
                CloseServiceHandle(hSc);
            }
 
            UnlockServiceDatabase(scLock);
        }
 
        CloseServiceHandle(hSCManager);
    }
 
    if (!bRet)
        GetError();
 
    return bRet;
}

Referenced by DoCreate(), and SaveDlgInfo().

StatusBarLoadAndFormatString()

BOOL StatusBarLoadAndFormatString	(	IN HWND	hStatusBar,
		IN INT	PartId,
		IN HINSTANCE	hInstance,
		IN UINT	uID,
			...
	)

Definition at line 108 of file misc.c.

{
    BOOL Ret = FALSE;
    LPWSTR lpFormat, lpStr;
    va_list lArgs;
 
    if (AllocAndLoadString(&lpFormat,
                           hInstance,
                           uID) > 0)
    {
        va_start(lArgs, uID);
        /* let's use FormatMessage to format it because it has the ability to allocate
           memory automatically */
        Ret = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
                             lpFormat,
                             0,
                             0,
                             (VOID*)&lpStr,
                             0,
                             &lArgs);
        va_end(lArgs);
 
        if (lpStr != NULL)
        {
            Ret = (BOOL)SendMessageW(hStatusBar,
                                     SB_SETTEXT,
                                     (WPARAM)PartId,
                                     (LPARAM)lpStr);
            LocalFree((HLOCAL)lpStr);
        }
 
        LocalFree((HLOCAL)lpFormat);
    }
 
    return Ret;
}

StatusBarLoadString()

BOOL StatusBarLoadString	(	IN HWND	hStatusBar,
		IN INT	PartId,
		IN HINSTANCE	hInstance,
		IN UINT	uID
	)

Definition at line 150 of file misc.c.

{
    BOOL Ret = FALSE;
    LPWSTR lpStr;
 
    if (AllocAndLoadString(&lpStr,
                           hInstance,
                           uID) > 0)
    {
        Ret = (BOOL)SendMessageW(hStatusBar,
                                 SB_SETTEXT,
                                 (WPARAM)PartId,
                                 (LPARAM)lpStr);
        LocalFree((HLOCAL)lpStr);
    }
 
    return Ret;
}

StopDependsDialogProc()

INT_PTR CALLBACK StopDependsDialogProc	(	HWND	hDlg,
		UINT	message,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 258 of file stop_dependencies.c.

{
 
    switch (Message)
    {
        case WM_INITDIALOG:
        {
            return InitDialog(hDlg,
                              Message,
                              wParam,
                              lParam);
        }
 
        case WM_COMMAND:
        {
            switch (LOWORD(wParam))
            {
                case IDOK:
                case IDCANCEL:
                {
                    EndDialog(hDlg,
                              LOWORD(wParam));
                    return TRUE;
                }
            }
        }
    }
 
    return FALSE;
}

Referenced by CreateStopDependsDialog().

TV1_AddDependantsToTree()

VOID TV1_AddDependantsToTree	(	PDEPENDDATA	pDependData,
		HTREEITEM	hParent,
		LPWSTR	lpServiceName
	)

Definition at line 82 of file dependencies_tv1.c.

{
    SC_HANDLE hSCManager;
    SC_HANDLE hService;
    LPQUERY_SERVICE_CONFIG lpServiceConfig;
    LPWSTR lpDependants;
    LPWSTR lpStr;
    LPWSTR lpNoDepends;
    BOOL bHasChildren;
 
    hSCManager = OpenSCManagerW(NULL,
                                NULL,
                                SC_MANAGER_ALL_ACCESS);
    if (hSCManager)
    {
        hService = OpenServiceW(hSCManager,
                                lpServiceName,
                                SERVICE_QUERY_STATUS | SERVICE_ENUMERATE_DEPENDENTS | SERVICE_QUERY_CONFIG);
        if (hService)
        {
            /* Get a list of service dependents */
            lpDependants = TV1_GetDependants(hService);
            if (lpDependants)
            {
                lpStr = lpDependants;
 
                /* Make sure this isn't the end of the list */
                while (*lpStr)
                {
                    /* Get the info for this service */
                    lpServiceConfig = GetServiceConfig(lpStr);
                    if (lpServiceConfig)
                    {
                        /* Does this item need a +/- box? */
                        if (lpServiceConfig->lpDependencies &&
                            *lpServiceConfig->lpDependencies != '\0')
                        {
                            bHasChildren = TRUE;
                        }
                        else
                        {
                            bHasChildren = FALSE;
                        }
 
                        /* Add it */
                        AddItemToTreeView(pDependData->hDependsTreeView1,
                                          hParent,
                                          lpServiceConfig->lpDisplayName,
                                          lpStr,
                                          lpServiceConfig->dwServiceType,
                                          bHasChildren);
 
                        HeapFree(GetProcessHeap(),
                                 0,
                                 lpServiceConfig);
                    }
 
                    /* Move to the end of the string */
                    while (*lpStr++)
                        ;
                }
 
                HeapFree(GetProcessHeap(),
                         0,
                         lpDependants);
            }
            else
            {
                /* If there is no parent, set the tree to 'no dependencies' */
                if (!hParent)
                {
                    /* Load the 'No dependencies' string */
                    AllocAndLoadString(&lpNoDepends, hInstance, IDS_NO_DEPENDS);
 
                    AddItemToTreeView(pDependData->hDependsTreeView1,
                                      NULL,
                                      lpNoDepends,
                                      NULL,
                                      0,
                                      FALSE);
 
                    LocalFree(lpNoDepends);
 
                    /* Disable the window */
                    EnableWindow(pDependData->hDependsTreeView1, FALSE);
                }
            }
 
            CloseServiceHandle(hService);
        }
 
        CloseServiceHandle(hSCManager);
    }
}

Referenced by DependenciesPageProc(), and TV1_Initialize().

TV1_Initialize()

BOOL TV1_Initialize	(	PDEPENDDATA	pDependData,
		LPWSTR	lpServiceName
	)

Definition at line 180 of file dependencies_tv1.c.

{
    BOOL bRet = FALSE;
 
    /* Associate the imagelist with TV1 */
    pDependData->hDependsTreeView1 = GetDlgItem(pDependData->hDependsWnd, IDC_DEPEND_TREE1);
    if (!pDependData->hDependsTreeView1)
    {
        ImageList_Destroy(pDependData->hDependsImageList);
        pDependData->hDependsImageList = NULL;
        return FALSE;
    }
    (void)TreeView_SetImageList(pDependData->hDependsTreeView1,
                                pDependData->hDependsImageList,
                                TVSIL_NORMAL);
 
    /* Set the first items in the control */
    TV1_AddDependantsToTree(pDependData, NULL, lpServiceName);
 
    return bRet;
}

Referenced by InitDependPage().

TV2_AddDependantsToTree()

VOID TV2_AddDependantsToTree	(	PDEPENDDATA	pDependData,
		HTREEITEM	hParent,
		LPWSTR	lpServiceName
	)

Definition at line 121 of file dependencies_tv2.c.

{
 
    LPENUM_SERVICE_STATUSW lpServiceStatus;
    LPWSTR lpNoDepends;
    DWORD count, i;
    BOOL bHasChildren;
 
    /* Get a list of service dependents */
    lpServiceStatus = TV2_GetDependants(lpServiceName, &count);
    if (lpServiceStatus)
    {
        for (i = 0; i < count; i++)
        {
            /* Does this item need a +/- box? */
            bHasChildren = TV2_HasDependantServices(lpServiceStatus[i].lpServiceName);
 
            /* Add it */
            AddItemToTreeView(pDependData->hDependsTreeView2,
                              hParent,
                              lpServiceStatus[i].lpDisplayName,
                              lpServiceStatus[i].lpServiceName,
                              lpServiceStatus[i].ServiceStatus.dwServiceType,
                              bHasChildren);
        }
 
        HeapFree(GetProcessHeap(),
                 0,
                 lpServiceStatus);
    }
    else
    {
        /* If there is no parent, set the tree to 'no dependencies' */
        if (!hParent)
        {
            /* Load the 'No dependencies' string */
            AllocAndLoadString(&lpNoDepends, hInstance, IDS_NO_DEPENDS);
 
            AddItemToTreeView(pDependData->hDependsTreeView2,
                              NULL,
                              lpNoDepends,
                              NULL,
                              0,
                              FALSE);
 
            LocalFree(lpNoDepends);
 
            /* Disable the window */
            EnableWindow(pDependData->hDependsTreeView2, FALSE);
        }
    }
}

Referenced by DependenciesPageProc(), and TV2_Initialize().

TV2_GetDependants()

LPENUM_SERVICE_STATUS TV2_GetDependants	(	LPWSTR	lpServiceName,
		LPDWORD	lpdwCount
	)

Definition at line 55 of file dependencies_tv2.c.

{
    SC_HANDLE hSCManager;
    SC_HANDLE hService;
    LPENUM_SERVICE_STATUSW lpDependencies = NULL;
    DWORD dwBytesNeeded;
    DWORD dwCount;
 
    /* Set the first items in each tree view */
    hSCManager = OpenSCManagerW(NULL,
                                NULL,
                                SC_MANAGER_ALL_ACCESS);
    if (hSCManager)
    {
        hService = OpenServiceW(hSCManager,
                                lpServiceName,
                                SERVICE_QUERY_STATUS | SERVICE_ENUMERATE_DEPENDENTS | SERVICE_QUERY_CONFIG);
        if (hService)
        {
            /* Does this have any dependencies? */
            if (!EnumDependentServicesW(hService,
                                        SERVICE_STATE_ALL,
                                        NULL,
                                        0,
                                        &dwBytesNeeded,
                                        &dwCount) &&
                GetLastError() == ERROR_MORE_DATA)
            {
                lpDependencies = (LPENUM_SERVICE_STATUSW)HeapAlloc(GetProcessHeap(),
                                                                  0,
                                                                  dwBytesNeeded);
                if (lpDependencies)
                {
                    /* Get the list of dependents */
                    if (EnumDependentServicesW(hService,
                                               SERVICE_STATE_ALL,
                                               lpDependencies,
                                               dwBytesNeeded,
                                               &dwBytesNeeded,
                                               &dwCount))
                    {
                        /* Set the count */
                        *lpdwCount = dwCount;
                    }
                    else
                    {
                        HeapFree(ProcessHeap,
                                 0,
                                 lpDependencies);
 
                        lpDependencies = NULL;
                    }
                }
            }
 
            CloseServiceHandle(hService);
        }
 
        CloseServiceHandle(hSCManager);
    }
 
    return lpDependencies;
}

Referenced by BuildListOfServicesToStop(), and TV2_AddDependantsToTree().

TV2_HasDependantServices()

BOOL TV2_HasDependantServices

(

LPWSTR

lpServiceName

)

Definition at line 13 of file dependencies_tv2.c.

{
    HANDLE hSCManager;
    HANDLE hService;
    DWORD dwBytesNeeded, dwCount;
    BOOL bRet = FALSE;
 
    hSCManager = OpenSCManagerW(NULL,
                                NULL,
                                SC_MANAGER_ALL_ACCESS);
    if (hSCManager)
    {
        hService = OpenServiceW(hSCManager,
                                lpServiceName,
                                SERVICE_QUERY_STATUS | SERVICE_ENUMERATE_DEPENDENTS);
        if (hService)
        {
            /* Does this have any dependencies? */
            if (!EnumDependentServices(hService,
                                       SERVICE_STATE_ALL,
                                       NULL,
                                       0,
                                       &dwBytesNeeded,
                                       &dwCount))
            {
                 if (GetLastError() == ERROR_MORE_DATA)
                 {
                     /* It does, return TRUE */
                     bRet = TRUE;
                 }
            }
 
            CloseServiceHandle(hService);
        }
 
        CloseServiceHandle(hSCManager);
    }
 
    return bRet;
}

Referenced by TV2_AddDependantsToTree().

TV2_Initialize()

BOOL TV2_Initialize	(	PDEPENDDATA	pDependData,
		LPWSTR	lpServiceName
	)

Definition at line 177 of file dependencies_tv2.c.

{
    BOOL bRet = FALSE;
 
    /* Associate the imagelist with TV2 */
    pDependData->hDependsTreeView2 = GetDlgItem(pDependData->hDependsWnd, IDC_DEPEND_TREE2);
    if (!pDependData->hDependsTreeView2)
    {
        ImageList_Destroy(pDependData->hDependsImageList);
        pDependData->hDependsImageList = NULL;
        return FALSE;
    }
    (void)TreeView_SetImageList(pDependData->hDependsTreeView2,
                                pDependData->hDependsImageList,
                                TVSIL_NORMAL);
 
    /* Set the first items in the control */
    TV2_AddDependantsToTree(pDependData, NULL, lpServiceName);
 
    return bRet;
}

Referenced by InitDependPage().

UninitMainWindowImpl()

VOID UninitMainWindowImpl

(

VOID

)

Definition at line 990 of file mainwnd.c.

{
    UnregisterClass(szMainWndClass,
                    hInstance);
}

UpdateServiceCount()

VOID UpdateServiceCount

(

PMAIN_WND_INFO

Info

)

Definition at line 125 of file mainwnd.c.

{
    LPWSTR lpNumServices;
 
    if (AllocAndLoadString(&lpNumServices,
                           hInstance,
                           IDS_NUM_SERVICES))
    {
        WCHAR szNumServices[32];
 
        INT NumListedServ = ListView_GetItemCount(Info->hListView);
 
        _snwprintf(szNumServices,
                   31,
                   lpNumServices,
                   NumListedServ);
 
        SendMessage(Info->hStatus,
                    SB_SETTEXT,
                    0,
                    (LPARAM)szNumServices);
 
        LocalFree(lpNumServices);
    }
}

Referenced by DeleteDialogProc(), and RefreshServiceList().

UpdateServiceStatus()

BOOL UpdateServiceStatus

(

ENUM_SERVICE_STATUS_PROCESS *

pService

)

Definition at line 373 of file query.c.

{
    SC_HANDLE hScm;
    BOOL bRet = FALSE;
 
    hScm = OpenSCManagerW(NULL,
                          NULL,
                          SC_MANAGER_ENUMERATE_SERVICE);
    if (hScm != NULL)
    {
        SC_HANDLE hService;
 
        hService = OpenServiceW(hScm,
                                pService->lpServiceName,
                                SERVICE_QUERY_STATUS);
        if (hService)
        {
            DWORD size;
 
            QueryServiceStatusEx(hService,
                                 SC_STATUS_PROCESS_INFO,
                                 (LPBYTE)&pService->ServiceStatusProcess,
                                 sizeof(SERVICE_STATUS_PROCESS),
                                 &size);
 
            CloseServiceHandle(hService);
            bRet = TRUE;
        }
 
        CloseServiceHandle(hScm);
    }
 
    return bRet;
}

Referenced by GeneralPageProc(), and MainWndCommand().

Variable Documentation

hInstance

HINSTANCE hInstance

extern

Definition at line 19 of file charmap.c.

ProcessHeap

HANDLE ProcessHeap

extern

Definition at line 15 of file servman.c.

Referenced by add_entry(), AddBootStoreEntry(), AddDiskToList(), AddNTOSInstallation(), AddPartitionToDisk(), AddProvider(), AppendGenericListEntry(), calloc(), ChangeListViewText(), CloseIniBootLoaderStore(), CommandDumpSector(), CommandPartInfo(), ConsoleCreateFileHandler(), CreateDialogProc(), CreateEditWindow(), CreateFileSystemList(), CreateGenericList(), CreateInsertBlankRegion(), CreateMainWindow(), CreatePartitionList(), CreateProgressBarEx(), DefaultProcessEntry(), DeleteDialogProc(), DeletePartition(), DestroyFileSystemList(), DestroyGenericList(), DestroyPartitionList(), DestroyProgressBar(), DestroyRegion(), DeviceInstallThread(), DismountPartition(), do_reg_operation(), EnumerateBiosDiskEntries(), free(), FreeBootCode(), FreeLdrEnumerateBootEntries(), FreeMemory(), freep(), FreeServiceList(), GetServiceDescription(), GetServiceList(), GetStringFromDialog(), INF_FreeData(), INF_GetDataField(), IniCacheAddKeyAorW(), IniCacheAddSectionAorW(), IniCacheCreate(), IniCacheDestroy(), IniCacheFreeKey(), IniCacheFreeSection(), IniCacheLoadByHandle(), IniCacheSaveByHandle(), IniFindClose(), IniFindFirstValue(), InitDialog(), InitGeneralPage(), InitVolume(), InstallDevice(), MainWndProc(), malloc(), MSZipAlloc(), MSZipFree(), NtLdrEnumerateBootEntries(), OpenIniBootLoaderStore(), OpenPropSheet(), PnpEventThread(), ProcessLangEntry(), ReadBootCodeByHandle(), ReAllocateLayoutBuffer(), RtlDestroyHeap(), RtlpFreeDebugInfo(), SaveDlgInfo(), SetConsoleOutputCP(), SetStartupType(), SetupCloseFileQueue(), SetupDeleteQueueEntry(), SetupOpenFileQueue(), SetupQueueCopyWithCab(), SetupQueueDeleteW(), SetupQueueRenameW(), split(), SystemConfigurationDataQueryRoutine(), TV1_GetDependants(), TV2_GetDependants(), WriteConsoleOutputCharacterA(), and WriteConsoleOutputCharacterW().