Добавил:
ivanov666
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:Системное программирование. Учебное пособие-1
.pdf
,
)
Ɍ ɚ ɛ ɥ ɢ ɰ ɚ 3.49
Ɏɨɪɦɚɬ ɪɟɝɢɫɬɪɚ ɭɩɪɚɜɥɟɧɢɹ ɢ ɫɬɚɬɭɫɚ
Ȼɢɬ Ɉɩɢɫɚɧɢɟ
ɉɪɢɦɟɱɚɧɢɟ
15–13 Ɋɟɡɟɪɜ ɍɫɬɚɧɨɜɢɬɶ ɜ 0 ɩɪɢ ɡɚɩɢɫɢ
Ⱦɨɫɬɭɩɟɧ ɞɥɹ ɱɬɟɧɢɹ ɢ ɡɚɩɢɫɢ ɢ ɨɩɪɟɞɟ-
12 Ɋɟɠɢɦ ɨɠɢɞɚɧɢɹ
ɥɹɟɬ ɫɨɫɬɨɹɧɢɟ ɪɟɠɢɦɚ Suspend mode
(1 – ɪɚɛɨɬɚ ɩɨɪɬɚ ɩɪɢɨɫɬɚɧɨɜɥɟɧɚ,
0 – ɩɨɪɬ ɪɚɛɨɬɚɟɬ)
11–10 Ɂɚɪɟɡɟɪɜɢɪɨɜɚɧɵ Ⱦɨɥɠɧɵ ɛɵɬɶ ɭɫɬɚɧɨɜɥɟɧɵ ɜ 0 ɩɪɢ ɡɚɩɢɫɢ
9 ɋɛɪɨɫ ɩɨɪɬɚ
ɍɩɪɚɜɥɹɟɬ ɫɛɪɨɫɨɦ ɩɨɪɬɚ (1 – ɩɨɪɬ ɛɵɥ
ɫɛɪɨɲɟɧ, 0 – ɩɨɪɬ ɧɟ ɛɵɥ ɫɛɪɨɲɟɧ)
Ɉɩɪɟɞɟɥɹɟɬ ɬɢɩ ɩɨɞɤɥɸɱɟɧɧɨɝɨ ɭɫɬɪɨɣ-
Ɍɢɩ ɩɨɞɤɥɸɱɟɧɧɨɝɨ
8
ɭɫɬɪɨɣɫɬɜɚ
(ɩɨ ɫɤɨɪɨɫɬɢ)
ɫɬɜɚ USB (1 – ɩɨɞɤɥɸɱɟɧɨ ɧɢɡɤɨɫɤɨɪɨɫɬɧɨɟ ɭɫɬɪɨɣɫɬɜɨ, 0 – ɩɨɞɤɥɸɱɟɧɨ ɜɵɫɨɤɨɫɤɨɪɨɫɬɧɨɟ ɭɫɬɪɨɣɫɬɜɨ). Ȼɢɬ ɢɫɩɨɥɶɡɭɟɬɫɹ ɬɨɥɶɤɨ ɞɥɹ ɱɬɟɧɢɹ
7 Ɂɚɪɟɡɟɪɜɢɪɨɜɚɧ
Ɍɨɥɶɤɨ ɞɥɹ ɱɬɟɧɢɹ. ȼɫɟɝɞɚ ɜɨɡɜɪɚɳɚɟɬ
ɡɧɚɱɟɧɢɟ 1
Ɉɩɪɟɞɟɥɹɟɬ ɫɨɫɬɨɹɧɢɟ ɩɨɪɬɚ ɞɥɹ ɪɟɠɢɦɚ
ɩɪɢɨɫɬɚɧɨɜɤɢ (1 – ɟɫɬɶ, 0 – ɧɟɬ). Ɂɚɩɢɫɶ
6 Ɋɟɠɢɦ ɨɠɢɞɚɧɢɹ
ɩɪɨɝɪɚɦɦɨɣ ɡɧɚɱɟɧɢɹ 1 ɜ ɷɬɨɬ ɛɢɬ ɩɨɡɜɨɥɹɟɬ ɩɨɥɭɱɚɬɶ ɫɨɫɬɨɹɧɢɟ ɪɟɠɢɦɚ ɩɪɢɨɫɬɚɧɨɜɤɢ ɞɥɹ ɩɨɪɬɚ
Ⱦɨɫɬɭɩɧɵ ɬɨɥɶɤɨ ɞɥɹ ɱɬɟɧɢɹ ɢ ɨɩɪɟɞɟ-
5–4 ɋɬɚɬɭɫ ɥɢɧɢɢ
ɥɹɸɬ ɥɨɝɢɱɟɫɤɢɣ ɭɪɨɜɟɧɶ ɫɢɝɧɚɥɚ ɧɚ ɥɢɧɢɢ
ɉɨɡɜɨɥɹɟɬ ɨɩɪɟɞɟɥɢɬɶ ɫɨɫɬɨɹɧɢɟ ɩɨɪɬɚ
(1 – ɩɨɪɬ ɛɵɥ ɜɤɥɸɱɟɧ, ɜɵɤɥɸɱɟɧ ɢ ɫɨ-
Ʉɨɧɬɪɨɥɶ ɢɡɦɟɧɟɧɢɣ
3
ɩɨɪɬɚ
ɫɬɨɹɧɢɟ ɢɡɦɟɧɢɥɨɫɶ, 0 – ɫɨɫɬɨɹɧɢɟ ɧɟ
ɢɡɦɟɧɢɥɨɫɶ). Ȼɢɬ ɞɨɫɬɭɩɟɧ ɞɥɹ ɱɬɟɧɢɹ ɢ
ɞɥɹ ɡɚɩɢɫɢ ɡɧɚɱɟɧɢɹ ɫɛɪɨɫɚ ɬɟɤɭɳɟɝɨ
ɫɨɫɬɨɹɧɢɹ
Ʉɨɧɬɪɨɥɶ ɜɤɥɸɱɟɧɢɹ
2
ɩɨɪɬɚ
ɍɩɪɚɜɥɹɟɬ ɪɚɛɨɬɨɣ ɩɨɪɬɚ (1 – ɩɨɪɬ ɜɤɥɸɱɟɧ, 0 – ɩɨɪɬ ɜɵɤɥɸɱɟɧ). ɗɬɨɬ ɛɢɬ ɞɨɫɬɭɩɟɧ ɞɥɹ ɱɬɟɧɢɹ ɢ ɡɚɩɢɫɢ
Ɉɩɪɟɞɟɥɹɟɬ ɫɨɫɬɨɹɧɢɟ ɫɨɟɞɢɧɟɧɢɹ. Ⱦɨ-
1
ɋɨɫɬɨɹɧɢɟ
ɫɨɟɞɢɧɟɧɢɹ
Ɍɟɤɭɳɟɟ
0
ɫɨɫɬɨɹɧɢɟ
ɫɨɟɞɢɧɟɧɢɹ
ɫɬɭɩɟɧ ɞɥɹ ɱɬɟɧɢɹ ɢ ɡɚɩɢɫɢ ɡɧɚɱɟɧɢɹ
ɨɱɢɫɬɤɢ ɬɟɤɭɳɟɝɨ ɫɨɫɬɨɹɧɢɹ (1 – ɟɫɬɶ
ɢɡɦɟɧɟɧɢɟ
0 – ɧɟɬ ɢɡɦɟɧɟɧɢɹ)
Ɉɩɪɟɞɟɥɹɟɬ ɬɟɤɭɳɟɟ ɫɨɫɬɨɹɧɢɟ ɫɨɟɞɢɧɟɧɢɹ ɢ ɞɨɫɬɭɩɟɧ ɬɨɥɶɤɨ ɞɥɹ ɱɬɟɧɢɹ (1 –
ɭɫɬɪɨɣɫɬɜɨ ɩɨɞɤɥɸɱɟɧɨ, 0 – ɭɫɬɪɨɣɫɬɜɨ
ɧɟ ɩɨɞɤɥɸɱɟɧɨ
141
Ɋɟɝɢɫɬɪɵ ɤɨɧɮɢɝɭɪɚɰɢɢ, ɜ ɩɟɪɜɭɸ ɨɱɟɪɟɞɶ, ɧɟɨɛɯɨɞɢɦɵ ɞɥɹ ɫɜɹɡɢ ɫ ɩɪɨɫɬɪɚɧɫɬɜɨɦ ɚɞɪɟɫɨɜ ɲɢɧɵ PCI. Ʉɚɠɞɨɟ ɭɫɬɪɨɣɫɬɜɨ ɧɚ ɲɢɧɟ PCI ɞɨɥɠɧɨ ɩɪɢɧɚɞɥɟɠɚɬɶ ɤ ɨɩɪɟɞɟɥɟɧɧɨɦɭ ɤɥɚɫɫɭ ɢ ɢɦɟɬɶ ɫɜɨɢ ɚɞɪɟɫɚ ɩɚɦɹɬɢ. Ʉ ɪɟɝɢɫɬɪɚɦ
ɤɨɧɮɢɝɭɪɚɰɢɢ ɨɬɧɨɫɹɬɫɹ: ɪɟɝɢɫɬɪ ɤɨɞɚ ɤɥɚɫɫɚ, ɪɟɝɢɫɬɪ ɛɚɡɨɜɨɝɨ ɚɞɪɟɫɚ ɢ ɪɟɝɢɫɬɪ ɧɨɦɟɪɚ ɜɟɪɫɢɢ.
Ɋɟɝɢɫɬɪ ɤɨɞɚ ɤɥɚɫɫɚ ɞɨɫɬɭɩɟɧ ɬɨɥɶɤɨ ɞɥɹ ɱɬɟɧɢɹ ɢ
ɩɪɟɞɧɚɡɧɚɱɟɧ ɞɥɹ ɢɞɟɧɬɢɮɢɤɚɰɢɢ ɤɨɞɚ ɤɥɚɫɫɚ ɢ ɩɨɞɤɥɚɫɫɚ ɭɫɬɪɨɣɫɬɜɚ, ɬɪɟɛɭɟɦɵɯ ɲɢɧɨɣ PCI ɞɥɹ ɜɵɞɟɥɟɧɢɹ ɫɢɫɬɟɦɧɵɯ ɪɟɫɭɪɫɨɜ. Ɋɟɝɢɫɬɪ 24-ɪɚɡɪɹɞɧɵɣ. Ɂɧɚɱɟɧɢɟ ɩɨ ɭɦɨɥɱɚɧɢɸ
ɪɚɜɧɨ 010180h. Ɏɨɪɦɚɬ ɪɟɝɢɫɬɪɚ ɩɪɟɞɫɬɚɜɥɟɧ ɜ ɬɚɛɥɢɰɟ 3.50.
Ɍ ɚ ɛ ɥ ɢ ɰ ɚ 3.50
Ɏɨɪɦɚɬ ɪɟɝɢɫɬɪɚ ɤɨɞɚ ɤɥɚɫɫɚ
Ȼɢɬ Ɉɩɢɫɚɧɢɟ
23–16
Ȼɚɡɨɜɵɣ ɤɨɞ ɤɥɚɫɫɚ. Ⱦɥɹ ɤɨɧɬɪɨɥɥɟɪɚ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɣ ɲɢɧɵ
ɪɚɜɟɧ 0Ch
15–8 Ʉɨɞ ɩɨɞɤɥɚɫɫɚ. Ⱦɥɹ ɤɨɧɬɪɨɥɥɟɪɚ ɛɚɡɨɜɨɝɨ ɭɡɥɚ USB ɪɚɜɟɧ 03h
7–0 ɉɪɨɝɪɚɦɦɢɪɭɟɦɵɣ ɢɧɬɟɪɮɟɣɫ. ȼɫɟɝɞɚ ɪɚɜɟɧ 00h
Ɋɟɝɢɫɬɪ ɛɚɡɨɜɨɝɨ ɚɞɪɟɫɚ ɩɨɡɜɨɥɹɟɬ ɭɫɬɚɧɚɜɥɢɜɚɬɶ ɢɥɢ ɩɨɥɭɱɚɬɶ ɛɚɡɨɜɵɣ
ɚɞɪɟɫ ɜɜɨɞɚ-ɜɵɜɨɞɚ ɞɥɹ ɨɛɦɟɧɚ ɞɚɧɧɵɦɢ ɫ ɭɫɬɪɨɣɫɬɜɨɦ USB. Ɋɟɝɢɫɬɪ ɹɜɥɹɟɬɫɹ
32-ɪɚɡɪɹɞɧɵɦ ɢ ɞɨɫɬɭɩɟɧ ɞɥɹ ɱɬɟɧɢɹ ɢ ɡɚɩɢɫɢ. ɉɨ ɭɦɨɥɱɚɧɢɸ ɡɧɚɱɟɧɢɟ ɪɟɝɢɫɬɪɚ ɪɚɜɧɨ 00000001h. Ɏɨɪɦɚɬ ɪɟɝɢɫɬɪɚ ɩɪɟɞɫɬɚɜɥɟɧ ɜ ɬɚɛɥɢɰɟ 3.51.
Ɍ ɚ ɛ ɥ ɢ ɰ ɚ 3.51
Ɏɨɪɦɚɬ ɪɟɝɢɫɬɪɚ ɛɚɡɨɜɨɝɨ ɚɞɪɟɫɚ
Ȼɢɬ Ɉɩɢɫɚɧɢɟ
31–16
15–5
Ɂɚɪɟɡɟɪɜɢɪɨɜɚɧɵ ɢ ɞɨɥɠɧɵ ɛɵɬɶ ɭɫɬɚɧɨɜɥɟɧɵ ɜ 0
Ɂɧɚɱɟɧɢɟ ɛɚɡɨɜɨɝɨ ɚɞɪɟɫɚ
Ɂɚɪɟɡɟɪɜɢɪɨɜɚɧɵ ɢ ɞɨɥɠɧɵ ɛɵɬɶ ɭɫɬɚɧɨɜɥɟɧɵ ɜ 0
4–1
Ⱦɨɫɬɭɩɟɧ ɬɨɥɶɤɨ ɞɥɹ ɱɬɟɧɢɹ ɢ ɜɫɟɝɞɚ ɪɚɜɟɧ 1
0
Ɋɟɝɢɫɬɪ ɧɨɦɟɪɚ ɜɟɪɫɢɢ ɹɜɥɹɟɬɫɹ 8-ɪɚɡɪɹɞɧɵɦ ɢ ɨɩɪɟɞɟɥɹɟɬ ɧɨɦɟɪ ɬɟɤɭɳɟɣ
ɜɟɪɫɢɢ USB, ɤɨɬɨɪɭɸ ɩɨɞɞɟɪɠɢɜɚɟɬ ɤɨɧɬɪɨɥɥɟɪ ɛɚɡɨɜɨɝɨ ɭɡɥɚ. Ɋɟɝɢɫɬɪ ɞɨɫɬɭɩɟɧ ɬɨɥɶɤɨ ɞɥɹ ɱɬɟɧɢɹ. Ȼɢɬɵ 7–0 ɫɨɞɟɪɠɚɬ ɧɨɦɟɪ ɜɟɪɫɢɢ ɞɥɹ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɣ
ɲɢɧɵ (00h – ɩɪɟɞɜɚɪɢɬɟɥɶɧɚɹ ɜɟɪɫɢɹ 1.0, 01h – ɜɟɪɫɢɹ 1.0, 02h – ɜɟɪɫɢɹ 2.0).
Ɍɟɩɟɪɶ ɪɚɫɫɦɨɬɪɢɦ ɪɚɛɨɬɭ ɫ USB-ɩɨɪɬɨɦ ɜ Linux [8].
Ɋɚɡɪɚɛɨɬɱɢɤ ɦɨɠɟɬ ɧɚɩɢɫɚɬɶ ɩɨɥɧɨɰɟɧɧɵɣ ɞɪɚɣɜɟɪ ɞɥɹ ɪɚɛɨɬɵ ɫɨ ɫɜɨɢɦ
USB-ɭɫɬɪɨɣɫɬɜɨɦ, ɩɪɢɦɟɧɹɹ ɭɠɟ
ɢɦɟɸɳɢɣɫɹ ɜ ɫɢɫɬɟɦɟ ɡɚɝɨɥɨɜɨɱɧɵɣ ɮɚɣɥ
linux/usb.h. Ⱦɪɚɣɜɟɪ, ɧɚɩɢɫɚɧɧɵɣ ɞɥɹ ɩɨɞɞɟɪɠɤɢ USB-ɭɫɬɪɨɣɫɬɜɚ, ɞɨɥɠɟɧ
ɪɟɲɚɬɶ ɫɥɟɞɭɸɳɢɟ ɡɚɞɚɱɢ:
ɪɟɝɢɫɬɪɚɰɢɹ ɢ ɭɞɚɥɟɧɢɟ ɞɪɚɣɜɟɪɚ;
ɪɟɝɢɫɬɪɚɰɢɹ ɢ ɭɞɚɥɟɧɢɟ ɭɫɬɪɨɣɫɬɜɚ;
ɨɛɦɟɧ ɞɚɧɧɵɦɢ ɫ ɭɫɬɪɨɣɫɬɜɨɦ.
142
ȿɫɥɢ ɧɟɬ ɜɪɟɦɟɧɢ ɩɢɫɚɬɶ ɞɪɚɣɜɟɪ, ɧɨ ɧɚɞɨ ɫɨɡɞɚɬɶ ɩɪɨɝɪɚɦɦɭ, ɪɚɛɨɬɚɸɳɭɸ ɫ USB-ɭɫɬɪɨɣɫɬɜɨɦ, ɤɨɬɨɪɚɹ ɫɚɦɚ ɛɭɞɟɬ ɪɟɲɚɬɶ, ɤɚɤ, ɤɨɝɞɚ ɢ ɫ ɤɚɤɢɦ
ɢɡ ɬɚɤɢɯ ɭɫɬɪɨɣɫɬɜ ɟɣ ɪɚɛɨɬɚɬɶ? Ⱦɥɹ ɷɬɨɝɨ ɢɫɩɨɥɶɡɭɟɦ ɛɢɛɥɢɨɬɟɤɭ libusb
(http://www. libusb.org/). ȿɫɥɢ ɜ ɞɢɫɬɪɢɛɭɬɢɜɟ Linux ɟɟ ɧɟɬ, ɦɨɠɧɨ ɫɚɦɨɫɬɨɹɬɟɥɶɧɨ ɭɫɬɚɧɨɜɢɬɶ ɷɬɨɬ ɩɚɤɟɬ.
ɉɟɪɜɨɟ ɞɟɣɫɬɜɢɟ – ɩɨɥɭɱɟɧɢɟ ɫɜɟɞɟɧɢɣ ɨɛ ɭɫɬɚɧɨɜɥɟɧɧɵɯ USB-ɭɫɬɪɨɣɫɬɜɚɯ
.
ɉɪɢɦɟɪ 3.37. ɑɬɟɧɢɟ ɢɧɮɨɪɦɚɰɢɢ ɨɛ ɭɫɬɪɨɣɫɬɜɚɯ USB ɜ Linux.
// ɉɪɢɦɟɪ ɧɚ ɛɚɡɟ ɛɢɛɥɢɨɬɟɤɢ libusb
// (http://libusb.sourceforge.net)
// ȼɟɪɫɢɹ ɩɚɤɟɬɚ libusb: libusb-0.1.12
// ɂɫɩɨɥɶɡɭɟɧɵɟ ɩɪɢ ɫɛɨɪɤɟ ɛɢɛɥɢɨɬɟɤɢ:
// libusb.so
// Ʉɨɦɩɢɥɹɬɨɪ ɩɪɢɦɟɪɚ: g++ (GCC) 4.4.0
#include <stdio.h>
#include "/usr/local/include/usb.h"
#include <sys/types.h>
void print_endpoint(struct
usb_endpoint_descriptor
*endpoint) {
// ɉɟɱɚɬɶ ɢɧɮɨɪɦɚɰɢɢ ɨ ɤɨɧɟɱɧɨɣ ɬɨɱɤɟ
}
void print_altsetting(struct usb_interface_descriptor
*interface) {
int i;
// ɉɟɱɚɬɶ ɢɧɮɨɪɦɚɰɢɢ ɨɛ ɢɧɬɟɪɮɟɣɫɟ
for (i = 0; i <interface->bNunEndpoints; i++) {
printf("\n Ɍɨɱɤɚ #%d\n",i);
print_endpoint(&interface->endpoint[i]); } }
void print_interface(struct usb_interface *interface)
{
int i;
for (i = 0; i <interface->num_altsetting; i++)
print_altsetting(&interface->altsetting[i]);
}
void print_configuration(struct
usb_config_descriptor *config)
{
int i;
//Ɇɚɫɫɢɜ ɢɧɬɟɪɮɟɣɫɨɜ, ɩɨɞɞɟɪɠɢɜɚɟɦɵɣ ɞɥɹ ɞɚɧɧɨɣ
// ɤɨɧɮɢɝɭɪɚɰɢɢ
for (i = 0; i <config->bNumInterfaces; i++) {
printf("\n
ɂɧɬɟɪɮɟɣɫ #%d\n",i);
print_interface(&config->interface[i]); } }
int main(int argc, char *argv[]) {
143
// ɋɬɪɭɤɬɭɪɚ ɨɩɢɫɚɧɢɹ USB-ɲɢɧɵ
struct usb_bus *bus;
// ɋɬɪɭɤɬɭɪɚ ɨɩɢɫɚɧɢɹ USB-ɭɫɬɪɨɣɫɬɜɚ struct
usb_device *dev;
usb_init(); // ɂɧɢɰɢɚɥɢɡɚɰɢɹ ɫɬɪɭɤɬɭɪ, ɧɟɨɛɯɨ-
// ɞɢɦɵɯ ɞɥɹ ɞɚɥɶɧɟɣɲɟɣ ɪɚɛɨɬɵ
usb find busses(); // ɇɚɯɨɞɢɦ ɜɫɟ USB-ɲɢɧɵ ɜ
// ɫɢɫɬɟɦɟ. ɍɱɢɬɵɜɚɸɬɫɹ ɜɫɟ ɢɡɦɟɧɟɧɢɹ ɫ ɦɨɦɟɧɬɚ
// ɩɪɨɲɥɨɝɨ ɜɵɡɨɜɚ ɞɚɧɧɨɣ Ɏɭɧɤɰɢɢ
usb_find_devices(); // Ɉɩɪɟɞɟɥɹɟɦ ɜɫɟ ɭɫɬɪɨɣɫɬɜɚ
// ɞɥɹ ɜɫɟɯ ɲɢɧ, ɭɱɢɬɵɜɚɸɬɫɹ ɜɫɟ ɢɡɧɟɧɟɧɢɹ ɫ
// ɦɨɦɟɧɬɚ ɩɪɨɢɥɨɝɨ ɜɵɡɨɜɚ Ɏɭɧɤɰɢɢ
for (bus = usb_busses; bus; bus = bus->next) { for
(dev = bus->devices; dev;
dev = dev->next) {
int ret, i;
char string[256];
usb_dev_handle *udev;
//ɍɤɚɡɚɬɟɥɶ USB-ɭɫɬɪɨɣɫɬɜɚ
printf("===================================\n");
//Ɉɫɧɨɜɧɵɟ ɩɚɪɚɦɟɬɪɵ ɬɟɤɭɳɟɝɨ ɭɫɬɪɨɣɫɬɜɚ
printf("ɒɢɧɚ: %s, ɍɫɬɪɨɣɫɬɜɨ: %s,
ɉɨɫɬɚɜɳɢɤ: %04ɏ,
ɉɪɨɞɭɤɬ: %04X\n*, bus->dirname,
dev->filename, dev->descriptor.idVendor,
dev->descriptor.idProduct);
//ɉɨɥɭɱɚɟɦ ɞɨɫɬɭɩ ɤ ɭɫɬɪɨɣɫɬɜɭ ɞɥɹ ɪɚɛɨɬɵ ɫ ɧɢɦ
udev = usb_open(dev);
//ɉɵɬɚɟɦɫɹ ɢɡɜɥɟɱɶ ɫɬɪɨɤɨɜɵɟ ɞɚɧɧɵɟ
// ɨ ɩɪɨɢɡɜɨɞɢɬɟɥɟ ɭɫɬɪɨɣɫɬɜɚ
if (udev) {
if (dev->descrlptor.iManufacturer) {
ret = usb_get_string_simple(udev,
dev->descriptor.iManufacturer, string,
sizeof(string));
if (ret > 0)
printf("ɉɪɨɢɡɜɨɞɢɬɟɥɶ : %s\n", string);
else
printf("ɇɟɥɶɡɹ ɩɨɥɭɱɢɬɶ ɫɬɪɨɤɭ ɩɪɨɢɡɜɨɞɢɬɟɥɹ^");
}
// ɉɵɬɚɟɦɫɹ ɢɡɜɥɟɱɶ ɫɬɪɨɤɨɜɵɟ ɞɚɧɧɵɟ ɨɛ ɭɫɬɪɨɣɫɬɜɟ
if (dev->descriptor.iProduct) {
ret = usb_get_string_simple(udev, dev-
>descriptor.iProduct, string, sizeof (string));
if (ret > 0)
144
printf("ɍɫɬɪɨɣɫɬɜɨ : %s\n", string);
else
printf("ɇɟɥɶɡɹ ɩɨɥɭɱɢɬɶ ɫɬɪɨɤɭ ɭɫɬɪɨɣɫɬɜɚ \n”);
}
//ɉɵɬɚɟɦɫɹ ɢɡɜɥɟɱɶ ɫɬɪɨɤɭ ɫɟɪɢɣɧɨɝɨ ɧɨɦɟɪɚ
// ɭɫɬɪɨɣɫɬɜɚ
if (dev->descriptor.iSerialNumber) {
ret = usb_get_string_simple(udev,
dev->descriptor.iSerialNumber, string,
sizeof (string));
if (ret > 0)
printf(“ ɋɟɪɢɣɧɵɣ ɧɨɦɟɪ: %s\n”, string);
else
printf(“ ɇɟɥɶɡɹ ɩɨɥɭɱɢɬɶ ɫɟɪɢɣɧɵɣ ɧɨɦɟɪ\n"):
}
//Ɂɚɤɪɵɜɚɟɦ ɞɨɫɬɭɩ ɤ ɬɟɤɭɳɟɦɭ ɭɫɬɪɨɣɫɬɜɭ
usb.close(udev);
}
//ɉɟɱɚɬɚɟɦ ɞɟɬɚɥɶɧɭɸ ɢɧɮɨɪɦɚɰɢɸ ɨ ɤɨɧɮɢɝɭɪɚɰɢɢ
// ɭɫɬɪɨɣɫɬɜɚ
if (!dev->config) {
printf("ɇɟɥɶɡɹ ɩɨɥɭɱɢɬɶ ɨɩɢɫɚɬɟɥɢ \n");
continue; }
for (i = 0;
i<dev->descriptor.bNumConfigurations; i++)
print_configuration(idev->config[i]);
}
}
return 0;
}
ȼ ɞɚɧɧɨɦ ɩɪɢɦɟɪɟ ɢɞɟɬ ɩɪɨɫɬɨɣ ɩɟɪɟɛɨɪ ɜɫɟɯ ɭɫɬɪɨɣɫɬɜ,
ɤɨɬɨɪɵɟ ɫɨɞɟɪɠɚɬɫɹ ɜ ɫɢɫɬɟɦɟ ɢ ɱɬɨ ɢɦɟɸɬ ɨɬɧɨɲɟɧɢɟ ɤ USB. ɇɨ ɷɬɨ ɞɟɥɚɬɶ ɧɟɨɛɹɡɚɬɟɥɶɧɨ. Ⱦɥɹ ɪɚɛɨɬɵ ɫ ɤɨɧɤɪɟɬɧɵɦ ɭɫɬɪɨɣɫɬɜɨɦ ɧɚɫ ɦɨɠɟɬ ɢɧɬɟɪɟɫɨɜɚɬɶ ɨɩɪɟɞɟɥɟɧɧɵɣ ɤɨɞ ɢɡɝɨɬɨɜɢɬɟɥɹ ɩɪɨɞɭɤɬɚ (idVendor) ɢ ɤɨɞ ɩɪɨɞɭɤɬɚ
(idProduct).
ɇɚɛɨɪɵ ɮɭɧɤɰɢɣ libusb-win32 (ɞɥɹ Windows) ɢ libusb (ɞɥɹ Linux) ɫɨɜɩɚɞɚɸɬ, ɚ ɩɥɚɬɮɨɪɦɟɧɧɵɟ ɪɚɡɥɢɱɢɹ ɭɤɚɡɚɧɵ ɜ ɞɨɤɭɦɟɧɬɚɰɢɢ. ɗɬɨ ɢ ɟɫɬɶ ɨɫɧɨɜɧɨɟ
ɞɨɫɬɨɢɧɫɬɜɨ ɛɢɛɥɢɨɬɟɤɢ libusb – ɤɪɨɫɫɩɥɚɬɮɨɪɦɟɧɧɚɹ ɩɟɪɟɧɨɫɢɦɨɫɬɶ ɢɫɯɨɞɧɨɝɨ ɤɨɞɚ.
3.4. Ʉɨɧɬɪɨɥɶɧɵɟ ɜɨɩɪɨɫɵ ɤ ɪɚɡɞɟɥɭ 3
1. ȼ ɤɚɤɨɦ ɮɨɪɦɚɬɟ ɩɨɫɬɭɩɚɟɬ ɜ ɤɨɦɩɶɸɬɟɪ ɢɧɮɨɪɦɚɰɢɹ ɨ ɤɥɚɜɢɲɚɯ, ɧɚɠɚ-
ɬɵɯ ɧɚ ɤɥɚɜɢɚɬɭɪɟ?
145
2. ɉɟɪɟɱɢɫɥɢɬɟ ɡɚɞɚɱɢ, ɪɟɲɚɟɦɵɟ ɤɨɧɬɪɨɥɥɟɪɨɦ ɤɥɚɜɢɚɬɭɪɵ.
3. ɑɟɦ ɨɬɥɢɱɚɸɬɫɹ ɤɨɞɵ ɚɥɮɚɜɢɬɧɨ-ɰɢɮɪɨɜɵɯ ɢ ɮɭɧɤɰɢɨɧɚɥɶɧɵɯ ɤɥɚɜɢɲ?
4. Ʉɚɤɢɦ ɨɛɪɚɡɨɦ ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ ɜɜɨɞ ɫɢɦɜɨɥɨɜ ɫ ɤɥɚɜɢɚɬɭɪɵ ɜ ɩɪɨɝɪɚɦ-
ɦɚɯ ɋɢ?
5. Ʉɚɤɢɦ ɨɛɪɚɡɨɦ ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ ɜɜɨɞ ɫɬɪɨɤ ɫ ɤɥɚɜɢɚɬɭɪɵ ɜ ɩɪɨɝɪɚɦɦɚɯ
ɋɢ? Ʉɚɤ ɨɬɮɨɪɦɚɬɢɪɨɜɚɬɶ ɜɜɨɞ ɫ ɤɥɚɜɢɚɬɭɪɵ?
6. Ʉɚɤ ɨɝɪɚɧɢɱɢɬɶ ɞɢɚɩɚɡɨɧ ɜɜɨɞɢɦɵɯ ɫ ɤɥɚɜɢɚɬɭɪɵ ɫɢɦɜɨɥɨɜ
ɜ ɩɪɨɝɪɚɦ-
ɦɚɯ ɋɢ?
7. Ʉɚɤɢɦ ɨɛɪɚɡɨɦ ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ ɜɵɜɨɞ ɫɢɦɜɨɥɨɜ ɧɚ ɷɤɪɚɧ ɜ ɩɪɨɝɪɚɦɦɚɯ
ɋɢ?
8. Ʉɚɤɢɦ ɨɛɪɚɡɨɦ ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ ɜɵɜɨɞ ɫɬɪɨɤ ɧɚ ɷɤɪɚɧ ɜ ɩɪɨɝɪɚɦɦɚɯ ɋɢ?
Ʉɚɤ ɨɬɮɨɪɦɚɬɢɪɨɜɚɬɶ ɜɵɜɨɞ ɧɚ ɷɤɪɚɧ?
9. ɇɚ ɤɚɤɢɟ ɷɥɟɦɟɧɬɵ ɪɚɡɞɟɥɟɧɨ ɞɢɫɤɨɜɨɟ ɩɪɨɫɬɪɚɧɫɬɜɨ?
10. Ʉɚɤ ɩɪɨɱɢɬɚɬɶ ɫɜɟɞɟɧɢɹ ɨ ɞɢɫɤɟ ɜ ɩɪɨɝɪɚɦɦɟ ɋɢ?
11. Ɏɭɧɤɰɢɹ DeviceIoControl Windows – ɧɚɡɧɚɱɟɧɢɟ,
ɨɫɨɛɟɧɧɨɫɬɢ ɡɚɞɚɧɢɹ
ɟɟ ɩɚɪɚɦɟɬɪɨɜ.
12. Ⱦɚɣɬɟ ɨɩɪɟɞɟɥɟɧɢɟ ɩɨɧɹɬɢɣ «ɤɚɬɚɥɨɝ» ɢ «ɮɚɣɥ». ɑɟɦ ɤɚɬɚɥɨɝ ɨɬɥɢɱɚɟɬ-
ɫɹ ɨɬ ɮɚɣɥɚ?
13. Ʉɚɤɢɟ ɮɭɧɤɰɢɢ ɞɥɹ ɪɚɛɨɬɵ ɫ ɤɚɬɚɥɨɝɚɦɢ ɜ ɩɪɨɝɪɚɦɦɚɯ ɋɢ ȼɵ ɡɧɚɟɬɟ?
14. Ʉɚɤɢɟ ɮɭɧɤɰɢɢ ɞɥɹ ɪɚɛɨɬɵ ɫ ɮɚɣɥɚɦɢ ɜ ɩɪɨɝɪɚɦɦɚɯ ɋɢ ȼɵ ɡɧɚɟɬɟ?
15. Ɉɫɨɛɟɧɧɨɫɬɢ ɱɬɟɧɢɹ ɢɡ ɮɚɣɥɚ ɢ ɡɚɩɢɫɢ ɜ ɮɚɣɥ ɜ
ɩɪɨɝɪɚɦɦɚɯ ɋɢ. Ʉɚɤ
ɢɞɟɧɬɢɮɢɰɢɪɨɜɚɬɶ ɜɨɡɦɨɠɧɭɸ ɨɲɢɛɤɭ ɜɜɨɞɚ-ɜɵɜɨɞɚ?
16. ɉɟɪɟɱɢɫɥɢɬɟ ɢɧɬɟɪɮɟɣɫɵ, ɢɫɩɨɥɶɡɭɟɦɵɟ ɞɥɹ ɩɨɞɤɥɸɱɟɧɢɹ ɜɧɟɲɧɢɯ
ɭɫɬɪɨɣɫɬɜ ɤ ɤɨɦɩɶɸɬɟɪɭ.
17. ɉɚɪɚɥɥɟɥɶɧɵɣ ɩɨɪɬ. ɉɪɢɧɰɢɩ ɪɚɛɨɬɵ. Ɉɫɧɨɜɧɵɟ ɧɚɫɬɪɨɣɤɢ.
18. Ʉɚɤ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɬɶ ɩɚɪɚɥɥɟɥɶɧɵɣ ɩɨɪɬ? Ʉɚɤ ɩɪɨɜɟɪɢɬɶ ɟɝɨ ɝɨɬɨɜ-
ɧɨɫɬɶ ɤ ɪɚɛɨɬɟ?
19. Ʉɚɤ ɩɟɪɟɞɚɬɶ ɞɚɧɧɵɟ ɱɟɪɟɡ ɩɚɪɚɥɥɟɥɶɧɵɣ ɩɨɪɬ?
20. ɉɨɫɥɟɞɨɜɚɬɟɥɶɧɵɣ ɩɨɪɬ COM. ɉɪɢɧɰɢɩ ɪɚɛɨɬɵ. Ɉɫɧɨɜɧɵɟ
ɧɚɫɬɪɨɣɤɢ.
21. Ʉɚɤ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɬɶ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɵɣ ɩɨɪɬ? Ʉɚɤ ɩɪɨɜɟɪɢɬɶ ɟɝɨ ɝɨ-
ɬɨɜɧɨɫɬɶ ɤ ɪɚɛɨɬɟ?
22. Ʉɚɤ ɡɚɞɚɬɶ ɧɚɫɬɪɨɣɤɢ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɝɨ ɩɨɪɬɚ?
23. Ʉɚɤ ɩɟɪɟɞɚɬɶ ɞɚɧɧɵɟ ɱɟɪɟɡ ɩɚɪɚɥɥɟɥɶɧɵɣ ɩɨɪɬ?
24. Ɉɫɨɛɟɧɧɨɫɬɢ ɪɚɛɨɬɵ ɫ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɵɦ ɩɨɪɬɨɦ ɜ Linux. Ʉɨɧɰɟɩɰɢɢ
ɜɜɨɞɚ ɱɟɪɟɡ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɵɣ ɩɨɪɬ.
25. ɉɪɨɝɪɚɦɦɧɵɣ ɞɨɫɬɭɩ ɤ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɦɭ ɩɨɪɬɭ ɜ Linux.
26. ɉɨɪɬ USB. ɉɪɢɧɰɢɩ ɪɚɛɨɬɵ. Ɏɭɧɤɰɢɢ ɤɨɪɧɟɜɨɝɨ
ɛɚɡɨɜɨɝɨ ɭɡɥɚ
27. USB.
28. Ʉɚɤɢɟ ɷɥɟɦɟɧɬɵ ɜɯɨɞɹɬ ɜ ɚɩɩɪɚɬɧɨ-ɩɪɨɝɪɚɦɦɧɵɣ ɤɨɦɩɥɟɤɫ USB?
29. Ʉɚɤ ɜɵɩɨɥɧɹɟɬɫɹ ɨɛɦɟɧ ɞɚɧɧɵɦɢ ɱɟɪɟɡ USB?
30. Ʉɚɤɢɟ ɬɢɩɵ ɡɚɩɪɨɫɨɜ ɦɨɠɧɨ ɩɟɪɟɞɚɜɚɬɶ ɱɟɪɟɡ USB?
31. Ʉɚɤɢɟ ɪɟɝɢɫɬɪɵ ɢɫɩɨɥɶɡɭɸɬɫɹ ɩɪɢ ɪɚɛɨɬɟ ɫ USB?
32. Ʉɚɤ ɩɪɨɱɢɬɚɬɶ ɫɜɟɞɟɧɢɹ ɨɛ ɭɫɬɪɨɣɫɬɜɚɯ USB?
146
4.ʠʚʢʕʐʪWINDOWSʗʓʔʛʝʜʪLINUX
ɋɥɭɠɛɵ Windows (Windows Services) – ɷɬɨ ɫɢɫɬɟɦɧɵɟ ɩɪɨɝɪɚɦɦɵ, ɪɚɛɨɬɚɸɳɢɟ ɜ ɮɨɧɨɜɨɦ ɪɟɠɢɦɟ. Ɂɚɩɭɫɤ ɫɥɭɠɛɵ ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ ɥɢɛɨ ɩɪɢ ɡɚɝɪɭɡɤɟ
Windows, ɥɢɛɨ ɩɨ ɬɪɟɛɨɜɚɧɢɸ ɩɨɥɶɡɨɜɚɬɟɥɹ (ɜɪɭɱɧɭɸ). Ȼɨɥɶɲɢɧɫɬɜɨ ɫɥɭɠɛ,
ɤɚɤ ɩɪɚɜɢɥɨ, ɧɟ ɢɦɟɸɬ ɝɪɚɮɢɱɟɫɤɨɝɨ ɢɧɬɟɪɮɟɣɫɚ ɞɥɹ ɜɡɚɢɦɨɞɟɣɫɬɜɢɹ ɫ ɩɨɥɶɡɨɜɚɬɟɥɟɦ. ɋɥɭɠɛɵ ɦɨɝɭɬ ɪɟɚɝɢɪɨɜɚɬɶ ɧɚ ɨɩɪɟɞɟɥɟɧɧɵɟ ɫɨɛɵɬɢɹ, ɥɢɛɨ ɜɵɩɨɥɧɹɬɶ
ɫɜɨɢ ɮɭɧɤɰɢɢ ɩɨ ɝɪɚɮɢɤɭ ɜ ɨɩɪɟɞɟɥɟɧɧɵɟ
ɦɨɦɟɧɬɵ ɜɪɟɦɟɧɢ. ɋɥɭɠɛɵ Windows
ɜɵɩɨɥɧɹɸɬɫɹ ɩɨɞ ɭɩɪɚɜɥɟɧɢɟɦ ɞɢɫɩɟɬɱɟɪɚ ɭɩɪɚɜɥɟɧɢɹ ɫɥɭɠɛɚɦɢ (Service Control Manager, ɫɨɤɪɚɳɟɧɧɨ SCM).
ȼ ɜɢɞɟ ɫɥɭɠɛ ɨɛɵɱɧɨ ɪɟɚɥɢɡɭɸɬ ɫɢɫɬɟɦɵ ɭɩɪɚɜɥɟɧɢɹ ɛɚɡɚɦɢ ɞɚɧɧɵɯ, ɩɨɱɬɨɜɵɟ ɫɟɪɜɟɪɵ, ɫɢɫɬɟɦɭ ɭɩɪɚɜɥɟɧɢɹ ɩɟɱɚɬɶɸ ɢ ɬ. ɩ. ȼ Windows ɩɨɫɬɨɹɧɧɨ ɪɚɛɨɬɚɟɬ ɧɟɫɤɨɥɶɤɨ ɞɟɫɹɬɤɨɜ ɫɥɭɠɛ.
Ⱦɟɦɨɧ Linux (ɚɧɚɥɨɝ ɫɥɭɠɛɵ Windows) – ɷɬɨ ɮɨɧɨɜɵɣ ɩɪɨɰɟɫɫ, ɪɚɛɨɬɚɸɳɢɣ ɚɜɬɨɧɨɦɧɨ ɫ ɦɢɧɢɦɚɥɶɧɵɦ ɜɦɟɲɚɬɟɥɶɫɬɜɨɦ ɩɨɥɶɡɨɜɚɬɟɥɹ ɢɥɢ ɜɨɨɛɳɟ
ɛɟɡ
ɧɟɝɨ. ɉɪɢɦɟɪɨɦ ɦɨɠɟɬ ɫɥɭɠɢɬɶ HTTP-ɞɟɦɨɧ ɜɟɛɫɟɪɜɟɪɚ Apache, ɤɨɬɨɪɵɣ ɪɚɛɨɬɚɟɬ ɜ ɮɨɧɨɜɨɦ ɪɟɠɢɦɟ, ɫɤɚɧɢɪɭɹ ɡɚɞɚɧɧɵɟ ɩɨɪɬɵ ɢ ɨɛɫɥɭɠɢɜɚɹ ɫɬɪɚɧɢɰɵ ɢɥɢ
ɜɵɩɨɥɧɹɹ ɨɩɪɟɞɟɥɟɧɧɵɟ ɫɰɟɧɚɪɢɢ ɜ ɡɚɜɢɫɢɦɨɫɬɢ ɨɬ ɜɢɞɚ ɡɚɩɪɨɫɚ.
4.1.1. ɋɬɪɭɤɬɭɪɚ ɫɥɭɠɛɵ
4.1. ɋɥɭɠɛɵ Windows [9]
Ʉɨɧɫɨɥɶɧɨɟ ɩɪɢɥɨɠɟɧɢɟ Windows ɦɨɠɧɨ ɩɪɟɨɛɪɚɡɨɜɚɬɶ ɜ ɫɥɭɠɛɭ, ɜɵɩɨɥ-
ɧɢɜ ɫɥɟɞɭɸɳɢɟ ɞɟɣɫɬɜɢɹ:
ɫɨɡɞɚɬɶ ɧɨɜɭɸ ɬɨɱɤɭ ɜɯɨɞɚ main(), ɪɟɝɢɫɬɪɢɪɭɸɳɭɸ ɫɥɭɠɛɭ ɜ SCM, ɢ
ɩɪɟɞɨɫɬɚɜɥɹɸɳɭɸ ɬɨɱɤɭ ɜɯɨɞɚ ɢ ɢɦɟɧɚ ɥɨɝɢɱɟɫɤɢɯ ɫɥɭɠɛ;
ɩɪɟɨɛɪɚɡɨɜɚɬɶ ɮɭɧɤɰɢɸ main() ɜ ɮɭɧɤɰɢɸ ServiceMain(), ɪɟɝɢ-
ɫɬɪɢɪɭɸɳɭɸ ɨɛɪɚɛɨɬɱɢɤ ɤɨɦɚɧɞ ɫɥɭɠɛɵ ɢ ɢɧɮɨɪɦɢɪɭɸɳɭɸ SCM ɨ ɫɜɨɟɦ ɫɨɫɬɨɹɧɢɢ. ɂɦɹ ServiceMain() ɹɜɥɹɟɬɫɹ ɡɚɦɟɧɢɬɟɥɟɦ ɢɦɟɧɢ ɥɨɝɢɱɟɫɤɨɣ
ɫɥɭɠɛɵ
, ɩɪɢɱɟɦ ɥɨɝɢɱɟɫɤɢɯ ɫɥɭɠɛ ɦɨɠɟɬ ɛɵɬɶ ɧɟɫɤɨɥɶɤɨ;
ɫɨɡɞɚɬɶ ɮɭɧɤɰɢɸ ɨɛɪɚɛɨɬɱɢɤɚ ɭɩɪɚɜɥɹɸɳɢɯ ɤɨɦɚɧɞ ɫɥɭɠɛɵ, ɤɨɬɨɪɚɹ
ɜɵɩɨɥɧɹɟɬ ɡɚɞɚɧɧɵɟ ɞɟɣɫɬɜɢɹ ɜ ɨɬɜɟɬ ɧɚ ɤɨɦɚɧɞɵ, ɩɨɫɬɭɩɚɸɳɢɟ ɨɬ SCM.
Ɋɚɫɫɦɨɬɪɢɦ ɮɭɧɤɰɢɢ, ɜɯɨɞɹɳɢɟ ɜ ɫɨɫɬɚɜ ɫɥɭɠɛɵ.
Ɏɭɧɤɰɢɹ main() ɜɵɩɨɥɧɹɟɬ ɪɟɝɢɫɬɪɚɰɢɸ ɫɥɭɠɛɵ ɜ SCM ɢ ɡɚɩɭɫɤɚɟɬ
ɞɢɫɩɟɬɱɟɪ ɫɥɭɠɛɵ, ɞɥɹ ɱɟɝɨ ɫɥɭɠɢɬ ɮɭɧɤɰɢɹ StartServiceCtrlDis-
patcher, ɤɨɬɨɪɨɣ ɩɟɪɟɞɚɸɬɫɹ ɢɦɟɧɚ ɢ ɬɨɱɤɢ ɜɯɨɞɚ
ɞɥɹ ɨɞɧɨɣ ɢɥɢ ɧɟɫɤɨɥɶɤɢɯ
ɥɨɝɢɱɟɫɤɢɯ ɫɥɭɠɛ.
Ɏɭɧɤɰɢɹ StartServiceCtrlDispatcher ɩɪɢɧɢɦɚɟɬ ɚɞɪɟɫ
lpServiceStartTable ɦɚɫɫɢɜɚ ɷɥɟɦɟɧɬɨɜ ɬɢɩɚ SERVICE_TABLE_ENTRY,
ɤɚɠɞɵɣ ɢɡ ɤɨɬɨɪɵɯ ɫɨɞɟɪɠɢɬ ɢɦɹ ɢ ɬɨɱɤɭ ɜɯɨɞɚ ɞɥɹ ɥɨɝɢɱɟɫɤɨɣ ɫɥɭɠɛɵ. ɉɪɢɡɧɚɤ ɤɨɧɰɚ ɦɚɫɫɢɜɚ – ɞɜɚ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɵɯ ɡɧɚɱɟɧɢɹ NULL. Ɏɭɧɤɰɢɹ ɜɨɡɜɪɚɳɚɟɬ TRUE, ɟɫɥɢ ɪɟɝɢɫɬɪɚɰɢɹ ɫɥɭɠɛɵ ɩɪɨɲɥɚ ɭɫɩɟɲɧɨ. ȿɫɥɢ ɫɥɭɠɛɚ ɭɠɟ ɜɵ-
147
ɩɨɥɧɹɟɬɫɹ ɢɥɢ ɜɨɡɧɢɤɚɸɬ ɩɪɨɛɥɟɦɵ ɫ ɨɛɧɨɜɥɟɧɢɟɦ ɡɚɩɢɫɟɣ ɪɟɟɫɬɪɚ
(HKEY_LOCAL_MACHINE\SYSTEM\ CurrentControlSet\ Services),
ɮɭɧɤɰɢɹ ɡɚɜɟɪɲɚɟɬɫɹ ɫ ɨɲɢɛɤɚɦɢ, ɨɛɪɚɛɨɬɤɚ ɤɨɬɨɪɵɯ ɦɨɠɟɬ ɨɫɭɳɟɫɬɜɥɹɬɶɫɹ
ɨɛɵɱɧɵɦ ɩɭɬɟɦ.
Ɉɫɧɨɜɧɨɣ ɩɨɬɨɤ ɩɪɨɰɟɫɫɚ ɫɥɭɠɛɵ, ɜɵɡɵɜɚɸɳɟɣ ɮɭɧɤɰɢɸ StartService-
CtrlDispatcher, ɫɜɹɡɵɜɚɟɬ ɩɨɬɨɤ ɫ SCM, ɤɨɬɨɪɵɣ ɪɟɝɢɫɬɪɢɪɭɟɬ ɫɥɭɠɛɭ ɫ
ɜɵɡɵɜɚɸɳɢɦ ɩɨɬɨɤɨɦ ɜ ɤɚɱɟɫɬɜɟ ɩɨɬɨɤɚ ɞɢɫɩɟɬɱɟɪɚ ɫɥɭɠɛɵ. SCM ɧɟ ɨɫɭɳɟɫɬɜɥɹɟɬ ɜɨɡɜɪɚɬɚ ɜ ɜɵɡɵɜɚɸɳɢɣ ɩɨɬɨɤ ɞɨ ɬɟɯ
ɩɨɪ, ɩɨɤɚ ɧɟ ɡɚɜɟɪɲɚɬ ɜɵɩɨɥɧɟɧɢɟ ɜɫɟ ɫɥɭɠɛɵ. Ɂɚɦɟɬɶɬɟ ɨɞɧɚɤɨ, ɱɬɨ ɮɚɤɬɢɱɟɫɤɨɝɨ ɡɚɩɭɫɤɚ ɥɨɝɢɱɟɫɤɢɯ
ɫɥɭɠɛ ɜ ɷɬɨɬ ɦɨɦɟɧɬ ɧɟ ɩɪɨɢɫɯɨɞɢɬ; ɡɚɩɭɫɤ ɫɥɭɠɛɵ ɬɪɟɛɭɟɬ ɜɵɡɨɜɚ ɮɭɧɤɰɢɢ
StartService.
Ɋɚɫɫɦɨɬɪɢɦ ɬɢɩɨɜɨɣ ɲɚɛɥɨɧ ɞɥɹ ɮɭɧɤɰɢɢ main().
ɉɪɢɦɟɪ 4.1. ɒɚɛɥɨɧ ɮɭɧɤɰɢɢ main ɞɥɹ ɫɥɭɠɛɵ Windows.
// Ƚɥɨɛɚɥɶɧɵɟ ɩɟɪɟɦɟɧɧɵɟ
DWORD dwErrCode; // ɤɨɞ ɨɲɢɛɤɢ
SERVICE_STATUS ss; // ɫɨɫɬɨɹɧɢɟ ɫɥɭɠɛɵ
// ɨɩɢɫɚɬɟɥɶ ɫɬɚɬɭɫɚ ɫɥɭɠɛɵ
SERVICE_STATUS_HANDLE ssHandle;
// ɢɦɹ
ɫɥɭɠɛɵ
LPTSTR SomeServiceName = "SomeService";
// Ɏɭɧɤɰɢɹ main()
void main(int argc, char* argv[]) {
// ɬɚɛɥɢɰɚ ɬɨɱɟɤ ɜɯɨɞɚ
SERVICE_TABLE_ENTRY DispatcherTable[] =
{ { SomeServiceName,
(LPSERVICE_MAIN_FUNCTION)ServiceMain },
{ NULL, NULL } };
// SomeServiceName - ɢɦɹ ɫɥɭɠɛɵ
// ServiceMain - ɝɥɚɜɧɚɹ ɮɭɧɤɰɢɹ ɫɥɭɠɛɵ
// ɡɚɩɭɫɤ ɞɢɫɩɟɬɱɟɪɚ
if(!StartServiceCtrlDispatcher(DispatcherTable)) {
printf("StartServiceCtrlDispatcher:Error %ld\n",
GetLastError());
getch(); return;
}
}
Ɏɭɧɤɰɢɹ StartServiceCtrlDispatcher() ɫɜɹɡɵɜɚɟɬ ɝɥɚɜɧɵɣ ɩɨɬɨɤ
ɫɥɭɠɛɵ ɫ SCM. Ʉɨɝɞɚ SCM ɡɚɩɭɫɤɚɟɬ ɫɥɭɠɛɭ, ɨɧ ɠɞɟɬ ɜɵɩɨɥɧɟɧɢɹ ɟɸ ɮɭɧɤɰɢɢ
StartServiceCtrlDispatcher(). Ƚɥɚɜɧɵɣ ɩɨɬɨɤ ɫɥɭɠɛɵ ɞɨɥɠɟɧ ɜɵɡɜɚɬɶ
ɷɬɭ ɮɭɧɤɰɢɸ ɤɚɤ ɦɨɠɧɨ ɛɵɫɬɪɟɟ, ɢ, ɟɫɥɢ ɮɭɧɤɰɢɹ ɜɵɩɨɥɧɟɧɚ ɭɫɩɟɲɧɨ, ɩɪɨɢɫ
ɯɨɞɢɬ ɫɜɹɡɵɜɚɧɢɟ ɜɵɡɵɜɚɸɳɟɝɨ ɟɟ ɩɨɬɨɤɚ ɫ SCM. Ɋɚɛɨɬɚ ɮɭɧɤɰɢɢ ɧɟ ɡɚɜɟɪɲɚɟɬɫɹ, ɩɨɤɚ ɧɟ ɛɭɞɟɬ ɨɫɬɚɧɨɜɥɟɧɚ ɫɥɭɠɛɚ. SCM ɢɫɩɨɥɶɡɭɟɬ ɷɬɨ ɫɨɟɞɢɧɟɧɢɟ, ɱɬɨɛɵ ɩɨɫɵɥɚɬɶ ɫɥɭɠɛɟ ɭɩɪɚɜɥɹɸɳɢɟ ɡɚɩɪɨɫɵ.
-
148
ȿɫɥɢ ɫɥɭɠɛɚ ɡɚɩɭɫɤɚɟɬɫɹ ɤɚɤ ɨɬɞɟɥɶɧɵɣ ɩɪɨɰɟɫɫ, ɨɧɚ ɞɨɥɠɧɚ ɜɵɡɜɚɬɶ
ɮɭɧɤɰɢɸ StartServiceCtrlDispatcher() ɧɟɦɟɞɥɟɧɧɨ. ȼɫɸ ɧɟɨɛɯɨɞɢɦɭɸ ɢɧɢɰɢɚɥɢɡɚɰɢɸ ɫɥɟɞɭɟɬ ɞɟɥɚɬɶ ɩɨɡɠɟ, ɜ ɮɭɧɤɰɢɢ ServiceMain(). ȿɫɥɢ
ɜ ɪɚɦɤɚɯ ɨɞɧɨɝɨ ɩɪɨɰɟɫɫɚ ɡɚɩɭɫɤɚɟɬɫɹ ɧɟɫɤɨɥɶɤɨ ɫɥɭɠɛ, ɝɥɚɜɧɵɣ ɩɨɬɨɤ ɞɨɥɠɟɧ
ɜɵɡɜɚɬɶ ɮɭɧɤɰɢɸ StartServiceC-trlDispatcher() ɧɟ ɩɨɡɞɧɟɟ, ɱɟɦ ɱɟɪɟɡ 30 ɫɟɤɭɧɞ.
Ɏɭɧɤɰɢɹ ServiceMain() ɨɩɪɟɞɟɥɹɟɬɫɹ ɩɪɨɰɟɫɫɨɦ, ɤɚɤ ɬɨɱɤɚ ɜɯɨɞɚ ɞɥɹ
ɫɥɭɠɛɵ. Ⱥɪɝɭɦɟɧɬɵ
ɮɭɧɤɰɢɢ ServiceMain() ɫɥɟɞɭɸɳɢɟ: argc – ɤɨɥɢɱɟɫɬɜɨ ɚɪɝɭɦɟɧɬɨɜ, argv – ɭɤɚɡɚɬɟɥɶ ɧɚ ɦɚɫɫɢɜ, ɤɨɬɨɪɵɣ ɫɨɞɟɪɠɢɬ ɭɤɚɡɚɬɟɥɢ ɧɚ
ɫɬɪɨɤɨɜɵɟ ɚɪɝɭɦɟɧɬɵ ɮɭɧɤɰɢɢ.
ɉɪɢɦɟɪ 4.2. Ɏɭɧɤɰɢɹ ɪɟɝɢɫɬɪɚɰɢɢ ɫɥɭɠɛɵ.
void WINAPI ServiceMain(DWORD argc, LPSTR* argv) {
//ɪɟɝɢɫɬɪɚɰɢɹ ɭɩɪɚɜɥɹɸɳɟɣ ɮɭɧɤɰɢɢ ɫɥɭɠɛɵ
ssHandle =
RegisterServiceCtrlHandler(SomeServiceName, ServiceControl);
if(!ssHandle) // ȿɫɥɢ ɜɨɡɧɢɤɥɚ ɨɲɢɛɤɚ
{
printf("Ɉɲɢɛɤɚ ɪɟɝɢɫɬɪɚɰɢɢ ServiceControl\n");
getch();
return; } }
Ɏɭɧɤɰɢɹ RegisterServiceCtrlHandler() ɪɟɝɢɫɬɪɢɪɭɟɬ ɮɭɧɤɰɢɸ,
ɤɨɬɨɪɚɹ ɛɭɞɟɬ ɨɛɪɚɛɚɬɵɜɚɬɶ ɭɩɪɚɜɥɹɸɳɢɟ ɡɚɩɪɨɫɵ ɤ ɫɥɭɠɛɟ (ɧɚɩɪɢɦɟɪ, ɨɫɬɚɧɨɜ ɫɥɭɠɛɵ). ȼ
ɫɥɭɱɚɟ ɭɫɩɟɲɧɨɝɨ ɡɚɜɟɪɲɟɧɢɹ ɮɭɧɤɰɢɹ ɜɨɡɜɪɚɳɚɟɬ ɨɩɢɫɚɬɟɥɶ
ɫɬɚɬɭɫɚ ɫɥɭɠɛɵ. ɉɪɢ ɧɟɭɞɚɱɧɨɦ ɡɚɜɟɪɲɟɧɢɢ ɮɭɧɤɰɢɹ ɜɨɡɜɪɚɳɚɟɬ ɧɨɥɶ.
Ɂɚɞɚɧɢɟ ɫɨɫɬɨɹɧɢɹ ɫɥɭɠɛɵ ɪɚɫɫɦɨɬɪɢɦ ɧɚ ɩɪɢɦɟɪɟ.
ɉɪɢɦɟɪ 4.3. Ɂɚɞɚɧɢɟ ɫɨɫɬɨɹɧɢɹ ɫɥɭɠɛɵ Windows.
// ɫɬɪɭɤɬɭɪɚ, ɨɩɪɟɞɟɥɹɸɳɚɹ ɫɨɫɬɨɹɧɢɟ ɫɥɭɠɛɵ:
//(ɫɥɭɠɛɚ ɜɵɩɨɥɧɹɟɬɫɹ ɤɚɤ ɨɬɞɟɥɶɧɵɣ ɩɪɨɰɟɫɫ)
ss.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
// ɫɨɫɬɨɹɧɢɟ ɨɠɢɞɚɧɢɹ ɡɚɩɭɫɤɚ ɫɥɭɠɛɵ SetSomeServiceStatus(SERVICE_START_PENDING, NO_ERROR, 4000);
//ɢɧɢɰɢɚɥɢɡɚɰɢɹ ɫɥɭɠɛɵ SomeService InitSomeServiceData(argc, argv);
//ɭɫɬɚɧɚɜɥɢɜɚɟɦ ɫɨɫɬɨɹɧɢɟ ɪɚɛɨɬɚɸɳɟɣ ɫɥɭɠɛɵ SetSomeServiceStatus(SERVICE_RUNNING, NO_ERROR, 0);
//ɨɫɧɨɜɧɨɣ ɤɨɞ
ɩɪɨɝɪɚɦɦɵ
. . . . . . . . .
return;
Ɋɚɡɛɟɪɟɦ ɩɨɫɥɟɞɧɢɣ ɩɪɢɦɟɪ.
ɉɨɥɟ dwServiceType ɫɬɪɭɤɬɭɪɵ ss ɭɫɬɚɧɨɜɥɟɧɨ ɤɚɤ SERVICE_
WIN32_OWN_PROCESS, ɩɨɷɬɨɦɭ ɫɥɭɠɛɚ ɛɭɞɟɬ ɜɵɩɨɥɧɹɬɶɫɹ ɤɚɤ ɨɬɞɟɥɶɧɵɣ
ɩɪɨɰɟɫɫ.
149
Ɂɚɬɟɦ ɭɫɬɚɧɚɜɥɢɜɚɟɦ ɫɨɫɬɨɹɧɢɟ ɨɠɢɞɚɧɢɹ ɡɚɩɭɫɤɚ ɫɥɭɠɛɵ c ɩɨɦɨɳɶɸ
ɜɫɩɨɦɨɝɚɬɟɥɶɧɨɣ ɮɭɧɤɰɢɢ SetSomeServiceStatus(), ɤɨɬɨɪɚɹ ɢɡɦɟɧɹɟɬ
ɫɨɞɟɪɠɢɦɨɟ ɫɬɪɭɤɬɭɪɵ ss, ɢ ɢɫɩɨɥɶɡɭɟɬ SCM ɞɥɹ ɩɨɥɭɱɟɧɢɹ ɢɧɮɨɪɦɚɰɢɢ ɨ
ɫɥɭɠɛɟ.
Ⱦɚɥɟɟ ɜɵɩɨɥɧɹɟɬɫɹ ɢɧɢɰɢɚɥɢɡɚɰɢɹ ɫɥɭɠɛɵ ɫ ɩɨɦɨɳɶɸ ɩɨɥɶɡɨɜɚɬɟɥɶɫɤɨɣ
ɮɭɧɤɰɢɢ InitSomeServiceData().
Ʉɨɝɞɚ ɢɧɢɰɢɚɥɢɡɚɰɢɹ ɜɵɩɨɥɧɟɧɚ, ɜɵɡɵɜɚɟɬɫɹ ɮɭɧɤɰɢɹ SetSomeServ-
iceStatus()ɫ ɩɚɪɚɦɟɬɪɨɦ SERVICE_RUNNING, ɱɬɨɛɵ ɭɫɬɚɧɨɜɢɬɶ ɫɨɫɬɨɹɧɢɟ
ɪɚɛɨɬɚɸɳɟɣ ɫɥɭɠɛɵ, ɩɨɫɥɟ ɱɟɝɨ ɜɵɩɨɥɧɹɟɬɫɹ ɨɫɧɨɜɧɨɣ ɤɨɞ ɩɪɨɝɪɚɦɦɵ.
Ɏɭɧɤɰɢɹ
ServiceControl() ɹɜɥɹɟɬɫɹ ɭɩɪɚɜɥɹɸɳɟɣ ɮɭɧɤɰɢɟɣ ɫɥɭɠɛɵ
ɢ ɦɨɠɟɬ ɧɨɫɢɬɶ ɥɸɛɨɟ ɢɦɹ, ɨɩɪɟɞɟɥɟɧɧɨɟ ɩɪɢɥɨɠɟɧɢɟɦ.
ɉɪɢɦɟɪ 4.4. Ɏɭɧɤɰɢɹ ɞɥɹ ɭɩɪɚɜɥɟɧɢɹ ɫɥɭɠɛɨɣ Windows.
void WINAPI ServiceControl(DWORD dwControlCode) {
// ɚɧɚɥɢɡɢɪɭɟɦ ɤɨɞ ɤɨɦɚɧɞɵ ɢ ɜɵɩɨɥɧɹɟɦ ɟɟ
switch(dwControlCode) {
// ɤɨɦɚɧɞɚ ɨɫɬɚɧɨɜɚ ɫɥɭɠɛɵ
case SERVICE_CONTROL_STOP:
// ɭɫɬɚɧɚɜɥɢɜɚɟɦ ɫɨɫɬɨɹɧɢɟ - ɨɠɢɞɚɧɢɹ ɨɫɬɚɧɨɜɚ
SetSomeServiceStatus(SERVICE_STOP_PENDING,
NO_ERROR,0);
// ɜɵɩɨɥɧɹɟɦ ɨɫɬɚɧɨɜ ɫɥɭɠɛɵ
StopSomeService();
// ɭɫɬɚɧɚɜɥɢɜɚɟɦ ɫɨɫɬɨɹɧɢɟ - ɨɫɬɚɧɨɜ ɫɥɭɠɛɵ
SetSomeServiceStatus(SERVICE STOPPED,
NO_ERROR, 0);
break;
// ɨɩɪɟɞɟɥɟɧɢɟ ɬɟɤɭɳɟɝɨ ɫɨɫɬɨɹɧɢɹ ɫɥɭɠɛɵ
case SERVICE_CONTROL_INTERROGATE:
SetSomeServiceStatus(ss.dwCurrentState,
NO_ERROR, 0);
break;
default:
SetSomeServiceStatus(ss.dwCurrentState,
NO_ERROR, 0);
break; }
}
ȼ ɩɪɢɜɟɞɟɧɧɨɦ ɩɪɢɦɟɪɟ ɫ ɩɨɦɨɳɶɸ ɮɭɧɤɰɢɢ SetSomeServiceStatus()
ɦɵ ɭɫɬɚɧɚɜɥɢɜɚɟɦ ɫɨɫɬɨɹɧɢɟ ɨɠɢɞɚɧɢɹ ɨɫɬɚɧɨɜɤɢ ɫɥɭɠɛɵ, ɩɨɫɥɟ ɱɟɝɨ ɦɨɠɧɨ
ɜɵɡɜɚɬɶ ɨɩɪɟɞɟɥɹɟɦɭɸ ɩɨɥɶɡɨɜɚɬɟɥɟɦ ɮɭɧɤɰɢɸ StopSomeService(), ɤɨɬɨɪɚɹ ɜɵɩɨɥɧɢɬ ɜɫɟ ɧɟɨɛɯɨɞɢɦɵɟ ɞɟɣɫɬɜɢɹ ɩɟɪɟɞ ɨɫɬɚɧɨɜɤɨɣ ɫɥɭɠɛɵ. ɋɨɞɟɪɠɢɦɨɟ ɷɬɨɣ ɮɭɧɤɰɢɢ ɪɚɡɥɢɱɚɟɬɫɹ ɞɥɹ ɤɚɠɞɨɣ ɤɨɧɤɪɟɬɧɨɣ ɫɥɭɠɛɵ.
Ⱦɚɥɟɟ ɫ ɩɨɦɨɳɶɸ ɮɭɧɤɰɢɢ SetSomeServiceStatus() ɫɨɨɛɳɚɟɦ SCM,
ɱɬɨ ɫɥɭɠɛɚ ɨɫɬɚɧɨɜɥɟɧɚ.
150
Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]