Разработка службы Windows "Контроль приложений"

Тип работы:
Курсовая
Предмет:
Программирование


Узнать стоимость

Детальная информация о работе

Выдержка из работы

Техническое задание

Разработка службы Windows: «Контроль приложений», осуществляющей контроль набора выполняющихся приложений и, возможно, управление ими. Кроме разработки службы, необходимо разработать приложение, которое будет осуществлять управление этой службой.

Введение

В данном курсовом проекте необходимо реализовать приложение «Служба Windows». Служба — это простое приложение, содержащее инфраструктуру для взаимодействия с SCM, который посылает службе команды запуска, останова, паузы, продолжения или выключения. Служба также вызывает специальные функции, передающие SCM сведения о её состоянии.

SCM (ServiceControlManager) — диспетчер управления службами, обеспечивает унифицированный и безопасный метод управления приложениями-службами, отвечает за взаимодействие с различными службами, указывая им, когда запуститься, остановиться, временно прервать и продолжить работу и т. д.

Службы OCWindows — приложения, автоматически (если настроено) запускаемые системой при запуске Windows и выполняющиеся вне зависимости от статуса пользователя.

В качестве среды разработки используем C++ BuilderXE2, т.к. данное программное обеспечение позволяет организовать удобный интерфейс разрабатываемого приложения. C++ Builder-- программный продукт, инструмент быстрой разработки приложений (RAD), интегрированная среда программирования (IDE), система, используемая программистами для разработки программного обеспечения на языке программирования C++.

Анализ

Согласно техническому заданию необходимо реализовать службу, осуществляющую контроль приложений, и приложение для управления данной службой. Под контролем приложений в данном случае подразумевается запуск и завершение определенных процессов, заданных пользователем перед началом работы службы. Процесс — основной динамический объект, над которым операционная система выполняет определенные действия.

От обычного приложения Win32 службу отличают три основных свойства.

1) Возможность корректного останова работы службы. Пользователь или другое приложение, использующие стандартные механизмы, имеют возможность изменить состояние службы — перевести её из состояния выполнения в состояние паузы или даже остановить её работу. При этом служба перед изменение своего состояния получает специальное уведомление, благодаря которому может совершить необходимые для перехода в новое состояние действия, например, освободить занятые ресурсы.

2) Возможность запуска службы до регистрации пользователя и, как следствие, возможность работы вообще без зарегистрированного пользователя. Любая служба может быть запущена автоматически при старте операционной системы и начать работы еще до того как пользователь произведет вход в систему.

3) Возможность работы в произвольном контексте безопасности.

Реализация службы возможна в двух вариантах:

1. С использованием WinAPI.

2. С использование встроенного класса VCLTService

Использование класса VCL значительно упрощает работу с сервисом, поэтому в данной работе будем использовать именно этот способ.

Одним из важнейших свойств службы является не интерактивность. Типичное «поведение» службы — это незаметная для обычного пользователя работа в фоновом режиме, поэтому они не могут иметь пользовательского интерфейса, т.к. почти всегда с этим интерфейсом некому работать. Службы начинают свою работу еще до того, как пользователь вошел в систему. Более того, на серверных машинах пользователь может вообще не входить в систему за всё время работы.

Кроме самой службы, необходимо реализовать приложение для управления ею. Под управлением службой подразумевается установка, удаление, запуск и остановка службы. Для упрощения взаимодействия пользователя со службой создадим графическое приложение. Также необходимо предусмотреть ввод временного интервала, через который служба произведет повторную проверку процессов. Для передачи параметров из приложения управления службой в саму службу воспользуемся реестром Windows. Кроме того, для удобства пользователя создадим поэтапную инструкцию по установке и эксплуатации.

Проектирование

Проектирование — разработка внутренней структуры программного продукта (ПП), структур данных и алгоритмов. Основной целью этого этапа является получение проектных решений, на основе которых может быть осуществлена реализация программного продукта.

Определим основной функционал разрабатываемой службы:

1. Создадим два текстовых файла — один для чтения создаваемых процессов, другой — для чтения завершаемых.

2. При запуске службы будет производиться чтение имен процессов из текстовых файлов.

3. Служба получит список запущенных процессов в данный момент времени

4. Сверяет список запущенных процессов с процессом из текстового файла

