[转]遍历windows服务

原文:http://www.codeproject.com/Articles/1573/About-Windows-Services

#include <windows.h>
#include <stdio.h>
#include "resource.h"
#include "services.h"

#define BUFF_LEN    256

TCHAR g_szSelectedComputer[BUFF_LEN];
int g_iLen = BUFF_LEN;
QUERY_SERVICE_CONFIG* g_psc = NULL;

// main program
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine,
                   int nCmdShow) {

    DialogBox(hInstance, MAKEINTRESOURCE(IDD_DIALOG), NULL, DialogProc);
    return 0;
}

// Dialog procedure
BOOL CALLBACK DialogProc(HWND p_hWnd, UINT p_uMsg, WPARAM p_wParam, LPARAM p_lParam) {

    HICON hIcon = NULL;
    static HWND hWndList = NULL;
    int iWidth = 120;

    switch (p_uMsg) {

    case WM_INITDIALOG:
        // Load Icon
        hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_MAIN));
        SendMessage(p_hWnd, WM_SETICON, TRUE, (LPARAM)hIcon);

        // initilize common control
        InitCommonControls();

        hWndList = GetDlgItem(p_hWnd, IDC_LIST_SERVICES);

        InsertColumn(hWndList, DISPLAY_NAME_COL, TEXT("Display Name"), iWidth);
        InsertColumn(hWndList, SERVICE_NAME_COL, TEXT("Service Name"), iWidth);
        InsertColumn(hWndList, TYPE_COL, TEXT("Type"), iWidth);
        InsertColumn(hWndList, STATE_COL, TEXT("Current State"), iWidth);
        InsertColumn(hWndList, CONTROL_COL, TEXT("Controls Accepted"), iWidth);

        // Set extended style of List control full row select
        SendMessage(hWndList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, (LPARAM) LVS_EX_FULLROWSELECT);
        break;

    case WM_COMMAND:
        switch(LOWORD(p_wParam)) {
        
        // Exit from the program
        case IDC_BTN_EXIT:
            PostQuitMessage(0);
            break;

        case IDC_BTN_UPDATE:
            GetWindowServices(hWndList);
            break;

        case IDC_BTN_COMPUTER:
             if (DialogBox(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_DIALOG_COMPUTER), NULL, DialogProcComputer)
                 == IDOK) {
             
                SetWindowText(GetDlgItem(p_hWnd, IDC_STATICCOMPUTER), g_szSelectedComputer);
             }
            break;
        }

        case WM_NOTIFY:
            switch (p_wParam) {

            case IDC_LIST_SERVICES:
                if (((NMHDR*)p_lParam)->code == NM_DBLCLK) {

                    TCHAR szService[BUFF_LEN];
                    int iPos = SendMessage(hWndList, LVM_GETNEXTITEM, 
                        -1, LVIS_SELECTED);
                    LVITEM lvItem;
                    ZeroMemory(&lvItem, sizeof(LVITEM));

                    // get the text of second column
                    lvItem.iSubItem = 1;
                    lvItem.pszText = szService;
                    lvItem.cchTextMax = g_iLen;
                    SendMessage(hWndList, LVM_GETITEMTEXT, (WPARAM)iPos, (LPARAM)&lvItem);

                    SC_HANDLE hSCM = OpenSCManager(g_szSelectedComputer, NULL, SC_MANAGER_ALL_ACCESS);
                    SC_HANDLE hService = OpenService(hSCM, szService, SERVICE_ALL_ACCESS);

                    QUERY_SERVICE_CONFIG sc;
                    DWORD dwBytesNeeded = 0;

                    // Try to get information about the query
                    BOOL bRetVal = QueryServiceConfig(hService, &sc, sizeof(QUERY_SERVICE_CONFIG),
                        &dwBytesNeeded);

                    if (!bRetVal) {
                        DWORD retVal = GetLastError();

                        // buffer size is small. 
                        // Required size is in dwBytesNeeded
                        if (ERROR_INSUFFICIENT_BUFFER == retVal) {

                            DWORD dwBytes = sizeof(QUERY_SERVICE_CONFIG) + dwBytesNeeded;
                            g_psc = new QUERY_SERVICE_CONFIG[dwBytesNeeded];

                            bRetVal = QueryServiceConfig(hService, g_psc, dwBytes, &dwBytesNeeded);

                            if (!bRetVal) {

                                ErrorDescription(GetLastError());

                                delete [] g_psc;
                                g_psc = NULL;
                                break;
                            }
                
                            DialogBox(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_DIALOG_SERVICE), NULL, DialogProcService);

                            delete [] g_psc;
                            g_psc = NULL;
                        }
                    }

                    CloseServiceHandle(hService);
                    CloseServiceHandle(hSCM);
                }
            }
            break;
    }

    return FALSE;
}

