Добавил:
ivanov666
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:Системное программирование. Учебное пособие-1
.pdf
Ɍɢɩ pid_t – ɷɬɨ ɰɟɥɵɣ ɬɢɩ, ɪɚɡɦɟɪɧɨɫɬɶ ɤɨɬɨɪɨɝɨ ɡɚɜɢɫɢɬ ɨɬ ɤɨɧɤɪɟɬɧɨɣ
ɫɢɫɬɟɦɵ. Ɂɧɚɱɟɧɢɹɦɢ ɷɬɨɝɨ ɬɢɩɚ ɦɨɠɧɨ ɨɩɟɪɢɪɨɜɚɬɶ ɤɚɤ ɨɛɵɱɧɵɦɢ ɰɟɥɵɦɢ
ɱɢɫɥɚɦɢ ɬɢɩɚ int.
ɑɬɨɛɵ ɢɦɟɬɶ ɜɨɡɦɨɠɧɨɫɬɶ ɜɟɫɬɢ ɡɚɩɢɫɶ ɜ ɥɸɛɵɟ ɮɚɣɥɵ (ɜɤɥɸɱɚɹ ɠɭɪɧɚɥɵ), ɫɨɡɞɚɧɧɵɟ ɞɟɦɨɧɨɦ, ɮɚɣɥɨɜɚɹ ɦɚɫɤɚ ɞɨɥɠɧɚ ɛɵɬɶ ɢɡɦɟɧɟɧɚ ɬɚɤɢɦ ɨɛɪɚɡɨɦ, ɱɬɨɛɵ ɨɧɢ ɦɨɝɥɢ ɛɵɬɶ ɤɚɤ ɡɚɩɢɫɚɧɵ, ɬɚɤ ɢ
ɩɪɨɱɢɬɚɧɵ. Ⱦɟɥɚɟɬɫɹ ɷɬɨ ɫ ɩɨ-
ɦɨɳɶɸ ɮɭɧɤɰɢɢ umask(), ɤɚɤ ɩɨɤɚɡɚɧɨ ɜ ɫɥɟɞɭɸɳɟɦ ɩɪɢɦɟɪɟ.
ɉɪɢɦɟɪ 4.8. ɂɡɦɟɧɟɧɢɟ ɮɚɣɥɨɜɨɣ ɦɚɫɤɢ.
/* ɨɬɞɟɥɹɟɦɫɹ ɨɬ ɪɨɞɢɬɟɥɶɫɤɨɝɨ ɩɪɨɰɟɫɫɚ –
ɫɦ. ɉɪɢɦɟɪ 4.7*/
umask(0); // ɂɡɦɟɧɹɟɦ ɮɚɣɥɨɜɭɸ ɦɚɫɤɭ
ɉɨɫɥɟ ɭɫɬɚɧɨɜɤɢ umask ɜ 0 ɦɵ ɩɨɥɭɱɢɥɢ ɩɨɥɧɵɣ ɞɨɫɬɭɩ ɤ ɮɚɣɥɚɦ, ɫɨɡɞɚɧɧɵɦ ɞɟɦɨɧɨɦ. Ⱦɚɠɟ ɟɫɥɢ ȼɵ ɧɟ ɩɥɚɧɢɪɭɟɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɤɚɤɢɟ-ɥɢɛɨ ɮɚɣɥɵ
ɜɨɨɛɳɟ, ɷɬɨ ɫɥɟɞɭɟɬ ɫɞɟɥɚɬɶ.
Ⱦɚɥɟɟ ɦɨɠɧɨ ɨɬɤɪɵɬɶ ɝɞɟ-ɧɢɛɭɞɶ ɜ ɫɢɫɬɟɦɟ ɮɚɣɥ ɠɭɪɧɚɥɚ ɧɚ ɡɚɩɢɫɶ (ɧɨ ɧɟ
ɨɛɹɡɚɬɟɥɶɧɨ). ɗɬɨ ɞɟɣɫɬɜɢɟ ɜɵɩɨɥɧɹɸɬ ɞɥɹ ɤɨɧɬɪɨɥɹ ɧɚɞ ɪɚɛɨɬɨɣ ɞɟɦɨɧɚ.
Ɂɚɬɟɦ ɫɨɡɞɚɧɧɵɣ ɧɚɦɢ ɞɨɱɟɪɧɢɣ ɩɪɨɰɟɫɫ ɞɨɥɠɟɧ ɩɨɥɭɱɢɬɶ ɭɧɢɤɚɥɶɧɵɣ
ɢɞɟɧɬɢɮɢɤɚɬɨɪ ɫɟɚɧɫɚ SID ɨɬ ɹɞɪɚ ɨɩɟɪɚɰɢɨɧɧɨɣ ɫɢɫɬɟɦɵ. Ⱦɟɥɚɟɬɫɹ ɷɬɨ ɫ ɩɨɦɨɳɶɸ ɮɭɧɤɰɢɢ setsid(), ɤɚɤ ɩɨɤɚɡɚɧɨ ɧɢɠɟ.
ɉɪɢɦɟɪ 4.9. ɉɨɥɭɱɟɧɢɟ ɢɞɟɧɬɢɮɢɤɚɬɨɪɚ ɫɟɚɧɫɚ.
pid_t pid, sid;
/* ɨɬɞɟɥɹɟɦɫɹ ɨɬ ɪɨɞɢɬɟɥɶɫɤɨɝɨ ɩɪɨɰɟɫɫɚ –
ɫɦ. ɉɪɢɦɟɪ 4.7*/
/* ɂɡɦɟɧɹɟɦ ɮɚɣɥɨɜɭɸ ɦɚɫɤɭ – ɫɦ. ɉɪɢɦɟɪ 4.8*/
umask(0);
/* ɋɨɡɞɚɟɦ ɧɨɜɵɣ SID ɞɥɹ ɞɨɱɟɪɧɟɝɨ ɩɪɨɰɟɫɫɚ */
sid = setsid();
/* Ɏɢɤɫɢɪɭɟɦ ɜɨɡɦɨɠɧɵɣ ɫɛɨɣ */
if (sid < 0) exit(EXIT_FAILURE);
Ɏɭɧɤɰɢɹ setsid() ɜɨɡɜɪɚɳɚɟɬ ɞɚɧɧɵɟ ɬɨɝɨ ɠɟ ɬɢɩɚ, ɱɬɨ ɢ fork().
ɑɬɨɛɵ ɩɪɨɜɟɪɢɬɶ, ɱɬɨ ɮɭɧɤɰɢɹ ɫɨɡɞɚɥɚ SID ɞɥɹ ɞɨɱɟɪɧɟɝɨ ɩɪɨɰɟɫɫɚ, ȼɵ ɦɨɠɟɬɟ ɢɫɩɨɥɶɡɨɜɚɬɶ ɚɧɚɥɨɝɢɱɧɭɸ ɩɪɨɰɟɞɭɪɭ
ɩɪɨɜɟɪɤɢ ɧɚ ɨɲɢɛɤɢ.
Ⱦɚɥɟɟ ɬɟɤɭɳɢɣ ɪɚɛɨɱɢɣ ɤɚɬɚɥɨɝ ɧɭɠɧɨ ɢɡɦɟɧɢɬɶ, ɭɤɚɡɚɜ ɧɚ ɧɟɤɨɬɨɪɨɟ ɦɟɫɬɨ, ɝɚɪɚɧɬɢɪɨɜɚɧɧɨ ɩɪɢɫɭɬɫɬɜɭɸɳɟɟ ɜ ɫɢɫɬɟɦɟ. ɉɨɫɤɨɥɶɤɭ ɦɧɨɝɢɟ ɞɢɫɬɪɢɛɭɬɢɜɵ Linux ɧɟ ɩɨɥɧɨɫɬɶɸ ɫɥɟɞɭɸɬ ɫɬɚɧɞɚɪɬɭ ɢɟɪɚɪɯɢɢ ɮɚɣɥɨɜɨɣ ɫɢɫɬɟɦɵ
Linux, ɬɨ ɜ ɫɢɫɬɟɦɟ ɝɚɪɚɧɬɢɪɨɜɚɧɧɨ ɩɪɢɫɭɬɫɬɜɭɟɬ ɬɨɥɶɤɨ ɤɨɪɟɧɶ ɮɚɣɥɨɜɨɣ ɫɢɫɬɟɦɵ. ɋɦɟɧɢɬɶ ɤɚɬɚɥɨɝ ɦɨɠɧɨ ɩɪɢ ɩɨɦɨɳɢ ɮɭɧɤɰɢɢ chdir().
ɉɪɢɦɟɪ 4.10. ɋɦɟɧɚ ɤɚɬɚɥɨɝɚ
ɞɥɹ ɞɟɦɨɧɚ.
pid_t pid, sid;
/* ɨɬɞɟɥɹɟɦɫɹ ɨɬ ɪɨɞɢɬɟɥɶɫɤɨɝɨ ɩɪɨɰɟɫɫɚ –
ɫɦ. ɉɪɢɦɟɪ 4.7*/
/* ɂɡɦɟɧɹɟɦ ɮɚɣɥɨɜɭɸ ɦɚɫɤɭ – ɫɦ. ɉɪɢɦɟɪ 4.8*/
umask(0);
/* ɋɨɡɞɚɟɦ ɧɨɜɵɣ SID ɞɥɹ ɞɨɱɟɪɧɟɝɨ ɩɪɨɰɟɫɫɚ – ɫɦ.
161
ɉɪɢɦɟɪ 4.9*/
/* ɂɡɦɟɧɹɟɦ ɬɟɤɭɳɢɣ ɪɚɛɨɱɢɣ ɤɚɬɚɥɨɝ */
/* Ɏɢɤɫɢɪɭɟɦ ɜɨɡɦɨɠɧɵɣ ɫɛɨɣ */
if ((chdir("/")) < 0) exit(EXIT_FAILURE);
Ɏɭɧɤɰɢɹ chdir() ɩɪɢ ɜɨɡɧɢɤɧɨɜɟɧɢɢ ɨɲɢɛɤɢ ɜɨɡɜɪɚɳɚɟɬ –1, ɱɬɨ ɩɨɡɜɨɥɹɟɬ ɩɪɨɤɨɧɬɪɨɥɢɪɨɜɚɬɶ ɫɦɟɧɭ ɤɚɬɚɥɨɝɚ.
Ɉɞɧɢɦ ɢɡ ɩɨɫɥɟɞɧɢɯ ɲɚɝɨɜ ɜ ɫɬɚɪɬɨɜɨɣ ɧɚɫɬɪɨɣɤɟ ɞɟɦɨɧɚ ɹɜɥɹɟɬɫɹ ɡɚɤɪɵɬɢɟ ɫɬɚɧɞɚɪɬɧɵɯ ɮɚɣɥɨɜɵɯ ɨɩɢɫɚɬɟɥɟɣ (ɬɚɤɢɯ ɤɚɤ STDIN, STDOUT, STDERR).
ɉɨɫɤɨɥɶɤɭ ɞɟɦɨɧ ɧɟ ɦɨɠɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶ ɬɟɪɦɢɧɚɥ, ɷɬɢ ɮɚɣɥɨɜɵɟ ɨɩɢɫɚɬɟɥɢ ɧɟ
ɧɭɠɧɵ
ɢ ɬɨɥɶɤɨ ɫɨɡɞɚɸɬ ɭɝɪɨɡɭ ɛɟɡɨɩɚɫɧɨɫɬɢ. Ɂɚɤɪɵɜɚɸɬ ɢɯ ɩɪɢ ɩɨɦɨɳɢ
ɮɭɧɤɰɢɢ close().
ɉɪɢɦɟɪ 4.11. Ɂɚɤɪɵɬɢɟ ɫɬɚɧɞɚɪɬɧɵɯ ɮɚɣɥɨɜɵɯ ɨɩɢɫɚɬɟɥɟɣ.
pid_t pid, sid;
/* ɨɬɞɟɥɹɟɦɫɹ ɨɬ ɪɨɞɢɬɟɥɶɫɤɨɝɨ ɩɪɨɰɟɫɫɚ –
ɫɦ. ɉɪɢɦɟɪ 4.7*/
/* ɂɡɦɟɧɹɟɦ ɮɚɣɥɨɜɭɸ ɦɚɫɤɭ – ɫɦ. ɉɪɢɦɟɪ 4.8 */
umask(0);
/* ɋɨɡɞɚɟɦ ɧɨɜɵɣ SID ɞɥɹ ɞɨɱɟɪɧɟɝɨ ɩɪɨɰɟɫɫɚ –
ɫɦ. ɉɪɢɦɟɪ 4.9 */
/* ɂɡɦɟɧɹɟɦ ɬɟɤɭɳɢɣ ɪɚɛɨɱɢɣ ɤɚɬɚɥɨɝ
– ɫɦ. ɉɪɢɦɟɪ 4.10 */
/* Ɂɚɤɪɵɜɚɟɦ ɫɬɚɧɞɚɪɬɧɵɟ ɮɚɣɥɨɜɵɟ ɨɩɢɫɚɬɟɥɢ */
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
ɍɥɭɱɲɟɧɢɟ
ɩɟɪɟɧɨɫɢɦɨɫɬɢ ɤɨɞɚ ɞɨɫɬɢɝɚɟɬɫɹ ɢɫɩɨɥɶɡɨɜɚɧɢɟɦ ɨɩɪɟɞɟɥɟɧ-
ɧɵɯ ɞɥɹ ɮɚɣɥɨɜɵɯ ɨɩɢɫɚɬɟɥɟɣ ɤɨɧɫɬɚɧɬ.
Ɋɚɡɪɚɛɨɬɤɚ ɩɪɨɝɪɚɦɦɧɨɝɨ ɤɨɞɚ ɞɟɦɨɧɚ.
ɋɧɚɱɚɥɚ ɧɭɠɧɨ ɜɵɩɨɥɧɢɬɶ ɢɧɢɰɢɚɥɢɡɚɰɢɸ. ɉɪɢ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɜ ɞɟɦɨɧɟ
ɧɟɨɛɯɨɞɢɦɨ ɩɪɢɦɟɧɹɬɶ ɦɟɬɨɞɵ ɨɛɧɚɪɭɠɟɧɢɹ ɢ ɨɛɪɚɛɨɬɤɢ ɨɲɢɛɨɤ. ɇɚ ɷɬɚɩɟ ɨɬɥɚɞɤɢ ɞɟɦɨɧɚ ɪɟɤɨɦɟɧɞɭɟɬɫɹ ɩɢɫɚɬɶ ɜ ɫɨɛɫɬɜɟɧɧɵɟ ɠɭɪɧɚɥɵ ɤɚɤ ɦɨɠɧɨ ɛɨɥɶɲɟ
ɢɧɮɨɪɦɚɰɢɢ ɨɛ ɟɝɨ ɪɚɛɨɬɟ.
Ʉɚɤ ɩɪɚɜɢɥɨ, ɨɫɧɨɜɧɨɣ ɤɨɞ
ɞɟɦɨɧɚ
ɧɚɯɨɞɢɬɫɹ ɜɧɭɬɪɢ ɛɟɫɤɨɧɟɱɧɨɝɨ ɰɢɤɥɚ.
ɑɚɳɟ ɜɫɟɝɨ ɢɫɩɨɥɶɡɭɟɬɫɹ ɰɢɤɥ while, ɢɦɟɸɳɢɣ ɛɟɫɤɨɧɟɱɧɨɟ ɭɫɥɨɜɢɟ ɡɚɜɟɪɲɟɧɢɹ ɫ ɜɵɡɨɜɨɦ ɮɭɧɤɰɢɢ ɨɫɬɚɧɨɜɚ sleep ɩɪɢ ɧɟɨɛɯɨɞɢɦɨɫɬɢ ɜɵɩɨɥɧɟɧɢɹ
ɱɟɪɟɡ ɮɢɤɫɢɪɨɜɚɧɧɵɟ ɢɧɬɟɪɜɚɥɵ. Ɍɚɤɢɦ ɨɛɪɚɡɨɦ, ɞɟɦɨɧ ɜɵɩɨɥɧɹɟɬ ɬɪɟɛɭɟɦɵɟ
ɞɟɣɫɬɜɢɹ, ɡɚɬɟɦ «ɡɚɫɵɩɚɟɬ» ɧɚ ɤɚɤɨɟ-ɬɨ ɜɪɟɦɹ, ɩɨɬɨɦ ɨɩɹɬɶ ɜɵɩɨɥɧɹɟɬ ɡɚɩɪɨɝɪɚɦɦɢɪɨɜɚɧɧɵɟ ɞɟɣɫɬɜɢɹ ɢ ɬ. ɞ.
ɉɪɢɦɟɪ 4.12. Ɉɫɧɨɜɧɨɣ ɰɢɤɥ ɞɟɦɨɧɚ
Linux.
pid_t pid, sid;
pid_t pid, sid;
/* ɨɬɞɟɥɹɟɦɫɹ ɨɬ ɪɨɞɢɬɟɥɶɫɤɨɝɨ ɩɪɨɰɟɫɫɚ –
162
ɫɦ. ɉɪɢɦɟɪ 4.7 */
/* ɂɡɦɟɧɹɟɦ ɮɚɣɥɨɜɭɸ ɦɚɫɤɭ – ɫɦ. ɉɪɢɦɟɪ 4.8 */
umask(0);
/* ɋɨɡɞɚɟɦ ɧɨɜɵɣ SID ɞɥɹ ɞɨɱɟɪɧɟɝɨ ɩɪɨɰɟɫɫɚ –
ɫɦ. ɉɪɢɦɟɪ 4.9 */
/* ɂɡɦɟɧɹɟɦ ɬɟɤɭɳɢɣ ɪɚɛɨɱɢɣ ɤɚɬɚɥɨɝ – ɫɦ. ɉɪɢɦɟɪ 4.10
*/
/* Ɂɚɤɪɵɜɚɟɦ ɫɬɚɧɞɚɪɬɧɵɟ ɮɚɣɥɨɜɵɟ ɨɩɢɫɚɬɟɥɢ – ɫɦ.
ɉɪɢɦɟɪ 4.11 */
/* ɂɧɢɰɢɚɥɢɡɚɰɢɹ ɞɟɦɨɧɚ */
/* «Ȼɟɫɤɨɧɟɱɧɵɣ» ɰɢɤɥ */
while (1) {
/* ȼɵɩɨɥɧɹɟɦ ɞɟɣɫɬɜɢɹ ... */ sleep(30); /* ɠɞɟɦ 30
ɫɟɤɭɧɞ */ }
Ɋɚɫɫɦɨɬɪɢɦ ɡɚɤɨɧɱɟɧɧɵɣ ɩɪɢɦɟɪ ɞɟɦɨɧɚ, ɤɨɬɨɪɵɣ ɢɥɥɸɫɬɪɢɪɭɟɬ ɜɫɟ ɷɬɚ-
ɩɵ, ɧɟɨɛɯɨɞɢɦɵɟ ɞɥɹ ɟɝɨ
ɡɚɩɭɫɤɚ ɢ ɞɚɥɶɧɟɣɲɟɣ ɪɚɛɨɬɵ. Ⱦɥɹ ɟɝɨ ɜɵɩɨɥɧɟɧɢɹ
ɫɤɨɦɩɢɥɢɪɭɣɬɟ ɤɨɞ ɩɪɢ ɩɨɦɨɳɢ gcc ɢ ɡɚɩɭɫɬɢɬɟ ɧɚ ɜɵɩɨɥɧɟɧɢɟ ɢɡ ɤɨɦɚɧɞɧɨɣ
ɫɬɪɨɤɢ. Ⱦɥɹ ɡɚɜɟɪɲɟɧɢɹ ɪɚɛɨɬɵ ɞɟɦɨɧɚ ɜɵɹɫɧɢɬɟ ɟɝɨ PID ɢ ɜɨɫɩɨɥɶɡɭɣɬɟɫɶ
ɤɨɦɚɧɞɨɣ kill ɜ ɬɟɪɦɢɧɚɥɟ Linux.
ȼ ɪɚɫɫɦɚɬɪɢɜɚɟɦɨɦ ɩɪɢɦɟɪɟ ɞɟɦɨɧɚ ɬɚɤɠɟ ɡɚɞɟɣɫɬɜɨɜɚɧɵ ɫɢɫɬɟɦɧɵɟ ɠɭɪɧɚɥɵ, ɢɫɩɨɥɶɡɨɜɚɧɢɟ ɤɨɬɨɪɵɯ ɪɟɤɨɦɟɧɞɭɟɬɫɹ ɮɢɤɫɚɰɢɢ ɢɧɮɨɪɦɚɰɢɢ ɨ ɡɚɩɭɫɤɟ/ɨɫɬɚɧɨɜɟ/ɩɚɭɡɟ/ɡɚɜɟɪɲɟɧɢɢ
ɞɟɦɨɧɚ. Ɍɚɤɠɟ ɦɨɠɧɨ ɢɫɩɨɥɶɡɨɜɚɬɶ ȼɚɲɢ ɫɨɛ-
ɫɬɜɟɧɧɵɟ ɠɭɪɧɚɥɵ, ɜɵɡɵɜɚɹ ɮɭɧɤɰɢɢ fopen(), fwrite() ɢ fclose().
ɉɪɢɦɟɪ 4.12. ɉɪɨɝɪɚɦɦɧɵɣ ɤɨɞ ɞɟɦɨɧɚ Linux.
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <syslog.h>
#include <string.h>
int main(void) {
/* ɂɞɟɧɬɢɮɢɤɚɬɨɪɵ ɩɪɨɰɟɫɫɚ ɢ ɫɟɚɧɫɚ */
pid_t pid, sid;
/* Ɉɬɜɟɬɜɥɹɟɦɫɹ ɨɬ ɪɨɞɢɬɟɥɶɫɤɨɝɨ ɩɪɨɰɟɫɫɚ */
pid = fork();
if (pid < 0) exit(EXIT_FAILURE);
else exit(EXIT_SUCCESS);
/* ɂɡɦɟɧɹɟɦ ɮɚɣɥɨɜɭɸ ɦɚɫɤɭ */
umask(0);
/* ɋɨɡɞɚɧɢɟ ɧɨɜɨɝɨ SID ɞɥɹ ɞɨɱɟɪɧɟɝɨ ɩɪɨɰɟɫɫɚ */
sid = setsid();
if (sid < 0) exit(EXIT_FAILURE);
163
/* ɂɡɦɟɧɹɟɦ ɬɟɤɭɳɢɣ ɪɚɛɨɱɢɣ ɤɚɬɚɥɨɝ */
if ((chdir("/")) < 0) exit(EXIT_FAILURE);
/* Ɂɚɤɪɵɜɚɟɦ ɫɬɚɧɞɚɪɬɧɵɟ ɮɚɣɥɨɜɵɟ ɨɩɢɫɚɬɟɥɢ */
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
/* ɂɧɢɰɢɚɥɢɡɚɰɢɹ ɞɟɦɨɧɚ */
/* «Ȼɨɥɶɲɨɣ» ɰɢɤɥ */
while (1) {
/* ȼɵɩɨɥɧɹɟɦ ɞɟɣɫɬɜɢɹ ... */
sleep(30); /* ɠɞɟɦ 30 ɫɟɤɭɧɞ */ }
exit(EXIT_SUCCESS);
}
ɇɢɠɟ ɩɪɢɜɟɞɟɧ ɩɪɢɦɟɪ ɪɟɚɥɢɡɚɰɢɢ ɞɟɦɨɧɚ, ɤɨɬɨɪɵɣ ɜɵɩɨɥɧɹɟɬ ɤɚɠɞɵɟ
10 ɦɢɧɭɬ ɤɨɦɚɧɞɭ who – ɩɨɥɭɱɟɧɢɟ ɫɩɢɫɤɚ ɩɨɞɤɥɸɱɟɧɧɵɯ ɩɨɥɶɡɨɜɚɬɟɥɟɣ, ɢ
ɡɚɩɢɫɵɜɚɟɬ ɪɟɡɭɥɶɬɚɬ ɜ ɠɭɪɧɚɥ [10].
ɉɪɢɦɟɪ 4.13. ɉɪɢɦɟɪ ɞɟɦɨɧɚ Linux, ɜɵɜɨɞɹɳɟɝɨ ɫɩɢɫɨɤ ɩɨɞɤɥɸɱɟɧɧɵɯ ɤ
ɫɢɫɬɟɦɟ
ɩɨɥɶɡɨɜɚɬɟɥɟɣ.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <syslog.h>
#include <time.h>
int Daemon(void);
char* getTime();
int writeLog(char msg[256]);
char* getCommand(char command[128]);
/*ɮɭɧɤɰɢɹ ɜɨɡɜɪɚɳɚɟɬ ɮɨɪɦɚɬɢɪɨɜɚɧɧɭɸ ɞɚɬɭ ɜɪɟɦɹ*/
char* getTime() { time_t now; struct tm *ptr; static
char tbuf[64]; bzero(tbuf,64);
time(&now);
ptr = localtime(&now);
strftime(tbuf,64, "%Y-%m-%e %H:%M:%S", ptr); return
tbuf;
}
// ɮɭɧɤɰɢɹ ɞɥɹ ɜɨɡɜɪɚɬɚ ɪɟɡɭɥɶɬɚɬɚ ɜɵɩɨɥɧɟɧɢɹ
// ɤɨɦɚɧɞɵ Linux
char* getCommand(char command[128]) {
FILE *pCom;
164
static char comText[256];
bzero(comText, 256);
char buf[64];
pCom = popen(command, "r");
//ɜɵɩɨɥɧɹɟɦ
if(pCom == NULL) {
writeLog("Error Command"); return ""; }
strcpy(comText, "");
//ɱɢɬɚɟɦ ɪɟɡɭɥɶɬɚɬ
while(fgets(buf, 64, pCom) != NULL) strcat(comText,
buf);
}
pclose(pCom); return comText;
}
// ɮɭɧɤɰɢɹ ɡɚɩɢɫɢ ɫɬɪɨɤɢ ɜ ɠɭɪɧɚɥ
int writeLog(char msg[256]) { FILE * pLog;
pLog =
fopen("/home/daemon.log",
"a");
if(pLog == NULL) return 1;
char str[312];
bzero(str, 312);
strcpy(str, getTime());
strcat(str,"==========================\n");
strcat(str, msg);
strcat(str, "\n");
fputs(str, pLog);
fclose(pLog);
return 0;
}
int main(int argc, char* argv[]) { writeLog("Daemon
Start"); pid_t parpid, sid;
parpid = fork(); //ɫɨɡɞɚɟɦ ɞɨɱɟɪɧɢɣ ɩɪɨɰɟɫɫ
if(parpid < 0) { exit(1);
} else if(parpid != 0) { exit(0);
}
/* ɂɡɦɟɧɹɟɦ ɮɚɣɥɨɜɭɸ ɦɚɫɤɭ */
umask(0);
//ɩɨɥɭɱɚɟɦ ɭɧɢɤɚɥɶɧɵɣ ɢɧɞɟɤɫ ɩɪɨɰɟɫɫɚ
sid = setsid();
if(sid < 0) { exit(1);
}
if((chdir("/")) < 0) {
// ɜɵɯɨɞɢɦ ɜ ɤɨɪɟɧɶ ɮɚɣɥɨɜɨɣ ɫɢɫɬɟɦɵ exit(1);
}
165
// ɡɚɤɪɵɜɚɟɦ ɞɨɫɬɭɩ ɤ
// ɫɬɚɧɞɚɪɬɧɵɦ ɩɨɬɨɤɚɦ ɜɜɨɞɚ-ɜɵɜɨɞɚ
close(STDIN_FILENO); close(STDOUT_FILENO);
close(STDERR_FILENO);
return Daemon(); }
// «ɛɟɫɤɨɧɟɱɧɵɣ» ɰɢɤɥ ɞɟɦɨɧɚ
int Daemon(void) {
char *log;
while(1) {
log = getCommand("who");
// ɟɫɥɢ ɜ ɫɢɫɬɟɦɟ ɤɬɨ-ɬɨ ɪɚɛɨɬɚɟɬ,
// ɬɨ ɩɢɲɟɦ ɜ ɠɭɪɧɚɥ
if(strlen(log) > 5) writeLog(log);
}
sleep(600); //ɠɞɟɦ 10 ɦɢɧɭɬ }
return 0; }
ɉɨɫɥɟ ɫɨɡɞɚɧɢɹ ɩɪɨɝɪɚɦɦɧɨɝɨ ɤɨɞɚ ɩɪɨɝɪɚɦɦɵ-ɞɟɦɨɧɚ ɟɟ ɫɥɟɞɭɟɬ ɫɤɨɦɩɢ-
ɥɢɪɨɜɚɬɶ, ɜɵɩɨɥɧɢɜ ɤɨɦɚɧɞɭ:
gcc daemon.c -g -o daemon
ȼ ɷɬɨɣ ɤɨɦɚɧɞɟ ɢɫɩɨɥɶɡɭɸɬɫɹ ɫɥɟɞɭɸɳɢɟ ɤɥɸɱɢ ɤɨɦɩɢɥɹɬɨɪɚ: -g ɜɤɥɸ
ɱɚɟɬ ɪɟɠɢɦ ɨɬɥɚɞɤɢ, -ɨ ɭɤɚɡɵɜɚɟɬ ɢɦɹ ɞɥɹ ɜɵɯɨɞɧɨɝɨ ɮɚɣɥɚ.
ɉɨɫɥɟ ɩɪɨɜɟɪɤɢ ɪɚɛɨɬɵ ɞɟɦɨɧɚ ɨɫɬɚɧɨɜɢɬɟ ɟɝɨ ɤɨɦɚɧɞɨɣ killall dae-
mon ɜ ɬɟɦɢɧɚɥɟ Linux.
-
4.3. Ʉɨɧɬɪɨɥɶɧɵɟ ɜɨɩɪɨɫɵ ɤ ɪɚɡɞɟɥɭ 4
1. ɑɬɨ ɬɚɤɨɟ ɫɥɭɠɛɚ Windows? Ʉɚɤɢɟ ɡɚɞɚɱɢ ɜɵɩɨɥɧɹɟɬ ɷɬɚ ɩɪɨɝɪɚɦɦɚ?
2. ɑɬɨ ɬɚɤɨɟ ɞɟɦɨɧ Linux? Ʉɚɤɢɟ ɡɚɞɚɱɢ ɜɵɩɨɥɧɹɟɬ ɷɬɚ ɩɪɨɝɪɚɦɦɚ?
3. ȼ ɱɟɦ ɫɨɫɬɨɢɬ ɨɬɥɢɱɢɟ ɞɟɦɨɧɚ Linux ɨɬ ɫɥɭɠɛɵ Windows?
4. ɉɟɪɟɱɢɫɥɢɬɟ ɮɭɧɤɰɢɢ, ɤɨɬɨɪɵɟ ɨɛɹɡɚɬɟɥɶɧɨ ɞɨɥɠɧɵ ɜɯɨɞɢɬɶ ɜ ɫɨɫɬɚɜ
ɫɥɭɠɛɵ Windows.
5. Ʉɚɤɢɟ ɜɵɡɨɜɵ ɞɨɥɠɧɚ ɜɤɥɸɱɚɬɶ ɝɥɚɜɧɚɹ ɮɭɧɤɰɢɹ ɫɥɭɠɛɵ Windows?
6. Ʉɚɤɢɦ ɨɛɪɚɡɨɦ ɨɫɭɳɟɫɬɜɥɹɟɬɫɹ ɭɩɪɚɜɥɟɧɢɟ ɫɨɫɬɨɹɧɢɟɦ ɫɥɭɠɛɵ
dows?
7. Ʉɚɤ ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɬɶ ɫɥɭɠɛɭ Windows?
8. ɉɨɪɹɞɨɤ ɢɧɢɰɢɚɥɢɡɚɰɢɢ ɫɥɭɠɛɵ Windows.
9. Ʉɚɤɢɟ ɬɢɩɵ ɫɥɭɠɛ Windows ȼɵ ɡɧɚɟɬɟ?
10. ɉɨɪɹɞɨɤ ɡɚɩɭɫɤɚ ɫɥɭɠɛɵ Windows.
11. ɉɨɪɹɞɨɤ ɨɫɬɚɧɨɜɚ ɫɥɭɠɛɵ Windows.
12. Ʉɚɤɢɟ ɞɟɣɫɬɜɢɹ ɞɨɥɠɟɧ ɜɵɩɨɥɧɹɬɶ ɞɟɦɨɧ Linux ɜ ɩɪɨɰɟɫɫɟ ɡɚɩɭɫɤɚ?
13. Ʉɚɤɢɟ ɮɭɧɤɰɢɢ ɹɡɵɤɚ ɋɢ ɢɫɩɨɥɶɡɭɸɬɫɹ ɞɥɹ ɡɚɞɚɧɢɹ ɩɚɪɚɦɟɬɪɨɜ ɞɟɦɨɧɚ
Linux?
14. ɉɨɱɟɦɭ ɞɟɣɫɬɜɢɹ ɞɟɦɨɧɚ Linux ɪɟɤɨɦɟɧɞɭɟɬɫɹ ɡɚɧɨɫɢɬɶ ɜ ɮɚɣɥ
15. Ʉɚɤɢɟ ɞɟɣɫɬɜɢɹ ɜɵɩɨɥɧɹɸɬɫɹ ɜ ɨɫɧɨɜɧɨɦ ɰɢɤɥɟ ɞɟɦɨɧɚ Linux?
166
Win-
ɠɭɪɧɚɥɚ?
ʞʔʟʔʦʔʜʫʠʠʪʚʝʙ
1. Ⱦɶɹɤɨɧɨɜ ȼ.ɘ. ɋɢɫɬɟɦɧɨɟ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɟ : ɭɱɟɛ. ɩɨɫɨɛɢɟ / ȼ.ɘ. Ⱦɶɹ-
ɤɨɧɨɜ, ȼ.Ⱥ. Ʉɢɬɨɜ, ɂ.Ⱥ. Ʉɚɥɢɧɱɟɜ ; ɩɨɞ ɪɟɞ. Ⱥ.Ʌ. Ƚɨɪɟɥɢɤɚ. – Ɇ. : ȼɵɫɲɚɹ ɲɤɨɥɚ, 1990. – 222 ɫ.; ɢɥ.
2. Ⱦɠɨɪɞɟɣɧ Ɋ. ɋɩɪɚɜɨɱɧɢɤ ɩɪɨɝɪɚɦɦɢɫɬɚ ɩɟɪɫɨɧɚɥɶɧɵɯ ɤɨɦɩɶɸɬɟɪɨɜ ɬɢ-
ɩɚ IBM PC, XT, AT : ɉɟɪ ɫ ɚɧɝɥ. – Ɇ. : «Ɏɢɧɚɧɫɵ ɢ ɫɬɚɬɢɫɬɢɤɚ», 1992. – 544 ɫ.
3. Ƚɭɤ Ɇ. Ⱥɩɩɚɪɚɬɧɵɟ
ɫɪɟɞɫɬɜɚ IBM PC : ɗɧɰɢɤɥɨɩɟɞɢɹ. – 3-ɟ ɢɡɞ. – ɋɉɛ. :
ɉɢɬɟɪ, 2006. – 1072 ɫ.; ɢɥ.
4. Ʌɚɜ Ɋ. Linux. ɋɢɫɬɟɦɧɨɟ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɟ. – ɋɉɛ. : ɉɢɬɟɪ, 2008. – 416 ɫ.;
ɢɥ. – (ɋɟɪɢɹ «Ȼɟɫɬɫɟɥɥɟɪɵ O'Reilly»).
5. Ʉɟɪɧɢɝɚɧ Ȼ. əɡɵɤ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɋɢ : ɩɟɪ. ɫ ɚɧɝɥ. / Ȼ. Ʉɟɪɧɢɝɚɧ, Ⱦ. Ɋɢɬ-
ɱɢ ; ɩɨɞ ɪɟɞ. ȼɫ.ɋ. ɒɬɚɪɤɦɚɧɚ. – Ɇ. : Ɏɢɧɚɧɫɵ ɢ ɫɬɚɬɢɫɬɢɤɚ, 1992. – 272 ɫ.
6. ɘɪɨɜ ȼ. Assembler : ɭɱɟɛɧɢɤ.– ɋɉȻ. : «ɉɢɬɟɪ», 2000. – 624 ɫ.
7.
ɇɟɫɜɢɠɫɤɢɣ ȼɫɟɜɨɥɨɞ. ɉɪɨɝɪɚɦɦɢɪɨɜɚɧɢɟ ɚɩɩɚɪɚɬɧɵɯ ɫɪɟɞɫɬɜ ɜ Win-
dows / ȼ. ɇɟɫɜɢɠɫɤɢɣ. – ɋɩɛ. : Ȼɏȼ-ɉɟɬɟɪɛɭɪɝ, 2004. – 880 ɫ.; ɢɥ.
8. ɉɟɪɨɜ Ɇɢɯɚɢɥ. ɉɪɨɝɪɚɦɦɢɪɨɜɚɧɢɟ USB ɜ Linux [ɗɥɟɤɬɪɨɧɧɵɣ ɪɟɫɭɪɫ] /
Ɇɢɯɚɢɥ ɉɟɪɨɜ. – Ɇɢɪ ɉɄ. – 2010. – ʋ 02. – Ɋɟɠɢɦ ɞɨɫɬɭɩɚ:
https://www.osp.ru/pcworld/2010/ 02/ 13001015/.
9. Ɋɚɡɪɚɛɨɬɤɚ ɤɥɚɫɫɢɱɟɫɤɢɯ ɩɪɢɥɨɠɟɧɢɣ Windows [ɗɥɟɤɬɪɨɧɧɵɣ ɪɟɫɭɪɫ]. –
Ɋɟɠɢɦ ɞɨɫɬɭɩɚ: https://developer.microsoft.com/ru-ru/windows/ desktop/develop.
10. ɒɟɜɟɥɟɜ Ⱦ. ɉɢɲɟɦ «ȾȿɆɈɇȺ» ɫɜɨɢɦɢ ɪɭɤɚɦɢ. [ɗɥɟɤɬɪɨɧɧɵɣ ɪɟɫɭɪɫ] /
Ⱦ. ɒɟɜɟɥɟɜ. – Ɋɟɠɢɦ ɞɨɫɬɭɩɚ: http://www.opennet.ru/ base/ dev/daemonexample.
txt.html.
167
ʞʟʗʚʝʕʔʜʗʔʏ.ʐʗʐʚʗʝʡʔʙʗʮʖʪʙʏʠʗ
ɋɬɚɧɞɚɪɬɧɚɹ ɛɢɛɥɢɨɬɟɤɚ ɋɢ ɧɟ ɹɜɥɹɟɬɫɹ ɱɚɫɬɶɸ ɫɨɛɫɬɜɟɧɧɨ ɹɡɵɤɚ, ɨɞɧɚɤɨ
ɜɫɹɤɚɹ ɫɪɟɞɚ, ɩɨɞɞɟɪɠɢɜɚɸɳɚɹ ɹɡɵɤ ɋɢ, ɨɛɹɡɚɧɚ ɩɪɟɞɨɫɬɚɜɢɬɶ ɩɪɨɝɪɚɦɦɢɫɬɭ
ɨɛɴɹɜɥɟɧɢɹ ɮɭɧɤɰɢɣ, ɬɢɩɨɜ ɢ ɦɚɤɪɨɫɨɜ, ɫɨɞɟɪɠɚɳɢɟɫɹ ɜ ɷɬɨɣ ɛɢɛɥɢɨɬɟɤɟ.
Ɏɭɧɤɰɢɢ, ɬɢɩɵ ɢ ɦɚɤɪɨɫɵ ɫɬɚɧɞɚɪɬɧɨɣ ɛɢɛɥɢɨɬɟɤɢ ɨɛɴɹɜɥɟɧɵ ɜ ɫɬɚɧɞɚɪɬɧɵɯ ɡɚɝɨɥɨɜɨɱɧɵɯ ɮɚɣɥɚɯ [5]:
<assert.h><float.h><math.h><stdarg.h>
<stdlib.h><ctype.h><limits.h><stddef.h>
<string.h><errno.h><locale.h><signal.h>
<stdio.h><time.h>
Ⱥ.1. Ȼɢɛɥɢɨɬɟɤɚ ɜɜɨɞɚ-ɜɵɜɨɞɚ stdio
Ɏɭɧɤɰɢɢ ɜɜɨɞɚ-ɜɵɜɨɞɚ, ɬɢɩɵ ɢ ɦɚɤɪɨɫɵ, ɨɩɪɟɞɟɥɟɧɧɵɟ ɜ ɮɚɣɥɟ
<stdio.h>, ɫɨɫɬɚɜɥɹɸɬ ɩɨɱɬɢ ɬɪɟɬɶ ɷɬɨɣ ɛɢɛɥɢɨɬɟɤɢ.
Ɏɭɧɤɰɢɹ fopen ɨɬɤɪɵɜɚɟɬ ɢɦɟɧɨɜɚɧɧɵɣ ɮɚɣɥ ɢ ɜɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɩɨɬɨɤɚ ɢɥɢ NULL, ɟɫɥɢ ɩɨɩɵɬɤɚ ɨɬɤɪɵɬɢɹ ɨɤɚɡɚɥɚɫɶ ɧɟɭɞɚɱɧɨɣ. ɋɢɧɬɚɤɫɢɫ ɮɭɧɤɰɢɢ:
FILE *fopen(const char *filename, const char *mode)
ɝɞɟ filename – ɢɦɹ ɮɚɣɥɚ;
mode – ɪɟɠɢɦ ɨɬɤɪɵɬɢɹ.
ɉɚɪɚɦɟɬɪ mode ɦɨɠɟɬ ɩɪɢɧɢɦɚɬɶ ɫɥɟɞɭɸɳɢɟ ɡɧɚɱɟɧɢɹ:
«r» – ɨɬɤɪɵɬɢɟ ɬɟɤɫɬɨɜɨɝɨ ɮɚɣɥɚ
ɞɥɹ ɱɬɟɧɢɹ;
«w» – ɫɨɡɞɚɧɢɟ ɬɟɤɫɬɨɜɨɝɨ ɮɚɣɥɚ ɞɥɹ ɡɚɩɢɫɢ; ɫɬɚɪɨɟ ɫɨɞɟɪɠɢɦɨɟ, ɟɫɥɢ ɨɧɨ
ɛɵɥɨ, ɫɬɢɪɚɟɬɫɹ;
«ɚ» – ɨɬɤɪɵɬɢɟ ɢɥɢ ɫɨɡɞɚɧɢɟ ɬɟɤɫɬɨɜɨɝɨ ɮɚɣɥɚ ɞɥɹ ɡɚɩɢɫɢ ɜ ɤɨɧɟɰ (ɞɨɩɢ-
ɫɵɜɚɧɢɹ);
«r+» – ɨɬɤɪɵɬɢɟ ɬɟɤɫɬɨɜɨɝɨ ɮɚɣɥɚ ɞɥɹ ɦɨɞɢɮɢɰɢɪɨɜɚɧɢɹ (ɱɬɟɧɢɹ ɢ ɡɚɩɢɫɢ);
«w+» – ɫɨɡɞɚɧɢɟ ɬɟɤɫɬɨɜɨɝɨ ɮɚɣɥɚ ɞɥɹ ɦɨɞɢɮɢɰɢɪɨɜɚɧɢɹ; ɫɬɚɪɨɟ ɫɨɞɟɪɠɢɦɨɟ, ɟɫɥɢ ɨɧɨ ɛɵɥɨ, ɫɬɢɪɚɟɬɫɹ;
ɚ+» – ɨɬɤɪɵɬɢɟ ɢɥɢ ɫɨɡɞɚɧɢɟ ɬɟɤɫɬɨɜɨɝɨ ɮɚɣɥɚ ɞɥɹ ɦɨɞɢɮɢɰɢɪɨɜɚɧɢɹ,
«
ɡɚɩɢɫɢ ɜ ɤɨɧɟɰ.
Ɋɟɠɢɦ ɦɨɞɢɮɢɰɢɪɨɜɚɧɢɹ ɩɨɡɜɨɥɹɟɬ ɜɵɩɨɥɧɹɬɶ ɱɬɟɧɢɟ ɢ ɡɚɩɢɫɶ ɜ ɨɞɢɧ ɢ
ɬɨɬ ɠɟ ɮɚɣɥ, ɩɟɪɟɞ ɩɟɪɟɯɨɞɨɦ ɨɬ ɱɬɟɧɢɹ ɤ ɡɚɩɢɫɢ ɢ ɨɛɪɚɬɧɨ ɧɟɨɛɯɨɞɢɦɨ ɜɵɡɜɚɬɶ ɮɭɧɤɰɢɸ fflush, ɢɥɢ ɮɭɧɤɰɢɸ ɩɨɡɢɰɢɨɧɢɪɨɜɚɧɢɹ ɜ ɮɚɣɥɟ. ȿɫɥɢ ɜɤɥɸɱɢɬɶ ɜ ɩɚɪɚɦɟɬɪ ɪɟɠɢɦɚ ɛɭɤɜɭ b ɩɨɫɥɟ
ɩɟɪɜɨɣ ɛɭɤɜɵ (ɧɚɩɪɢɦɟɪ, «rb» ɢɥɢ
«w+b»), ɷɬɨ ɛɭɞɟɬ ɨɡɧɚɱɚɬɶ, ɱɬɨ ɮɚɣɥ – ɞɜɨɢɱɧɵɣ. ɂɦɹ ɮɚɣɥɚ ɞɨɥɠɧɨ ɛɵɬɶ ɧɟ
ɞɥɢɧɧɟɟ FILENAME_MAX ɫɢɦɜɨɥɨɜ. Ɉɞɧɨɜɪɟɦɟɧɧɨ ɦɨɝɭɬ ɨɫɬɚɜɚɬɶɫɹ ɨɬɤɪɵɬɵɦɢ ɧɟ ɛɨɥɟɟ FOPEN_MAX ɮɚɣɥɨɜ.
Ɏɭɧɤɰɢɹ freopen ɨɬɤɪɵɜɚɟɬ ɮɚɣɥ ɜ ɡɚɞɚɧɧɨɦ ɪɟɠɢɦɟ ɢ ɚɫɫɨɰɢɢɪɭɟɬ ɫ
ɧɢɦ ɩɨɬɨɤ. Ɉɧɚ ɜɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɩɨɬɨɤ ɢɥɢ NULL ɜ ɫɥɭɱɚɟ ɨɲɢɛɤɢ. Ʉɚɤ
ɩɪɚɜɢɥɨ, freopen ɢɫɩɨɥɶɡɭɟɬɫɹ ɞɥɹ ɡɚɦɟɧɵ ɮɚɣɥɨɜ, ɚɫɫɨɰɢɢɪɨɜɚɧɧɵɯ ɫ ɩɨɬɨɤɚɦɢ stdin, stdout ɢ stderr. ɋɢɧɬɚɤɫɢɫ ɮɭɧɤɰɢɢ:
168
FILE *freopen(const char *filename,
const char *mode, FILE *stream)
ɝɞɟ stream – ɭɤɚɡɚɬɟɥɶ ɧɚ ɩɨɬɨɤ.
ɉɪɢɦɟɧɢɬɟɥɶɧɨ ɤ ɩɨɬɨɤɭ ɜɵɜɨɞɚ ɮɭɧɤɰɢɹ fflush ɜɵɩɨɥɧɹɟɬ ɡɚɩɢɫɶ ɜɫɟɯ
ɛɭɮɟɪɢɡɨɜɚɧɧɵɯ, ɧɨ ɟɳɟ ɧɟ ɡɚɩɢɫɚɧɧɵɯ ɞɚɧɧɵɯ; ɪɟɡɭɥɶɬɚɬ ɩɪɢɦɟɧɟɧɢɹ ɤ ɩɨɬɨɤɭ ɜɜɨɞɚ ɧɟ ɨɩɪɟɞɟɥɟɧ:
int fflush(FILE *stream)
ȼ ɫɥɭɱɚɟ ɨɲɢɛɤɢ ɡɚɩɢɫɢ ɮɭɧɤɰɢɹ ɜɨɡɜɪɚɳɚɟɬ EOF, ɜ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ –
ɧɭɥɶ. ȼɵɡɨɜ fflush (NULL) ɜɵɩɨɥɧɹɟɬ ɭɤɚɡɚɧɧɵɟ ɨɩɟɪɚɰɢɢ ɞɥɹ ɜɫɟɯ ɩɨɬɨɤɨɜ ɜɵɜɨɞɚ. ɋɢɧɬɚɤɫɢɫ
ɮɭɧɤɰɢɢ:
int fclose(FILE *stream)
Ɏɭɧɤɰɢɹ fclose ɜɵɩɨɥɧɹɟɬ ɡɚɩɢɫɶ ɛɭɮɟɪɢɡɨɜɚɧɧɵɯ, ɧɨ ɟɳɟ ɧɟ ɡɚɩɢɫɚɧɧɵɯ ɞɚɧɧɵɯ, ɭɧɢɱɬɨɠɚɟɬ ɧɟɩɪɨɱɢɬɚɧɧɵɟ ɛɭɮɟɪɢɡɨɜɚɧɧɵɟ ɜɯɨɞɧɵɟ ɞɚɧɧɵɟ,
ɨɫɜɨɛɨɠɞɚɟɬ ɜɫɟ ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɜɵɞɟɥɟɧɧɵɟ ɛɭɮɟɪɚ, ɩɨɫɥɟ ɱɟɝɨ ɡɚɤɪɵɜɚɟɬ ɩɨɬɨɤ. ȼɨɡɜɪɚɳɚɟɬ EOF ɜ ɫɥɭɱɚɟ ɨɲɢɛɤɢ ɢ ɧɭɥɶ ɜ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ.
Ɏɭɧɤɰɢɹ remove ɭɞɚɥɹɟɬ ɮɚɣɥ ɫ ɭɤɚɡɚɧɧɵɦ ɢɦɟɧɟɦ; ɩɨɫɥɟɞɭɸɳɚɹ ɩɨɩɵɬɤɚ ɨɬɤɪɵɬɶ ɮɚɣɥ ɫ ɷɬɢɦ
ɢɦɟɧɟɦ ɩɪɢɜɟɞɟɬ ɤ ɨɲɢɛɤɟ. ȼɨɡɜɪɚɳɚɟɬ ɧɟɧɭɥɟɜɨɟ
ɡɧɚɱɟɧɢɟ ɜ ɫɥɭɱɚɟ ɧɟɭɞɚɱɧɨɣ ɩɨɩɵɬɤɢ. ɋɢɧɬɚɤɫɢɫ ɮɭɧɤɰɢɢ:
int remove(const char *filename)
Ɏɭɧɤɰɢɹ rename ɡɚɦɟɧɹɟɬ ɫɬɚɪɨɟ ɢɦɹ ɮɚɣɥɚ (oldname) ɧɚ ɧɨɜɨɟ
(newname). Ɉɧɚ ɜɨɡɜɪɚɳɚɟɬ ɧɟɧɭɥɟɜɨɟ ɡɧɚɱɟɧɢɟ, ɟɫɥɢ ɩɨɩɵɬɤɚ ɢɡɦɟɧɢɬɶ ɢɦɹ
ɨɤɚɡɚɥɚɫɶ ɧɟɭɞɚɱɧɨɣ.
ɋɢɧɬɚɤɫɢɫ ɮɭɧɤɰɢɢ:
int rename(const char *oldname,
const char *newname)
Ɏɭɧɤɰɢɹ tmpfile ɫɨɡɞɚɟɬ ɜɪɟɦɟɧɧɵɣ ɮɚɣɥ ɫ ɪɟɠɢɦɨɦ ɞɨɫɬɭɩɚ «wb+»,
ɤɨɬɨɪɵɣ ɚɜɬɨɦɚɬɢɱɟɫɤɢ ɭɞɚɥɹɟɬɫɹ ɩɪɢ ɟɝɨ ɡɚɤɪɵɬɢɢ
ɢɥɢ ɧɨɪɦɚɥɶɧɨɦ ɡɚɜɟɪɲɟɧɢɢ ɩɪɨɝɪɚɦɦɵ. ɗɬɚ ɮɭɧɤɰɢɹ ɜɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɩɨɬɨɤɚ ɢɥɢ NULL, ɟɫɥɢ ɧɟ
ɫɦɨɝɥɚ ɫɨɡɞɚɬɶ ɮɚɣɥ.
FILE *tmpfile(void)
ȼɵɡɨɜ tmpnam (NULL) ɫɨɡɞɚɟɬ ɫɬɪɨɤɭ, ɧɟ ɫɨɜɩɚɞɚɸɳɭɸ ɧɢ ɫ ɨɞɧɢɦ ɢɡ
ɢɦɟɧ ɫɭɳɟɫɬɜɭɸɳɢɯ ɮɚɣɥɨɜ, ɢ ɜɨɡɜɪɚɳɚɟɬ ɭɤɚɡɚɬɟɥɶ ɧɚ ɜɧɭɬɪɟɧɧɢɣ ɫɬɚɬɢɱɟɫɤɢɣ ɦɚɫɫɢɜ. ɋɢɧɬɚɤɫɢɫ ɮɭɧɤɰɢɢ:
char *tmpnam(char s[L_tmpnam])
ȼɵɡɨɜ tmpnam (s) ɩɨɦɟɳɚɟɬ ɫɬɪɨɤɭ ɜ s ɢ ɜɨɡɜɪɚɳɚɟɬ ɟɟ ɜ
ɤɚɱɟɫɬɜɟ ɡɧɚ-
ɱɟɧɢɹ ɮɭɧɤɰɢɢ; ɞɥɢɧɚ s ɞɨɥɠɧɚ ɛɵɬɶ ɧɟ ɦɟɧɟɟ L_tmpnam ɫɢɦɜɨɥɨɜ. ɉɪɢ
ɤɚɠɞɨɦ ɜɵɡɨɜɟ tmpnam ɝɟɧɟɪɢɪɭɟɬɫɹ ɧɨɜɨɟ ɢɦɹ; ɩɪɢ ɷɬɨɦ ɝɚɪɚɧɬɢɪɭɟɬɫɹ ɧɟ
ɛɨɥɟɟ ɌɆɊ_ɆȺɏ ɪɚɡɥɢɱɧɵɯ ɢɦɟɧ ɡɚ ɨɞɢɧ ɫɟɚɧɫ ɪɚɛɨɬɵ ɩɪɨɝɪɚɦɦɵ. Ɉɬɦɟɬɢɦ,
ɱɬɨ tmpnam ɫɨɡɞɚɟɬ ɢɦɹ, ɚ ɧɟ ɫɚɦ ɮɚɣɥ.
int setvbuf(FILE *stream, char *buf# int mode, size_t
size)
Ɏɭɧɤɰɢɹ setvbuf ɭɩɪɚɜɥɹɟɬ ɛɭɮɟɪɢɡɚɰɢɟɣ ɩɨɬɨɤɚ; ɟɟ ɧɭɠɧɨ ɜɵɡɜɚɬɶ ɞɨ
, ɤɚɤ ɛɭɞɟɬ ɜɵɩɨɥɧɹɬɶɫɹ ɱɬɟɧɢɟ, ɡɚɩɢɫɶ ɢɥɢ ɤɚɤɚɹ-ɥɢɛɨ ɞɪɭɝɚɹ ɨɩɟɪɚɰɢɹ. ɉɚ-
ɬɨɝɨ
169
ɪɚɦɟɬɪ mode ɫɨ ɡɧɚɱɟɧɢɟɦ _IOFBF ɡɚɞɚɟɬ ɩɨɥɧɭɸ ɛɭɮɟɪɢɡɚɰɢɸ, _IOLBF –
ɩɨɫɬɪɨɱɧɭɸ ɛɭɮɟɪɢɡɚɰɢɸ ɬɟɤɫɬɨɜɨɝɨ ɮɚɣɥɚ, a _IONBF ɨɬɦɟɧɹɟɬ ɛɭɮɟɪɢɡɚɰɢɸ
ɜɨɨɛɳɟ. ȿɫɥɢ ɩɚɪɚɦɟɬɪ buf ɧɟ ɪɚɜɟɧ NULL, ɬɨ ɟɝɨ ɡɧɚɱɟɧɢɟ ɛɭɞɟɬ ɢɫɩɨɥɶɡɨɜɚɬɶɫɹ ɤɚɤ ɭɤɚɡɚɬɟɥɶ ɧɚ ɛɭɮɟɪ; ɜ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɞɥɹ ɛɭɮɟɪɚ ɛɭɞɟɬ ɜɵɞɟɥɟɧɚ
ɩɚɦɹɬɶ. ɉɚɪɚɦɟɬɪ size ɡɚɞɚɟɬ ɪɚɡɦɟɪ ɛɭɮɟɪɚ.
Ɏɭɧɤɰɢɹ setbuf ɜɨɡɜɪɚɳɚɟɬ ɧɟɧɭɥɟɜɨɟ ɡɧɚɱɟɧɢɟ ɜ ɫɥɭɱɚɟ ɨɲɢɛɤɢ.
ɋɢɧ-
ɬɚɤɫɢɫ ɮɭɧɤɰɢɢ:
void setbuf(FILE *stream, char *buf)
ȿɫɥɢ ɩɚɪɚɦɟɬɪ buf ɪɚɜɟɧ NULL, ɬɨ ɞɥɹ ɩɨɬɨɤɚ stream ɛɭɮɟɪɢɡɚɰɢɹ ɨɬɦɟɧɹɟɬɫɹ. ȼ ɩɪɨɬɢɜɧɨɦ ɫɥɭɱɚɟ ɜɵɡɨɜ setbuf ɷɤɜɢɜɚɥɟɧɬɟɧ ɜɵɡɨɜɭ (void)
setvbuf (stream, buf, _IOFBF, BUFSIZ).
Ɏɭɧɤɰɢɹ fprintf ɩɪɟɨɛɪɚɡɭɟɬ ɢ ɜɵɜɨɞɢɬ ɞɚɧɧɵɟ ɜ ɩɨɬɨɤ stream ɩɨɞ
ɭɩɪɚɜɥɟɧɢɟɦ ɫɬɪɨɤɢ ɮɨɪɦɚɬɚ format. ɋɢɧɬɚɤɫɢɫ ɮɭɧɤɰɢɢ:
int fprintf (FILE *stream, const char *format,
...)
Ɏɭɧɤɰɢɹ ɜɨɡɜɪɚɳɚɟɬɫɹ ɤɨɥɢɱɟɫɬɜɨ ɡɚɩɢɫɚɧɧɵɯ ɫɢɦɜɨɥɨɜ ɢɥɢ, ɜ ɫɥɭɱɚɟ
ɨɲɢɛɤɢ, ɨɬɪɢɰɚɬɟɥɶɧɨɟ ɱɢɫɥɨ.
ɋɬɪɨɤɚ ɮɨɪɦɚɬɚ ɫɨɞɟɪɠɢɬ ɫɩɟɰɢɚɥɶɧɵɟ ɫɢɦɜɨɥɵ, ɨɩɪɟɞɟɥɹɸɳɢɟ ɜɢɞ ɜɵɜɨɞɢɦɨɣ ɢɧɮɨɪɦɚɰɢɢ (ɫɦ. ɬɚɛɥ. 3.2).
Ɏɭɧɤɰɢɹ sprintf ɪɚɛɨɬɚɟɬ ɬɚɤ ɠɟ, ɤɚɤ ɢ printf, ɬɨɥɶɤɨ ɜɵɜɨɞ ɜɵɩɨɥɧɹɟɬ ɜ ɫɬɪɨɤɭ s, ɡɚɜɟɪɲɚɹ ɟɟ ɫɢɦɜɨɥɨɦ '\0 '. ɋɬɪɨɤɚ s ɞɨɥɠɧɚ ɛɵɬɶ ɞɨɫɬɚɬɨɱɧɨ
ɛɨɥɶɲɨɣ, ɱɬɨɛɵ ɜɦɟɳɚɬɶ ɪɟɡɭɥɶɬɚɬ ɜɵɜɨɞɚ. ȼɨɡɜɪɚɳɚɟɬ
ɤɨɥɢɱɟɫɬɜɨ ɡɚɩɢɫɚɧ-
ɧɵɯ ɫɢɦɜɨɥɨɜ ɛɟɡ ɭɱɟɬɚ '\ 0 '. ɋɢɧɬɚɤɫɢɫ ɮɭɧɤɰɢɢ:
int sprintf(char *s, const char *format, ...)
Ɏɭɧɤɰɢɢ vprintf, vfprintf ɢ vsprintf ɷɤɜɢɜɚɥɟɧɬɧɵ ɫɨɨɬɜɟɬɫɬɜɭɸɳɢɦ ɮɭɧɤɰɢɹɦ printf ɫ ɬɨɣ ɪɚɡɧɢɰɟɣ, ɱɬɨ ɩɟɪɟɦɟɧɧɵɣ ɫɩɢɫɨɤ ɚɪɝɭɦɟɧɬɨɜ ɜ ɧɢɯ ɩɪɟɞɫɬɚɜɥɟɧ ɩɚɪɚɦɟɬɪɨɦ arg, ɢɧɢɰɢɚɥɢɡɢɪɨɜɚɧɧɵɦ ɫ ɩɨɦɨɳɶɸ
ɦɚɤɪɨɫɚ va_start ɢ, ɜɨɡɦɨɠɧɨ, ɜɵɡɨɜɚɦɢ va_arg (ɫɦ. ɨɩɢɫɚɧɢɟ ɮɚɣɥɚ
<stdarg.h>). ɋɢɧɬɚɤɫɢɫ ɮɭɧɤɰɢɣ:
int vprintf(const char *format, va list arg)
int vfprintf(FILE *stream, const char *format,
va_list arg)
int vsprintf (char *s, const char *format,
va_list arg)
Ɏɭɧɤɰɢɹ fread ɫɱɢɬɵɜɚɟɬ
ɢɡ ɩɨɬɨɤɚ stream ɜ ɦɚɫɫɢɜ ptr ɧɟ ɛɨɥɶɲɟ
nobj ɨɛɴɟɤɬɨɜ ɪɚɡɦɟɪɚ size. Ɉɧɚ ɜɨɡɜɪɚɳɚɟɬ ɤɨɥɢɱɟɫɬɜɨ ɫɱɢɬɚɧɧɵɯ ɨɛɴɟɤɬɨɜ,
ɤɨɬɨɪɨɟ ɦɨɠɟɬ ɨɤɚɡɚɬɶɫɹ ɦɟɧɶɲɟ ɡɚɩɪɚɲɢɜɚɟɦɨɝɨ. size_t. ɋɢɧɬɚɤɫɢɫ ɮɭɧɤɰɢɢ:
fread(void *ptr, size_t size, size_t nobj,
FILE *stream)
Ⱦɥɹ ɨɩɪɟɞɟɥɟɧɢɹ ɭɫɩɟɲɧɨɝɨ ɡɚɜɟɪɲɟɧɢɹ ɢɥɢ ɨɲɢɛɤɢ ɩɪɢ ɱɬɟɧɢɢ ɫɥɟɞɭɟɬ
ɢɫɩɨɥɶɡɨɜɚɬɶ feof ɢ ferror.
170
Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]