5. Если создаваемый процесс не был запущен ранее, произойдет запуск данного процесса. В противном случае, запуск процесса не произойдет, и служба будет ожидать повторной проверки. Аналогично для завершаемых процессов, если завершаемый процесс запущен на момент проверки службой, произойдет завершение данного процесса. Иначе, служба перейдет в режим ожидания.

Существует два способа реализации работы службы:

1. Стартует служба, вы начинаете что-то делать, время от времени уведомляя систему о своём состоянии, потом служба останавливается.

2. Стартует служба, создаёт рабочие потоки. По уведомлению от системы потоки останавливаются и служба выключается.

Обычно в службах используется второй вариант, поэтому используем именно этот вариант.

Далее, рассмотрим приложение для управления службой.

Приложение необходимо для установки, удаления, запуска и остановки службы. Так же реализуем окно ввода временного интервала, через который будет происходить повторная проверка списка процессов разрабатываемой службой.

Служба или сервис Windows -- это обычное приложение Windows, но написанное по определённым правилам. Такие приложения содержат дополнительный код, позволяющий стандартному менеджеру служб Windows (SCM -- ServiceControlManager) единообразно управлять процессами служб. SCM располагается в файле services. exe, запускается при старте системы и останавливается только при завершении работы ОС.

Разработка приложения будет осуществляться в среде разработки C++ BuilderXE2. Распишем основные пункты разрабатываемого приложения:

· Установка службы

· Удаление службы

· Запуск службы

· Остановка службы

· Ввод временного интервала

· Справка

· Выход

Данные пункты будут реализованы на основной форме приложения управления службой.

Кодирование и отладка

Разработка службы Windows

Целью данного этапа является программная реализация проектных решений, полученных на этапе проектирования, т. е. создание работоспособного программного продукта

При создании службы были автоматически сгенерированы два метода:

TServiceController __fastcall TService1: :GetServiceController (void)

{

return (TServiceController) ServiceController;

}

void __stdcallServiceController (unsigned CtrlCode)

{

Service1-> Controller (CtrlCode);

}

Листинг программы приведен в приложениях, А и Б.

Эти два метода мы трогать не будет, т. к. за ними скрывается процесс взаимодействия с SCM.

Используя встроенный в C++ BuilderXE2 класс TThread, создадим дополнительный поток. Главным методов объекта TThread является метод Execute (). Именно в теле данного метода должен содержаться программный код, представляющий собой программу потока.

Win32 предоставляет несколько способов перечисления запущенных процессов:

· Спомощьюбиблиотеки Process Status Helper (PSAPI)

· с помощью ToolHelp32 API

· с помощью недокументированной функции ZwQuerySystemInformation

· Через счетчики производительности

· Сиспользованиеминтерфейсов Windows Management Instrumentation

Используем набор функций под название ToolHelp32 API.

Используя ToolHelp32 API, мы сначала создаем моментальный снимок (snapshot) списка процессов с помощью функции CreateToolhelp32Snapshot, а затем проходим по списку используя функции Process32First и Process32Next. Структура PROCESSENTRY32, заполняемая этими функциями, содержит всю необходимую информацию.

Перед вызовом функций Process32First и Process32Next мы должны инициализировать поле dwSize структуры PROCESSENTRY32 таким образом, чтобы оно содержало размер структуры. Функции в свою очередь заносят в это поле количество байтов, записанных в структуру. Мы сравниваем это значение со смещением поля szExeFile в структуре, чтобы определить, было ли заполнено имя процесса.

Для создания процессов используем функцию CreateProcess. Для завершения процессов создадим дополнительную функцию KillProcess.

voidKillProcess (int id) {

HANDLE ps = OpenProcess (1, false, id);

if (ps)

TerminateProcess (ps, -9);

}

Используя функцию fgetws, построчно считаем имена процессов из текстовых файлов.Т.к. имена процессов в текстовом файле записываются построчно, то во всех строках, кроме последней, будет присутствовать символ переноса строки. Из-за этого символа запуск процесса посредством функции CreateProcess () невозможен. Для устранения данного факта заменим во всех строках данный символ на символ пустоты.

Параметром данной функции является идентификатор процесса (PID), получаемый при создании снимка списка процессов. Для организации временной задержки используем конструкцию:

while (1)

{

Sleep ();

}

Разработка приложения для управления службой