// insert column in the list control
int InsertColumn(HWND p_hWnd, int p_iCol, LPCTSTR p_lpszHeading, int p_iWidth) {

    LVCOLUMN column;

    column.mask = LVCF_TEXT | LVCF_FMT | LVCF_WIDTH;
    column.fmt = LVCFMT_LEFT;
    column.cx = p_iWidth;
    column.pszText = (LPTSTR)p_lpszHeading;
    column.iSubItem = -1;
    column.iImage = -1;
    column.iOrder = 0;
    
    return (int) SendMessage(p_hWnd, LVM_INSERTCOLUMN, p_iCol, (LPARAM)&column);
}

// insert rows in the list control
int InsertItem(HWND p_hWnd, int p_iRow, LPCTSTR p_lpszText) {

    LVITEM lvItem;

    lvItem.mask = LVIF_TEXT;
    lvItem.iItem = p_iRow;
    lvItem.iSubItem = 0;
    lvItem.state = 0;
    lvItem.stateMask = 0;
    lvItem.pszText = (LPTSTR)p_lpszText;    
    lvItem.iImage = 0;
    lvItem.lParam = 0;
    lvItem.iIndent = 0;

    return (int) SendMessage(p_hWnd, LVM_INSERTITEM, 0, (LPARAM)&lvItem);
}

// insert the item in the other columns of the list control
int InsertSubItem(HWND p_hWnd, int p_iRow, LPCTSTR p_lpszText, int p_iSubItem) {

    LVITEM lvItem;

    lvItem.iSubItem = p_iSubItem;
    lvItem.pszText = (LPTSTR)p_lpszText;

    return (int) SendMessage(p_hWnd, LVM_SETITEMTEXT, p_iRow, (LPARAM)&lvItem);
}

// get all the services of the window
BOOL GetWindowServices(HWND p_hWnd) {

    // first delete all item
    SendMessage(p_hWnd, LVM_DELETEALLITEMS, 0, 0);

    // open service manager
    SC_HANDLE hHandle = OpenSCManager(g_szSelectedComputer, NULL, SC_MANAGER_ENUMERATE_SERVICE);

    if (!hHandle) {
    
        ErrorDescription(GetLastError());
        return FALSE;
    }

    ENUM_SERVICE_STATUS service;

    DWORD dwBytesNeeded = 0;
    DWORD dwServicesReturned = 0;
    DWORD dwResumedHandle = 0;

    // Query services
    BOOL retVal = EnumServicesStatus(hHandle, SERVICE_WIN32 | SERVICE_DRIVER, SERVICE_STATE_ALL, 
        &service, sizeof(ENUM_SERVICE_STATUS), &dwBytesNeeded, &dwServicesReturned,
        &dwResumedHandle);

    if (!retVal) {
    
        // Need big buffer
        if (ERROR_MORE_DATA == GetLastError()) {
        
            // Set the buffer
            DWORD dwBytes = sizeof(ENUM_SERVICE_STATUS) + dwBytesNeeded;
            ENUM_SERVICE_STATUS* pServices = NULL;
            pServices = new ENUM_SERVICE_STATUS [dwBytes];

            // Now query again for services
            EnumServicesStatus(hHandle, SERVICE_WIN32 | SERVICE_DRIVER, SERVICE_STATE_ALL, 
                pServices, dwBytes, &dwBytesNeeded, &dwServicesReturned, &dwResumedHandle);

            // now traverse each service to get information
            for (unsigned iIndex = 0; iIndex < dwServicesReturned; iIndex++) {
            
                InsertItem(p_hWnd, iIndex, (pServices + iIndex)->lpDisplayName);
                InsertSubItem(p_hWnd, iIndex, (pServices + iIndex)->lpServiceName, SERVICE_NAME_COL);

                // get type of the service
                GetTypeOfService(p_hWnd, (pServices + iIndex)->ServiceStatus.dwServiceType, iIndex);

                // get current status of the services
                GetCurrentStatus(p_hWnd, (pServices + iIndex)->ServiceStatus.dwCurrentState, iIndex);

                // check the control code which service can accept
                GetControlCode(p_hWnd, (pServices + iIndex)->ServiceStatus.dwControlsAccepted, iIndex);
            }

            delete [] pServices;
            pServices = NULL;
        }
        else
            return FALSE;
    }

    CloseServiceHandle(hHandle);

    return TRUE;
}
    
// get type of the service
void GetTypeOfService(HWND p_hWnd, DWORD p_dwType, int p_iIndex) {

    switch (p_dwType) {
    
    case SERVICE_WIN32_OWN_PROCESS:
        InsertSubItem(p_hWnd, p_iIndex, TEXT("Run its own process"), TYPE_COL);
        break;

    case SERVICE_WIN32_SHARE_PROCESS:
        InsertSubItem(p_hWnd, p_iIndex, TEXT("Share a process with other application"), TYPE_COL);
        break;

    case SERVICE_KERNEL_DRIVER:
        InsertSubItem(p_hWnd, p_iIndex, TEXT("Device driver"), TYPE_COL);
        break;

    case SERVICE_FILE_SYSTEM_DRIVER:
        InsertSubItem(p_hWnd, p_iIndex, TEXT("File system driver"), TYPE_COL);
        break;

    case SERVICE_INTERACTIVE_PROCESS:
        InsertSubItem(p_hWnd, p_iIndex, TEXT("Service can interactive with desktop"), TYPE_COL);
        break;
    }
}

// get current status of the services
void GetCurrentStatus(HWND p_hWnd, DWORD p_dwType, int p_iIndex) {

    switch (p_dwType) {
    
    case SERVICE_STOPPED:
        InsertSubItem(p_hWnd, p_iIndex, TEXT("Not running"), STATE_COL);
        break;

    case SERVICE_START_PENDING:
        InsertSubItem(p_hWnd, p_iIndex, TEXT("Starting"), STATE_COL);
        break;

    case SERVICE_STOP_PENDING:
        InsertSubItem(p_hWnd, p_iIndex, TEXT("Stopping"), STATE_COL);
        break;

    case SERVICE_RUNNING:
        InsertSubItem(p_hWnd, p_iIndex, TEXT("Running"), STATE_COL);
        break;

    case SERVICE_CONTINUE_PENDING:
        InsertSubItem(p_hWnd, p_iIndex, TEXT("Continue is pending"), STATE_COL);
        break;

    case SERVICE_PAUSE_PENDING:
        InsertSubItem(p_hWnd, p_iIndex, TEXT("Pause is pending"), STATE_COL);
        break;

    case SERVICE_PAUSED:
        InsertSubItem(p_hWnd, p_iIndex, TEXT("Paused"), STATE_COL);
        break;
    }
}