Для создания сервиса используется функция CreateService (), которая возвращает дескриптор созданного сервиса или NULL в случае неудачного выполнения. Одним из параметров функции является путь к сервису, который должен соответствовать расположению сервиса в Вашем компьютере. В качестве типа сервиса мы указали SERVICE_WIN32_OWN_PROCESS. Это означает, что сервис будет выполняться как отдельный процесс. При успешном завершении функция CreateService () добавляет сервис в базу данных SCM.

Так же при создании службы в реестр передается два параметра: временной интервал и единицы измерения времени.

SCM хранит базу данных служб в ключе реестра

HKEY_LOCAL_MACHINESYSTEMCurrentControlSetServices

Удобно все параметры службы хранить в ключе

HKEY_LOCAL_MACHINESYSTEMCurrentControlSetServicesИмя-Службы (свойство Name) Parameters

Служба может считывать свои параметры оттуда при запуске, а приложение-конфигуратор -- писать в этот ключ настройки.

Для передачи данных используются две функции:

1. RegCreateKeyEx- создает новый ключ реестра или, если он существует, открывает его.

2. RegSetValueEx — запись данных в созданный ключ.

Удаление сервиса

В этом случае, открывая сервис, мы используем комбинацию флагов SERVICE_STOP и DELETE, поскольку если сервис в данный момент работает, то прежде чем его удалять из системы, его необходимо остановить. Для удаления сервиса из системы используется функция DeleteService ().

Запуск сервиса

Для открытия сервиса мы используем функцию OpenService (). Третьим параметром этой функции является тип доступа к сервису. Указывая тип доступа SERVICE_START, мы получаем возможность запускать сервис. Запуск сервиса осуществляется с помощью функции StartService (), которая возвращает нулевое значение, если запустить сервис не удалось.

Остановка сервиса

Здесь мы открываем сервис, используя уровень доступа SERVICE_STOP.

Для остановки сервиса используется функция ControlService (). Эта функция посылает сервису управляющий код, который она получает в качестве второго параметра. В нашем случае управляющий код равен константе SERVICE_CONTROL_STOP. Третьим параметром функции является адрес структуры типа SERVICE_STATUS, в которой содержится информация о текущем статусе сервиса. Содержимое этой структуры использует SCM. Если сервис остановить не удалось функция ControlService () возвращает нулевое значение.

Тестирование

Тестирование — выявление дефектов посредством испытания ПП на соответствие техническому заданию и их устранение.

Отладка и тестирование служб очень трудоемкий процесс. Он значительно отличается от отладки обычного приложения. Есть несколько вариантов выхода из данной ситуации. Воспользуемся наиболее простым. Суть его в том, что проверить функциональность основного кода службы можно и в приложении, если ошибок не обнаружено, то перенести его в службу и затем проверять ее функционирование. Как правило, при таком подходе на последней стадии ошибок не возникает.

Проведем поэтапную проверку каждого пункта в данном приложении:

Установка и удаление службы

Рис. 1 Основное окно управления службой

Откроем окно «Службы» для проверки списка запущенных служб.

Рис. 2 Исходный список служб

Рис. 3 Список служб после установки службы Service1

Рис. 4 Список служб после удаления службы Service1

Как видно из данных рисунков (Рис. 2 — Рис. 4) в процессе функционирования приложения, служба Service1 успешно устанавливается и удаляется.

Запуск и остановка службы

В текстовом файле file_open (процессы, которые необходимо открыть, в случае если они не были запущены ранее) впишем два процесса:

calc. exe

lispworks-personal-4460. exe

Рис. 5 Обрабатываемые процессы

Откроем Диспетчер задач и проверим список запущенных процессов.

Рис. 6 Список процессов до запуска службы

Произведем запуск службы и проверим список запущенных процессов с помощью Диспетчера задач.

Рис. 7 Список процессов после запуска службы

Как видно из Рис. 7, процессы calc. exeи lispworks-personal-4460. exeуспешно запустились. Аналогично служба работает и при завершении процессов.

Проверка записи данных в реестр

Рис. 8 Окно ввода данных

Рис. 9 Параметры службы Service1

Как видно из Рис. 9, при вводе временного интервала в 10 сек. данные успешно записываются в реестр.

Сопровождение

Инструкция по установке:

· Скопируйте файл службы ServiceApp. exe в корень диска C:

· В корне диска C: создайте два текстовых файла file_open и file_close

· Введите имена процессов в данные файлы

· Откройте приложение «Управление службой»

· Введите временной интервал

· Установите службу

· Запустите службу

Примечания:

· Для изменения временного интервала необходимо удалить службу и повторно установить.