// check the control code which service can accept
void GetControlCode(HWND p_hWnd, DWORD p_dwType, int p_iIndex) {

    switch (p_dwType) {
    
    case SERVICE_ACCEPT_STOP:
        InsertSubItem(p_hWnd, p_iIndex, TEXT("Can Stop"), CONTROL_COL);
        break;

    case SERVICE_ACCEPT_PAUSE_CONTINUE:
        InsertSubItem(p_hWnd, p_iIndex, TEXT("Can Pause and continue"), CONTROL_COL);
        break;

    case SERVICE_ACCEPT_SHUTDOWN:
        InsertSubItem(p_hWnd, p_iIndex, TEXT("Notified when shutdown"), CONTROL_COL);
        break;

    // win 2000 and above
    case SERVICE_ACCEPT_PARAMCHANGE:
        InsertSubItem(p_hWnd, p_iIndex, TEXT("Reread startup paramater"), CONTROL_COL);
        break;

    // win 2000 and above
    case SERVICE_ACCEPT_NETBINDCHANGE:
        InsertSubItem(p_hWnd, p_iIndex, TEXT("Can change network binding"), CONTROL_COL);
        break;
    }
}

// dialog procedure for computer dialog
BOOL CALLBACK DialogProcComputer(HWND p_hWnd, UINT p_uMsg, WPARAM p_wParam, LPARAM p_lParam) {

    HICON hIcon = NULL;
    static HWND hWndList = NULL;
    int iWidth = 85;
    int iPos = 0;

    switch (p_uMsg) {
    
    case WM_INITDIALOG:
        // Load Icon
        hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_MAIN));
        SendMessage(p_hWnd, WM_SETICON, TRUE, (LPARAM)hIcon);

        hWndList = GetDlgItem(p_hWnd, IDC_LIST_COMPUTER);

        InsertColumn(hWndList, PLATEFORM_COLUMN, TEXT("Plateform"), iWidth);
        InsertColumn(hWndList, NAME_COLUMN, TEXT("Name"), iWidth);
        InsertColumn(hWndList, VERSION_COLUMN, TEXT("Version"), iWidth);
        InsertColumn(hWndList, TYPE_COLUMN, TEXT("Type"), iWidth);
        InsertColumn(hWndList, COMMENT_COLUMN, TEXT("Comment"), iWidth);

        // Set extended style of List control full row select
        SendMessage(hWndList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, (LPARAM) LVS_EX_FULLROWSELECT);
        GetComputerInfo(hWndList);

        break;

    case WM_COMMAND:
        switch(LOWORD(p_wParam)) {
        
        case IDOK:
            iPos = SendMessage(hWndList, LVM_GETNEXTITEM, -1, LVIS_SELECTED);
            LVITEM lvItem;
            ZeroMemory(&lvItem, sizeof(LVITEM));

            // get the text of second column
            lvItem.iSubItem = 1;
            lvItem.pszText = g_szSelectedComputer;
            lvItem.cchTextMax = g_iLen;
            SendMessage(hWndList, LVM_GETITEMTEXT, (WPARAM)iPos, (LPARAM)&lvItem);

            EndDialog(p_hWnd, IDOK);
            break;

        case IDCANCEL:
            strcpy(g_szSelectedComputer, TEXT(""));
            EndDialog(p_hWnd, IDCANCEL);
            break;
        }

    case WM_NOTIFY:
        switch (p_wParam) {
        
        case IDC_LIST_COMPUTER:
            if (((NMHDR*)p_lParam)->code == NM_DBLCLK) {

                SendMessage(p_hWnd, WM_COMMAND, IDOK, NULL);
            }
            break;
        }

        break;
    }

    return FALSE;
}

// get the information about the computer
void GetComputerInfo(HWND p_hWnd) {

    NET_API_STATUS nStatus;
    LPSERVER_INFO_101 pBuff = NULL;
    DWORD dwEntriesRead = NULL;
    DWORD dwTotalEntries = NULL;
    DWORD dwResumeHandle = NULL;
    TCHAR buff[BUFF_LEN];
    DWORD dwPrefMaxLen = -1;

    // get information
    nStatus = NetServerEnum(NULL, 101, (LPBYTE*)&pBuff, MAX_PREFERRED_LENGTH, 
        &dwEntriesRead,    &dwTotalEntries, SV_TYPE_SERVER, NULL, &dwResumeHandle);

    if ((NERR_Success == nStatus) || (ERROR_MORE_DATA == nStatus)) {
    
        // first delete all item
        SendMessage(p_hWnd, LVM_DELETEALLITEMS, 0, 0);

        for (unsigned int iIndex = 0; iIndex < dwEntriesRead; iIndex++) {
        
            if ((pBuff+iIndex)->sv101_platform_id == PLATFORM_ID_DOS) {

                sprintf(buff, TEXT("%s"), TEXT("DOS"));
            }
            else if ((pBuff+iIndex)->sv101_platform_id == PLATFORM_ID_OS2) {

                sprintf(buff, TEXT("%s"), TEXT("OS/2 or Win9x"));
            }
            else if ((pBuff+iIndex)->sv101_platform_id == PLATFORM_ID_NT) {

                sprintf(buff, TEXT("%s"), TEXT("Win NT/2000"));
            }
            else if ((pBuff+iIndex)->sv101_platform_id == PLATFORM_ID_VMS) {

                sprintf(buff, TEXT("%s"), TEXT("VMS"));
            }

            InsertItem(p_hWnd, iIndex, buff);

            // Name
            // convert UNICODE to ANSI
            sprintf(buff, TEXT("%S"), (pBuff+iIndex)->sv101_name);
            InsertSubItem(p_hWnd, iIndex, buff, NAME_COLUMN);

            // version
            sprintf(buff, TEXT("%d.%d"), (pBuff+iIndex)->sv101_version_major, 
                (pBuff+iIndex)->sv101_version_minor);
            InsertSubItem(p_hWnd, iIndex, buff, VERSION_COLUMN);

            // type
            if ((pBuff+iIndex)->sv101_type & SV_TYPE_DOMAIN_CTRL) {
            
                sprintf(buff, TEXT("%s"), TEXT("PDC"));
            }
            else if ((pBuff+iIndex)->sv101_type & SV_TYPE_DOMAIN_BAKCTRL) {
            
                sprintf(buff, TEXT("%s"), TEXT("BDC"));
            }
            else if ((pBuff+iIndex)->sv101_type & SV_TYPE_WORKSTATION){ 
            
                sprintf(buff, TEXT("%s"), TEXT("WorkStation"));
            }

            InsertSubItem(p_hWnd, iIndex, buff, TYPE_COLUMN);

            // comment
            // convert UNICODE to ANSI
            sprintf(buff, TEXT("%S"), (pBuff+iIndex)->sv101_comment);
            InsertSubItem(p_hWnd, iIndex, buff, COMMENT_COLUMN);
        }
    }
    else {
    
        ErrorDescription(GetLastError());
    }

    if (pBuff != NULL) {
    
        NetApiBufferFree(pBuff);
    }
}

// get the description of the error
void ErrorDescription(DWORD p_dwError) {

    HLOCAL hLocal = NULL;

    FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER,
        NULL, p_dwError, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),(LPTSTR)&hLocal, 
        0, NULL);

    MessageBox(NULL, (LPCTSTR)LocalLock(hLocal), TEXT("Error"), MB_OK | MB_ICONERROR);
    LocalFree(hLocal);
}