· Для корректного функционирования службы необходимы права администратора.

Кроме того, в главном окне приложения управления службой была реализована справка.

служба windows приложение

Рис. 10 Инструкция по установке и эксплуатации

Заключение

В ходе данного курсового проекта было спроектирована служба Windows и приложение для управления этой службой. Разработанное программное обеспечение вместе со службой позволяет контролировать приложения Windows, т. е. запускать и завершать определенные процессы по желанию пользователя через определенные промежутки времени.

Разработанный программный продукт может использоваться в учебных заведениях для контроля приложений. Данное приложение предполагает использование без определенных знаний языка программирования и других особенностей.

В процессе выполнения курсового проекта, были закреплены и углублены теоретические знаний, также приобретены практические умения и навыки в самостоятельном проектировании программных продуктов и составлении документов подобного рода.

Список используемой литературы

1. Рихтер, Д. Программирование серверных приложений для Microsoft Windows 2000: мастер-класс / Д. Рихтер, Д. Кларк. — М.: Русская редакция; СПб.: Питер, 2001. — 592 с.

2. Создание служб Windows в Delphi с использованием VCL [Электронный ресурс] - Режим доступа: http: //www. interface. ru/home. asp? artId=16 705

3. Службы Windows [Электронный ресурс] - Режим доступа: http: //ru. wikipedia. org/wiki/%D1%EB%F3%E6%E1%FB_Windows

4. Службы WindowsNT [Электронный ресурс] - Режим доступа: www. infocity. kiev. ua/os/content/os248. phtml

5. Список запущенных процессов [Электронный ресурс] - Режим доступа: www. rsdn. ru/article/qna/baseserv/enumproc. xml

6. Библиотека MSDN [Электронный ресурс] - Режим доступа: http: //msdn. microsoft. com/

Приложение A. Файл реализации службы

1: // ----------------------------------------------------------------

2: #include < vcl. h>

3: #pragma hdrstop

4: #include < tchar. h>

5: #include «Service. h»

6: #include «Thread. h»

7: #pragma package (smart_init)

8: // ---------------------------------------------------------------------------

9: // Important: Methods and properties of objects in VCL can only be

10: // used in a method called using Synchronize, for example:

11: //

12: // Synchronize (UpdateCaption);

13: //

14: // where UpdateCaption could look like:

15: //

16: // void __fastcallMyThread: :UpdateCaption ()

17: // {

18: // Form1-> Caption = «Updated in a thread»;

19: // }

20: // ---------------------------------------------------------------------------

21: __fastcallMyThread: :MyThread (boolCreateSuspended): TThread (CreateSuspended) {

22: }

23: // ---------------------------------------------------------------------------

24: intIsProcessPresent (wchar_t * szExe) {

25: int PID;

26: HANDLE hSnapshot = CreateToolhelp32Snapshot (TH32CS_SNAPPROCESS, 0);

27: PROCESSENTRY32 pe;

28:

29: pe. dwSize = sizeof (PROCESSENTRY32);

30: Process32First (hSnapshot, & pe);

31:

32: if (!_wcsicmp ((wchar_t *)& pe. szExeFile, szExe)) {

33: PID = pe. th32ProcessID;

34: return PID;

35: }

36:

37: while (Process32Next (hSnapshot, & pe)) {

38: if (!_wcsicmp ((wchar_t *)& pe. szExeFile, szExe)) {

39: PID = pe. th32ProcessID;

40: return PID;

41: }

42: }

43:

44: return 0;

45: }

46: void KillProcess (int id) {

47: HANDLE ps = OpenProcess (1, false, id);

48: if (ps)

49: TerminateProcess (ps, -9);

50: }

51:

52: // ---------------------------------------------------------------------------