// call back function for service dialog
BOOL CALLBACK DialogProcService(HWND p_hWnd, UINT p_uMsg, WPARAM p_wParam, LPARAM p_lParam) {

    HWND hWndEdit = NULL;
    HICON hIcon = NULL;
    TCHAR szBuff[BUFF_LEN];

    switch(p_uMsg) {
    
    case WM_INITDIALOG:
        // Load Icon
        hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_MAIN));
        SendMessage(p_hWnd, WM_SETICON, TRUE, (LPARAM)hIcon);

        // display information
        SetDlgItemText(p_hWnd, IDC_EDIT_PATH_NAME, g_psc->lpBinaryPathName);
        SetDlgItemText(p_hWnd, IDC_EDIT_DEPENDENCIES, g_psc->lpDependencies);
        SetDlgItemText(p_hWnd, IDC_EDIT_START_NAME, g_psc->lpServiceStartName);
        SetDlgItemText(p_hWnd, IDC_EDIT_DISPLAY_NAME, g_psc->lpDisplayName);
        SetDlgItemText(p_hWnd, IDC_EDIT_ORDER_GROUP, g_psc->lpLoadOrderGroup);

        SetServiceType(p_hWnd, g_psc->dwServiceType);
        SetStartType(p_hWnd, g_psc->dwStartType);
        SetErrorControl(p_hWnd, g_psc->dwErrorControl);

        sprintf(szBuff, TEXT("%d"), g_psc->dwTagId);
        SetDlgItemText(p_hWnd, IDC_EDIT_TAG_ID, szBuff);
        break;

    case WM_COMMAND:
        switch(LOWORD(p_wParam)) {
        
        case IDOK:
            EndDialog(p_hWnd, IDOK);
            break;
        }
    }

    return FALSE;
}

// display the service type
void SetServiceType(HWND p_hWnd, DWORD p_dwType) {

    TCHAR szBuff[BUFF_LEN];

    // service type
    switch(p_dwType) {

    case SERVICE_WIN32_OWN_PROCESS:
        sprintf(szBuff, TEXT("%s"), TEXT("Runs in its own process"));
        break;

    case SERVICE_WIN32_SHARE_PROCESS:
        sprintf(szBuff, TEXT("%s"), TEXT("Service shares a process with other services"));
        break;

    case SERVICE_KERNEL_DRIVER:
        sprintf(szBuff, TEXT("%s"), TEXT("Service is device driver"));
        break;

    case SERVICE_FILE_SYSTEM_DRIVER:
        sprintf(szBuff, TEXT("%s"), TEXT("Service is file system driver"));
        break;

    case SERVICE_INTERACTIVE_PROCESS:
        sprintf(szBuff, TEXT("%s"), TEXT("Service can interact with desktop"));
        break;
    }

    SetDlgItemText(p_hWnd, IDC_EDIT_SERVICE_TYPE, szBuff);
}

// dispalay the start type
void SetStartType(HWND p_hWnd, DWORD p_dwType) {

    TCHAR szBuff[BUFF_LEN];

    // service type
    switch(p_dwType) {
    
    case SERVICE_BOOT_START:
        sprintf(szBuff, TEXT("%s"), TEXT("Start by System Loader"));
        break;

    case SERVICE_SYSTEM_START:
        sprintf(szBuff, TEXT("%s"), TEXT("Started by IoInitSystem function"));
        break;

    case SERVICE_AUTO_START:
        sprintf(szBuff, TEXT("%s"), TEXT("Started by Service Control Manager"));
        break;

    case SERVICE_DEMAND_START:
        sprintf(szBuff, TEXT("%s"), TEXT("Start by StartService function"));
        break;

    case SERVICE_DISABLED:
        sprintf(szBuff, TEXT("%s"), TEXT("No Longer be started"));
        break;
    }

    SetDlgItemText(p_hWnd, IDC_EDIT_START_TYPE, szBuff);
}

// set error control
void SetErrorControl(HWND p_hWnd, DWORD p_dwErrro) {

    TCHAR szBuff[BUFF_LEN];

    // service type
    switch(p_dwErrro) {
    
    case SERVICE_ERROR_IGNORE:
        sprintf(szBuff, TEXT("%s"), TEXT("Logs error but continue operation"));
        break;

    case SERVICE_ERROR_NORMAL:
        sprintf(szBuff, TEXT("%s"), TEXT("Logs error and display message box"));
        break;

    case SERVICE_ERROR_SEVERE:
        sprintf(szBuff, TEXT("%s"), TEXT("Logs error and restarted with Last Known Good Configuration"));
        break;

    case SERVICE_ERROR_CRITICAL:
        sprintf(szBuff, TEXT("%s"), TEXT("Log error if possible"));
        break;
    }

    SetDlgItemText(p_hWnd, IDC_EDIT_ERROR_CONTROL, szBuff);
}