53: void __fastcallMyThread: :Execute () {

54:

55: TCHAR *szPath = L"SYSTEM\CurrentControlSet\Services\Service1″;

56: TCHAR szBuf[2*MAX_PATH];

57: DWORD dwBufLen = 2*MAX_PATH;

58: DWORD dwBufLen1 = 2*MAX_PATH;

59: TCHAR szBuf1[MAX_PATH];

60: HKEY Key;

61: HKEY hKey;

62: DWORD ktp = REG_SZ;

63:

64: RegOpenKeyEx (HKEY_LOCAL_MACHINE, szPath, 0, KEY_ALL_ACCESS, & Key);

65: RegQueryValueEx (Key, L"time", NULL, & ktp, (LPBYTE)szBuf, & dwBufLen);

66: Service1 -> time = _wtoi (szBuf);

67: RegCloseKey (Key);

68:

69: RegOpenKeyEx (HKEY_LOCAL_MACHINE, szPath, 0, KEY_ALL_ACCESS, & hKey);

70: RegQueryValueEx (hKey, L"timeP", NULL, & ktp, (LPBYTE)szBuf1, & dwBufLen1);

71: Service1 -> timeP = _wtoi (szBuf1);

72: RegCloseKey (hKey);

73:

74: FILE *file_open;

75: FILE *file_close;

76:

77: TCHAR lines_open[100][1000];

78: intnl = 0, nlmax = 100;

79: TCHAR lines_close[100][1000];

80:

81: file_open = _wfopen (L"C: \file_open. txt", L"r");

82: file_close = _wfopen (L"C: \file_close. txt", L"r");

83:

84: while (1) {

85: while (fgetws (lines_open[nl], 1000, file_open)) {

86: for (int i = 0; i < nlmax; i++)

87: for (int j = 0; j < 1000; j++)

88: if (lines_open[i][j] == char (10))

89: lines_open[i][j] = char (0);

90: nl++;

91: }

92: for (int i = 0; i < nl; i++) {

93: if (IsProcessPresent (ExtractFileName ((wchar_t*)& lines_open[i]). t_str ())) {}

94: else

95: STARTUPINFO si;

96: PROCESS_INFORMATION pi;

97: ZeroMemory (& si, sizeof (si));

98: ZeroMemory (& pi, sizeof (pi));

99: si. cb = sizeof (si);

100: si. dwXSize = 200;

101: si. dwYSize = 100;

102: si. dwFlags = STARTF_USEPOSITION

106: }

107:

108: while (fgetws (lines_close[nl], 1000, file_close)) {

109: for (int i = 0; i < nlmax; i++)

110: for (int j = 0; j < 1000; j++)

111: if (lines_close[i][j] == char (10))

112: lines_close[i][j] = char (0);

113: nl++;

114: }

115: for (int i = 0; i < nl; i++)

116: while (IsProcessPresent ((wchar_t*)& lines_close[i]))

117: KillProcess (IsProcessPresent ((wchar_t*)& lines_close[i]));

118:

119: Sleep ((Service1 -> time)*(Service1 -> timeP));

120:

121: }

122: fclose (file_open);

123: fclose (file_close);

124: }

125: // --------------------------------------------------------------

Приложение Б. Файл реализации приложения управления службой

1: //---------------------------------------------------------------------------

2:

3: #include < vcl. h>

4: #pragma hdrstop

5:

6: #include «Unit1. h»

7: #include «Unit2. h»

8: #include «Unit3. h»

9: //---------------------------------------------------------------------------

10: #pragma package (smart_init)

11: #pragma resource «*. dfm»

12: TForm1 *Form1;

13: //---------------------------------------------------------------------------

14: __fastcall TForm1: :TForm1(TComponent* Owner)

15:: TForm (Owner)

16: {

17: flag = false;

18: flagS = false;

19: Label2 -> Font -> Color = clRed;

20: Label2 -> Caption = «Неустановлена»;

21: }

22: //---------------------------------------------------------------------------

23: intWriteTime (wchar_t *time) {

24: HKEY hKey;

25: long s;

26:

27: TCHAR szTestString[] = L"";

28:

29: TCHAR szPath[] = L"SYSTEM\CurrentControlSet\Services\Service1″;

30:

31: if ((s = RegCreateKeyEx (HKEY_LOCAL_MACHINE, szPath, 0, NULL,

32: REG_OPTION_VOLATILE, KEY_WRITE, NULL, & hKey, NULL)) ≠ ERROR_SUCCESS) {

33: return -1;

34: }

35:

36: wcscpy (szTestString, time);

37: if ((s = RegSetValueEx (hKey, L"time", 0, REG_SZ, (unsigned char*)szTestString,

38: 2*sizeof (szTestString))) ≠ ERROR_SUCCESS) {

39: return -1;

40: }

41:

42: if ((s = RegCloseKey (hKey)) ≠ ERROR_SUCCESS) {

43: return -1;

44: }

45: return 0;

46: }

47:

48:

49: //установкасервиса

50: intServiceInstall (LPTSTR ServiceName)

51: {

52: TCHAR szPath[] = _T («SYSTEM\CurrentControlSet\Services\Service1»);

53: TCHAR Descpription[] = L"Контроль приложений";

54: TCHAR second[] = L"1000″;

55: TCHAR minute[] = L"60 000″;

56: TCHAR hour[] = L"3 600 000″;

57: HKEY hKey;

58:

59: SC_HANDLE hSCManager = OpenSCManager (NULL, NULL, SC_MANAGER_CREATE_SERVICE);

60: if (!hSCManager)

61: {

62: return -1;

63: }

64: SC_HANDLE hService = CreateService (hSCManager, ServiceName,

65: ServiceName, SERVICE_ALL_ACCESS,

66: SERVICE_WIN32_OWN_PROCESS, SERVICE_DEMAND_START,

67: SERVICE_ERROR_NORMAL,

68: L"C: \ServiceApp. exe",

69: NULL, NULL, NULL, NULL, NULL);

70: RegCreateKeyEx (HKEY_LOCAL_MACHINE, szPath, 0, NULL,

71: REG_OPTION_VOLATILE, KEY_WRITE, NULL, & hKey, NULL);

72: RegSetValueEx (hKey, L"Description", 0, REG_SZ,

73: (BYTE*)Descpription, sizeof (Descpription));

74: RegCloseKey (hKey);

75:

76: switch (Form2 -> ComboBox1 -> ItemIndex)

77: {

78:

79: case 0: RegCreateKeyEx (HKEY_LOCAL_MACHINE, szPath, 0, NULL,

80: REG_OPTION_VOLATILE, KEY_WRITE, NULL, & hKey, NULL);

81: RegSetValueEx (hKey, L"timeP", 0, REG_SZ,

82: (BYTE*)second, sizeof (second));

83: RegCloseKey (hKey);

84: break;

85: case 1: RegCreateKeyEx (HKEY_LOCAL_MACHINE, szPath, 0, NULL,

86: REG_OPTION_VOLATILE, KEY_WRITE, NULL, & hKey, NULL);

87: RegSetValueEx (hKey, L"timeP", 0, REG_SZ,

88: (BYTE*)minute, sizeof (minute));

89: RegCloseKey (hKey);

90: break;

91: case 2: RegCreateKeyEx (HKEY_LOCAL_MACHINE, szPath, 0, NULL,

92: REG_OPTION_VOLATILE, KEY_WRITE, NULL, & hKey, NULL);

93: RegSetValueEx (hKey, L"timeP", 0, REG_SZ,

94: (BYTE*)hour, sizeof (hour));

95: RegCloseKey (hKey);

96: break;

97: }

98:

99: WriteTime (Form2 -> LabeledEdit1-> Text. w_str ());

100: if (!hService)

101: {

102: CloseServiceHandle (hSCManager);

103: return -1;

104: }

105: CloseServiceHandle (hService);

106: CloseServiceHandle (hSCManager);

107: return 0;

108: }

109: //удалениесервиса

110: intServiceRemove (LPTSTR ServiceName, SERVICE_STATUS SStatus)

111: {

112: SC_HANDLE hSCManager = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS);

113: if (!hSCManager)

114: {

115: return -1;

116: }

117: SC_HANDLE hService = OpenService (hSCManager, ServiceName,

118: SERVICE_STOP | DELETE);

119: if (!hService)

120: {

121: CloseServiceHandle (hSCManager);

122: return -1;

123: }

124: if (SStatus. dwCurrentState ≠ SERVICE_STOPPED)

125: ControlService (hService, SERVICE_CONTROL_STOP, & SStatus);

126: DeleteService (hService);

127: CloseServiceHandle (hService);

128: CloseServiceHandle (hSCManager);

129: return 0;

130: }

131:

132: //запусксервиса

133: intStartService (LPTSTR ServiceName)

134: {

135: SC_HANDLE hSCManager = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS);

136: if (!hSCManager)

137: {

138: return -1;

139: }

140:

141: SC_HANDLE hService = OpenService (hSCManager, ServiceName,

142: SERVICE_START);

143: if (!hService)

144: {

145: CloseServiceHandle (hSCManager);

146: return -1;

147: }

148: if (!StartService (hService, 0, NULL))

149: {

150: CloseServiceHandle (hService);

151: CloseServiceHandle (hSCManager);

152: return -1;

153: }

154: CloseServiceHandle (hService);

155: CloseServiceHandle (hSCManager);

156: return 0;

157: }

158:

159: //Остановкасервиса

160: intStopService (LPTSTR ServiceName, SERVICE_STATUS SStatus)

161: {

162: SC_HANDLE hSCManager = OpenSCManager (NULL, NULL, SC_MANAGER_ALL_ACCESS);

163: if (!hSCManager)

164: {

165: return -1;

166: }

167: SC_HANDLE hService = OpenService (hSCManager, ServiceName, SERVICE_STOP);

168: if (!hService)

169: {

170: CloseServiceHandle (hSCManager);

171: return -1;

172: }

173: if (!ControlService (hService, SERVICE_CONTROL_STOP, & SStatus))

174: {

175: CloseServiceHandle (hService);

176: CloseServiceHandle (hSCManager);

177: return -1;

178: }

179: CloseServiceHandle (hService);

180: CloseServiceHandle (hSCManager);

181: return 0;

182: }

183: //---------------------------------------------------------------------------

184: void __fastcall TForm1: :BitBtn1Click (TObject *Sender)

185: {

186: LPTSTR ServiceName = L"Service1″;

187: if (flag == false & & Form2 -> LabeledEdit1-> Text. Length () > 0) {

188: if (Form2 -> LabeledEdit1-> Text. Length () > 0)

189: ServiceInstall (ServiceName);

190: Label2 -> Font -> Color = clGreen;

191: Label2 -> Caption = «Установлена»;

192: flag = true;

193: }

194: else

195: if (flag == true)

196: MessageDlg («Службаустановлена», mtInformation,

197: TMsgDlgButtons () < <mbOK, 0);

198: else

199: if (Form2 -> LabeledEdit1-> Text. Length () <= 0)

200: MessageDlg («Введитевремя», mtInformation,

201: TMsgDlgButtons () < <mbOK, 0);

202: //}

203: }

204: //---------------------------------------------------------------------------

205: void __fastcall TForm1: :BitBtn2Click (TObject *Sender)

206: {

207: LPTSTR ServiceName = L"Service1″;

208: SERVICE_STATUS SStatus;

209: if (flag == true) {

210: ServiceRemove (ServiceName, SStatus);

211: Label2 -> Font -> Color = clRed;

212: Label2 -> Caption = «Неустановлена»;

213: flag = false;

214: }

215: else

216: MessageDlg («Службанеустановлена», mtInformation,

217: TMsgDlgButtons () < <mbOK, 0);

218: }

219: //---------------------------------------------------------------------------

220: void __fastcall TForm1: :BitBtn3Click (TObject *Sender)

221: {

222: LPTSTR ServiceName = L"Service1″;

223: if (flag == true & &flagS == false) {

224: StartService (ServiceName);

225: Label2 -> Caption = «Работает»;

226: flagS = true;

227: }

228: else

229: if (flag == false)

230: MessageDlg («Служба не установлена», mtInformation,

231: TMsgDlgButtons () < <mbOK, 0);

232: else

233: if (flagS == true)

234: MessageDlg («Службазапущенаранее», mtInformation,

235: TMsgDlgButtons () < <mbOK, 0);

236: }

237: //---------------------------------------------------------------------------

238: void __fastcall TForm1: :BitBtn4Click (TObject *Sender)

239: {

240: LPTSTR ServiceName = L"Service1″;

241: SERVICE_STATUS SStatus;

242: if (flag == true & &flagS == true) {

243: StopService (ServiceName, SStatus);

244: Label2 -> Font -> Color = clGreen;

245: Label2 -> Caption = «Установлена»;

246: flagS = false;

247: }

248: else

249: if (flag == false)

250: MessageDlg («Службанеустановлена», mtInformation,

251: TMsgDlgButtons () < <mbOK, 0);

252: else

253: if (flagS == false)

254: MessageDlg («Служба была остановлена ранее», mtInformation,

255: TMsgDlgButtons () < <mbOK, 0);

256: }

257: //---------------------------------------------------------------------------

258: void __fastcall TForm1: :BitBtn7Click (TObject *Sender)

259: {

260: Form2 -> ShowModal ();

261: }

262: //---------------------------------------------------------------------------

263: void __fastcall TForm1: :BitBtn5Click (TObject *Sender)

264: {

265: Form3 -> Show ();

266: }

267: //----------------------------------------------------------------------

ПоказатьСвернуть
Заполнить форму текущей работой