Основы программирования в Linux.
· · ·
У всех программистов есть своя груда записей и черновиков. Они собирают собственные примеры текстов программ, накопившиеся за время героических погружений в многочисленные руководства или добытые из сети Usenet, в которой порой даже дураки боятся блуждать. (Другая точка зрения состоит в том, что у всех дураков свободный доступ к Usenet, и они используют ее безостановочно.) Поэтому довольно странно, что так мало книг выпущено в подобном стиле. В интерактивном мире существует множество коротких документов, касающихся конкретных проблем программирования и администрирования по существу. В рамках проекта по созданию документации Linux выпущено множество документов, посвященных самым разным темам, начиная с установки ОС Linux и Windows на одной машине и заканчивая написанием вашей виртуальной машины Java для Linux. На самом деле, загляните на Web-сайт Linux Documentation Project (проект документации Linux) по адресу http://www.tldp.org.
С другой стороны, книжный мир кажется состоящим в основном из подробных и самых полных научных томов, читать которые у вас нет времени, или книг для новичков, которые вы покупаете в шутку друзьям. Есть очень немного книг, которые пытаются рассмотреть основы целого ряда полезных проблем. Предлагаемая книга — одна из них, это набор расшифрованных (попробуйте прочесть что-нибудь, написанное программистом от руки), отредактированных и собранных в логически оправданную структуру заметок и черновиков программистов.
Данное издание книги было проверено и исправлено в соответствии с современным уровнем разработок в ОС Linux.
Алан Кокс (Alan Сох).· · ·
Рады предложить вам легкое в использовании руководство по разработке программ для Linux и других UNIX-подобных операционных систем.
В этой книге мы стремимся дать вам представление о разнообразных понятиях, важных для разработчика, применяющего систему Linux, так сказать, основы. Слово "основы" скорее относится к ее содержимому, чем к уровню подготовки читателя. Мы построили книгу так, чтобы, несмотря на уже приобретенный вами опыт, вы узнали больше о том, что может предложить Linux. Программирование в ОС Linux — обширная область, и мы стараемся представить достаточно сведений, касающихся различных тем, чтобы дать вам прочные "основы" для усвоения каждой из них.
Для кого эта книга?
Если вы программист, стремящийся повысить квалификацию за счет функциональных возможностей, предлагаемых разработчикам Linux (или UNIX), уделить больше внимания программированию и расширить применение ваших приложений в системе Linux, вы выбрали нужную книгу. Понятные объяснения и практический на основе пошаговых проверок подход поможет вам быстро повысить профессиональный уровень и освоить все ключевые методы.
Мы полагаем, что у вас есть некоторый опыт программирования на языках С и/или С++ в ОС Windows или какой-нибудь другой операционной системе, но мы старались сохранить простоту приведенных в книге примеров, чтобы для их понимания не требовалось слишком высокой квалификации в программировании на С. Все явные сопоставления методов программирования в Linux с приемами программирования на языках C/C++ отмечены в тексте книги.
Примечание. Особое примечание для тех, кто впервые знакомится с ОС Linux. Эта книга не об установке и настройке Linux. Если вы хотите узнать больше об администрировании системы Linux, возможно вы захотите познакомиться с дополнительными книгами.Поскольку книга задумана как учебник, знакомящий с различными средствами и наборами функций/библиотек, доступных вам в большинстве систем Linux, а также удобный справочник, к которому вы можете обращаться время от времени, она отличается четкой и понятной формой изложения, исчерпывающими пояснениями и подробными примерами.
Чему посвящена книга?
У книги есть ряд задач, перечисленных далее.
□ Научить применению стандартных библиотек языка С в ОС Linux и других средств, описанных в разных стандартах Linux и UNIX.
□ Показать, как использовать большинство стандартных средств разработки Linux.
□ Дать краткий обзор способов хранения данных под управлением Linux с помощью СУБД DBM и MySQL.
□ Показать, как создавать графические интерфейсы пользователя на базе графической системы X Window System. Мы воспользуемся библиотеками GTK (основы графической среды GNOME) и Qt (основы графической среды KDE).
□ Поддержать вас и дать вам практические навыки разработки собственных реальных приложений.
В ходе обсуждения этих тем мы знакомим вас с теорией программирования и затем иллюстрируем ее соответствующими примерами и понятными пояснениями. Таким образом, вы сможете быстро освоить тему и потом при необходимости вернуться к ней, чтобы освежить все существенные ее составляющие.
Помимо маленьких примеров, разработанных в основном для иллюстрации работы ряда функций или некоторых элементов теории в действии, в книге рассматривается большой пример: разработка простого приложения для работы с базой данных, хранящей информацию о коллекции аудио компакт-дисков. По мере накопления ваших знаний вы сможете разрабатывать, переделывать и расширять проект в соответствии со своими желаниями. Несмотря на сказанное, приложению для работы с компакт-дисками не отводится главная роль в главах книги, и вы можете пропустить посвященные ему страницы, но нам кажется, что оно предлагает полезные, более сложные примеры применения обсуждаемых нами методов. Оно также позволяет наилучшим образом проиллюстрировать все более сложные темы по мере их рассмотрения. Наше первое обсуждение данного приложения появится в конце главы 2 и покажет, как организован сценарий командной оболочки очень большого объема, как командная оболочка обрабатывает ввод пользователя и как она может формировать меню, хранить и искать данные.
После повторения основных правил компиляции программ, компоновки их с библиотеками и доступа к интерактивным руководствам вы проникните на время в командные оболочки. Затем вы перейдете к программированию на языке С, здесь мы обсудим работу с файлами, получение данных из окружения ОС Linux, обработку терминального ввода и вывода и библиотеку curses (позволяющую легче обрабатывать интерактивный ввод и вывод). После этого вы будете готовы взяться за новую реализацию приложения для работы с компакт-дисками на языке С. Проект приложения останется прежним, но в программном коде будет использована библиотека curses для создания экранного пользовательского интерфейса.
После этого мы обсудим управление данными. Знакомство с библиотекой базы данных dbm, к которой мы обратимся в нескольких последующих главах, — достаточное основание для переделки приложения, но на этот раз вместе с проектом. В следующей главе рассматривается хранение данных в реляционной базе данных средствами СУРБД MySQL и позже мы также повторно применим эти методы хранения данных, поэтому вы сможете сравнить разные способы управления данными. Размер новых версий приложения таков, что нам далее придется иметь дело с такими практическими задачами, как отладка, контроль исходного текста программы, распространение программного обеспечения и make-файлы.
Вы также узнаете, как могут взаимодействовать разные процессы в ОС Linux и как программы в Linux могут применять сокеты для поддержки сетевых соединений разных машин на базе протоколов TCP/IP, включая проблемы, касающиеся связи машин с процессорами разной архитектуры.
После изложения основ программирования в Linux мы обсуждаем создание программ в графическом режиме. Этому посвящены две главы, в которых сначала рассматривается комплект инструментальных средств GTK+, лежащий в основе графической среды GNOME, а затем комплект Qt, лежащий в основе графической среды KDE.
Заканчиваем мы кратким рассмотрением стандартов, делающих системы Linux разных поставщиков настолько подобными, что мы можем легко переходить из одной системы в другую и писать программы, которые будут работать в разных дистрибутивах Linux.
Как вы догадываетесь, в книге есть и многое другое, но мы надеемся, что этот краткий обзор даст вам достаточное представление о материале, который мы обсуждаем.
Что вам потребуется для использования книги?
В этой книге мы привьем вам вкус к программированию в Linux. Для того чтобы извлечь максимум пользы, нужно в процессе чтения выполнять примеры. Они служат хорошей практической базой и наверняка вдохновят вас на создание собственных программ. Мы надеемся, что вы будете читать эту книгу и одновременно экспериментировать в установленной у вас системе Linux.
Существуют варианты Linux для самых разных систем. Адаптируемость Linux такова, что предприимчивые люди заставляют ее работать в том или ином виде на любом оборудовании, имеющем процессор! Примеры включают системы на базе процессоров Alpha, ARM, IBM Cell, Itanium, PA-RISC, PowerPC, SPARC, SuperH и ЦП 68k, а также на базе различных процессоров класса х86 с 32- и 64-разрядными версиями.
Мы писали эту книгу и разрабатывали примеры в двух системах Linux с разными спецификациями, поэтому мы уверены, что если у вас есть работающая система Linux, вы сможете найти хорошее применение этой книге. Более того, пока проходило техническое рецензирование книги, мы проверили программный код в других версиях Linux.
Работая над книгой, мы сначала главным образом использовали системы на базе процессоров x86, хотя мало что из описанного в книге характерно только для х86. Несмотря на то, что можно успешно запускать Linux на PC 486 с 8 Мбайт RAM, для успешной работы современного дистрибутива Linux и выполнения примеров из этой книги мы советуем выбрать современную версию одного из наиболее популярных дистрибутивов Linux, например Fedora, openSUSE или Ubuntu, и проверить их аппаратные рекомендации.
Что касается требований к программному обеспечению, мы полагаем, что вы используете современную версию предпочитаемого вами дистрибутива Linux и, чтобы поддерживать систему на современном уровне и иметь самые свежие исправления найденных ошибок, применяете текущий набор обновлений, которые большинство поставщиков делают доступными интерактивно в виде автоматических обновлений. Linux и комплект инструментальных средств проекта GNU выпускаются на условиях GNU General Public License (GPL) (Общедоступной лицензии проекта GNU). Большинство других компонентов типичного дистрибутива Linux ссылаются либо на GPL, либо на одну из множества других лицензий Open Source (открытый или свободно распространяемый программный код), и это означает, что у них есть определенные характеристики, одна из которых — свобода. У них всегда есть исходный программный код, и никто не может отнять эту свободу. Дополнительную информацию о GPL см. на Web-сайте http://www.gnu.org/licenses/, а определение Open Source и разные применяемые лицензии — на Web-сайте http://www.opensource.org. В случае GNU/Linux у вас всегда будет возможность технической поддержки либо благодаря самостоятельной работе с исходным программным кодом, либо за счет найма стороннего специалиста или обращения к одному из поставщиков, предлагающих платную техническую поддержку.
Исходный программный код.
Для работы с примерами книги можно ввести программный код вручную или воспользоваться сопроводительными файлами с исходным текстом примеров. Весь программный код, применяемый в книге, можно найти на Web-сайте http://www.wrox.com. Открыв главную страницу сайта, просто найдите заголовок книги (либо с помощью поля Search (Поиск), либо используя один из списков заголовков) и на странице с описанием книги щелкните кнопкой мыши ссылку Download Code для того, чтобы получить весь программный код примеров.
Примечание. Поскольку у многих книг похожие заголовки, легче всего найти нужную книгу по номеру ISBN (International Standard Book Number); ISBN этой книги (оригинальной) — 978-0-470-14762-7.После загрузки программного кода из Интернета просто распакуйте его своей любимой программой сжатия. Вы также можете перейти на главную страницу загрузки программного кода издательства Wrox http://www.wrox.com/dynamic/books/download.aspx, для того чтобы просмотреть код к данной книге и ко всем остальным книгам издательства.
Замечание, касающееся программного кода примеров.
Мы старались представить примеры программ и фрагменты программного кода, наилучшим образом иллюстрирующие темы и понятия, обсуждаемые в тексте. Для того чтобы сделать новую функциональную возможность, которая рассматривается, максимально понятной, мы допускали одну-две вольности в стиле программирования.
В основном мы не всегда проверяли результаты, возвращаемые каждой вызываемой нами функцией, на соответствие ожидаемым. В профессиональном программном коде для реальных приложений мы всегда выполняли бы такую проверку, и вы должны внедрять строгие методы, касающиеся обработки ошибок. (В главе 3 мы обсуждаем некоторые способы обнаружения и обработки ошибок.)
Общедоступная лицензия проекта GNU.
Исходный программный код книги сделан доступным на условиях Общедоступной лицензии проекта GNU версии 2 (GNU General Public License, version 2), опубликованной на Web-странице http://www.gnu.org/licenses/old-licenses/gpl-2.0.html. Приведенное далее положение о разрешении и правах применяется ко всему программному коду данной книги.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
(Это программа — свободно распространяемое программное обеспечение; вы можете
распространять ее и/или изменять на условиях Общедоступной лицензии GNU,
опубликованной Фондом свободного программного обеспечения;
либо версии 2 этой лицензии, либо (по вашему усмотрению) любой более свежей версии.)
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
(Эта программа распространяется в расчете на ее полезность, но без каких-либо
гарантий, даже без подразумеваемой гарантии ТОВАРНОГО СОСТОЯНИЯ ПРИ ПРОДАЖЕ И
ПРИГОДНОСТИ ДЛЯ ИСПОЛЬЗОВАНИЯ В КОНКРЕТНЫХ ЦЕЛЯХ. Более подробную информацию
см. в Общедоступной лицензии проекта GNU.)
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
(Вы должны были получить копию Общедоступной лицензии GNU вместе с этой
программой; если этого не произошло, напишите в Фонд свободного программного
обеспечения по адресу Free Software Foundation, Inc., 59 Temple Place, Suite
330, Boston, MA 02111-1307 USA)
Стилевое оформление, принятое в книге.
Для того чтобы помочь вам максимально усвоить текст и следить за тем, что происходит, мы применили во всей книге ряд стилевых оформлений и выделений текста.
Примечание. Фрагменты, подобные данному, содержат требующую запоминания критически важную информацию, которая непосредственно относится к окружающему тексту, а также советы, подсказки, особенности и замечания, касающиеся текущего обсуждения.Когда вводятся важные понятия, мы выделяем их курсивом. Символы, которые вы должны ввести, выделяются жирным моноширинным шрифтом. Элементы интерфейса выделены полужирным шрифтом. Комбинации клавиш обозначаются следующим образом: <Ctrl>+<A>
Программный код и терминальные сеансы мы приводим тремя разными способами:
$ who
root tty1 Sep 10 16:12
rick tty2 Sep 10 16:10
Верхняя строка приведенного кода — это командная строка, а остальные строки отображаются в обычном стиле. Знак $ — приглашение (если для ввода команды требуется суперпользователь, приглашение обозначается знаком #); жирным шрифтом помечается текст, который вы должны ввести, и для выполнения команды следует нажать клавишу <Enter> (или <Return>). Любой последующий текст, набранный тем же шрифтом, но без выделения жирным, — это вывод обозначенной жирным шрифтом команды. В приведенном примере вы вводите команду who и видите ее вывод в двух строках, расположенных под ней.
Прототипы функций и структуры, определенные в системе Linux, приводятся жирным шрифтом, как показано далее:
#include <stdio.h>
int printf(const char *format, ...);
В программном коде наших примеров строки с выделенным фоном указывают на новый важный материал, например, так:
/* Это новый материал, и соответствующий код выглядит так. */
если код выглядит так, как показано далее (без выделения фоном), он менее важен:
/* Этот код уже встречался, и он выглядит так. */
Часто, когда программа создается на протяжении главы, только что добавленный код первый раз приводится без фона. Например, новая программа будет выглядеть следующим образом.
/* Программный код примера */
/* Это строка завершения. */
Если позже в этой главе мы добавим в нее новые строки, она будет выглядеть так:
/* Программный код примера. */
/* В эти строки */
/* добавляется новый код */
/* Это строка завершения. */
И последнее, принятое в книге стилевое оформление, о котором следует упомянуть, — все примеры программного кода начинаются с заголовка "Упражнение", который помогает разделить код там, где это полезно, выделить его составные части и показать, как развивается приложение. Когда это важно, мы после программного кода включаем раздел "Как это работает" для пояснения основных мест в тексте программы, касающихся изложенной перед ним теории. Мы считаем,, что эти два приема помогают разбить наиболее громоздкие листинги на легко перевариваемые кусочки.
Ошибки.
Мы приложили максимум усилий, чтобы избежать ошибок в тексте и программном коде. Но никто не идеален, и ошибки есть. Если вы найдете ошибку в одной из наших книг, мы будем очень благодарны, получив ваше сообщение о ней. Сообщив об ошибке, вы, быть может, убережете другого читателя от многочасового разочарования и в то же время поможете нам, предоставив информацию еще более высокого качества.
Для поиска страницы с ошибками, найденными в этой книге, перейдите на Web-сайт http://www.wrox.corn и найдите заголовок с помощью поля Search (Поиск) или одного из списков заголовков. Далее на странице с выходными данными книги щелкните кнопкой мыши ссылку Errata (Ошибки). Вы попадете на страницу, отображающую все ошибки, представленные на рассмотрение и опубликованные редакторами издательства Wrox. На Web-странице www.wrox.com/misc-pages/booklist.shtml можно найти полный список книг, включающий ссылки на ошибки, найденные в каждой книге.
Если вы не обнаружили "свою" ошибку на странице Errata (Ошибки), перейдите на страницу www.wrox.com/contact/techsupport.shtml и заполните форму для отправки нам найденной вами ошибки. Мы проверим присланную информацию и, если согласимся с ней, опубликуем сообщение на странице с ошибками, найденными в книге, и исправим ее в последующих изданиях книги.
Сайт p2p.wrox.com.
Для обмена мнениями с авторами и такими же, как вы, читателями присоединяйтесь к форумам Р2Р (Programmer to Programmer) на Web-сайте p2p.wrox.com. Форумы — это система на основе Web-технологии, предназначенная для отправки вашего сообщения, относящегося к книгам издательства Wrox и родственным технологиям, и обмена мнениями с другими читателями и пользователями этих технологий. Форумы предлагают функцию подписки для отправки вам по электронной почте по мере поступления новых сообщений, относящихся к выбранным вами и интересующих вас темам. На этих форумах представлены авторы и редакторы Wrox и другие специалисты, работающие в области информационных технологий.
На Web-сайте http://p2p.wrox.com вы найдете ряд разных форумов, которые помогут вам не только во время чтения книги, но и в процессе разработки ваших собственных приложений. Для присоединения к форумам выполните следующие действия:
1. Перейдите на Web-сайт p2p.wrox.com и щелкните кнопкой мыши ссылку Register (Зарегистрироваться).
2. Прочтите условия пользования и щелкните мышью кнопку Agree (Принять).
3. Введите необходимую для присоединения к форуму информацию и любую необязательную информацию, которую хотите предоставить, и щелкните мышью кнопку Submit (Отправить).
4. Вы получите по электронной почте сообщение со сведениями, описывающими, как проверить вашу учетную запись и завершить процесс присоединения к форуму.
Примечание. Читать сообщения на форумах вы сможете и без регистрации в Р2Р, но для того чтобы отправлять собственные сообщения, придется зарегистрироваться.После присоединения к форуму вы можете посылать новые сообщения и отвечать на сообщения, посланные другими пользователями. Читать сообщения можно будет в любое время, находясь в Web-пространстве. Если вы хотите получать по электронной почте новые сообщения, появляющиеся на конкретном форуме, щелкните мышью пиктограмму Subscribe to this Forum (Подписаться на этот форум), расположенную рядом с именем форума в списке форумов.
Для получения дополнительной информации о правилах использования системы Wrox Р2Р непременно прочтите Р2Р FAQ (часто задаваемые вопросы) и получите ответы о работе программного обеспечения форумов и ответы на общие вопросы, касающиеся Р2Р и книг издательства Wrox. Для чтения этих вопросов и ответов щелкните мышью ссылку FAQ на любой странице Р2Р.
Глава 1. Приступая к работе.
В этой главе вы узнаете, что такое ОС Linux и как она связана со своим прообразом — ОС UNIX, познакомитесь с функциями и средствами, предоставляемыми средой разработки программ в ОС Linux, и напишите и выполните свою первую программу. Попутно вы получите представление о:
□ UNIX, Linux и проекте GNU;
□ программах и языках программирования в ОС Linux;
□ способах поиска ресурсов разработки;
□ статических и совместно используемых библиотеках;
□ теоретических основах ОС UNIX.
Введение в UNIX, Linux и проект GNU.
В последние годы ОС Linux стала заметным явлением. И дня не проходит без того или иного упоминания Linux в электронных средствах массовой информации. Мы потеряли счет приложениям, которые стали доступны в ОС Linux и внедрившим ее организациям, включая некоторые министерства и городские администрации. Основные поставщики компьютерного оборудования, такие как корпорации IBM и Dell, поддерживают ОС Linux, а крупнейшие разработчики программного обеспечения, например компания Oracle, обеспечивают выполнение своих программ в ОС Linux. Linux стала по-настоящему конкурентоспособной операционной системой, особенно на серверном рынке.
Своим успехом она обязана системам и приложениям — предшественникам: ОС UNIX и программному обеспечению GNU. В этом разделе рассматривается, как появилась ОС Linux и каковы ее корни.
Что такое ОС UNIX?
Операционная система UNIX первоначально была разработана в компании Bell Laboratories, бывшей в то время частью телекоммуникационного гиганта, компании AT&T. Разработанная в 1970-х гг. для мини-компьютеров PDP корпорации Digital Equipment ОС UNIX стала очень популярной многопользовательской, многозадачной операционной системой для самых разных аппаратных платформ, начиная с рабочих станций PC и заканчивая многопроцессорными серверами и суперкомпьютерами.
Краткая история ОС UNIX.
Строго говоря, UNIX — это торговое название, контролируемое организацией Open Group и относящееся к компьютерной операционной системе, соответствующей определенной спецификации. В этой спецификации, именуемой "The Single UNIX Specification" ("Единая спецификация UNIX"), определены имена, интерфейсы и поведение всех обязательных функций операционной системы UNIX. Данная спецификация в значительной степени представляет собой расширенный набор более ранних спецификаций, стандартов Р1003 или POSIX (Portable Operating System Interface, интерфейс переносимой операционной системы), разработанных IEEE (Institute of Electrical and Electronic Engineers, Институт инженеров по электротехнике и радиоэлектронике).
Существует много коммерческих UNIX-подобных систем, таких как AIX корпорации IBM, UX компании HP и Solaris компании Sun Microsystems. Некоторые системы, например FreeBSD и Linux, свободно распространяются. В настоящее время спецификации Open Group удовлетворяют лишь несколько операционных систем, что позволяет предлагать их на рынке с названием UNIX.
В прошлом совместимость разных систем UNIX была реальной проблемой, хотя стандарт POSIX и оказывал неоценимую помощь в ее решении. В наши дни следование нескольким простым правилам сделало возможным создание приложений, работающих под управлением всех UNIX и UNIX-подобных систем. Более подробную информацию о стандартах ОС Linux и UNIX вы сможете найти в главе 18.
Идеология UNIX.
В последующих главах мы надеемся представить особенности программирования в ОС Linux (а следовательно, и в UNIX). Несмотря на то, что в большинстве своем программирование на языке С одинаково на разных платформах, у разработчиков Linux и UNIX есть свой взгляд на разработку программ и операционных систем.
В операционной системе UNIX, а значит и в Linux, поощряется определенный стиль программирования. Далее перечислены некоторые характеристики, общие для типовых программ и систем UNIX.
□ Простота. Многие из наиболее полезных утилит UNIX очень просты и как результат малы и понятны. KISS (Keep It Small and Simple, сохраняйте программу маленькой и простой) — отличный подход, которому следует научиться. Чем больше и сложнее система, тем наверняка в ней больше сложных ошибок, и отладка превращается в тяжелую работу, которой хотелось бы избежать.
□ Узкая направленность. Зачастую лучше сделать программу, хорошо выполняющую одну задачу, чем включать в каждую функцию полный набор нужного и ненужного. "Раздутую" программу трудно использовать и поддерживать ее работоспособность. Одноцелевые программы легче усовершенствовать при появлении улучшенных алгоритмов или интерфейсов. В ОС UNIX при необходимости выполнения трудных задач чаще комбинируются маленькие утилиты, чем делается попытка в одной большой программе предусмотреть все потребности пользователя.
□ Многократно используемые компоненты. Превращайте ядро вашего приложения в доступную библиотеку. Хорошо документированные библиотеки с простыми, но гибкими программными интерфейсами могут помочь другим пользователям разрабатывать различные варианты или применять методы в новых сферах приложения. К примерам можно отнести библиотеку базы данных dbm, представляющую собой пакет функций многократного использования, а не единую программу управления базой данных.
□ Фильтры. Многие приложения UNIX могут применяться как фильтры. Они преобразуют свой ввод и формируют вывод. Как вы увидите в дальнейшем, ОС UNIX обладает функциональными возможностями, позволяющими разрабатывать очень сложные приложения из других UNIX-программ путем комбинирования их оригинальными способами. Конечно, подобное многократное использование возможно благодаря методам разработки, упоминавшимся ранее.
□ Открытые файловые форматы. Наиболее удачные и популярные UNIX- программы применяют файлы конфигурации и файлы данных в виде обычного текста ASCII или файла на языке XML. Если в разрабатываемой вами программе можно использовать любой из этих форматов — это хороший выбор. Он позволит другим пользователям применить стандартные средства при изменении или поиске элементов конфигурации и разрабатывать новые средства для выполнения новых функций обработки файлов данных. Хорошим примером такого подхода может служить система перекрестных ссылок исходного кода ctags, записывающая сведения о местоположении символа в. виде регулярного выражения, подходящего для использования программами поиска.
□ Гибкость. Вы не можете точно предусмотреть заранее, как изобретательные пользователи будут применять вашу программу. Программируя, попытайтесь быть настолько гибким, "насколько это возможно. Старайтесь избегать любых ограничений размеров полей или числа записей. Если можно, пишите программу в расчете на применение в сети, способную выполняться одинаково хорошо при сетевом вызове и на локальной машине. Никогда не думайте, что вы знаете все о потребностях будущего пользователя.
Что такое Linux?
Как вы уже, возможно, знаете, Linux — это свободно распространяемая реализация UNIX-подобного ядра, низкоуровневой сердцевины операционной системы. Поскольку прообразом ОС Linux стала система UNIX, Linux- и UNIX-программы очень похожи. В действительности почти все программы, написанные для ОС UNIX, могут быть скомпилированы и выполнены в ОС Linux. Кроме того, некоторые коммерческие приложения, продаваемые для коммерческих версий UNIX, могут выполняться без изменения их двоичного кода в системах под управлением Linux.
ОС Linux была разработана Линусом Торвальдсом (Linus Torvalds) из Университета г. Хельсинки совместно с программистами UNIX, оказывавшими ему помощь по Интернету. Работа начиналась как хобби, а вдохновителем стала ОС Minix Энди Таненбаума (Andy Tanenbaum), маленькая UNIX-подобная система. Со временем Linux выросла, превратившись в сложную самостоятельную систему. Ее цель — отказ от патентованного кода и применение только свободно распространяемого программного кода.
В настоящее время ОС Linux существует для широкого набора компьютерных систем с разными типами процессоров, включая PC на 16- и 32-битных процессорах Intel x86 и совместимых с ними процессорах; рабочие станции и серверы на процессорах Sun SPARC, IBM PowerPC, AMD Opteron и Intel Itanium и даже некоторые карманные компьютеры PDA и игровые приставки Playstation 2 и 3 фирмы Sony. Если у устройства есть процессор, кто-то где-нибудь пытается добыть ОС Linux, выполняющуюся на этом процессоре!
Проект GNU и Фонд свободного ПО.
ОС Linux обязана своим существованием совместным усилиям множества людей. Ядро операционной системы само по себе образует лишь малую часть пригодной к использованию системы разработки. Коммерческие системы UNIX традиционно снабжаются приложениями, обеспечивающими системные сервисы и средства. Для систем Linux подобные дополнительные программы написаны множеством разных программистов и распространяются они свободно.
Linux-сообщество (совместно с другими людьми) поддерживает идею свободного программного обеспечения (ПО), т.е. свободного от ограничений и подчиняющегося Общедоступной лицензии проекта GNU (GNU General Public License, GPL). (GNU означает GNU's Not UNIX (GNU не UNIX).) Несмотря на то, что получение программного обеспечения может быть небесплатным, это ПО может использоваться как угодно и обычно распространяется в виде исходного программного кода.
Фонд свободного программного обеспечения (Free Software Foundation) был организован Ричардом Столлменом (Richard Stallman) — автором GNU Emacs, одного из самых известных текстовых редакторов для ОС UNIX и других систем. Столлмен — автор концепции свободного программного обеспечения и организатор проекта GNU, попытки создания операционной системы и среды разработки, совместимой с ОС UNIX, но не подверженной ограничениям, связанным с торговой маркой UNIX и предоставлением исходного программного кода. В любой момент может оказаться, что проект GNU сильно отличается от UNIX способами поддержки аппаратных средств и управления исполняемыми программами, но он будет продолжать поддерживать приложения в стиле UNIX.
Проект GNU уже снабдил программистское сообщество множеством приложений, сильно напоминающих, компоненты, входящие в системы UNIX. Все эти программы, называемые программным обеспечением GNU, распространяются в соответствии с Общедоступной лицензией GNU (GPL), копию которой можно найти на сайте http://www.gnu.org. В этой лицензии вводится понятие "авторского "лева" (copyleft)" (в противоположность авторскому праву ("copyright")). Авторское "лево" задумано как препятствие установлению каких-либо ограничений на использование свободного программного обеспечения.
Далее приведены основные примеры ПО проекта GNU, распространяемого в соответствии с лицензией GPL:
□ пакет компиляторов GCC (GNU Compiler Collection), включающий компилятор GNU С;
□ G++ — компилятор С++, включающий как часть GCC;
□ GDB — отладчик на уровне исходного кода;
□ GNU make — версия UNIX-автосборщика make;
□ Bison — генератор синтаксических анализаторов, совместимый с генератором компиляторов UNIX yacc;
□ bash — командная оболочка;
□ GNU Emacs — текстовый редактор и среда разработки.
Кроме того, было разработано и распространено на принципах свободного ПО и под контролем лицензии GPL множество других пакетов, включая электронные таблицы, средства управления программным кодом, компиляторы, интерпретаторы, интернет-средства, программы обработки графических объектов, например, графический редактор Gimp и две законченные объектно-ориентированные среды разработки: GNOME и KDE. Мы обсудим GNOME и KDE в главах 16 и 17.
Сейчас существует такое множество доступного свободного программного обеспечения, что если добавить к нему ядро Linux, можно сказать, что благодаря Linux достигнута основная цель проекта GNU — свободная UNIX-подобная система. Признавая вклад программного обеспечения проекта GNU, многие люди теперь, как правило, называют Linux-системы GNU/Linux.
Более подробную информацию о концепции свободного программного обеспечения можно получить на Web-сайте http://www.gnu.org.
Дистрибутивы Linux.
Как мы уже упоминали, Linux — это только ядро. Вы можете получить исходный программный код ядра, откомпилировать его и установить на машину, а затем получить и установить много другого свободного программного обеспечения для завершения установки ОС Linux. Такие установки часто называют системами Linux, т.к. они содержат много программ помимо ядра. Большинство утилит приходит от проекта GNU Фонда свободного ПО.
Понятно, что создание системы Linux только из исходного программного кода — трудное дело. К счастью, многие люди подготовили готовые к установке дистрибутивы (часто называемые разновидностями (flavor)), обычно загружаемые из Интернета или с CD/DVD-накопителей и содержащие не только ядро, но и множество других программных средств и утилит. Часто в их состав входит реализация X Window System — графической оболочки, общей для множества систем UNIX. Дистрибутивы обычно снабжаются программой установки и дополнительной документацией (как правило, все на компакт-дисках), чтобы помочь вам установить собственную систему Linux. К некоторым хорошо известным дистрибутивам, в особенности для семейства процессоров Intel х86, относятся дистрибутивы Red Hat Enterprise Linux и его усовершенствованный сообществом родственник Fedora, Novell SUSE Linux и свободно распространяемый вариант openSUSE, Ubuntu Linux, Slackware, Gentoo и Debian GNU/Linux. Подробную информацию о множестве других дистрибутивов можно найти на Web-сайте DistroWatch по адресу http://distrowatch.com.
Программирование в ОС Linux.
Многие думают, что программирование в Linux означает применение языка программирования С. Известно, что ОС UNIX первоначально была написана на С и что большинство UNIX-приложений были написаны на языке С. Но для программистов ОС Linux, или UNIX, С — не единственно возможный вариант. Далее в книге мы назовем пару альтернатив.
Примечание. На самом деле первая версия UNIX была написана в 1969 г. на ассемблере PDP 7. Язык С был задуман Деннисом Ритчи (Dennis Ritchie) примерно в это время, и в 1973 г. он вместе с Кеном Томпсоном (Ken Tompson) по существу переписал на С все ядро UNIX, совершив настоящий подвиг в эпоху разработки системного программного обеспечения на языке ассемблера.В системах Linux доступен широкий диапазон языков программирования, многие из них свободно распространяются и есть на компакт-дисках или в архивах на FTP- сайтах в Интернете. Далее перечислена часть языков программирования, доступных программистам Linux:
□ Ada;
□ С;
□ С++;
□ Eiffel;
□ Forth;
□ Fortran;
□ Icon;
□ Java;
□ JavaScript;
□ Lisp;
□ Modula 2;
□ Modula 3;
□ Oberon;
□ Objective С;
□ Pascal;
□ Perl;
□ Prolog;
□ PostScript;
□ Python;
□ Ruby;
□ Smalltalk;
□ PHP;
□ Tcl/Tk;
□ Bourne Shell.
В главе 2 мы покажем, как применять оболочку Linux для разработки приложений малого и среднего размера. В оставшейся части книги мы сконцентрируемся главным образом на языке С и уделим основное внимание изучению программных интерфейсов ОС Linux с точки зрения программиста, поэтому мы рассчитываем на знание читателей языка программирования С.
Linux-программы.
Linux-приложения представлены файлами двух типов: исполняемыми (executable) и сценариями или пакетными файлами (script). Исполняемые файлы — это программы, которые могут непосредственно выполняться на компьютере; они соответствуют файлам ОС Windows с расширением exe. Сценарии или пакетные файлы — это наборы команд для выполнения другой программой, интерпретатором. Они соответствуют в ОС Windows файлам с расширением bat или cmd или интерпретируемым программам на языке Basic.
ОС Linux не требует, чтобы исполняемые или пакетные файлы имели определенные имена или какие-либо расширения. Для обозначения файла как способной выполняться программы применяются атрибуты файловой системы, которые будут обсуждаться в главе 2. В ОС Linux вы можете заменять пакетные файлы откомпилированными программами (и наоборот), не оказывая влияния на другие программы или пользователей, которые обращаются к ним. На уровне пользователя, по сути, между ними нет разницы.
В процессе регистрации в системе Linux вы взаимодействуете с программой командной оболочки (часто bash), которая запускает программы так же, как это делает оболочка командной строки в ОС Windows. Она находит запрашиваемые вами программы по имени, выполняя поиск файла с тем же именем в заданном наборе каталогов. Каталоги, предназначенные для поиска, хранятся в переменной оболочки PATH, так же как в ОС Windows. Путь поиска (который вы можете пополнять) настраивается вашим системным администратором и обычно содержит стандартные каталоги, в которых сохраняются системные программы. К ним относятся:
□ /bin — бинарные файлы (binaries), программы, применяемые для загрузки системы;
□ /usr/bin — пользовательские библиотеки, стандартные программы, доступные пользователям;
□ /usr/local/bin — локальные библиотеки, программы, относящиеся к этапу инициализации.
Если войти в систему как администратор, например с именем root, можно использовать переменную PATH, которая включает каталоги с хранящимися системными программами, такие как /sbin и /usr/sbin.
Необязательные компоненты операционной системы и приложения сторонних производителей могут устанавливаться в подкаталоги /opt, а добавить инсталляционные программы в вашу переменную PATH можно через пользовательские инсталляционные сценарии.
Примечание. Не стоит удалять каталоги из переменной PATH, пока нет полной уверенности в результате, который будет получен.Обратите внимание на то, что в ОС Linux, как и UNIX, для разделения отдельных элементов в переменной PATH применяется символ двоеточия (:) в отличие от символа точки с запятой, используемого в ОС MS-DOS и Windows. (ОС UNIX сделала выбор первой, поэтому спрашивайте, почему отличается Windows, а не почему в UNIX все не так!) Далее приведен пример переменной PATH:
/usr/local/bin:/bin:/usr/bin:.:/home/neil/bin:/usr/X11R6/bin
В этой переменной PATH содержатся каталоги для хранения стандартных программ, текущий каталог (.), исходный каталог пользователя и каталог графической оболочки X Window System.
Запомните, в ОС Linux используется прямой слэш (/) для отделения имен каталогов в полном имени файла в отличие от обратного слэша (\), применяемого в ОС Windows. И снова ОС UNIX выбирала первой.
Текстовые редакторы.
Для ввода и набора примеров программного кода, приведенных в книге, вам понадобится текстовый редактор. В типовых системах Linux есть большой выбор таких программ. У многих пользователей популярен редактор vi.
Оба автора предпочитают Emacs, поэтому мы предлагаем потратить немного времени на знакомство с основными функциями этого мощного редактора. Почти во все дистрибутивы ОС Linux Emacs включен как необязательный пакет, который можно установить. Кроме того, вы можете получить его на Web-сайте GNU по адресу http://www.gnu.org или же взять версию для графических сред разработки на Web-сайте XEmacs по адресу http://www.xemacs.org.
Для того чтобы узнать больше о редакторе Emacs, можно воспользоваться его интерактивным средством обучения. Начните с выполнения команды emacs, затем нажмите комбинацию клавиш <Ctrl>+<H> с последующим вводом символа t для доступа к этому средству. У редактора Emacs есть также полное руководство. Для получения дополнительной информации о нем в редакторе Emacs нажмите комбинацию клавиш <Ctrl>+<H> с последующим вводом символа i. В некоторых версиях Emacs может быть меню, предоставляющее доступ к средству обучения и полному руководству.
Компилятор языка С.
В системах, соответствующих стандарту POSIX, компилятор языка С называется с89. Раньше компилятор языка С назывался просто сс. Шли годы, разные поставщики продавали UNIX-подобные системы с компиляторами С, обладающими разными функциями и параметрами, но очень часто все также названными сс.
Когда создавался стандарт POSIX, выяснилось, что невозможно определить стандартную команду cc, которая была бы совместима со всеми этими разработками.
Вместо этого комитет решил создать новую стандартную команду для компилятора языка С — с89. Если эта команда представлена, она всегда использует одни и те же опции независимо от машины.
В системах Linux, которые на деле пытаются следовать стандартам, можно обнаружить, что все или некоторые из команд с89, cc и gcc ссылаются на системный компилятор языка С, обычно компилятор GNU С или gcc. В системах UNIX компилятор языка С почти всегда называется cc.
В этой книге мы используем gcc, поскольку он поставляется в дистрибутивах Linux и потому что он поддерживает для языка С синтаксис стандарта ANSI. Если когда-нибудь вы обнаружите, что в вашей системе нет gcc, мы советуем получить его и установить. Найти его вы можете по адресу http://www.gnu.org. Всюду, где мы используем в книге команду gcc, просто заменяйте ее подходящей командой вашей системы.
Упражнение 1.1. Ваша первая Linux-программа на языке C.
В этом примере вы начнете разработку в ОС Linux с помощью языка С, написав, откомпилировав и выполнив свою первую Linux-программу. Ею, кстати, может стать самая известная из всех программ для начинающих — программа, выводящая сообщение "Hello World" ("Привет, мир").
1. Далее приводится текст файла hello.c:
#include <stdio.h>
#include <stdlib.h>
int main() {
printf("Hello World\n");
exit(0);
}
2. Теперь откомпилируйте, скомпонуйте и выполните вашу программу.
$ gcc -о hello.c $ ./hello
Hello World
Как это работает
Вы запустили компилятор GNU С (в Linux, вероятнее всего, он будет доступен и как cc), который оттранслировал исходный код на языке С в исполняемый файл, названный hello. Вы выполнили программу, и она вывела на экран приветствие. Это наипростейший из существующих примеров, но если вы смогли с помощью вашей системы добраться до этого места, то сможете откомпилировать и выполнить и остальные примеры из книги. Если же программа не сработала, убедитесь в том, что в вашей системе установлен компилятор языка С. Например, во многих дистрибутивах Linux есть установочная опция, названная Software Development (Разработка ПО) (или что-то похожее), которую следует выбрать для установки необходимых пакетов.
Поскольку это первая выполненная вами программа, самое время обратить внимание на некоторые основные положения. Программа hello, вероятно, должна быть в вашем исходном каталоге. Если в переменную PATH не включена ссылка на ваш исходный каталог, оболочка не сможет найти программу hello. Более того, если один из каталогов в переменной PATH содержит другую программу, названную hello, вместо вашей будет выполнена эта программа. То же самое произойдет, если такой каталог упомянут в переменной path раньше вашего исходного каталога. Для решения этой потенциальной проблемы можно снабдить имена программ префиксом ./ (например, ./hello). Данный префикс сообщает оболочке о необходимости выполнить программу с заданным именем, находящуюся в текущем каталоге. (Точка — это условное название текущего каталога.)
Если вы забыли опцию -o name, которая указывает компилятору, куда поместить исполняемый файл, компилятор поместит его в файл с именем a.out (что означает ассемблерный вывод). Не забудьте поискать файл с именем a.out, если вы уверены, что скомпилировали программу, а найти ее не можете! Когда ОС UNIX только появилась, пользователи, хотевшие играть в ней в игры, часто запускали их как файл с именем a.out, чтобы не быть пойманными системным администратором, и некоторые установки ОС UNIX традиционно удаляют каждый вечер все файлы с именем a.out.
Маршрутная карта системы разработки.
Разработчику ОС Linux важно знать кое-что о том, где размещаются средства и ресурсы разработки. В следующих разделах дан краткий обзор некоторых важных каталогов и файлов.
Приложения.
Приложения обычно хранятся в отведенных для них каталогах. Приложения, предоставляемые системой для общего использования, включая средства разработки программ, находятся в каталоге /usr/bin. Приложения, добавленные системными администраторами для конкретного хост-компьютера или локальной сети, часто хранятся в каталоге /usr/local/bin или /opt.
Администраторы предпочитают /opt и /usr/local, потому что они хранят предоставляемые конкретными поставщиками файлы и свежие дополнения отдельно от приложений, предоставляемых системой. Подобная организация хранения файлов может помочь, когда придет время обновлять операционную систему, т.к. в этом случае потребуется сберечь только каталоги /opt и /usr/local. Мы рекомендуем компилировать в ветви иерархии /usr/local только системные приложения общего назначения, предназначенные для запуска и доступа к требуемым файлам. Для разрабатываемых программ и личных приложений лучше всего применять папку в вашем исходном каталоге.
Дополнительные средства и системы программирования могут иметь собственные структуры каталогов и каталоги программ. Важнейшая среди них — графическая оболочка X Window System, которая обычно устанавливается в каталог /usr/X11 или каталог /usr/bin/X11. В дистрибутивах Linux, как правило, применяется версия X.Org Foundation графической оболочки X Window System, базирующаяся на модификации Revision 7 (X11R7). В других UNIX-подобных системах могут быть выбраны иные версии X Window System, устанавливаемые в другие каталоги, например, каталог /usr/openwin для оболочки Open Windows компании Sun в системе Solaris.
Программа системного драйвера компилятора GNU, gcc (которую вы использовали в предыдущем упражнении) обычно помещается в каталог usr/bin или usr/local/bin, но она будет запускать различные поддерживающие компиляцию приложения из других каталогов. Эти каталоги задаются во время компиляции самого компилятора и зависят от типа хост-компьютера. В системах Linux это может быть зависящий от конкретной версии подкаталог /usr/lib/gcc/. На одной из машин одного из авторов во время написания книги это был подкаталог /usr/lib/gcc/i586-suse-linux/4.1.3. В нем хранятся отдельные проходы компилятора GNU C/C++ и специфические заголовочные файлы GNU.
Заголовочные файлы.
В процессе программирования на языке С и других языках вам потребуются заголовочные файлы или файлы заголовков для включения определений констант и объявлений вызовов системных и библиотечных функций. В случае языка С эти файлы почти всегда находятся в каталоге /usr/include и его подкаталогах. Заголовочные файлы, зависящие от конкретного воплощения запущенной вами ОС Linux, вы, как правило, найдете в каталогах /usr/include/sys и /usr/include/linux.
У других систем программирования тоже есть заголовочные файлы, хранящиеся в каталогах, которые автоматически находятся соответствующим компилятором. Примерами могут служить каталоги /usr/include/X11 для графической оболочки X Window System и /usr/include/c++ для языка GNU С++.
Вы можете использовать заголовочные файлы из подкаталогов или нестандартных мест хранения, указав флаг -I (для include) в строке вызова компилятора языка С. Например, команда
$ gcc -I/usr/openwin/include fred.c
заставит искать заголовочные файлы, использованные в программе fred.c, в стандартных каталогах и в каталоге /usr/openwin/include. Для получения дополнительных сведений обратитесь к руководству компилятора С ( man gcc).
Искать заголовочные файлы с конкретными определениями и прототипами конкретных функций часто удобно с помощью команды grep. Предположим, вам нужно знать имя из директив #define, используемое для возврата из программы статуса завершения. Просто замените каталог на /usr/include и примените grep для поиска предполагаемой части имени следующим образом:
$ grep EXIT_ *.h
...
stdlib.h#define EXIT_FAILURE 1 /*Failing exit status. */
stdlib.h#define EXIT_SUCCESS 0 /*Successful exit status. */
...
$
В этом случае команда grep ищет в каталоге все файлы с именами, заканчивающимися на .h, со строкой EXIT_. В данном примере она нашла (среди прочих) нужное вам определение в файле stdlib.h.
Библиотечные файлы.
Библиотеки — это наборы заранее откомпилированных функций, написанных в расчете на многократное использование. Обычно они состоят из наборов связанных функций, предназначенных для решения общей задачи. Примерами могут служить библиотеки функций работы с экраном (библиотеки curses и ncurses) и процедуры доступа к базе данных (библиотека dbm). В последующих главах мы познакомим вас с некоторыми библиотеками.
Стандартные системные библиотеки обычно хранятся в каталогах /lib и /usr/lib. Компилятору языка С (или, точнее, компоновщику) необходимо сообщить, в каких библиотеках искать, поскольку по умолчанию он ищет только в стандартной библиотеке С. Это пережиток, пришедший к нам из того времени, когда компьютеры были медленными и циклы ЦПУ были дороги. Недостаточно поместить библиотеку в стандартный каталог и ждать, что компилятор найдет ее; библиотеки должны следовать очень специфическим правилам именования и быть упомянуты в командной строке.
Имя файла библиотеки всегда начинается с символов lib. Далее следует часть, указывающая на назначение библиотеки (например, с для библиотеки С или m для математической библиотеки). Последняя часть имени начинается с точки (.) и задает тип библиотеки:
□ а — для традиционных статических библиотек;
□ .so — для совместно используемых библиотек (см. далее).
Обычно библиотеки существуют в статическом и совместно используемом форматах, как покажет быстрый просмотр каталога командой ls /usr/lib. Вы можете заставить компилятор искать библиотеку, задав полное имя ее файла или применив флаг -l. Например, команда
$ gcc -о fred fred.c /usr/lib/libm.a
сообщает компилятору о необходимости компилировать файл fred.c и искать разрешения ссылок на функции в библиотеке математических функций в дополнение к стандартной библиотеке С. Аналогичного результата можно добиться с помощью следующей команды:
$ gcc -о fred fred.c -lm
-lm (без пробела между символами l и m) — это сокращенное обозначение (сокращенные формы очень ценятся в UNIX-кругах) библиотеки с именем libm.a, хранящейся в одном из стандартных библиотечных каталогов (в данном случае /usr/lib). Дополнительное преимущество обозначения -lm в том, что компилятор автоматически выберет совместно используемую библиотеку, если она существует.
Несмотря на то что библиотеки, как и заголовочные файлы, обычно хранятся в стандартных каталогах, вы можете добавить каталоги для поиска, указав флаг -L (заглавная буква) в команде вызова компилятора. Например, команда
$ gcc -о x11fred -L/usr/openwin/lib x11fred.c -lX11
будет компилировать и компоновать программу x11fred, используя версию библиотеки libX11, найденную в каталоге /usr/openwin/lib.
Статические библиотеки.
Простейшая форма библиотеки — это коллекция объектных файлов, хранящихся вместе в виде, готовом к использованию. Когда программе нужна функция, содержащаяся в библиотеке, в нее включают заголовочный файл, объявляющий эту функцию. За соединение программного кода и библиотеки в единый исполняемый файл отвечают компилятор и компоновщик. Вы только должны применить опцию -l для указания нужных библиотек, отличных от стандартной библиотеки С исполняющей системы.
Статические библиотеки, также называемые архивами, в соответствии с принятыми соглашениями имеют окончание .а. Например, lib/libc.а и /usr/lib/libX11 для библиотек С и X11 соответственно.
Вы можете очень легко создавать и поддерживать собственные статические библиотеки с помощью программы ar (для создания архивов) и отдельно компилировать функции с помощью команды gcc -с. Старайтесь, насколько это возможно, хранить функции в отдельных исходных файлах. Если функциям нужен доступ к общим данным, вы можете поместить данные в один исходный файл и использовать статические переменные, объявленные в этом файле.
Упражнение 1.2. Статические библиотеки.
В этом упражнении вы создадите свою маленькую библиотеку, содержащую две функции, и затем используете одну из функций в примере программы. Функции называются fred и bill и просто выводят приветствия.
1. Сначала создайте отдельные исходные файлы (как не удивительно, названные fred.c и bill.c) для каждой функции.
Далее приведен первый из них:
#include <stdio.h>
void fred(int arg) {
printf("fred: you passed %d\n", arg);
}
А это второй:
#include <stdio.h>
void bill(char *arg) {
printf("bill: you passed %s\n", arg);
}
2. Вы можете отдельно откомпилировать эти функции и создать объектные файлы, готовые к включению в библиотеку. Для этого запустите компилятор С с опцией -с, которая помешает компилятору создать законченную программу. Попытка создать законченную программу окажется безуспешной, т.к. вы не определили функцию с именем main.
$ gcc -с bill.с fred.c
$ ls *.o
bill.о fred.о
3. Теперь напишите программу, вызывающую функцию bill. Прежде всего, хорошо бы создать заголовочный файл для вашей библиотеки. В нем будут объявлены функции из вашей библиотеки, и он будет включаться во все приложения, которые захотят применить вашу библиотеку. В файлы fred.c и bill.c тоже хорошо бы включить заголовочный файл, чтобы помочь компилятору обнаружить любые ошибки.
/*
Это файл lib.h. В кем объявлены пользовательские функции fred and bill
*/[1]
void bill(char *);
void fred(int);
4. Вызывающая программа (program.с) может быть очень простой. Она включает заголовочный файл и вызов из библиотеки одной из функций.
#include <stdlib.h>
#include "lib.h"
int main() {
bill("Hello World");
exit(0);
}
5. Теперь можно откомпилировать и протестировать программу. Для этого задайте компилятору явно объектные файлы и попросите его откомпилировать ваш файл и связать его с ранее откомпилированным объектным модулем bill.o.
$ gcc -с program.с
$ gcc -о program program.о bill.о
$ ./program
bill: we passed Hello World
$
6. Для создания архива и включения в него ваших объектных файлов используйте программу ar. Программа называется ar, поскольку она создает архивы или коллекции отдельных файлов, помещая их все в один большой файл. Имейте в виду, что программу ar можно применять для создания архивов из файлов любого типа. (Как многие утилиты UNIX, ar — универсальное средство.)
$ ar crv 1iьfоо.a bill.о fred.о
а - bill.о а - fred.о
7. Библиотека создана, и в нее добавлены два объектных файла. Для того чтобы успешно применять библиотеку в некоторых системах, в особенности в производных от Berkeley UNIX, требуется создать для библиотеки индекс содержимого архива или список вложенных в библиотеку функций и переменных (table of contents). Сделайте это с помощью команды ranlib. В ОС Linux при использовании программных средств разработки GNU этот шаг не является необходимым (но и не приносит вреда).
$ ranlib libfoo.a
Теперь ваша библиотека готова к использованию. Вы можете добавить следующий список файлов, которые должен обработать компилятор для создания вашей программы:
$ gcc -о program program.о 1iьfоо.а
$ ./program
bill: we passed Hello world
Можно было бы применить для доступа к библиотеке флаг -l, но т.к. она хранится не в одном из стандартных каталогов, вы должны сообщить компилятору место поиска с помощью флага -L следующим образом:
$ gcc -о program .program.о -L. -lfoo
Опция -L заставляет компилятор искать библиотеки в текущем каталоге (.). Опция -lfoo сообщает компилятору, что нужно использовать библиотеку с именем libfoo.a (или совместно используемую библиотеку libfoo.so, если она есть). Для того чтобы посмотреть, какие функции включены в объектный файл, библиотеку или исполняемую программу, можно применить команду nm. Если вы взглянете на файлы program и libfoo.a, то увидите, что библиотека содержит обе функции: fred и bill, а файл program — только функцию bill. Когда создается программа, в нее включаются из библиотеки только те функции, которые ей действительно нужны. Вставка заголовочного файла, содержащего объявления всех функций библиотеки, не вызывает включения в конечную программу целиком всей библиотеки.
Если вы знакомы с разработкой программ в ОС Windows, то поймете, что в ОС UNIX существует ряд прямых аналогий, перечисленных в табл. 1.1.
Таблица 1.1
Элемент | UNIX | Windows |
---|---|---|
Объектный модуль | func.o | FUNC.OBJ |
Статическая библиотека | lib.a | LIB.LIB |
Программа | program | PROGRAM.EXE |
Совместно используемые библиотеки.
У статических библиотек один недостаток — когда вы запускаете много приложений одновременно и все они используют функции из одной библиотеки, в результате образуется множество копий одних и тех же функций в памяти и множество реальных копий функций в самих файлах программ. Это может привести к потреблению большого объема полезной памяти и дискового пространства.
Устранить этот недостаток могут многие системы UNIX и Linux с поддержкой совместно используемых или разделяемых библиотек. Подробное обсуждение совместно используемых библиотек и их реализации в разных ОС не входило в нашу задачу, поэтому ограничимся только реализацией их в ОС Linux.
Совместно используемые библиотеки хранятся в тех же каталогах, что и статические, но у имен файлов совместно используемых библиотек другой суффикс. В типовой системе Linux имя совместно используемой версии стандартной библиотеки математических функций — /lib/libm.so.
Когда программа применяет совместно используемую библиотеку, она компонуется таким образом, что содержит не код функции как таковой, а ссылки на совместно используемый код, который станет доступен на этапе выполнения. Когда окончательная программа загружается в память для выполнения, ссылки на функции разрешаются, и выполняются вызовы совместно используемой библиотеки, которая будет загружаться в память по мере необходимости.
В этом случае система предоставляет возможность многим приложениям одновременно использовать единственную копию совместно используемой библиотеки и хранить ее на диске в единственном экземпляре. Дополнительным преимуществом служит возможность обновления совместно используемой библиотеки независимо от базирующихся на ней приложений. Применяются символические ссылки из файла /lib/libm.so на текущую версию библиотеки (/lib/libm.so.N, где N — основной номер версии — 6 во время написания книги). Когда ОС Linux запускает приложение, она учитывает номер версии библиотеки, требующийся приложению, чтобы не дать ведущим новым версиям библиотеки испортить более старые приложения.
Примечание. Вывод в следующем примере получен из дистрибутива SUSE 10.3. Если вы применяете другой дистрибутив, ваш вывод может слегка отличаться.В системах Linux программа (динамический загрузчик), отвечающая за загрузку совместно используемых библиотек и разрешение ссылок на функции в клиентских программах, называется ld.so и может присутствовать в системе как ld-linux.so.2, или li-lsb.so.2, или li-lsb.so.3. Дополнительные каталоги поиска совместно используемых библиотек настраиваются в файле /etc/ld.so.conf, который после внесения изменений (например, если добавляются совместно используемые библиотеки X11 при установке графической оболочки X Window System) следует обработать командой ldconfig.
Запустив утилиту ldd, вы можете увидеть, какие совместно используемые библиотеки требуются программе. Например, если вы попытаетесь выполнить утилиту для приложения из нашего примера, то получите следующие строки:
$ ldd program
linux-gate.so.1 => (0xffffe000)
libc.so.6 => /lib/libc.so.6 (0xb7db4000)
/lib/ld-linux.so.2 (0xb7efc000)
В этом случае вы видите стандартную библиотеку С (libc) как совместно используемую (.so). Программе требуется основная версия 6. В других системах UNIX принимаются аналогичные меры для получения доступа к совместно используемым библиотекам. Подробную информацию можно найти в системной документации.
Во многом совместно используемые библиотеки аналогичны динамически подключаемым библиотекам в ОС Windows. Библиотеки с расширением .so соответствуют файлам с расширением dll и требуются во время выполнения, а библиотеки с расширением .а аналогичны файлам с расширением lib, которые включаются в исполняемые программы.
Получение справки.
Подавляющее большинство систем Linux хорошо документировано в отношении системных программных интерфейсов и стандартных утилит. Это на самом деле так, потому что со времени первых систем UNIX программистов призывали снабжать свои приложения справочными материалами или описаниями. Эти справочные страницы (man pages), которые иногда предоставлялись в печатной форме, всегда доступны и в электронном виде.
Доступ к интерактивным справочным руководствам обеспечивает команда man. Эти справочные руководства отличаются качеством и деталями. Одни могут просто переадресовать читателя к другой, более полной документации, в то время как другие дают полный перечень всех опций и команд, поддерживаемых утилитой. В любом случае справочные руководства — подходящий способ знакомства с приложением.
Комплект программного обеспечения проекта GNU и другое свободное ПО используют интерактивную систему документации, названную info. Вы можете просмотреть всю документацию в интерактивном режиме с помощью специальной программы info или команды info редактора emacs. Достоинство системы info в том, что вы можете перемещаться по разделам документации с помощью связей и перекрестных ссылок, переходя непосредственно к нужному вам разделу. Для разработчика документации преимущество в том, что справочные файлы могут автоматически генерироваться из того же источника, что и печатные или набранные на клавиатуре страницы документации.
Упражнение 1.3. Справочные руководства и система info
Давайте познакомимся с документацией для компилятора GNU С (gcc).
1. Сначала посмотрим на справочное руководство.
$ man gcc
GCC(1) GNU GCC(1)
NAME
gcc — GNU project С and С++ compiler
SYNOPSIS
gcc [-с|-S|-E] [-std=standard]
[-g] [-pg] [-Olevel]
[-Wwarn...] [-pedantic]
[-Idir...] [-Ldir...]
[-Dmacro[=defn]...] [-Umacro]
[-foption...] [-mmachine-option...]
[-о outfile] infile...
Only the most useful options are listed here; see below
for the remainder. g++ accepts mostly the same options as
gcc.
DESCRIPTION
When you invoke GCC, it normally does preprocessing, com-
pilation, assembly and linking. The "overall options"
allow you to stop this process at an intermediate stage.
For example, the -c option says not to run the linker.
Then the output consists of object files output by the assembler.
Other options are passed on to one stage of processing.
Some options control the preprocessor and others the com-
piler itself. Yet other options control the assembler and
linker; most of these are not documented here, since we
rarely need to use any of them.
...
Если хотите, можно прочесть об опциях, поддерживаемых транслятором. В этом случае справочное руководство очень длинное, хотя содержит лишь малую часть полной документации по компилятору GNU С (и С++).
При чтении справочных страниц можно использовать клавишу <Пробел> для перехода к следующей странице, клавишу <Enter> (или клавишу <Return>, если на вашей клавиатуре применяется эта клавиша вместо <Enter>) для перехода к следующей строке и клавишу <q> для полного выхода из программы.
2. Для получения более подробной информации о компиляторе GNU С можно попробовать применить команду info.
$ info gcc
File: gcc.info. Node: Top, Next: G++ and GCC, Up: (DIR)
Introduction
************
This manual documents how to use the GNU compilers, as well as their
features and incompatibilities, and how to report bugs. It corresponds to
GCC version 4.1.3. The internals of the GNU compilers, including how to port
them to new targets and some information about how to write front ends for
new languages, are documented in a separate manual.
*Note Introduction: (gccint)Top.
*Menu:
* G++ and GCC:: You can compile С or С++ Applications.
* Standards:: Language standards supported by GCC,
* Invoking GCC:: Command options supported by `gcc'.
* С Implementation:: How GCC implements theISO С specification.
* С Extensions:: GNU extensions to the С language family.
* С++ Extensions:: GNU extensions to the С++ language.
* Objective-C:: GNU Objective-C runtime features.
* Compatibility:: Binary Compatibility
--zz-Info: (gcc.info.gz)Top, 39 lines --Top--------------------------
Welcome to Info version 4.8. Type ? for help, m for menu item.
Вам предоставляется длинное меню опций, которые можно выбирать для перемещения в полной текстовой версии документации. Элементы меню и иерархия страниц позволяют находить нужные разделы в очень большом документе. На бумаге документация к компилятору GNU С занимает многие сотни страниц.
У системы info есть собственная справка, конечно, в формате страниц info. Если нажать комбинацию клавиш <Ctrl>+<H>, можно познакомиться со справочным руководством, включающим средства обучения пользованию системой info. Программа info входит в состав многих дистрибутивов Linux и может устанавливаться в других ОС UNIX.
Резюме.
В этой вводной главе мы познакомились с программированием в ОС Linux и другими компонентами ОС Linux, общими с патентованными системами UNIX. Мы отметили огромное разнообразие систем программирования, доступных UNIX-разработчикам. Мы также представили простые программу и библиотеку, чтобы показать базовые средства языка С и сравнить их с эквивалентными средствами в ОС Windows.
Глава 2. Программирование средствами командной оболочки.
Начав книгу с программирования в ОС Linux на языке С, теперь мы сделаем отступление и остановимся на написании программ в командной оболочке. Почему? ОС Linux не относится к системам, у которых интерфейс командной строки — запоздалое детище графического интерфейса. У систем UNIX, прообраза Linux, первоначально вообще не было графического интерфейса; все выполнялось из командной строки. Поэтому оболочка командной строки UNIX все время развивалась и превратилась в очень мощный инструмент. Эти свойства перекочевали и в Linux, и некоторые самые серьезные задачи вы можете выполнить наиболее легким способом именно из командной оболочки. Поскольку она так важна для ОС Linux и столь полезна для автоматизации простых задач, программирование средствами командной оболочки рассматривается прежде всего.
В этой главе мы познакомим вас с синтаксисом, структурами и командами, доступными при программировании в командной оболочке, как правило, используя интерактивные (основанные на экранах) примеры. Они помогут продемонстрировать функциональные возможности командной оболочки и собственные действия. Мы также бросим беглый взгляд на пару особенно полезных утилит режима командной строки, часто вызываемых из командной оболочки: grep и find. Рассматривая утилиту grep, мы познакомимся с основными положениями, касающимися регулярных выражений, которые появляются в утилитах ОС Linux и языках программирования, таких как Perl, Ruby и PHP. В конце главы вы узнаете, как писать настоящие сценарии, которые будут перепрограммироваться и расширяться на языке С на протяжении всей книги. В этой главе рассматриваются следующие темы:
□ что такое командная оболочка;
□ теоретические основы;
□ тонкости синтаксиса: переменные, условия и управление программой;
□ списки;
□ функции;
□ команды и их выполнение;
□ встроенные (here) документы;
□ отладка;
□ утилита grep и регулярные выражения;
□ утилита find.
Если вы столкнулись со сложным сценарием командной оболочки при администрировании системы, хотите смоделировать вашу последнюю грандиозную (но удивительно простую) идею или просто повысить производительность какой-либо итеративной задачи, эта глава вам будет полезна.
Почему программа в командной оболочке?
Одна из причин применения командной оболочки — возможность быстрого и простого программирования. Более того, командная оболочка всегда есть даже в самых упрощенных установках ОС Linux, поэтому благодаря простому моделированию вы сможете понять, работает ли ваша идея. Командная оболочка очень удобна и для небольших утилит, выполняющих относительно простую задачу, для которой производительность менее важна, чем простые настройка, сопровождение и переносимость. Вы можете применять оболочку для управления процессами, обеспечивая выполнение команд в заданном порядке, зависящем от успешного завершения каждого этапа выполнения.
Хотя внешне командная оболочка очень похожа на режим командной строки в ОС Windows, она гораздо мощнее и способна выполнять самостоятельно очень сложные программы. Вы можете не только выполнять команды и вызывать утилиты ОС Linux; но и разрабатывать их. Командная оболочка выполняет программы оболочки, часто называемые сценариями или скриптами, которые интерпретируются во время выполнения. Такой подход облегчает отладку, потому что вы легко можете выполнять программу построчно и не тратить время на перекомпиляцию. Но для задач, которым важно время выполнения или необходимо интенсивное использование процессора, командная оболочка оказывается неподходящей средой.
Немного теории.
Вот мы и добрались до теоретических основ UNIX и, конечно, Linux. ОС UNIX основана на интенсивном многократном применении кода и зависит от него. Вы разработали маленькую простую утилиту, и пользователи применяют ее как одну из ссылок в строке, формирующей команду. Одно из наслаждений, доставляемых ОС Linux, — разнообразие имеющихся отличных средств. Примером может служить следующая команда:
$ ls -al | more
Эта команда применяет утилиты ls и more и передает вывод списка файлов для поэкранного отображения. Каждая утилита — это отдельный блок. Зачастую вы можете применять множество мелких утилит для создания больших и сложных комплексов программ.
Например, если вы хотите напечатать контрольную копию справочного руководства оболочки bash, примените следующую команду:
$ man bash | col -b | lpr
Более того, благодаря автоматической обработке типов файлов пользователям этих утилит обычно не нужно знать, на каком языке данные программы написаны. Если необходимо ускорить выполнение утилиты, как правило, ее сначала моделируют в командной оболочке и затем, когда работоспособность утилиты проверена, реализуют ее на языке С или С++, Perl, Python или каком-либо другом, обеспечивающем более быстрое выполнение. В противном случае, если в командной оболочке утилита действует адекватно, вы вполне можете оставить ее в покое.
Необходимость переделки сценария зависит от того, нуждается ли он в оптимизации, должен ли он быть переносимым, необходимо ли обеспечить легкую модификацию и не перерос ли он (как это обычно случается) первоначально поставленную задачу.
Примечание. Для удовлетворения вашего любопытства в вашу ОС Linux уже загружены многочисленные примеры сценариев, включая инсталляторы пакетов, .xinitrc и startx, и сценарии в каталоге /etc/rc.d, предназначенные для настройки системы в процессе загрузки.Что такое командная оболочка?
Прежде чем переходить к обсуждению того, как программа использует оболочку, давайте рассмотрим, как функционирует оболочка и какие оболочки есть в Linux-подобных системах. Командная оболочка — это программа, которая действует как интерфейс между вами и ОС Linux, позволяя вам вводить команды, которые должна выполнить операционная система. В этом смысле она похожа на командную строку в ОС Windows, но, как уже упоминалось, командные оболочки Linux гораздо мощнее. Например, ввод и вывод можно перенаправить с помощью символов < и >, передавать данные между двумя одновременно выполняющимися программами с помощью символа |, а перехватывать вывод подпроцесса с помощью конструкции $(...). В ОС Linux вполне может сосуществовать несколько установленных командных оболочек, и разные пользователи могут выбрать ту, которая им больше нравится. На рис. 2.1 показано, как командная оболочка (на самом деле, две командные оболочки: bash и csh) и другие программы располагаются вокруг ядра Linux.

Рис. 2.1
Поскольку ОС Linux — модульная система, вы можете вставить и применять одну из множества различных стандартных командных оболочек, хотя большинство из них — потомки первоначальной оболочки Bourne. В Linux стандартная командная оболочка, всегда устанавливаемая как /bin/sh и входящая в комплект средств проекта GNU, называется bash (GNU Bourne-Again SHell). Именно ее мы будем применять, т. к. это отличная командная оболочка, всегда устанавливаемая в системах Linux, со свободно распространяемым программным кодом и переносимая почти на все варианты UNIX-систем. В данной главе используется оболочка bash версии 3, и в большинстве случаев применяются ее функциональные возможности, общие для всех командных оболочек, удовлетворяющих требованиям стандарта POSIX. Мы полагаем, что командная оболочка, установленная как /bin/sh и для вашей учетной записи, считается командной оболочкой по умолчанию. В большинстве дистрибутивов Linux программа /bin/sh, командная оболочка по умолчанию, — это ссылка на программу /bin/bash.
Вы можете определить используемую в вашей системе версию bash с помощью следующей команды:
$ /bin/bash --version
GNU bash, version 3.2.9(1)-release (i686-pc-linux-gnu)
Copyright (C) 2005 Free Software Foundation, Inc.
Примечание. Для перехода на другую командную оболочку, если в вашей системе по умолчанию установлена не bash, просто выполните программу нужной вам командной оболочки (т.е. /bin/bash) для запуска новой оболочки и смены приглашения в командной строке. Если вы используете ОС UNIX, и командная оболочка bash не установлена, вы можете бесплатно загрузить ее с Web-сайта www.gnu.org. Исходный код обладает высокой степенью переносимости, и велика вероятность, что он откомпилируется в вашей версии UNIX прямо в готовую к использованию программу.Когда создаются учетные записи пользователей ОС Linux, вы можете задать командную оболочку, которой они будут пользоваться, в момент создания учетной записи пользователя или позже, откорректировав ее параметры. На рис. 2.2 показан выбор командной оболочки для пользователя дистрибутива Fedora.

Рис. 2.2
Существует много других командных оболочек, распространяемых свободно или на коммерческой основе. В табл. 2.1 предлагается краткая сводка некоторых самых распространенных командных оболочек.
Таблица 2.1
Название командной оболочки | Краткие исторические сведения |
---|---|
sh (Bourne) | Первоначальная оболочка в ранних версиях ОС UNIX |
csh, tcsh, zsh | Командная оболочка C-shell (и ее производные), первоначально созданная Биллом Джойем (Bill Joy) для систем Berkeley UNIX. C-shell, возможно, третья по популярности командная оболочка после оболочек bash и Korn |
ksh, pdksh | Командная оболочка Korn и ее безлицензионный родственник. Написанная Дэвидом Корном (David Korn) эта оболочка применяется по умолчанию во многих коммерческих версиях UNIX |
bash | Основная командная оболочка ОС Linux из проекта GNU или Bourne Again SHell со свободно распространяемым программным кодом. Если в настоящий момент она не выполняется в вашей системе UNIX, вероятно, есть вариант оболочки, перенесенный на вашу систему. У bash много сходств с оболочкой Korn |
За исключением оболочки C-shell и небольшого числа ее производных все перечисленные оболочки очень похожи и очень близки к оболочке, определенной в спецификациях Х/Ореn 4.2 и POSIX 1003.2. В спецификации POSIX 1003.2 задан минимум, необходимый для создания командной оболочки, а в спецификации Х/Open представлена более дружественная и мощная оболочка.
Каналы и перенаправление.
Прежде чем заняться подробностями программ командной оболочки, необходимо сказать несколько слов о возможностях перенаправления ввода и вывода программ (не только программ командной оболочки) в ОС Linux.
Перенаправление вывода.
Возможно, вы уже знакомы с некоторыми видами перенаправления, например, таким как:
$ ls -l > lsoutput.txt
сохраняющим вывод команды ls в файле с именем lsoutput.txt.
Однако перенаправление позволяет сделать гораздо больше, чем демонстрирует этот простой пример. В главе 3 вы узнаете больше о дескрипторах стандартных файлов, а сейчас вам нужно знать только то, что дескриптор файла 0 соответствует стандартному вводу программы, дескриптор файла 1 — стандартному выводу, а дескриптор файла 2 — стандартному потоку ошибок. Каждый из этих файлов можно перенаправлять независимо друг от друга. На самом деле можно перенаправлять и другие дескрипторы файлов, но, как правило, нет нужды перенаправлять любые другие дескрипторы, кроме стандартных: 0, 1 и 2.
В предыдущем примере стандартный вывод перенаправлен в файл с помощью оператора >. По умолчанию, если файл с заданным именем уже есть, он будет перезаписан. Если вы хотите изменить поведение по умолчанию, можно применить команду set -о noclobber (или set -С), которая устанавливает опцию noclobber, чтобы помешать перезаписи при перенаправлении. Отменить эту опцию можно с помощью команды set +о noclobber. Позже в этой главе будут приведены другие опции команды set.
Для дозаписи в конец файла используйте оператор >>. Например, команда
$ ps >> lsoutput.txt
добавит вывод команды ps в конец заданного файла.
Для перенаправления стандартного потока ошибок перед оператором > вставьте номер дескриптора файла, который хотите перенаправить. Поскольку у стандартного потока ошибок дескриптор файла 2, укажите оператор 2>. Часто бывает полезно скрывать стандартный поток ошибок, запрещая вывод его на экран.
Предположим, что вы хотите применить команду kill для завершения процесса из сценария. Всегда существует небольшой риск, что процесс закончится до того, как выполнится команда kill. Если это произойдет, команда kill выведет сообщение об ошибке в стандартный поток ошибок, который по умолчанию появится на экране. Перенаправив стандартный вывод команды и ошибку, вы сможете помешать команде kill выводить какой бы то ни было текст на экран.
Команда
$ kill -HUP 1234 >killout. txt 2>killer.txt
поместит вывод и информацию об ошибке в разные файлы.
Если вы предпочитаете собрать оба набора выводимых данных в одном файле, можно применить оператор >& для соединения двух выводных потоков. Таким образом, команда
$ kill -1 1234 >killerr.txt 2>&1
поместит свой вывод и стандартный поток ошибок в один и тот же файл. Обратите внимание на порядок следования операторов. Приведенный пример читается как "перенаправить стандартный вывод в файл killerr.txt, а затем перенаправить стандартный поток ошибок туда же, куда и стандартный вывод". Если вы нарушите порядок, перенаправление выполнится не так, как вы ожидаете.
Поскольку обнаружить результат выполнения команды kill можно с помощью кода завершения (который будет подробно обсуждаться далее в этой главе), часто вам не потребуется сохранять какой бы то ни было стандартный вывод или стандартный поток ошибок. Для того чтобы полностью отбросить любой вывод, вы можете использовать универсальную "мусорную корзину" Linux, /dev/null, следующим образом:
$ kill -l 1234 >/dev/null 2>&1
Перенаправление ввода.
Также как вывод вы можете перенаправить ввод. Например,
$ more < killout.txt
Понятно, что это тривиальнейший пример для ОС Linux; команда more в системе Linux в отличие от своего эквивалента командной строки в ОС Windows с радостью принимает имена файлов в качестве параметров.
Каналы.
Вы можете соединять процессы с помощью оператора канала ( |). В ОС Linux, в отличие от MS-DOS, процессы, соединенные каналами, могут выполняться одновременно и автоматически переупорядочиваться в соответствии с потоками данных между ними. Как пример, можно применить команду sort для сортировки вывода команды ps.
Если не применять каналы, придется использовать несколько шагов, подобных следующим:
$ ps > psout.txt
$ sort psout.txt > pssort.out
Соединение процессов каналом даст более элегантное решение:
$ ps | sort > pssort.out
Поскольку вы, вероятно, захотите увидеть на экране вывод, разделенный на страницы, можно подсоединить третий процесс, more, и все это в одной командной строке:
$ ps | sort | more
Практически нет ограничений на допустимое количество процессов. Предположим, что вы хотите видеть все имена выполняющихся процессов, за исключением командных оболочек. Можно применить следующую командную строку:
$ ps -хо соmm | sort | uniq | grep -v sh | more
В ней берется вывод команды ps, сортируется в алфавитном порядке, из него извлекаются процессы с помощью команды uniq, применяется утилита grep -v sh для удаления процесса с именем sh и в завершение полученный список постранично выводится на экран.
Как видите, это гораздо более элегантное решение, чем строка из отдельных команд, каждая со своими временными файлами. Но в этом случае имейте в виду следующее. Если строка состоит из команд, файл вывода создается или записывается сразу, как только сформирован набор команд, поэтому в строке из нескольких команд никогда не используйте дважды одно и то же имя файла. Если вы попытаетесь сделать что-то подобное:
cat mydata.txt | sort | uniq > mydata.txt
то в результате получите пустой файл, т.к. вы перезапишете файл mydata.txt, прежде чем прочтете его.
Командная оболочка как язык программирования.
Теперь, когда вы увидели некоторые базовые операции командной оболочки, самое время перейти к реальным программам оболочки. Есть два способа написания таких программ. Вы можете ввести последовательность команд и разрешить командной оболочке выполнить их в интерактивном режиме или сохранить эти команды в файле и затем запускать его как программу.
Интерактивные программы.
Легкий и очень полезный во время обучения или тестирования способ проверить работу небольших фрагментов кода — просто набрать с клавиатуры в командной строке сценарий командной оболочки.
Предположим, что у вас большое количество файлов на языке С, и вы хотите проверить наличие в них строки POSIX. Вместо того чтобы искать в файлах строку с помощью команды grep и затем выводить на экран отдельно каждый файл, вы можете выполнить всю операцию в интерактивном сценарии, похожем на следующий:
$ for file in *
> do
> if grep -l POSIX $file
> then
> more $file
> fi
> done
posix
This is a file with POSIX in it - treat it well
$
Обратите внимание на то, как меняется знак $, стандартная подсказка или приглашение командной оболочки, на символ >, когда оболочка ожидает очередной ввод. Вы можете продолжить набор, дав оболочке понять, когда закончите, и сценарий немедленно выполнится.
В этом примере команда grep выводит на экран найденные ею имена файлов, содержащих строку POSIX, а затем команда more отображает на экране содержимое файла. В конце на экран возвращается приглашение командной оболочки. Обратите внимание также на то, что вы ввели переменную командной оболочки, которая обрабатывает каждый файл для самодокументирования сценария. С таким же успехом вы могли бы использовать переменную i, но имя file более информативно с точки зрения пользователей.
Командная оболочка также обрабатывает групповые символы или метасимволы (часто называемые знаками подстановки). Вы почти наверняка знаете о применении символа * как знака подстановки, соответствующего строке символов. Но вы можете не знать о существовании односимвольного знака подстановки, ?, а конструкция [set] позволяет проверить любое количество одиночных символов, [^set] — применяет логическую операцию "НЕ" к множеству, т.е. включает все, кроме того, что вы задали. Подстановочный шаблон из фигурных скобок {} (доступен в некоторых командных оболочках, включая bash) позволяет формировать множество из произвольных строк, которое командная оболочка раскроет. Например, команда
$ ls my_{finger, toe}s
будет выводить файлы my_fingers и my_toes. Эта команда использует оболочку для проверки всех файлов в текущем каталоге. Мы вернемся к этим правилам соответствия шаблонам в конце главы, когда будем более подробно рассматривать утилиту grep и возможности регулярных выражений.
Опытные пользователи ОС Linux, вероятно, выполнят эту операцию более эффективным способом, возможно, с помощью следующей команды:
$ more `grep -l POSIX *`
или синонимической конструкции
$ more $(grep -l POSIX *)
В дополнение команда
$ grep -l POSIX * | more
выведет на экран имя файла, содержащего строку POSIX. В этом сценарии мы видим, что командная оболочка для выполнения трудной работы привлекает другие команды, например, grep и more. Оболочка просто позволяет собрать вместе несколько имеющихся команд новыми оригинальными способами. В следующих сценариях вы увидите использование знаков подстановки неоднократно. Мы подробно рассмотрим целую область подстановок, когда будем знакомиться с регулярными выражениями в разделе, посвященном команде grep.
Заниматься этой канителью каждый раз, когда хочешь выполнить последовательность команд, утомительно. Нужно сохранить команды в файле, который принято называть сценарием или скриптом командной оболочки, а затем вы можете выполнять эти файлы, когда захотите.
Создание сценария.
С помощью любого текстового редактора необходимо создать файл, содержащий команды. Создайте файл с именем first с таким содержимым:
#!/bin/sh
# first
# Этот файл просматривает все файлы в текущем каталоге
# для поиска строки POSIX, а затем выводит имена
# найденных файлов в стандартный вывод.
for file in *
do
if grep -q POSIX $file
then
echo $file
fi
done
exit 0
Комментарий начинается со знака # и продолжается до конца строки. Принято знак # ставить в первой символьной позиции строки. Сделав такое общее заявление, далее отметим, что первая строка #!/bin/sh — это особая форма комментария; символы #! сообщают системе о том, что следующий за ними аргумент — программа, применяемая для выполнения данного файла. В данном случае программа /bin/sh — командная оболочка, применяемая по умолчанию.
Примечание. Обратите внимание на абсолютный путь, заданный в комментарии. Принято сохранять его длиной не более 32 символов для обратной совместимости, поскольку некоторые старые версии ОС UNIX могут использовать только такое ограниченное количество символов в комментарии #!, хотя у ОС Linux обычно нет подобного ограничения.Поскольку сценарий по существу обрабатывается как стандартный ввод командной оболочки, он может содержать любые команды ОС Linux, на которые ссылается переменная окружения PATH.
Команда exit гарантирует, что сценарий вернет осмысленный код завершения (подробнее об этом чуть позже в данной главе). Он редко проверяется при интерактивном выполнении программ, но если вы хотите запускать данный сценарий из другого сценария и проверять, успешно ли он завершился, возврат соответствующего кода завершения очень важен. Даже если вы не намерены разрешать вашему сценарию запускаться из другого сценария, все равно следует завершать его с подходящим кодом. Верьте в полезность своего сценария: вдруг когда-нибудь он потребуется для многократного использования как часть другого сценария.
В программировании средствами командной оболочки ноль означает успех. Поскольку представленный вариант сценария не может обнаружить какие-либо ошибки, он всегда возвращает код успешного завершения. Мы вернемся к причинам использования нулевого кода завершения для обозначения успешного выполнения программы позже в этой главе, когда будем более подробно обсуждать команду exit.
В сценарии не используются никакие расширения и суффиксы имен файлов; ОС Linux и UNIX, как правило, редко применяют при именовании файлов расширения для указания типа файла. Вы могли бы использовать расширение sh или любое другое, командную оболочку это не волнует. У большинства предустановленных сценариев нет никакого расширения в именах файлов и лучший способ проверить, сценарий это или нет применить команду file, например, file first или file /bin/bash. Пользуйтесь любыми правилами, принятыми в вашей организации или удобными для вас.
Превращение сценария в исполняемый файл.
Теперь, когда у вас есть файл сценария, его можно выполнить двумя способами. Более простой путь — запустить оболочку с именем файла сценария как параметром:
$ /bin/sh first
Этот вариант будет работать, но гораздо лучше запускать сценарий, введя его имя и тем самым присвоив ему статус других команд Linux. Сделаем это с помощью команды chmod, изменив режим файла (file mode) и сделав его исполняемым для всех пользователей:
$ chmod +х first
Примечание. Конечно, превращение файла в исполняемый — это не единственный вариант применения команды chmod. Для того чтобы узнать больше о восьмеричных аргументах и других опциях команды, наберите man chmod.После этого вы можете выполнять файл с помощью команды
$ first
При этом может появиться сообщение об ошибке, говорящее о том, что команда не найдена. Почти наверняка причина в том, что в переменной PATH не задан текущий каталог для поиска выполняемых команд. Исправить это можно либо введя с клавиатуры в командной строке PATH=$PATH:., либо добавив данную команду в конец файла .bash_profile. Затем выйдите из системы и зарегистрируйтесь снова. В противном случае введите ./first в каталог, содержащий сценарий, чтобы задать командной оболочке полный относительный путь к файлу.
Указание пути, начинающегося с символов ./, дает еще одно преимущество: в этом случае вы случайно не сможете выполнить другую команду с тем же именем, что и у вашего файла сценария.
Примечание. Не следует вносить подобные изменения в переменную PATH для суперпользователя, как правило, с именем root. Это лазейка в системе безопасности, т.к. системного администратора, зарегистрировавшегося как root, обманным путём могут заставить запустить фиктивную версию стандартной команды. Один из авторов однажды разрешил сделать это — конечно только для того, чтобы поставить перед системным администратором вопрос о безопасности! В случае обычных учетных записей включение текущего каталога в полный путь сопряжено с очень небольшим риском, поэтому, если вам это нужно, примите за правило добавление комбинации символов ./ перед всеми командами, находящимися в локальном каталоге.После того как вы убедитесь в корректной работе вашего сценария, можете переместить его в более подходящее место, чем текущий каталог. Если команда предназначена только для собственных нужд, можете создать каталог bin в своем исходном каталоге и добавить его в свой путь. Если вы хотите, чтобы сценарий выполняли другие пользователи, можно использовать каталог /usr/local/bin или другой системный каталог как удобное, хранилище для вновь созданных программ. Если в вашей системе у вас нет прав суперпользователя, можно попросить системного администратора скопировать ваш файл для вас, хотя сначала, возможно, придется убедить его в неоспоримых достоинствах вашего файла. Для того чтобы установить владельца и права доступа к файлу, администратору придется задать такую последовательность команд:
# ср first /usr/local/bin
# chown root /usr/local/bin/first
# chgrp root /usr/local/bin/first
# chmod 755 /usr/local/bin/first
Обратите внимание на то, что в данном случае вместо изменения определенной части флагов прав доступа вы используете абсолютную форму команды chmod, потому что точно знаете, какие требуются права доступа.
Если захотите, можно применить более длинную, но более понятную форму команды chmod:
# chmod u=rwx, go=rx /usr/local/bin/first
Более подробную информацию можно найти в справочном руководстве команды chmod.
Примечание. В ОС Linux вы можете удалить файл, если у вас есть право записи в каталог, содержащий этот файл. Для безопасности убедитесь в том, что право записи в каталоги, содержащие файлы, которые вы хотели бы защитить, есть только у суперпользователя. В этом есть смысл, потому что каталог — это всего лишь еще один файл, и наличие права записи в файл каталога позволяет пользователям добавлять и удалять имена.Синтаксис командной оболочки.
Теперь, когда мы рассмотрели пример простой программы командной оболочки, пришло время углубиться в функциональные возможности программирования средствами командной оболочки. Командная оболочка — довольно легкий для изучения язык программирования, в немалой степени потому, что легко проверить в интерактивном режиме работу небольших фрагментов программы, прежде чем собирать их в большие сценарии. Командную оболочку bash можно использовать для создания довольно больших структурированных программ. В нескольких последующих разделах мы обсудим такие темы:
□ переменные: строки, числа, переменные окружения и параметры;
□ условия: булевы или логические выражения (Booleans);
□ управление выполнением программы: if, elif, for, while, until, case;
□ списки;
□ функции;
□ команды, встроенные в командную оболочку;
□ получение результата выполнения команды;
□ встроенные (here) документы.
Переменные.
В командной оболочке переменные перед применением обычно не объявляются. Вместо этого вы создаете их, просто используя (например, когда присваиваете им начальное значение). По умолчанию все переменные считаются строками и хранятся как строки, даже когда им присваиваются числовые значения. Командная оболочка и некоторые утилиты преобразуют строки, содержащие числа, в числовые значения, когда нужно их обработать должным образом. Linux — система, чувствительная к регистру символов, поэтому командная оболочка считает foo и Foo двумя разными переменными, отличающимися от третьей переменной FOO.
В командной оболочке можно получить доступ к содержимому переменной, если перед ее именем ввести знак $. Каждый раз, когда вы извлекаете содержимое переменной, вы должны к началу ее имени добавить знак $. Когда вы присваиваете переменной значение, просто используйте имя переменной, которая при необходимости будет создана динамически. Легко проверить содержимое переменной, выведя ее на терминал с помощью команды echo и указав перед именем переменной знак $.
Вы можете увидеть это в действии, если в командной строке будете задавать и проверять разные значения переменной salutation:
$ salutation=Hello
$ echo $salutation
Hello
$ salutation="Yes Dear"
$ echo $salutation
Yes Dear
$ salutation=7+5
$ echo $salutation
7+5
Примечание. Обратите внимание на то, что при наличии пробелов в содержимом переменной ее заключают в кавычки. Кроме того, не может быть пробелов справа и слева от знака равенства.Вы можете присвоить переменной пользовательский ввод с помощью команды read. Она принимает один параметр — имя переменной, в которую будут считываться данные, и затем ждет, пока пользователь введет какой-либо текст. Команда read обычно завершается после нажатия пользователем клавиши <Enter>. При чтении переменной с терминала, как правило, заключать ее значения в кавычки не требуется:
$ read salutation
Wie geht's?
$ echo $salutation
Wie geht's?
Заключение в кавычки.
Прежде чем двигаться дальше, вам следует уяснить одно правило командной оболочки: использование кавычек.
Обычно параметры в сценариях отделяются неотображаемыми символами или знаками форматирования (например, пробелом, знаком табуляции или символом перехода на новую строку). Если вы хотите, чтобы параметр содержал один или несколько неотображаемых символов, его следует заключить в кавычки.
Поведение переменных, таких как $foo, заключенных в кавычки, зависит от вида используемых кавычек. Если вы заключаете в двойные кавычки $-представление переменной, оно во время выполнения командной строки заменяется значением переменной. Если вы заключаете его в одинарные кавычки или апострофы, никакой замены не происходит. Вы также можете отменить специальное назначение символа $, вставив перед ним символ \ (обратный слэш).
Выполним упражнение 2.1.
Упражнение 2.1. Игра с переменными.
В этом упражнении показано, как кавычки влияют на вывод переменной:
#!/bin/sh
myvar="Hi there"
echo $myvar
echo "$myvar"
echo '$myvar'
echo \$myvar
echo Enter some text
read myvar
echo '$myvar' now equals $myvar
exit 0
Данный сценарий ведет себя следующим образом:
$ ./variable
Hi there
Hi there
$myvar
$myvar
Enter some text
Hello World
$myvar now equals Hello World
Как это работает
Создается переменная myvar, и ей присваивается строка Hi there. Содержимое переменной выводится на экран с помощью команды echo, демонстрирующей, как символ $ раскрывает содержимое переменной. Вы видите, что применение двойных кавычек не влияет на раскрытие содержимого переменной, а одинарные кавычки и обратный слэш влияют. Вы также применяете команду read для получения строки от пользователя.
Переменные окружения.
Когда стартует сценарий командной оболочки, некоторым переменным присваиваются начальные значения из окружения или рабочей среды. Обычно такие переменные обозначают прописными буквами, чтобы отличать их в сценариях от определенных пользователем переменных (командной оболочки), которые принято обозначать строчными буквами. Формируемые переменные зависят от ваших персональных настроек. Многие из них перечислены на страницах справочных руководств, а основные приведены в табл. 2.2.
Таблица 2.2
Переменная окружения | Описание |
---|---|
$НОМЕ | Исходный каталог текущего пользователя |
$PATH | Разделенный двоеточиями список каталогов для поиска команд |
$PS1 | Подсказка или приглашение командной строки. Часто знак $, но в оболочке bash можно применять и более сложные варианты. Например, строка [\u@\h \w]$ — популярный стандарт, сообщающий в подсказке пользователя имя компьютера и текущий каталог, а также знак $ |
$PS2 | Дополнительная подсказка или приглашение, применяемое как приглашение для дополнительного ввода; обычно знак > |
$IFS | Разделитель полей ввода. Список символов, применяемых для разделения слов при чтении оболочкой ввода, как правило, пробел, знак табуляции и символ перехода на новую строку |
$0 | Имя сценария командной оболочки |
$# | Количество передаваемых параметров |
$$ | ID (идентификатор) процесса сценария оболочки, часто применяемый внутри сценария для генерации уникальных имен временных файлов; например, /tmp/tmpfile_$$ |
Переменные-параметры.
Если ваш сценарий вызывается с параметрами, создается несколько дополнительных переменных. Если параметры не передаются, переменная окружения $# все равно существует, но равна 0.
Переменные-параметры перечислены в табл. 2.3.
Таблица 2.3
Переменная-параметр | Описание |
---|---|
$1, $2, ... | Параметры, передаваемые сценарию |
$* | Список всех параметров в единственной переменной, разделенных первым символом из переменной окружения IFS. Если IFS корректируется, способ разделения командной строки на параметры в переменной $* изменяется |
$@ | Едва различимая вариация $*; не использует переменную окружения IFS, поэтому параметры не сольются, даже если переменная IFS пуста |
Легче всего увидеть разницу между переменными-параметрами $* и $@, опробовав их.
$ IFS=''
$ set foo bar bam
$ echo "$@"
foo bar bam
$ echo "$*"
foobarbam
$ unset IFS
$ echo "$*"
foo bar bam
Как видите, заключенная в двойные кавычки переменная-параметр $@ представляет позиционные параметры как отдельные поля, независимо от значения переменной окружения IFS. Как правило, если вы хотите получить доступ к параметрам, лучше использовать переменную-параметр.
Помимо вывода на экран содержимого переменных с помощью команды echo, вы также можете прочитать его командой read (упражнение 2.2).
Упражнение 2.2. Манипулирование параметрами и переменными окружения.
В приведенном далее сценарии показано несколько простых манипуляций переменными. После ввода сценария и записи его в файл try_var не забудьте превратить его в исполняемый файл с помощью команды chmod +х try_var.
#!/bin/sh
salutation="Hello"
echo $salutation
echo "The program $0 is now running"
echo "The second parameter was $2"
echo "The first parameter was $1"
echo "The parameter list was
echo "The user's home directory is $HOME"
echo "Please enter a new greeting"
read salutation
echo $salutation
echo "The script is now complete"
exit 0
Если вы выполните этот сценарий, то получите следующий вывод:
$ ./try_var foo bar baz
Hello
The program ./try_var is now running
The second parameter was bar
The first parameter was foo
The parameter list was foo bar baz
The user's home directory is /home/rick
Please enter a new greeting
Sire
Sire
The script is now complete $
Как это работает
Сценарий создает переменную salutation, выводит на экран ее содержимое и затем показывает, что уже сформированы и имеют соответствующие значения различные переменные-параметры и переменная окружения $НОМЕ.
Далее в этой главе мы рассмотрим более подробно подстановку параметров.
Условия.
Основа всех языков программирования — средства проверки условий и выполнение различных действий с учетом результатов этой проверки. Но прежде чем говорить об этом, давайте рассмотрим условные конструкции, которые можно применять в сценариях командной оболочки, а затем познакомимся с использующими их управляющими структурами.
Сценарий командной оболочки может проверить код завершения любой команды, вызванной из командной строки, включая сценарии, написанные вами. Вот почему так важно всегда включать в создаваемые вами сценарии команду exit с определенным значением.
Команда test или [
На практике в большинстве сценариев широко используется команда [ или test — логическая проверка командной оболочки. В некоторых системах команды [ и test — синонимы, за исключением того, что при использовании команды [ для удобочитаемости применяется и завершающая часть ]. Наличие команды [ может показаться странным, но в программном коде она упрощает синтаксис и делает его более похожим на другие языки программирования.
Примечание. Эти команды в некоторых ранних оболочках UNIX вызывают внешнюю программу, но в более современных версиях их стараются делать встроенными. Мы вернемся к этому, когда будем рассматривать команды в следующем разделе. Поскольку команда test не часто применяется за пределами сценариев командной оболочки, многие пользователи ОС Linux, никогда раньше не писавшие сценариев, пытаются создавать простые программы и называют их test. Если такая программа не работает, вероятно, она конфликтует с командой оболочки test. Для того чтобы выяснить, есть ли в вашей системе внешняя команда с данным именем, попытайтесь набрать что-нибудь вроде which test и проверить, какая именно команда test выполняется в данный момент, или используйте форму ./test, чтобы быть уверенным в том, что вы выполняете сценарий из текущего каталога. Если сомневаетесь, примите за правило выполнять свои сценарии, предваряя при запуске их имена комбинацией символов ./.Мы представим команду test на примере одного простейшего условия: проверки наличия файла. Для нее понадобится следующая команда: test -f <имя_файла>, поэтому в сценарии можно написать
if test -f fred.c
then
...
fi
To же самое можно записать следующим образом:
if [ -f fred.c ]
then
...
fi
Код завершения команды test (выполнено ли условие) определяет, будет ли выполняться условный программный код.
Примечание. Имейте в виду, что вы должны вставлять пробелы между квадратной скобкой [ и проверяемым условием. Это легко усвоить, если запомнить, что вставить символ [ — это все равно, что написать test, а после имени команды вы всегда должны вставлять пробел. Если вы предпочитаете помещать слово then в той же строке, что и if, нужно добавить точку с запятой для отделения команды test от then: if [ -f fred.c ]; then ... fiВарианты условий, которые вы можете применять в команде test, делятся на три типа: строковые сравнения, числовые сравнения и проверка файловых флагов (file conditionals). Эти типы условий описаны в табл. 2.4.
Таблица 2.4
Варианты условий | Результат |
---|---|
Сравнения строк | |
Строка1 = Строка2 | True (истина), если строки одинаковы |
Строка1 != Строка2 | True (истина), если строки разные |
-n Строка | True (истина), если Строка не null |
-z Строка | True (истина), если Строка null (пустая строка) |
Сравнения чисел | |
Выражение1 -eq Выражение2 | True (истина), если выражения равны |
Выражение1 -ne Выражение2 | True (истина), если выражения не равны |
Выражение1 -gt Выражение2 | True (истина), если Выражение1 больше, чем Выражение2 |
Выражение1 -ge Выражение2 | True (истина), если Выражение1 не меньше Выражение2 |
Выражение1 -lt Выражение2 | True (истина), если Выражение1 меньше, чем Выражение2 |
Выражение1 -1е Выражение2 | True (истина), если Выражение1 не больше Выражение2 |
! Выражение | True (истина), если Выражение ложно, и наоборот |
Файловый флаг | |
-d файл | True (истина), если файл — каталог |
-е файл | True (истина), если файл существует. Исторически, опция -e не была переносима на другие платформы, поэтому обычно применяется -f |
-f файл | True (истина), если файл — обычный файл |
-g файл | True (истина), если для файла установлен бит set-group-id |
-r файл | True (истина), если файл доступен для чтения |
-s файл | True (истина), если файл ненулевого размера |
-u файл | True (истина), если для файла установлен бит set-user-id |
-v файл | True (истина), если файл доступен для записи |
-х файл | True (истина), если файл — исполняемый файл |
Мы немного сами себя обогнали, но далее следует пример тестирования состояния файла /bin/bash, так что вы сможете увидеть, как это выглядит на практике.
#!/bin/sh
if [ -f /bin/bash ]
then
echo "file /bin/bash exists"
fi
if [ -d /bin/bash ]
then
echo "/bin/bash is a directory"
else
echo "/bin/bash is NOT a directory"
fi
Для того чтобы тест мог оказаться истинным, предварительно, для проверки всех файловых флагов требуется наличие файла. Данный перечень включает только самые широко используемые опции команды test, полный список можно найти в интерактивном справочном руководстве. Если вы применяете оболочку bash, в которую встроена команда test, используйте команду help test для получения дополнительных сведений. Позже в этой главе мы применим некоторые из этих опций.
Теперь, когда вы познакомились с условиями, можно рассмотреть управляющие структуры, использующие эти условия.
Управляющие структуры.
В командной оболочке есть ряд управляющих структур или конструкций, похожих на аналогичные структуры в других языках программирования.
Примечание. В следующих разделах элемент синтаксической записи операторы — это последовательности команд, которые выполняются, когда или пока условие удовлетворяется или пока оно не удовлетворяется.if.
Управляющий оператор if очень прост: он проверяет результат выполнения команды и затем в зависимости от условия выполняет ту или иную группу операторов.
if условие
then
операторы
else
операторы
fi
Наиболее часто оператор if применяется, когда задается вопрос, и решение принимается в зависимости от ответа:
#!/bin/sh
echo "Is it morning? Please answer yes or no "
read timeofday
if [ $timeofday = "yes" ]; then
echo "Good morning"
else
echo "Good afternoon"
fi
exit 0
В результате будет получен следующий вывод на экран:
Is it morning? Please answer yes or no
yes
Good morning
$
В этом сценарии для проверки содержимого переменной timeofday применяется команда [. Результат оценивается оператором командной оболочки if, который затем разрешает выполнять разные строки программного кода.
Примечание. Обратите внимание на дополнительные пробелы, используемые для формирования отступа внутри оператора if. Это делается только для удобства читателя; командная оболочка игнорирует дополнительные пробелы.elif.
К сожалению, с этим простым сценарием связано несколько проблем. Во-первых, он принимает в значении no (нет) любой ответ за исключением yes (да). Можно помешать этому, воспользовавшись конструкцией elif, которая позволяет добавить второе условие, проверяемое при выполнении части else оператора if (упражнение 2.3).
Упражнение 2.3. Выполнение проверок с помощью elif.
Вы можете откорректировать предыдущий сценарий так, чтобы он выводил сообщение об ошибке, если пользователь вводит что-либо отличное от yes или no. Для этого замените ветку else веткой elif и добавьте еще одно условие:
#!/bin/sh
echo "Is it morning? Please answer yes or no "
read timeofday
if [ $timeofday = "yes" ]
then
echo "Good morning"
elif [ $timeofday = "no" ]; then
echo "Good afternoon"
else
echo "Sorry, $timeofday not recognized. Enter yes or no "
exit 1
fi
exit 0
Как это работает
Этот пример очень похож на предыдущий, но теперь, если первое условие не равно true, оператор командной оболочки elif проверяет переменную снова. Если обе проверки не удачны, выводится сообщение об ошибке, и сценарий завершается со значением 1, которое в вызывающей программе можно использовать для проверки успешного выполнения сценария.
Проблема, связанная с переменными.
Данный сценарий исправляет наиболее очевидный дефект, а более тонкая проблема остается незамеченной. Запустите новый вариант сценария, но вместо ответа на вопрос просто нажмите клавишу <Enter> (или на некоторых клавиатурах клавишу <Return>). Вы получите сообщение об ошибке:
[: =: unary operator expected
Что же не так? Проблема в первой ветви оператора if. Когда проверялась переменная timeofday, она состояла из пустой строки. Следовательно, ветвь оператора if выглядела следующим образом:
if [ = "yes" ]
и не представляла собой верное условие. Во избежание этого следует заключить имя переменной в кавычки:
if [ "$timeofday" = "yes" ]
Теперь проверка с пустой переменной будет корректной:
if [ "" = "yes" ]
Новый сценарий будет таким:
#!/bin/sh
echo "Is it morning? Please answer yes or no "
read timeofday
if [ "$timeofday" = "yes" ]
then
echo "Good morning"
elif [ "$timeofday" = "no" ]; then
echo "Good afternoon"
else
echo "Sorry, $timeofday not recognized. Enter yes or no "
exit 1
fi
exit 0
Этот вариант безопасен, даже если пользователь в ответ на вопрос просто нажмет клавишу <Enter>.
Примечание. Если вы хотите, чтобы команда echo удалила новую строку в конце, наиболее легко переносимый вариант — применить команду printf (см. разд. "printf" далее в этой главе) вместо команды echo. В некоторых командных оболочках применяется команда echo -е, но она поддерживается не всеми системами. В оболочке bash для запрета перехода на новую строку допускается команда echo -n, поэтому, если вы уверены, что вашему сценарию придется трудиться только в оболочке bash, предлагаем вам использовать следующий синтаксис: echo -n "Is it morning? Please answer yes or no: " Помните о том, что нужно оставлять дополнительный пробел перед закрывающими кавычками, таким образом формируется зазор перед вводимым пользователем ответом, который в этом случае выглядит четче.for.
Применяйте конструкцию for для обработки в цикле ряда значений, которые могут представлять собой любое множество строк. Строки могут быть просто перечислены в программе или, что бывает чаще, представлять собой результат выполненной командной оболочкой подстановки имен файлов.
Синтаксис этого оператора прост:
for переменная in значения
do
операторы
done
Выполните упражнения 2.4 и 2.5.
Упражнение 2.4. Применение цикла for к фиксированным строкам.
В командной оболочке значения обычно представлены в виде строк, поэтому можно написать следующий сценарий:
#!/bin/sh
for foo in bar fud 43
do
echo $foo
done
exit 0
В результате будет получен следующий вывод:
bar
fud
43
Примечание. Что произойдет, если вы измените первую строку с for foo in bar fud 43 на for foo in "bar fud 43"? Напоминаем, что вставка кавычек заставляет командную оболочку считать все, что находится между ними, единой строкой. Это один из способов сохранения пробелов в переменной.Как это работает
В данном примере создается переменная foo и ей в каждом проходе цикла for присваиваются разные значения. Поскольку оболочка считает по умолчанию все переменные строковыми, применять строку 43 так же допустимо, как и строку fud.
Упражнение 2.5. Применение цикла for с метасимволами.
Как упоминалось ранее, цикл for обычно используется в командной оболочке вместе с метасимволами или знаками подстановки для имен файлов. Это означает применение метасимвола для строковых значений и предоставление оболочке возможности подставлять все значения на этапе выполнения.
Вы уже видели этот прием в первом примере first. В сценарии применялись средства подстановки командной оболочки — символ * для подстановки имен всех файлов из текущего каталога. Каждое из этих имен по очереди используется в качестве значения переменной $file внутри цикла for.
Давайте бегло просмотрим еще один пример подстановки с помощью метасимвола. Допустим, что вы хотите вывести на экран все имена файлов сценариев в текущем каталоге, начинающиеся с буквы "f", и вы знаете, что имена всех ваших сценариев заканчиваются символами .sh. Это можно сделать следующим образом:
#!/bin/sh
for file in $(ls f*.sh); do
lpr $file
done
exit 0
Как это работает
В этом примере показано применение синтаксической конструкции $(команда), которая будет подробно обсуждаться далее (в разделе, посвященном выполнению команд). Обычно список параметров для цикла for задается выводом команды, включенной в конструкцию $().
Командная оболочка раскрывает f*.sh, подставляя имена всех файлов, соответствующих данному шаблону.
Примечание. Помните о том, что все подстановки переменных в сценариях командной оболочки делаются во время выполнения сценария, а не в процессе их написания, поэтому все синтаксические ошибки в объявлениях переменных обнаруживаются только на этапе выполнения, как было показано ранее, когда мы заключали в кавычки пустые переменные.while.
Поскольку по умолчанию командная оболочка считает все значения строками, оператор for хорош для циклической обработки наборов строк, но не слишком удобен, если вы не знаете заранее, сколько раз придется его выполнить.
Если нужно повторить выполнение последовательности команд, но заранее не известно, сколько раз следует их выполнить, вы, как правило, будете применять цикл while со следующей синтаксической записью:
while условие
do
операторы
done
Далее приведен пример довольно слабой программы проверки паролей.
#!/bin/sh
echo "Enter password"
read trythis
while [ "$trythis" != "secret" ]; do
echo "Sorry, try again"
read trythis
done
exit 0
Следующие строки могут служить примером вывода данного сценария:
Enter password
password
Sorry, try again
secret
$
Ясно, что это небезопасный способ выяснения пароля, но он вполне подходит для демонстрации применения цикла while. Операторы, находящиеся между операторами do и done, выполняются бесконечное число раз до тех пор, пока условие остается истинным ( true). В данном случае вы проверяете, равно ли значение переменной trythis строке secret. Цикл будет выполняться, пока $trythis не равно secret. Затем выполнение сценария продолжится с оператора, следующего сразу за оператором done.
until.
У цикла until следующая синтаксическая запись:
until условие
do
операторы
done
Она очень похожа на синтаксическую запись цикла while, но с обратным проверяемым условием. Другими словами, цикл продолжает выполняться, пока условие не станет истинным (true).
Примечание. Как правило, если нужно выполнить цикл хотя бы один раз, применяют цикл while; если такой необходимости нет, используют цикл until.Как пример цикла until можно установить звуковой сигнал предупреждения, инициируемый во время регистрации нового пользователя, регистрационное имя которого передается в командную строку.
#!/bin/bash
until who | grep "$1" > /dev/null
do
sleep 60
done
# Теперь звонит колокольчик и извещает о новом пользователе
echo -е '\а'
echo "**** $1 has just logged in ****"
exit 0
Если пользователь уже зарегистрировался в системе, выполнять цикл нет необходимости. Поэтому естественно выбрать цикл until, а не цикл while.
case.
Оператор case немного сложнее уже рассмотренных нами операторов. У него следующая синтаксическая запись:
case переменная in
образец [ | образец] ...) операторы;;
образец [ | образец] ...) операторы;;
esac
Конструкция оператора case выглядит слегка устрашающей, но она позволяет довольно изощренным способом сопоставлять содержимое переменной с образцами и затем выполнять разные операторы в зависимости от того, с каким образцом найдено соответствие. Это гораздо проще, чем проверять несколько условий, применяемых во множественных операторах if, elif и else.
Примечание. Обратите внимание на то, что каждая ветвь с образцами завершается удвоенным символом "точка с запятой" ( ;;). В каждой ветви оператора case можно поместить несколько операторов, поэтому сдвоенная точка с запятой необходима для отметки завершения очередного оператора и начала следующей ветви с новым образцом в операторе case.Возможность сопоставлять многочисленные образцы и затем выполнять множественные связанные с образцом операторы делают конструкцию case очень удобной для обработки пользовательского ввода. Лучше всего увидеть, как работает конструкция case на примерах. Мы будем применять ее в упражнениях 2.6–2.8, каждый раз совершенствуя сопоставление с образцами.
Примечание. Применяя конструкцию case с метасимволами в образцах, такими как *, будьте особенно внимательны. Проблема заключается в том, что принимается во внимание первое найденное соответствие образцу, несмотря на то, что в последующих ветвях могут быть образцы с более точным соответствием.Упражнение 2.6. Вариант 1: пользовательский ввод.
Вы можете написать новую версию сценария проверки пользовательского ввода с помощью конструкции case, сделав сценарий немного более избирательным и терпимым к неожиданным вариантам ввода.
#!/bin/sh
echo "Is it morning? Please answer yes or no "
read timeofday
case "$timeofday" in
yes) echo "Good Morning";;
no ) echo "Good Afternoon";;
y ) echo "Good Morning";;
n ) echo "Good Afternoon";;
* ) echo "Sorry, answer not recognized";;
esac
exit 0
Как это работает
Когда выполняется оператор case, он берет содержимое переменной timeofday и сравнивает его поочередно с каждой строкой-образцом. Как только строка совпадает с введенной информацией, оператор case выполняет код, следующий за ), и завершается.
Оператор case выполняет обычную подстановку в строках, которые он использует для сравнения. Следовательно, вы можете задать часть строки с последующим метасимволом *. Применение единственного символа * будет соответствовать совпадению с любой введенной строкой, поэтому поместите этот вариант после всех остальных образцов строк для того, чтобы задать некоторое стандартное поведение оператора case, если не будут найдены совпадения с другими строками-образцами. Это возможно, потому что оператор case сравнивает с каждой строкой-образцом поочередно. Он не ищет наилучшее соответствие, а всего лишь первое встретившееся. Условие, принятое по умолчанию, часто оказывается невыполнимым, поэтому применение метасимвола * может помочь в отладке сценариев.
Упражнение 2.7. Вариант 3: объединение образцов.
Предыдущая версия конструкции case, безусловно, элегантнее варианта с множественными операторами if, но, объединив все образцы, можно создать более красивую версию.
#!/bin/sh
echo "Is it morning? Please answer yes or no "
read timeofday
case "$timeofday" in
yes | y | Yes | YES ) echo "Good Morning";;
n* | N*) echo "Good Afternoon";;
* ) echo "Sorry, answer not recognized";;
esac
exit 0
Как это работает
Данный сценарий в операторе case использует несколько строк-образцов в каждой ветви, таким образом, case проверяет несколько разных строк для каждого возможного оператора. Этот прием делает сценарий короче и, как показывает практика, облегчает его чтение. Приведенный программный код также показывает, как можно использовать метасимвол *, несмотря на то, что он может соответствовать непредусмотренным образцам. Например, если пользователь введет строку never, она будет соответствовать образцу n*, и на экран будет выведено приветствие Good Afternoon (Добрый день), хотя такое поведение в сценарии не предусматривалось. Учтите также, что заключенный в кавычки знак подстановки * не действует.
Упражнение 2.8. Вариант 3: выполнение нескольких операторов.
В заключение, для того чтобы сделать сценарий многократно используемым, вам необходимо использовать другое значение кода завершения в том случае, когда применяется образец по умолчанию для непонятного варианта ввода.
#!/bin/sh
echo "Is it -morning? Please answer yes or no"
read timeofday
case "$timeofday" in
yes | y | Yes | YES )
echo "Good Morning"
echo "Up bright and early this morning"
;;
[nN]*)
echo "Good Afternoon"
;;
*)
echo "Sorry, answer not recognized"
echo "Please answer yes or no"
exit 1
;;
esac
exit 0
Как это работает
Для демонстрации другого способа определения соответствия образцу в этом программном коде изменен вариант определения соответствия для ветви no. Также видно, как в каждой ветви оператора case может выполняться несколько операторов. Следует быть внимательным и располагать в операторе самые точные образцы строк первыми, а самые общие варианты образцов последними. Это очень важно, потому что оператор case выполняется, как только найдено первое, а не наилучшее соответствие. Если вы поставите ветвь *) первой, совпадение с этим образцом будет определяться всегда, независимо от варианта введенной строки.
Примечание. Учтите, что сдвоенная точка с запятой ;; перед служебным словом esac необязательна. В отличие от программирования на языке С, в котором пропуск маркера завершения считается плохим стилем программирования, пропуск ;; не создает проблем, если последняя ветвь оператора case — это вариант, принятый по умолчанию, поскольку другие образцы уже не будут анализироваться.Для того чтобы сделать средства установления соответствия образцам более мощными, можно применять следующие строки-образцы:
[yY] | [Yy][Ее][Ss])
В них ограничен набор разрешенных букв, но при этом допускаются разнообразные ответы и предлагается более строгий контроль, чем при применении метасимвола *.
Списки.
Иногда может понадобиться сформировать последовательность команд. Например, вы хотите выполнить оператор, только если удовлетворяется несколько условий.
if [ -f this_file ]; then
if [ -f that_file ]; then
if [ -f the_other_file ]; then
echo "All files present, and correct"
fi
fi
fi
Или вы хотите, чтобы хотя бы одно условие из последовательности условий было истинным.
if [ -f this_file ]; then
foo="True"
elif [ -f that_file ]; then
foo="True"
elif [ -f the_other_file ];
then foo="True"
else
foo="False"
fi
if ["$foo" = "True" ]; then
echo "One of the files exists"
fi
Несмотря на то, что это можно реализовать с помощью нескольких операторов if, как видите, результаты получаются очень громоздкими. В командной оболочке есть пара специальных конструкций для работы со списками команд: И-список (AND list) и ИЛИ-список (OR list). Обе они часто применяются вместе, но мы рассмотрим синтаксическую запись каждой из них отдельно.
И-список.
Эта конструкция позволяет выполнять последовательность команд, причем каждая последующая выполняется только при успешном завершении предыдущей. Синтаксическая запись такова:
оператор1 && оператор2 && операторЗ && ...
Выполнение операторов начинается с самого левого, если он возвращает значение true (истина), выполняется оператор, расположенный справа от первого оператора. Выполнение продолжается до тех пор, пока очередной оператор не вернет значение false (ложь), после чего никакие операторы списка не выполняются. Операция &&проверяет условие предшествующей команды.
Каждый оператор выполняется независимо, позволяя соединять в одном списке множество разных команд, как показано в приведенном далее сценарии. И-список успешно обрабатывается, если все команды выполнены успешно, в противном случае его обработка заканчивается неудачно.
Выполните упражнение 2.9.
Упражнение 2.9. И-списки.
В следующем сценарии вы обращаетесь к файлу file_one (для проверки его наличия, и если файл не существует, создаете его) и затем удаляете файл file_two. Далее И-список проверяет наличие каждого файла и между делом выводит на экран кое-какой текст.
#!/bin/sh
touch file_one
rm -f file_two
if [ -f file_one ] && echo "hello" [ -f file_two ] && echo " there"
then
echo "in if"
else
echo "in else"
fi
exit 0
Попробуйте выполнить сценарий, и вы получите следующий вывод:
hello
in else
Как это работает
Команды touch и rm гарантируют, что файлы в текущем каталоге находятся в известном состоянии. Далее И-список выполняет команду [ -f file one ], которая возвращает значение true, потому что вы только что убедились в наличии файла. Поскольку предыдущий оператор завершился успешно, теперь выполняется команда echo. Она тоже завершается успешно ( echo всегда возвращает true). Затем выполняется третья проверка [ -f file_two ]. Она возвращает значение false, т.к. файл не существует. Поскольку последняя команда вернула false, заключительная команда echo не выполняется. В результате И-список возвращает значение false, поэтому в операторе if выполняется вариант else.
ИЛИ-список.
Эта конструкция позволяет выполнять последовательность команд до тех пор, пока одна из них не вернет значение true, и далее не выполняется ничего более. У нее следующая синтаксическая запись:
оператор1 || оператор2 || операторЗ || ...
Операторы выполняются слева направо. Если очередной оператор возвращает значение false, выполняется следующий за ним оператор. Это продолжается до тех пор, пока очередной оператор не вернет значение true, после этого никакие операторы уже не выполняются.
ИЛИ-список очень похож на И-список, за исключением того, что правило для выполнения следующего оператора — выполнение предыдущего оператора со значением false.
Рассмотрим упражнение 2.10.
Упражнение 2.10. ИЛИ-списки.
Скопируйте сценарий из предыдущего упражнения и измените затененные строки следующим образом.
#!/bin/sh
rm -f file_one
if [ -f file_one ] || echo "hello" || echo " there" then
echo "in if"
else
echo "in else"
fi
exit 0
В результате выполнения данного сценария будет получен следующий вывод:
hello
in if
Как это работает
В первых двух строках просто задаются файлы для остальной части сценария. Первая команда списка [ -f file one ] возвращает значение false, потому что файла в каталоге нет. Далее выполняется команда echo. Вот это да — она возвращает значение true, и больше в ИЛИ-списке не выполняются никакие команды. Оператор if получает из списка значение true, поскольку одна из команд ИЛИ-списка (команда echo) вернула это значение.
Результат, возвращаемый обоими этими списками, — это результат последней выполненной команды списка.
Описанные конструкции списков выполняются так же, как аналогичные конструкции в языке С, когда проверяются множественные условия. Для определения результата выполняется минимальное количество операторов. Операторы, не влияющие на конечный результат, не выполняются. Обычно этот подход называют оптимизацией вычислений (short circuit evaluation).
Комбинирование этих двух конструкций — высшее блаженство для любителей логических задач. Попробуйте проанализировать следующий список:
[ -f file_one ] && команда в случае true || команда в случае false
В нем будет выполняться первая команда в случае истинности проверки и вторая команда в противном случае. Всегда лучше всего поэкспериментировать с этими довольно необычными списками, и, как правило, вам придется использовать скобки для изменения порядка вычислений.
Операторные блоки.
Если вы хотите применить несколько операторов в том месте программного кода, где разрешен только один, например в ИЛИ-списке или И-списке, то можете сделать это, заключив операторы в фигурные скобки {} и создав тем самым операторный блок. Например, в приложении, представленном далее в этой главе, вы увидите следующий фрагмент программного кода:
get_confirm && {
grep -v "$cdcatnum" $tracks_file > $temp_file
cat $temp_file > $tracks_file
echo
add record_tracks
}
Функции.
В командной оболочке можно определять функции, и, если вы пишете сценарии любого размера, функции можно применять для структурирования кода.
Примечание. Как альтернативу можно использовать разбиение большого сценария на много маленьких, каждый из которых выполняет небольшую задачу. У этого подхода есть несколько недостатков: выполнение вложенного в сценарий другого сценария будет гораздо медленнее, чем выполнение функции. Значительно труднее возвращать результаты, и может появиться большое количество маленьких сценариев. Следует рассмотреть наименьшую практически самостоятельную часть вашего сценария и использовать ее как эталон для того, чтобы определить, когда возникает необходимость разбиения большого сценария на коллекцию меньших по размеру сценариев.Для определения функции в командной оболочке просто введите ее имя и следом за ним пустые круглые скобки, а операторы тела функции заключите в фигурные скобки.
Имя_функции() {
операторы
}
Выполните упражнения 2.11 и 2.12.
Упражнение 2.11. Простая функция.
Давайте начнем с действительно простой функции.
#!/bin/sh
foo() {
echo "Function foo is executing"
}
echo "script starting"
foo
echo "script ended"
exit 0
Выполняющийся сценарий, выведет на экран следующий текст:
script starting
Function foo is executingscript ended
Как это работает
Данный сценарий начинает выполняться с первой строки. Таким образом, ничего необычного нет, но, когда он находит конструкцию foo() {, он знает, что здесь дается определение функции, названной foo. Он запоминает ссылку на функцию и foo продолжает выполнение после обнаружения скобки }. Когда выполняется строка с единственным именем foo, командная оболочка знает, что нужно выполнить предварительно определенную функцию. Когда функция завершится, выполнение сценария продолжится в строке, следующей за вызовом функции foo.
Вы должны всегда определить функцию прежде, чем сможете ее запустить, немного похоже на стиль, принятый в языке программирования Pascal, когда вызову функции предшествует ее определение, за исключением того, что в командной оболочке нет опережающего объявления (forward) функции. Это ограничение не создает проблем, потому что все сценарии выполняются с первой строки, поэтому если просто поместить все определения функций перед первым вызовом любой функции, все функции окажутся определенными до того, как будут вызваны.
Когда функция вызывается, позиционные параметры сценария $*, $@, $#, $1, $2 и т.д. заменяются параметрами функции. Именно так вы считываете параметры, передаваемые функции. Когда функция завершится, они восстановят свои прежние значения.
Примечание. Некоторые более ранние командные оболочки не могут восстанавливать значения позиционных параметров после выполнения функций. Не стоит полагаться на описанное в предыдущем абзаце поведение, если вы хотите, чтобы ваши сценарии были переносимыми.Вы можете заставить функцию возвращать числовые значения с помощью команды return. Обычный способ возврата функцией строковых значений — сохранение строки в переменной, которую можно использовать после завершения функции. Другой способ — вывести строку с помощью команды echo и перехватить результат, как показано далее.
foo() { echo JAY;}
...
result="$(foo)"
Вы можете объявлять локальные переменные в функциях командной оболочки с помощью ключевого слова local. В этом случае переменная действительна только в пределах функции. В других случаях функция может обращаться к переменным командной оболочки, у которых глобальная область действия. Если у локальной переменной то же имя, что и у глобальной, в пределах функции локальная переменная перекрывает глобальную. Для того чтобы убедиться в этом на практике, можно изменить предыдущий сценарий следующим образом.
#!/bin/sh
sample_text="global variable"
foo() {
local sample_text="local variable"
echo "Function foo is executing"
echo $sample_text
}
echo "script starting"
echo $sample_text
foo
echo "script ended"
echo $sample_text
exit 0
При отсутствии команды return, задающей возвращаемое значение, функция возвращает статус завершения последней выполненной команды,
Упражнение 2.12. Возврат значения.
В следующем сценарии, my_name, показано, как в функцию передаются параметры и как функции могут вернуть логический результат true или false. Вы можете вызвать этот сценарий с параметром, задающим имя, которое вы хотите использовать в вопросе.
1. После заголовка командной оболочки определите функцию yes_or_no.
#!/bin/sh
yes_or_no() {
echo "Is your name $* ? "
while true
do
echo -n "Enter yes or no: "
read x
case "$x" in
y | yes ) return 0;;
n | no ) return 1;;
* ) echo "Answer yes or no"
esac
done
}
2. Далее начинается основная часть программы.
echo "Original parameters are $*"
if yes_or_no "$1"
then
echo "Hi $1, nice name"
else
echo "Never mind"
fi
exit 0
Типичный вывод этого сценария может выглядеть следующим образом:
$ ./my_name Rick Neil
Original parameters are Rick Neil
Is your name Rick ?
Enter yes or no: yes
Hi Rick, nice name
$
Как это работает
Когда сценарий начинает выполняться, функция определена, но еще не выполняется. В операторе if сценарий вызывает функцию yes_or_no, передавая ей оставшуюся часть строки как параметры после замены $1 первым параметром исходного сценария строкой Rick. Функция использует эти параметры, в данный момент хранящиеся в позиционных параметрах $1, $2 и т.д., и возвращает значение в вызывающую программу. В зависимости от возвращенного функцией значения конструкция if выполняет один из операторов.
Как видите, у командной оболочки есть большой набор управляющих структур и условных операторов. Вам необходимо познакомиться с некоторыми командами, встроенными в оболочку; после этого вы будете готовы решать реальные программистские задачи без компилятора под рукой!
Команды.
В сценариях командной оболочки можно выполнять два сорта команд. Как уже упоминалось, существуют "обычные" команды, которые могут выполняться и из командной строки (называемые внешними командами), и встроенные команды (называемые внутренними командами). Внутренние команды реализованы внутри оболочки и не могут вызываться как внешние программы. Но большинство внутренних команд представлено и в виде автономных программ, это условие — часть требований стандарта POSIX. Обычно, не важно, команда внешняя или внутренняя, за исключением того, что внутренние команды действуют эффективнее.
В этом разделе представлены основные команды, как внутренние, так и внешние, которые мы используем при написании сценариев. Как пользователь ОС Linux, вы, возможно, знаете много других команд, которые принимает командная строка. Всегда помните о том, что вы можете любую из них применить в сценарии в дополнение к встроенным командам, представленным в данном разделе.
break.
Используйте команду break для выхода из циклов for, while и until до того, как будет удовлетворено управляющее условие. В команде break можно задать дополнительный числовой параметр, указывающий на число циклов, из которых предполагается выход. Однако это может сильно усложнить чтение сценариев, поэтому мы не советуем вам использовать его. По умолчанию break обеспечивает выход из одного цикла.
#!/bin/sh
rm -rf fred*
echo > fred1
echo > fred2
mkdir fred3
echo > fred4
for file in fred*
do
if [ -d "$file" ]; then
break;
fi
done
echo first directory starting fred was $file
m -rf fred*
exit 0
Команда :
Команда "двоеточие" — фиктивная команда. Она иногда полезна для упрощения логики в условиях, будучи псевдонимом команды true. Поскольку команда : встроенная, она выполняется быстрее, чем true, хотя ее вывод гораздо менее читабелен.
Вы можете найти эту команду в условии для циклов while. Конструкция while : выполняет бесконечный цикл вместо более общего while true.
Конструкция : также полезна для условного задания переменных. Например,
: ${var:=value}
Без : командная оболочка попытается интерпретировать $var как команду.
Примечание. В некоторых более старых версиях сценариев командной оболочки можно встретить двоеточие, применяемое в начале строки для обозначения комментариев, однако в современных сценариях следует всегда применять для обозначения начала комментариев знак #, поскольку этот вариант действует эффективнее.#!/bin/sh
rm -f fred
if [ -f fred ]; then
:
else
echo file fred did not exist
fi
exit 0
continue.
Как и одноименный оператор языка С, эта команда заставляет охватывающий ее цикл for, while или until начать новый проход или следующую итерацию. При этом переменная цикла принимает следующее значение в списке.
#!/bin/sh
rm -rf fred*
echo > fred1
echo > fred2
mkdir fred3
echo > fred4
for file in fred*
do
if [ -d "$file" ]; then
echo "skipping directory $file"
continue
fi
echo file is $file
done
rm -rf fred*
exit 0
Команда continue может принимать в качестве необязательного параметра номер прохода охватывающего цикла, с которого следует возобновить выполнение цикла.
Таким образом, вы сможете иногда выскочить из вложенных циклов. Данный параметр редко применяется, т.к. он часто сильно затрудняет понимание сценариев. Например,
for x in 1 2 3
do
echo before $x
continue 1
echo after $x
done
У приведенного фрагмента будет следующий вывод:
before 1
before 2
before 3
Команда .
Команда "точка" ( .) выполняет команду в текущей оболочке:
. ./shell_script
Обычно, когда сценарий выполняет внешнюю команду или сценарий, создается новое окружение (подоболочка), команда выполняется в новом окружении и затем окружение удаляется, за исключением кода завершения, который возвращается в родительскую оболочку. Внешняя команда source и команда "точка" (еще два синонима) выполняют команды, приведенные в сценарии, в той же командной оболочке, которая выполняет сценарий.
Поскольку по умолчанию во время работы сценария создается новое окружение, любые изменения переменных окружения, сделанные в сценарии, теряются. С другой стороны, команда "точка" позволяет выполняющемуся сценарию изменять текущее окружение. Это часто бывает полезно, когда сценарий применяется как оболочка для настройки окружения, предназначенного для последующего выполнения какой-либо другой команды. Например, когда вы работаете над несколькими разными проектами одновременно, может оказаться, что вам необходимо выполнять команды с разными параметрами, например, запускать более старую версию компилятора для поддержки старой программы.
В сценариях командной оболочки команда "точка" играет роль, немного похожую на роль директивы #include в языках программирования С и С++. И хотя она не подключает сценарий в буквальном смысле слова, она действительно выполняет команду в текущем контексте, поэтому вы можете применять ее для включения переменных и определений функций в ваш сценарий.
Выполните упражнение 2.13.
Упражнение 2.13. Команда точка.
В следующем примере команда "точка" применяется в командной строке, но с таким же успехом вы можете использовать ее и в сценарии.
1. Предположим, что у вас есть два файла, содержащие параметры окружения для двух разных сред разработки. Для установки окружения, предназначенного для старых классических команд, classic_set, можно применить следующий программный код.
#!/bin/sh
version=classic
PATH=/usr/local/old_bin:/usr/bin:/bin:
.
PS1="classic> "
2. Для новых команд применяется latest_set.
#!/bin/sh
version=latest
PATH=/usr/local/new_bin:/usr/bin:/bin:
.
PS1=" latest version> "
Вы можете установить окружение, применяя эти сценарии в сочетании с командой "точка", как показано в следующей порции примера.
$ . ./classic_set
classic> echo $version
classic
classic> . /latest_set
latest version> echo $version
latest
latest version>
Как это работает
Сценарии выполняются, используя команду "точка", поэтому каждый из них выполняется в текущей командной оболочке. Это позволяет сценарию изменять параметры окружения в текущей оболочке, которая сохраняет изменения даже после того, как сценарий завершился.
echo.
Несмотря на призыв группы Х/Open применять в современных командных оболочках команду printf, мы будем продолжать следовать общепринятой практике использования команды echo для вывода строки с последующим переходом на новую строку.
При этом возникает общая проблема: удаление символа перехода на новую строку. К сожалению, в разных версиях ОС UNIX реализованы разные решения. В ОС Linux общепринятый метод
echo -n "string to output"
Но вы часто будете сталкиваться и с вариантом
echo -е "string to output\c"
Второй вариант echo -е рассчитан на то, что задействована интерпретация символов escape-последовательности, начинающихся с обратного слэша, таких как \c для подавления новой строки, \t для вывода табуляции, \n для вывода символов возврата каретки. В более старых версиях bash этот режим установлен по умолчанию, а в более современных версиях интерпретация символов escape-последовательностей с обратным слэшем отключена. Подробные сведения о поведении вашего дистрибутива ищите на страницах интерактивного справочного руководства.
Примечание. Если вам нужен легко переносимый способ удаления завершающей новой строки, для избавления от нее можно воспользоваться внешней командой tr, но она будет выполняться немного медленнее. Если вашим системам UNIX нужна переносимость и нужно избавиться от завершающей новой строки, как правило, лучше придерживаться команды printf. Если ваши сценарии предназначены для работы только в ОС Linux и bash, вполне подойдет echo -n, хотя, возможно, придется начинать файл со строки #!/bin/bash для того, чтобы в явной форме показать, что вы рассчитываете на поведение в стиле bash.eval.
Команда eval позволяет вычислять аргументы. Она встроена в командную оболочку и обычно не представлена как отдельная команда. Лучше всего ее действие демонстрирует короткий пример, позаимствованный непосредственно из стандарта X/Open.
foo=10
x=foo
у='$'$х
echo $у
Будет выведено $foo. Однако код
foo=10
x=foo
eval у='$'$х
echo $у
выведет на экран 10. Таким образом, eval немного похожа на дополнительный знак $: она возвращает значение значения переменной.
Команда eval очень полезна, т.к. позволяет генерировать и выполнять код на лету. Применение этой команды усложняет отладку сценария, но разрешает делать то, что в противном случае выполнить сложно или даже невозможно.
exec.
У команды exec два варианта применения. Обычно ее используют для замены текущей командной оболочки другой программой.
Например, строка
exec wall "Thanks for all the fish"
в сценарии заменит текущую оболочку командой wall. Строки, следующие за командой exec, не обрабатываются, потому что командная оболочка, выполнявшая сценарий, больше не существует.
Второй вариант применения exec — модификация текущих дескрипторов файлов.
exec 3< afile
Эта команда открывает файловый дескриптор 3 для чтения из файла afile. Этот вариант редко используется.
exit n.
Команда exit вызывает завершение сценария с кодом завершения n. Если вы примените ее в строке подсказки или приглашения любой интерактивной командной оболочки, она приведет к вашему выходу из системы. Если разрешить сценарию завершиться без указания кода завершения, статус последней выполненной в сценарии команды используется как возвращаемое значение. Задание кода завершения считается хорошим стилем программирования.
При программировании сценариев в командной оболочке код завершения 0 — успешное завершение сценария, коды от 1 до 125 включительно — коды ошибок, которые можно использовать в сценариях. Оставшиеся значения зарезервированы в соответствии с табл. 2.5.
Таблица 2.5
Код завершения | Описание |
---|---|
126 | Файл не является исполняемым |
127 | Команда не найдена |
128 и выше | Появившийся сигнал |
Многим программистам на языках С и С++ использование нуля как признака успешного завершения может показаться несколько необычным. Большое преимущество сценариев — возможность применения 125 кодов ошибок, определенных пользователем, и отсутствие необходимости в глобальной переменной для хранения кода ошибки.
Далее приведен простой пример, возвращающий код успешного завершения, если в текущем каталоге существует файл с именем .profile.
#!/bin/sh
if [ -f .profile ]; then
exit 0
fi
exit 1
Если вы любитель острых ощущений или, как минимум, лаконичных сценариев, можете переписать сценарий в виде одной строки, используя комбинацию И-списка и ИЛИ-списка, описанных ранее:
[ -f .profile ] && exit 0 || exit 1
export.
Команда export делает переменную, называемую ее параметром, доступной в подоболочках. По умолчанию переменные, созданные в командной оболочке, не доступны в новых дочерних подоболочках, запускаемых из данной. Команда export создает из своего параметра переменную окружения, которая видна другим сценариям и программам, запускаемым из текущей программы. Говоря профессиональным языком, экспортируемые переменные формируют переменные окружения в любых дочерних процессах, порожденных командной оболочкой. Лучше всего проиллюстрировать это примером из двух сценариев: export1 и export2 (упражнение 2.14).
Упражнение 2.14. Экспорт переменных.
1. Первым представим сценарий export2.
#!/bin/sh
echo "$foo"
echo "$bar"
2. Теперь сценарий export1. В конце сценария запускается export2.
#!/bin/sh
foo="The first meta-syntactic variable"
export bar="The second meta-syntactic variable"
export2
Если вы запустите их, то получите следующий результат.
$ ./export1
The second meta-syntactic variable
$
Как это работает
Сценарий export2 просто выводит значения двух переменных. В сценарии export1 задаются значения обеих переменных, но только переменная bar помечается как экспортируемая, поэтому, когда впоследствии запускается сценарий export2, значение переменной foo потеряно, а значение переменной bar экспортировано во второй сценарий. На экране появляется пустая строка, поскольку $foo ничего не содержит и вывод переменной со значением null приводит к отображению новой строки.
После того как переменная была экспортирована из командной оболочки, она экспортируется в любые сценарии, запускаемые из этой оболочки, и в любые командные оболочки, которые в свою очередь запускают эти сценарии, и т.д. Если бы сценарий export2 вызвал другой сценарий, в нем переменная bar также была бы доступна.
Примечание. Команды set -а или set -allexport экспортируют все переменные соответственно.expr.
Команда expr вычисляет выражение, составленное из ее аргументов. Чаще всего она применяется для подсчета простых арифметических выражений в следующем виде:
х=`expr $x + 1`
Символы `` (обратная кавычка или обратный апостроф) заставляют переменную х принять результат выполнения команды expr $х + 1. Ее можно также записать с помощью синтаксической конструкции $( ) вместо обратной кавычки, например, следующим образом:
х=$(expr $х + 1)
Команда expr обладает большими возможностями, с ее помощью можно вычислять различные выражения. Основные виды вычислений перечислены в табл. 2.6.
Таблица 2.6
Вычисление выражения | Описания |
---|---|
Выражение1 | Выражение2 | Выражение1, если Выражение1 не равно нулю, в противном случае Выражение2 |
Выражение1 & Выражение2 | Нуль, если оба выражения равны нулю, в противном случае Выражение1 |
Выражение1 = Выражение2 | Равенство |
Выражение1 > Выражение2 | Больше чем |
Выражение1 >= Выражение2 | Больше или равно |
Выражение1 < Выражение2 | Меньше чем |
Выражение1 <= Выражение2 | Меньше или равно |
Выражение1 != Выражение2 | Неравенство |
Выражение1 + Выражение2 | Сложение |
Выражение1 — Выражение2 | Вычитание |
Выражение1 * Выражение2 | Умножение |
Выражение1 / Выражение2 | Деление нацело |
Выражение1 % Выражение2 | Остаток от деления нацело |
В современных сценариях вместо команды expr обычно применяется более эффективная синтаксическая конструкция $((...)), которая будет описана далее в этой главе.
printf.
Команда printf есть только в современных командных оболочках. Группа X/Open полагает, что ее следует применять вместо команды echo для генерации форматированного вывода, несмотря на то, что, кажется, лишь немногие следуют этому совету.
У команды следующая синтаксическая запись.
printf "строка формата" параметр1 параметр2 ...
Строка формата очень похожа с некоторыми ограничениями на применяемую в языках программирования С и С++. Главным образом не поддерживаются числа с плавающей точкой, поскольку все арифметические операции в командной оболочке выполняются над целыми числами. Строка формата состоит из произвольной комбинации литеральных символов, escape-последовательностей и спецификаторов преобразования. Все символы строки формата, отличающиеся от \ и %, отображаются на экране при выводе.
В табл. 2.7 приведены поддерживаемые командой escape-последовательности.
Таблица 2.7
Escape-последовательность | Описание |
---|---|
\" | Двойная кавычка |
\\ | Символ обратный слэш |
\a | Звуковой сигнал тревоги (звонок колокольчика или прерывистый звуковой сигнал) |
\b | Символ Backspace (стирание слева) |
\c | Отбрасывание последующего вывода |
\f | Символ Form feed (подача бумаги) |
\n | Символ перехода на новую строку |
\r | Возврат каретки |
\t | Символ табуляции |
\v | Символ вертикальной табуляции |
\ooo | Один символ с восьмеричным значением ooo |
\xHH | Один символ с шестнадцатеричным значением HH |
Спецификаторы преобразований довольно сложны, поэтому мы приведем наиболее распространенные варианты их применения. Более подробную информацию можно найти в интерактивном справочном руководстве командной оболочки bash или на страницах раздела 1 интерактивного руководства к команде printf ( man 1 printf). (Если вы не найдете нужных сведений в разделе 1, попробуйте поискать в разделе 3.) Спецификатор преобразования состоит из символа %, за которым следует символ преобразования. Основные варианты преобразований перечислены в табл. 2.8.
Таблица 2.8
Символ преобразования | Описание |
---|---|
D | Вывод десятичного числа |
С | Вывод символа |
S | Вывод строки |
% | Вывод знака % |
Строка формата используется для интерпретации остальных параметров команды и вывода результата, как показано в следующем примере:
$ printf "%s\n" hello
hello
$ printf "%s %d\t%s" "Hi There" 15 people
Hi There 15 people
Обратите внимание на то, что для защиты строки Hi There и превращения ее в единый параметр, строку нужно заключить в кавычки ( "").
return.
Команда return служит для возврата значений из функций, как уже упоминалось ранее при обсуждении функций. Команда принимает один числовой параметр, который становится доступен в сценарии, вызывающем функцию. Если параметр не задан, команда return по умолчанию возвращает код завершения последней команды.
set.
Команда set задает переменные-параметры командной оболочки. Она может быть полезна при использовании полей в командах, выводящих значения, разделенные пробелами.
Предположим, что вы хотите использовать в сценарии название текущего месяца. В системе есть команда date, содержащая название месяца в виде строки, но нужно отделить его от других полей. Это можно сделать с помощью комбинации команды set и конструкции $(...), которые обеспечат выполнение команды date и возврат результата (более подробно об этом см. далее). В выводе команды date строка с названием месяца — второй параметр.
#!/bin/sh
echo the date is $(date)
set $(date)
echo The month is $2
exit 0
Программа задает список параметров для вывода команды date и затем использует позиционный параметр $2 для получения названия месяца.
Мы использовали команду date только как простой пример, демонстрирующий, как извлекать позиционные параметры. Поскольку команда date зависит от языковых параметров или локализации, в действительности мы бы извлекли название месяца командой date +%B. У команды date много других вариантов форматирования, более подробную информацию см. на страницах интерактивного справочного руководства к команде.
Команду set можно также применять для передачи параметров командной оболочке и тем самым управления режимом ее работы. Наиболее часто используемый вариант команды set -х, который заставляет сценарий выводить на экран трассировку выполняемой в данный момент команды. Мы обсудим команду set и ее дополнительные опции позже в этой главе, когда будем рассматривать отладку программ.
shift.
Команда shift сдвигает все переменные-параметры на одну позицию назад, так что параметр $2 становится параметром $1, параметр $3 — $2 и т.д. Предыдущее значение параметра $1 отбрасывается, а значение параметра $0 остается неизменным. Если в вызове команды shift задан числовой параметр, параметры сдвигаются на указанное количество позиций. Остальные переменные $*, $@ и $# также изменяются в связи с новой расстановкой переменных-параметров.
Команда shift часто полезна при поочередном просмотре параметров, переданных в сценарий, и если вашему сценарию требуется 10 и более параметров, вам понадобится команда shift для обращения к 10-му параметру и следующим за ним.
Например, вы можете просмотреть все позиционные параметры:
#!/bin/sh
while [ "$1" != "" ]; do
echo "$1"
shift
done
exit 0
trap.
Команда trap применяется для задания действий, предпринимаемых при получении сигналов, которые подробно будут обсуждаться далее в этой книге. Обычное действие — удалить сценарий, когда он прерван. Исторически командные оболочки всегда использовали числа для обозначения сигналов, но в современных сценариях следует применять имена, которые берутся из файла signal.h директивы #include с опущенным префиксом SIG. Для того чтобы посмотреть номера сигналов и соответствующие им имена, можно ввести в командной строке команду trap -l.
Примечание. Для тех, кто не знаком с сигналами, это события, асинхронно посылаемые программе. Стандартно они обычно вызывают прекращение выполнения программы.С помощью команды trap передается предпринимаемое действие, за которым следует имя (имена) сигнала для перехвата:
trap команда сигнал
Напоминаем, что обычно сценарии обрабатываются интерпретатором сверху вниз, поэтому вы должны задать, команду trap перед той частью сценария, которую хотите защитить.
Для возврата к стандартной реакции на сигнал, просто задайте команду как -. Для игнорирования сигнала задайте в команде пустую строку ''. Команда trap без параметров выводит текущий список перехватов и действий.
В табл. 2.9 перечислены самые важные, включенные в. стандарт Х/Open сигналы, которые можно отследить (со стандартными номерами в скобках). Дополнительную информацию можно найти на страницах раздела 7 интерактивного справочного руководства, посвященного сигналам ( man 7 signal).
Таблица 2.9
Сигнал | Описание |
---|---|
HUP (1) | Неожиданный останов; обычно посылается, когда отключается терминал или пользователь выходит из системы |
INT (2) | Прерывание; обычно посылается нажатием комбинации клавиш <Ctrl>+<C> |
QUIT (3) | Завершение выполнения; обычно посылается нажатием комбинации клавиш <Ctrl>+<\> |
ABRT (6) | Аварийное завершение; обычно посылается при возникновении серьезной ошибки выполнения |
ALRM (14) | Аварийный сигнал; обычно посылается для обработки превышений лимита времени |
TERM (15) | Завершение; обычно посылается системой, когда она завершает работу |
А теперь выполните упражнение 2.15.
Упражнение 2.15. Сигналы прерываний.
В следующем сценарии показана простая обработка сигнала.
#!/bin/sh
trap 'rm -f /tmp/my_tmp_file_$$' INT
echo creating file /tmp/my_tmp_file_$$
date > /tmp/my_tmp_file_$$
echo "press interrupt (CTRL-C) to interrupt..."
while [ -f /tmp/my_tmp_file_$$ ] ; do
echo File exists
sleep 1
done
echo The file no longer exists trap INT
echo creating file /tmp/my_tmp_file_$$
date > /tmp/my_tmp_file_$$
echo "press interrupt (CTRL-C) to interrupt..."
while [ -f /tmp/my_tmp_file_$$ ]; do
echo File exists
sleep 1
done
echo we never get here
exit 0
Если вы выполните этот сценарий, нажимая и удерживая нажатой клавишу <Ctrl> и затем нажимая клавишу <C> (или любую другую прерывающую комбинацию клавиш) в каждом из циклов, то получите следующий вывод:
creating file /tmp/my_tmp_file_141
press interrupt (CTRL-C) to interrupt ...
File exists
File exists
File exists
File exists
The file no longer exists
creating file /tmp/my tmp_file_141
press interrupt (CTRL-C) to interrupt ...
File exists
File exists
File exists
File exists
Как это работает
Сценарий использует команду trap для организации выполнения команды rm -f /tmp/my_tmp_file_$$ при возникновении сигнала INT (прерывание). Затем сценарий выполняет цикл while до тех пор, пока существует файл. Когда пользователь нажимает комбинацию клавиш <Ctrl>+<C>, выполняется команда rm -f /tmp/my_tmp_file_$$, а затем возобновляется выполнение цикла while. Поскольку теперь файл удален, первый цикл while завершается стандартным образом.
Далее сценарий снова применяет команду trap, на этот раз для того, чтобы сообщить, что при возникновении сигнала INT никакая команда не выполняется. Затем сценарий создает заново файл и выполняет второй цикл while. Когда пользователь снова нажимает комбинацию клавиш <Ctrl>+<C>, не задана команда для выполнения, поэтому реализуется стандартное поведение: немедленное прекращение выполнения сценария. Поскольку сценарий завершается немедленно, заключительные команды echo и exit никогда не выполняются.
unset.
Команда unset удаляет переменные или функции из окружения. Она не может проделать это с переменными, предназначенными только для чтения и определенными командной оболочкой, такими как IFS. Команда применяется редко.
В следующем сценарии сначала выводится строка Hello world, а во второй раз новая строка.
#!/bin/sh
foo="Hello World"
echo $foo
unset foo
echo $foo
Примечание. Написание foo= подобно, но не идентично применению команды unset в только что приведенной программе. Оператор foo= задает для переменной foo значение null, но при этом переменная foo все еще существует. Команда unset foo удаляет из окружения переменную foo.Еще две полезные команды и регулярные выражения.
Прежде чем вы увидите, как применять на практике полученные навыки программирования в командной оболочке, давайте рассмотрим еще две очень полезные команды, которые, хотя и не являются часть оболочки, очень пригодятся при написании ее программ. Попутно мы также познакомимся с регулярными выражениями, средством поиска по шаблону, которое обнаруживает себя в разных частях ОС Linux и тесно связанных с нею программах.
Команда find.
Первой рассмотрим команду find. Эта команда, применяющаяся для поиска файлов, чрезвычайно полезна, но новички в ОС Linux часто находят ее немного сложной в использовании в немалой степени из-за ее опций, критериев и аргументов, определяющих действия (action-type), причем результат одного из этих аргументов может влиять на обработку последующих аргументов.
Прежде чем углубиться в изучение опций, критериев и аргументов команды, рассмотрим очень простой пример поиска на вашей машине файла test. Выполните приведенную далее команду под именем суперпользователя root, чтобы иметь достаточно прав доступа для обследования всего компьютера.
# find / -name test -print
/usr/bin/test
#
В зависимости от варианта установки системы на вашей машине вы можете найти и другие файлы, также названные test. Как вы, вероятно, догадываетесь, команда звучит так: "искать, начиная с каталога /, файл с именем test и затем вывести на экран имя файла". Легко, не правда ли? Безусловно.
Выполнение команды займет какое-то время, она будет искать на нашей машине и на сетевом диске машины с ОС Windows. Это происходит потому, что на компьютере с Linux смонтирована (с помощью пакета SAMBA) порция файловой системы машины с ОС Windows. Похоже, что подобный поиск будет вестись, даже если мы знаем, что искомый файл находится на машине под управлением ОС Linux.
В этом случае на помощь приходит первая опция. Если вы укажете опцию -mount, то сможете сообщить команде find о том, что смонтированные каталоги проверять не нужно.
# find / -mount -name test -print
/usr/bin/test
#
Мы нашли все тот же файл на нашей машине, но на сей раз гораздо быстрее и без поиска в смонтированных файловых системах.
Полная синтаксическая запись команды find выглядит следующим образом:
find [путь] [опции] [критерии] [действия]
Часть записи [путь] понятна и проста: вы можете указать абсолютный путь поиска, например, /bin, или относительный, например .. При необходимости можно задать несколько путей — например, find /var /home.
В табл. 2.10 перечислены основные опции команды.
Таблица 2.10
Опция | Описание |
---|---|
-depth | Поиск в подкаталогах перед поиском в самом каталоге |
-follow | Следовать по символическим ссылкам |
-maxdepths N | При поиске проверять не более N вложенных уровней каталога |
-mount (или -xdev) | Не искать в каталогах других файловых систем |
Теперь о критериях. В команде find можно задать большое число критериев, и каждый из них возвращает либо true, либо false. В процессе работы команда find рассматривает по очереди каждый файл и применяет к нему все критерий в порядке их определения. Если очередной критерий возвращает значение false, команда find прекращает анализ текущего файла и переходит к следующему; если критерий возвращает значение true, команда применяет следующий критерий к текущему файлу или совершает заданное действие над ним. В табл. 2.11 перечислены самые распространенные критерии; полный список тестов, которые можно применять в команде find, вы найдете на страницах интерактивного справочного руководства.
Таблица 2.11
Критерий | Описание |
---|---|
-atime N | К файлу обращались последний раз N дней назад |
-mtime N | Файл последний раз изменялся N дней назад |
-name шаблон | Имя файла без указания пути соответствует заданному шаблону. Для гарантии того, что шаблон будет передан в команду find и не будет немедленно обработан командной оболочкой, его следует всегда заключать в кавычки |
-newer другой файл | Текущий файл, измененный позже, чем другой файл |
-type С | Файл типа C, где C может принимать определенные значения; наиболее широко используемые " d" для каталогов и " f" для обычных файлов. Остальные обозначения типов можно посмотреть на страницах интерактивного справочного руководства |
-user имя пользователя | Файл принадлежит пользователю с заданным именем |
Вы также можете объединять критерии с помощью операторов. Как показано в табл. 2.12, у большинства из них две формы записи: короткая и более длинная форма.
Таблица 2.12
Оператор, короткая форма | Оператор, длинная форма | Описание |
---|---|---|
! | -not | Инвертирование критерия |
-а | -and | Оба критерия должны быть истинны |
-о | -or | Один из критериев должен быть истинным |
Изменить порядок проверки критериев и выполнения операторов можно с помощью скобок. Поскольку в командной оболочке у них есть особое назначение, скобки также следует выделять с помощью обратного слэша. Кроме того, если вы применяете шаблон для имени файла, то следует использовать кавычки, чтобы оболочка не выполняла подстановку имени, а прямо передала шаблон команде find. Например, если вы хотите задать критерий "измененный позже, чем файл X, или с именем, начинающимся со знака подчеркивания", его можно записать следующим образом:
\(-newer X -о -name "_*" \)
Мы приведем пример сразу после описания "Как это работает". А сейчас выполните упражнение 2.16.
Упражнение 2.16 Применение команды find с критериями.
Попытаемся найти в текущем каталоге файлы, измененные после модификации файла while2.
$ find . -newer while2 -print
.
./elif3
./words.txt
./words2.txt
./_trap
$
Все чудесно, за исключением того, что вы нашли ненужный вам текущий каталог. Вас интересуют только обычные файлы, поэтому добавьте дополнительный критерий -type f.
$ find . -newer while2 -type f -print
./elif3
./words.txt
./words2.txt
./_trap
$
Как это работает
Как это работает? Вы определили, что команда find должна искать в текущем каталоге ( .) файлы, измененные позже, чем файл while2 ( -newer while2), и, если этот критерий пройден, проверять с помощью следующего критерия ( -type f), обычные ли это файлы. В заключение вы применили действие, с которым уже сталкивались, -print, просто для того чтобы подтвердить, что файлы были найдены.
Теперь найдем файлы с именами, начинающимися с символа подчеркивания или измененные позже, чем файл while2, но в любом случае обычные файлы. Этот пример покажет, как объединять критерии с помощью скобок.
$ find . \( -name "_*" -or -newer while2 \) -type f -print
./elif3
./words.txt
./words2.txt
./_break
./_if
./set
./_shift
./_trap
./_unset
./ until
$
Это не слишком трудный пример, не так ли? Вы должны экранировать скобки, чтобы они не обрабатывались командной оболочкой, и заключить в кавычки символ *, чтобы он также был передан непосредственно в команду find.
Теперь, когда вы можете правильно искать файлы, рассмотрим действия, которые можно совершить, когда найден файл, соответствующий вашей спецификации. И снова в табл. 2.13 перечислены только самые популярные действия; полный список можно найти на страницах интерактивного справочного руководства.
Таблица 2.13
Действие | Описание |
---|---|
-exec команда | Выполняет команду. Наиболее широко используемое действие. После табл. 2.13 приведено объяснение способа передачи параметров в команду. Это действие следует завершать символьной парой \; |
-ok команда | Подобно действию exec, за исключением того, что перед обработкой файлов командой выводится подсказка для получения подтверждения пользователя на обработку каждого файла. Это действие следует завершать символьной парой \; |
Вывод на экран имени файла | |
-ls | Применение команды ls -dils к текущему файлу |
Команда в аргументах -exec и -ok принимает последующие параметры в строке как собственные, пока не встретится последовательность \; В действительности команда, в аргументах -exec и -ok выполняет встроенную команду, поэтому встроенная команда должна завершиться экранированной точкой с запятой, для того чтобы команда find могла определить, когда ей следует продолжить поиск в командной строке аргументов, предназначенных для нее самой. Магическая строка {} — параметр специального типа для команд -exec и -ok, который заменяется полным путем к текущему файлу.
Объяснение, возможно, не слишком легкое для понимания, поэтому рассмотрим пример, который поможет внести ясность. Взгляните на простой пример, использующий хорошую безопасную команду ls:
$ find . -newer while2 -type f -exec ls -l {} \;
-rwxr-xr-x 1 rick rick 275 Feb 8 17:07 ./elif3
-rwxr-xr-x 1 rick rick 336 Feb 8 16:52 ./words.txt
-rwxr-xr-x 1 rick rick 1274 Feb 8 16:52 ./words2.txt
-rwxr-xr-x 1 rick rick 504 Feb 8 18:43 ./_trap
$
Как видите, команда find чрезвычайно полезна; она только требует небольшой практики для умелого ее применения. И такая практика, как и эксперименты с командой find, обязательно принесет дивиденды.
Команда grep.
Вторая очень полезная команда, заслуживающая рассмотрения, — это команда grep. Необычное имя, означающее общий синтаксический анализатор регулярных выражений (general regular expression parser). Вы применяете команду find для поиска файлов в вашей системе, а команду grep для поиска строк в ваших файлах. Действительно, очень часто при использовании команды find команда grep передается после аргумента -exec.
Команда grep принимает опции, шаблон соответствия и файлы для поиска:
grep [опции] шаблон [файлы]
Если имена файлов не заданы, команда анализирует стандартный ввод.
Давайте начнем с изучения основных опций команды grep. И на этот раз в табл. 2.14 приведены только самые важные из них; полный список см. на страницах интерактивного справочного руководства.
Таблица 2.14
Опция | Описание |
---|---|
-с | Вместо вывода на экран совпавших с шаблоном строк выводит их количество |
-E | Включает расширенные регулярные выражения |
-h | Ужимает обычное начало каждой строки вывода за счет удаления имени файла, в котором строка найдена |
-i | Не учитывает регистр букв |
-l | Перечисляет имена файлов со строками, совпадающими с шаблоном; не выводит сами найденные строки |
-v | Меняет шаблон соответствия для выбора вместо строк, соответствующих шаблону, несовпадающих с ним строк |
Выполните упражнение 2.17.
Упражнение 2.17. Основной вариант использования команды grep.
Посмотрим команду grep в действии на примерах простых шаблонов.
$ grep in words.txt
When shall we three meet again. In thunder, lightning, or in rain?
I come, Graymalkin!
$ grep -c in words.txt words2.txt
words.txt:2 words2.txt:14
$ grep -c -v in words.txt words2.txt
words.txt:9
words2.txt:16$
Как это работает
В первом примере нет опций; в нем просто ищется строка in в файле words.txt и выводятся на экран любые строки, соответствующие условию поиска. Имя файла не отображается, поскольку поиск велся в единственном файле.
Во втором примере в двух разных файлах подсчитывается количество строк, соответствующих шаблону. В этом случае имена файлов выводятся на экран.
В заключение применяется опция -v для инвертирования критерия поиска и подсчета строк, не совпадающих с шаблоном.
Регулярные выражения.
Как вы убедились, основной вариант применения команды grep легко усвоить. Теперь пришло время рассмотреть основы построения регулярных выражений, которые позволят вам выполнять более сложный поиск. Как упоминалось ранее в этой главе, регулярные выражения применяются в системе Linux и многих языках программирования с открытым исходным кодом. Вы можете использовать их в редакторе vi и в скриптах на языке Perl, применяя одни и те же принципы, общие для регулярных выражений, где бы они ни появлялись.
При обработке регулярных выражений определенные символы интерпретируются особым образом. В табл. 2.15 приведены наиболее часто используемые в регулярных выражениях символы.
Таблица 2.15
Символ | Описание |
---|---|
^ | Привязка к началу строки |
$ | Привязка к концу строки |
. | Любой одиночный символ |
[] | В квадратных скобках содержится диапазон символов, с любым из них возможно совпадение, например, диапазон символов a-e или инвертированный диапазон, перед которым стоит символ ^ |
Если вы хотите использовать любые из перечисленных символов как "обычные", поставьте перед ними символ \. Например, если нужно найти символ $, просто введите \$.
Есть также несколько полезных специальных проверочных шаблонов, которые могут указываться в квадратных скобках (табл. 2.16).
Таблица 2.16
Проверочный шаблон | Описание |
---|---|
[:alnum:] | Буквенно-цифровые символы |
[:alpha:] | Буквы |
[:ascii:] | Символы таблицы ASCII |
[:blank:] | Пробел или табуляция |
[:cntrl:] | Управляющие символы ASCII |
[:digit:] | Цифры |
[:graph:] | Неуправляющие и непробельные символы |
[:lower:] | Строчные буквы |
[:print:] | Печатные символы |
[:punct:] | Знаки пунктуации |
[:space:] | Пробельные символы, включая вертикальную табуляцию |
[:upper:] | Прописные буквы |
[:xdigit:] | Шестнадцатиричные цифры |
Кроме того, если задана опция =E для расширенного соответствия, за регулярным выражением могут следовать и другие символы, управляющие выполнением проверки на соответствие шаблону (табл. 2.17). В команде grep перед этими символами необходимо вводить символ \.
Таблица 2.17
Опция | Описание |
---|---|
? | Совпадение не обязательно, но возможно не более одного раза |
* | Совпадения может не быть, оно может быть однократным или многократным |
+ | Совпадение должно быть однократным или многократным |
{n} | Совпадение должно быть n раз |
{n, } | Совпадение должно быть n раз и больше |
{n, m} | Совпадение должно быть от n до m раз включительно |
Все это выглядит немного запутанно, но если осваивать все возможности постепенно, то вы увидите, что все не так сложно, как кажется на первый взгляд. Самый легкий способ понять регулярные выражения — просто попробовать применить несколько.
1. Начнем с поиска строк, заканчивающихся буквой "е". Возможно, вы уже догадались, что нужно использовать специальный символ $:
$ grep e$ words2.txt
Art thou not, fatal vision, sensible
I see thee yet, in form as palpable
Nature seems dead, and wicked dreams abuse
$
Как видите, найдены строки, заканчивающиеся буквой "е".
2. Теперь найдите трехбуквенные слова, начинающиеся с символов "Th". В данном случае вам понадобится шаблон [[:space:]] для ограничения длины слова и . для единственного дополнительного символа.
$ grep Th.[[:space:]] words 2.txt
The handle toward my hand? Come, let me clutch thee.
The curtain'd sleep; witchcraft celebrates
Thy very stones prate of my whereabout,
$
3. В заключение примените расширенный режим поиска в команде grep для обнаружения слов из строчных букв длиной ровно 10 символов. Для этого задайте диапазон совпадающих символов от а до z и 10 повторяющихся совпадений.
$ grep -Е [a-z]\{10\} words2.txt
Proceeding from the heat-oppressed brain?
And such an instrument I was to use.
The curtain'd sleep; witchcraft celebrates
hy very stones prate of my whereabout,
$
Приведенные примеры лишь коснулись наиболее важных компонентов регулярных выражений. Как и для большинства составных частей ОС Linux, существует множество дополнительной документации помимо этой книги, которая поможет вам узнать еще больше подробностей, но лучший способ изучения регулярных выражений — экспериментировать с ними.
Выполнение команд.
При написании сценариев вам часто требуется перехватить результат выполнения команды для использования его в сценарии командной оболочки; т.е. вы хотите выполнить команду и поместить ее вывод в переменную.
Сделать это можно с помощью синтаксической конструкции $(команда), показанной ранее в примере с командой set. Существует устаревший вариант подстановки команды `команда`, который все еще широко распространен.
Примечание. В более раннем варианте конструкции применяется обратный апостроф или обратная кавычка ( `), а не обычный апостроф ( '), который мы использовали раньше в командной оболочке для экранирования (защиты от подстановки переменных). В сценариях оболочки применяйте этот вариант, только если вы хотите добиться высокой степени переносимости сценариев.Во всех современных сценариях следует применять конструкцию выполнения или подстановки команды $(команда), которая введена для того, чтобы избавиться от довольно сложных правил использования символов $, ' и \ внутри команды, заключенной в обратные апострофы. Если применяется обратный апостроф внутри конструкции `...` , его необходимо экранировать символом \. Эти непонятные знаки часто заставляют программистов путаться, и иногда даже опытные специалисты в программировании средствами командной оболочки вынуждены ставить опыты для того, чтобы добиться правильного использования кавычек и апострофов в командах, заключенных в обратные апострофы.
Результат выполнения конструкции $(команда) — просто вывод команды. Имейте в виду, что это не статус возврата команды, а просто строковый вывод, показанный далее.
#!/bin/sh
echo The current directory is $PWD
echo The current users are $(who)
exit 0
Поскольку текущий каталог — это переменная окружения командной оболочки, первая строка не нуждается в применении подстановки команды. Результат выполнения программы who, напротив, нуждается в ней, если он должен стать переменной в сценарии.
Если вы хотите поместить результат в переменную, то можете просто присвоить его обычным образом:
whoisthere=$(who)
echo Swhoisthere
Возможность поместить результат выполнения команды в переменную сценария — очень мощное средство, поскольку оно облегчает использование существующих команд в сценариях и перехват результата их выполнения. Если когда-нибудь вам понадобится преобразовать набор параметров, представляющих собой вывод команды на стандартное устройство вывода, и передать их как аргументы в программу, возможно, вас порадует то, что команда xargs сможет это сделать за вас. Дополнительные подробности ищите на страницах интерактивного справочного руководства.
Иногда возникают проблемы, если команда, которую вы хотите выполнить, выводит несколько пробелов перед нужным вам текстом, или больше информации, чем вам нужно. В таких случаях можно воспользоваться командой set, как было показано ранее.
Подстановки в арифметических выражениях.
Мы уже использовали команду expr, которая позволяет выполнять простые арифметические операции, но она делает это очень медленно, потому что для выполнения команды expr запускается новая командная оболочка.
Современная и лучшая альтернатива — синтаксическая конструкция $((...)). Поместив в эту конструкцию выражение, которое вы хотите вычислить, вы можете выполнить простые арифметические операции гораздо эффективнее.
#!/bin/sh
х=0
while [ "$х" -ne 10 ]; do
echo $х
х=$(($x+1))
done
exit 0
Примечание. Обратите внимание на тонкое отличие приведенной подстановки от команды х=$(...). Двойные скобки применяются для подстановки значений в арифметические выражения. Вариант с одиночными скобками, показанный ранее, используется для выполнения команд и перехвата их вывода.Подстановка значений параметров.
Вы уже видели простейший вариант присваивания параметра и подстановки значения параметра:
foo=fredecho $foo
Проблема возникает, когда вы хотите вставить дополнительные символы в конец значения переменной. Предположим, что вы хотите написать короткий сценарий обработки файлов 1_tmp и 2_tmp. Вы могли бы написать следующие строки:
#!/bin/sh
for i in 1 2 do
my_secret_process $i_tmp
done
Но в каждом проходе цикла вы получите следующее сообщение:
my_secret_process: too few arguments
В чем ошибка?
Проблема заключается в том, что командная оболочка попыталась подставить значение переменной $i_tmp, которая не существует. Оболочка не считает это ошибкой; она просто не делает никакой подстановки, поэтому в сценарий my_secret_process не передаются никакие параметры. Для обеспечения подстановки в переменную части ее значения $i необходимо i заключить в фигурные скобки следующим образом:
#!/bin/sh
for i in 1 2 do
my_secret_process ${i}_tmp
done
В каждом проходе цикла вместо ${i} подставляется значение i и получаются реальные имена файлов. Вы подставляете значение параметра в строку.
В командной оболочке можно выполнять разнообразные виды подстановок. Часто они помогают найти красивое решение задач, требующих обработки многих параметров. Самые распространенные виды подстановок значений параметров приведены в табл. 2.18.
Таблица 2.18
Шаблон подстановки параметра | Описание |
---|---|
${парам:-значение по умолчанию} | Если у парам нет значения, ему присваивается значение по умолчанию |
${#парам} | Задается длина парам |
${парам%строка} | От конца значения парам отбрасывается наименьшая порция, совпадающая со строкой, и возвращается остальная часть значения |
${парам%%строка} | От конца значения парам отбрасывается наибольшая порция, совпадающая со строкой, и возвращается остальная часть значения |
${парам#строка} | От начала значения парам отбрасывается наименьшая порция, совпадающая со строкой, и возвращается остальная часть значения |
${парам##строка} | От начала значения парам отбрасывается наибольшая порция, совпадающая со строкой, и возвращается остальная часть значения |
Эти подстановки очень полезны при работе со строками. Последние четыре варианта, удаляющие части строк, особенно пригодятся при обработке имен файлов и путей к ним, как показано в упражнении 2.18.
В приведенном далее сценарии показано применение шаблонов при подстановках значений параметров.
#!/bin/sh
unset foo
echo ${foo:-bar}
foo=fud
echo ${foo:-bar}
foo=/usr/bin/X11/startx
echo ${foo#*/}
echo ${foo##*/}
bar=/usr/local/etc/local/networks
echo ${bar%local*}
echo ${bar%%local*}
exit 0
У этого сценария следующий вывод:
bar
fud
usr/bin/X11/startx
startx
/usr/local/etc/usr
Как это работает
Первая подстановка ${foo:-bar} дает значение bar, поскольку у foo нет значения в момент выполнения команды. Переменная foo остается неизменной, т.е. она остается незаданной.
Примечание. Подстановка ${foo:=bar} установила бы значение переменной $foo. Этот строковый шаблон устанавливает, что переменная foo существует и не равна null. Если значение переменной не равно null, оператор возвращает ее значение, в противном случае вместо этого переменной foo присваивается значение bar. Подстановка ${foo:?bar} выведет на экран foo: bar и аварийно завершит команду, если переменной foo не существует или ее значение не определено. И наконец, ${foo:+bar} вернет bar, если foo существует и не равна null. Какое разнообразие вариантов!Шаблон {foo#*/} задает поиск и удаление только левого символа / (символ * соответствует любой строке, в том числе и пустой). Шаблон {foo##*/} задает поиск максимальной подстроки, совпадающей с ним, и, таким образом, удаляет самый правый символ / и все предшествующие ему символы.
Шаблон ${bar%local*} определяет просмотр символов в значении параметра, начиная от крайнего правого, до первого появления подстроки local, за которой следует любое количество символов, а в случае шаблона ${bar%%local*} ищется максимально возможное количество символов, начиная от крайнего правого символа значения и заканчивая крайним левым появлением подстроки local.
Поскольку в системах UNIX и Linux многое основано на идеи фильтров, результат какой-либо операции часто должен перенаправляться вручную. Допустим, вы хотите преобразовать файлы GIF в файлы JPEG с помощью программы cjpeg:
$ cjpeg image.gif > image.jpg
Порой вам может потребоваться выполнить такого рода операцию над большим числом файлов. Как автоматизировать подобное перенаправление? Это очень просто:
#!/bin/sh
for image in *.gif
do
cjpeg $image > {image%%gif}jpg
done
Этот сценарий, giftojpeg, создает в текущем каталоге для каждого файла формата GIF файл формата JPEG.
Встроенные документы.
Особый способ передачи из сценария командной оболочки входных данных команде — использование встроенного документа (here document). Такой документ позволяет команде выполняться так, как будто она читает данные из файла или с клавиатуры, в то время как на самом деле она получает их из сценария.
Встроенный документ начинается со служебных символов <<, за которыми следует специальная символьная последовательность, повторяющаяся и в конце документа. Символы << обозначают в командной оболочке перенаправление данных, которое в данном случае заставляет вход команды превратиться во встроенный документ. Специальная последовательность символов действует как маркер, указывая оболочке, где завершается встроенный документ. Маркерная последовательность не должна включаться в строки, передаваемые команде, поэтому лучше всего сделать ее запоминающейся и четко выделяющейся.
Рассмотрим упражнение 2.19.
Упражнение 2.19. Применение встроенных документов.
Простейший пример просто передает входные данные команде cat.
#!/bin/sh
cat <<!FUNKY!
hello
this is a here
document
!FUNKY!
Этот пример выводит на экран следующие строки:
hello
this is a here
document
Встроенные документы могут показаться странным средством, но они очень полезны, т.к. позволяют запускать интерактивные программы, например редактор, и снабжать их каким-либо заранее определенным вводом. Но особенно часто они применяются при выводе из сценария больших порций текста, как вы уже видели, и при этом позволяют избавиться от необходимости применять команду echo для каждой выводимой строки. Вы можете использовать восклицательные знаки ( !) с двух сторон от идентификатора документа во избежание путаницы.
Если вы хотите обработать несколько строк заранее определенным способом, можно применить в сценарии строчный редактор ed и передать ему команды из встроенного документа (упражнение 2.20).
Упражнение 2.20. Ещё одно применение встроенного документа.
1. Начнем с файла, названного a_text_file и содержащего следующие строки:
That is line 1
That is line 2
That is line 3That is line 4
2. Вы можете отредактировать этот файл, совместно используя встроенный документ и редактор ed:
#!/bin/sh
ed a_text_file <<!FunkyStuff!
3
d
., \$s/is/was/ w
q
!FunkyStuff!
exit 0
Если вы выполните этот сценарий, то увидите, что теперь файл содержит следующие строки:
That is line 1
That is line 2
That was line 4
Как это работает
Сценарий командной оболочки запускает редактор ed и передает ему команды, необходимые для перехода к третьей строке, удаления строки и затем замены ее содержимым текущей строки (поскольку строка 3 (line 3) была удалена, теперь текущая строка — последняя строка файла). Эти команды редактора ed берутся из строк сценария, формирующих встроенный документ, строк между маркерами !Funky Stuff!.
Примечание. Обратите внимание на знак \ внутри встроенного документа, применяемый для защиты от подстановки, выполняемой командной оболочкой. Символ \ экранирует знак $, поэтому оболочка знает, что не следует пытаться подставить вместо строки \$s/is/was/ ее значение, которого у нее конечно же нет. Оболочка просто передает текст \$ как $, который затем сможет интерпретировать редактор eОтладка сценариев.
Обычно отлаживать сценарии командной оболочки довольно легко, хотя специальных вспомогательных средств отладки не существует. В этом разделе мы дадим краткий обзор наиболее распространенных приемов.
Когда возникает ошибка, командная оболочка, как правило, выводит на экран номер строки, содержащей ошибку. Если ошибка сразу не видна, вы можете добавить несколько дополнительных команд echo для отображения содержимого переменных и протестировать фрагменты программного кода, просто вводя их в командной оболочке в интерактивном режиме.
Поскольку сценарии обрабатываются интерпретатором, нет затрат на компиляцию при корректировке и повторном выполнении сценария. Основной способ отслеживания наиболее трудно выявляемых ошибок — задание различных опций командной оболочки. Для этого вы можете применять опции командной строки после запуска командной оболочки или использовать команду set. В табл. 2.19 перечислены эти опции.
Таблица 2.19
Опция командной строки | Опция команды set | Описание |
---|---|---|
sh -n <сценарий> | set -о noexec set -n | Только проверяет синтаксические ошибки; не выполняет команды |
sh -v <сценарий> | set -о verbose set -v | Выводит на экран команды перед их выполнением |
sh -х <сценарий> | set -о xtrace set -x | Выводит на экран команды после обработки командной строки |
sh -u <сценарий> | set -o nounset set -u | Выдает сообщение об ошибке при использовании неопределенной переменной |
Вы можете установить опции с помощью флагов -о и сбросить их с помощью флагов +о подобным же образом в сокращенных версиях. Получить простое отслеживание выполнения можно, используя опцию xtrace. Для начала вы можете применить опцию командной строки, но для более тщательной отладки следует поместить опции xtrace (задавая выполнение и сброс отслеживания выполнения) внутрь сценария, в тот фрагмент кода, который создает проблему. Отслеживание выполнения заставляет командную оболочку перед выполнением каждой строки сценария выводить на экран эту строку и подставлять в нее значения используемых переменных.
Для установки опции xtrace используйте следующую команду:
set -о xtrace
Для того чтобы снова отключить эту опцию, применяйте следующую команду:
set +о xtrace
Уровень выполняемых подстановок задается (по умолчанию) количеством знаков + в начале каждой строки. Вы можете заменить знак + на что-то более осмысленное, определив переменную командной оболочки PS4 в вашем файле конфигурации оболочки.
В командной оболочке также можно выяснить состояние программы после ее завершения, перехватив сигнал EXIT с помощью строки, подобной приведенной далее и помещенной в начале вашего сценария:
trap 'echo Exiting: critical variable = $critical_variable' EXIT
По направлению к графическому режиму — утилита dialog.
Прежде чем мы закончим обсуждение сценариев командной оболочки, обратимся к еще одному средству, которое, хотя, строго говоря, и не является частью оболочки, в основном полезно применять именно в программах командной оболочки.
Если вы знаете, что ваш сценарий придется выполнять только с консоли ОС Linux, существует довольно изящный способ оживить сценарий, применяя служебную команду dialog. Она использует средства псевдографики текстового режима и цвет, но при этом выглядит привлекательно.
Примечание. В некоторых дистрибутивах команда dialog по умолчанию не устанавливается; например, в Ubuntu вам, возможно, придется добавить совместно поддерживаемые репозитарии для поиска готовой версии. В других дистрибутивах вы можете найти уже установленный альтернативный вариант, gdialog. Он очень похож, но рассчитан на пользовательский интерфейс GNOME, применяемый для отображения диалоговых окон команды. В этом случае вы получите настоящий графический интерфейс. Как правило, в любой программе, использующей команду dialog, можно заменить все вызовы этой команды на gdialog, и вы получите графическую версию вашей программы. В конце этого раздела мы покажем пример программы, использующей команду gdialog.Общая концепция утилиты dialog проста — одна программа с множеством параметров и опций, позволяющих отображать различные типы графических окон, начиная с простых окон с кнопками типа Yes/No (Да/Нет) и заканчивая окнами ввода и даже выбором пункта меню. Утилита обычно возвращает результат, когда пользователь выполнил какой-либо ввод, и результат может быть получен или из статуса завершения, или, если вводился текст, извлечением стандартного потока ошибок.
Прежде чем переходить к подробностям, давайте рассмотрим очень простой пример применения утилиты dialog. Вы можете вызывать ее непосредственно из командной строки, что прекрасно с точки зрения создания прототипов. Поэтому создадим простое окно сообщений для отображения традиционной первой программы:
dialog --msgbox "Hello World" 9 18
На экране появится графическое информационное окно, дополненное кнопкой OK (рис. 2.3).

Рис. 2.3
Теперь, когда вы убедились в простоте утилиты dialog, давайте поподробнее рассмотрим ее функциональные возможности. Основные типы диалоговых окон, которые вы можете создавать, перечислены в табл. 2.20.
Таблица 2.20
Тип диалогового окна | Опция, применяемая для создания окна этого типа | Назначение окна |
---|---|---|
Окна с флажками (Check boxes) | --checklist | Позволяет отображать список флажков, каждый из которых можно установить или сбросить |
Информационные окна (Info boxes) | --infobox | Простое немедленное отображение в окне, без очистки экрана, возвращаемых данных |
Окна ввода (Input boxes) | --inputbox | Позволяет пользователю вводить в окно текст |
Окна меню (Menu boxes) | --menu | Позволяет пользователю выбрать один пункт из списка |
Окна сообщений (Message boxes) | --msgbox | Отображает сообщения для пользователей и снабжено кнопкой OK, которую они должны нажать для продолжения |
Окна с переключателями (Radio selection boxes) | --radiolist | Позволяет пользователю выбрать один переключатель из списка |
Текстовые окна (Text boxes) | --textbox | Позволяют отображать содержимое файла в окне с прокруткой |
Диалоговые окна Да/Нет (Yes/No boxes) | --yesno | Позволяют задать вопрос, на который пользователь может ответить "Да" или "Нет" |
Доступны также и некоторые дополнительные типы диалоговых окон (например, индикатор процесса или окно ввода пароля). Если вы хотите узнать побольше о необычных типах диалоговых окон, как всегда подробную информацию можно найти на страницах интерактивного справочного руководства.
Для получения вывода из диалогового окна любого типа, допускающего текстовый ввод или выбор, вы должны перехватить стандартный поток ошибок, как правило, направляя его во временный файл, который вы сможете обработать позже. Для получения ответа на вопросы типа "Да"/"Нет", просто проверьте код завершения, который, как и во всех соблюдающих приличия программах, в случае успеха возвращает 0 (т. е. выбор ответа "Да" (Yes)) и 1 в остальных случаях.
У всех типов диалоговых окон есть дополнительные управляющие параметры, такие как размер и контур отображаемого окна. В табл. 2.21 перечислены разные параметры, необходимые окнам каждого типа, а затем демонстрируется использование некоторых из них в командной строке. В заключение вы увидите простой пример, объединяющий в одной программе несколько диалоговых окон разных типов.
Таблица 2.21
Тип диалогового окна | Параметры |
---|---|
--checklist | text height width list-height [tag text status] ... |
--infobox | text height width |
--inputbox | text height width [initial string] |
--menu | text height width menu-height [tag item ] ... |
--msgbox | text height width |
--radiolist | text height width list-height [tag text status] ... |
--textbox | filename height width |
--yesno | text height width |
Помимо параметров диалоговые окна всех типов принимают ряд опций. Мы не будем перечислять все, а упомянем лишь две из них: --title, позволяющую задать заголовок окна, и -clear, применяемую по прямому назначению, т.е. для очистки экрана. Полный список опций см. на страницах интерактивного справочного руководства.
Выполните упражнения 2.21 и 2.22.
Упражнение 2.21. Применение утилиты dialog.
Давайте сразу перейдем к красивому сложному примеру. Если вы поймете его, все остальные покажутся легкими! В этом примере вы создадите диалоговое окно со списком флажков, с заголовком Check me (Поставь галочку) и пояснительной надписью Pick Numbers (Выбери номера). Окно с флажками будет высотой 15 строк и шириной 25 символов, и каждый флажок будет занимать 3 символа по высоте. И последнее, но не по степени важности, вы перечислите отображаемые элементы вместе с принятой по умолчанию установкой или сбросом (on/off) флажка.
dialog --title "Check me" --checklist "Pick Numbers" 15 25 3 1 "one" "off" 2 "two" "on" 3 "three" "off"
Полученный результат показан на рис. 2.4.
Как это работает
В этом примере параметр --checklist указывает на то, что вы собираетесь создать диалоговое окно с флажками. Вы используете опцию --title для задания заголовка " Check me", следующий параметр — пояснительная надпись " Pick Numbers".
Далее вы переходите к указанию размеров диалогового окна. Оно будет высотой 15 строк и шириной 25 символов и 3 строки отводятся для меню. Это не самый удачный выбор размеров, но он позволит вам увидеть, как размещаются элементы.
Опции выглядят несколько мудрено, но вам следует запомнить только то, что у каждого элемента списка есть три значения:
□ номер в списке;
□ текст;
□ состояние.

Рис. 2.4
У первого элемента номер 1, отображается текст "one" (один) и выбрано состояние "off" (сброшен). Далее вы переходите ко второму элементу с номером 2, текстом "two" и состоянием "on" (установлен). Так продолжается до тех пор, пока вы не опишите все элементы списка.
Легко, не правда ли? Теперь попробуйте ввести несколько вариантов в командной строке и убедитесь, насколько эту утилиту легко применять. Для того чтобы включить этот пример в программу, вы должны иметь доступ к результатам пользовательского ввода. Это совсем просто: перенаправьте стандартный поток ошибок в текстовый ввод или проверьте переменную окружения $?, которая, как вы помните, не что иное, как код завершения предыдущей команды.
Упражнение 2.22. Более сложная программа, использующая утилиту dialog.
Давайте рассмотрим простую программу questions, которая принимает к сведению пользовательские ответы.
1. Начните с простого диалогового окна, сообщающего пользователю о происходящем. Вам не нужно получать результат или какой бы то ни было ввод пользователя, поэтому все просто и ясно:
#!/bin/sh
# Задайте несколько вопросов и получите ответ
dialog --title "Questionnaire" --msgbox "Welcome to my simple survey" 9 18
2. Спросите пользователя с помощью простого диалогового окна с кнопками типа Yes/No, хочет ли он продолжать. Воспользуйтесь переменной окружения $? для того, чтобы выяснить, выбрал пользователь ответ Yes (код завершения 0) или No. Если он не хочет двигаться дальше, используйте простое информационное окно, не требующее никакого пользовательского ввода для своего завершения.
dialog --title "Confirm" --yesno "Are you willing to take part?" 9 18
if [ $? != 0 ]; then
dialog --infobox "Thank you anyway" 5 20 sleep 2
dialog --clear exit 0
fi
3. Спросите у пользователя его имя с помощью диалогового окна ввода. Перенаправьте стандартный поток ошибок во временный файл _1.txt, который затем вы сможете обработать в переменной QNAME.
dialog --title "Questionnaire" --inputbox "Please enter your name" 9 30 2>_1.txt
Q_NAME=$(cat _1.txt)
4. Здесь у вас появляется меню из четырех пунктов. И снова вы перенаправляете стандартный поток ошибок и загружаете его в переменную.
dialog --menu "$Q_NAME, what music do you like best?" 15 30 4 1 "Classical" 2 "Jazz" 3 "Country" 4 "Other" 2>_1.txt
Q_MUSIC=$(cat _1.txt)
5. Номер, выбранный пользователем, будет запоминаться во временном файле _1.txt, который перехватывается переменной Q_MUSIC, поэтому вы сможете проверить результат.
if [ "$Q_MUSIC" = "1" ]; then
dialog --title "Likes Classical" --msgbox "Good choice!" 12 25
else
dialog --title "Doesn't like Classical" --msgbox "Shame" 12 25
fi
В заключение очистите последнее диалоговое окно и завершите программу.
sleep 2
dialog --clear
exit 0
На рис. 2.5 показан результат.
Как это работает
В данном примере вы соединяете команду dialog и простой программный код на языке командной оболочки для того, чтобы показать, как можно создавать простые программы с графическим пользовательским интерфейсом, используя только сценарий командной оболочки. Вы начинаете с обычного экрана-приветствия, а затем с помощью простого диалогового окна с кнопками типа Yes/No спрашиваете пользователя о его желании участвовать в опросе. Вы используете переменную $? для проверки ответа пользователя. Если он согласен, вы запрашиваете его имя, сохраняете его в переменной Q_NAME и выясняете с помощью диалогового окна-меню, какой музыкальный стиль он любит. Сохранив числовой вывод в переменной Q_MUSIC, вы сможете увидеть, что ответил пользователь, и отреагировать соответственно.

Рис. 2.5

Рис. 2.6
Если вы применяете графический пользовательский интерфейс (GUI) на базе графической среды GNOME и в данный момент запустили в нем сеанс работы с терминалом, на месте команды dialog можно использовать команду gdialog. У обеих команд одинаковые параметры, поэтому вы сможете воспользоваться тем же программным кодом, не считая замены запускаемой вами команды dialog командой gdialog. На рис. 2.6 показано, как выглядит этот сценарий в дистрибутиве Ubuntu, когда применяется команда gdialog.
Это очень лёгкий способ формирования из сценария удачного графического пользовательского интерфейса.
Соединяем все вместе.
Теперь, когда вы познакомились с основными функциональными возможностями командной оболочки как языка программирования, пора написать программу, в которой используется кое-что из того, чему вы научились.
На протяжении всей книги вы будете пытаться разработать приложение управления базой данных компакт-дисков для того, чтобы продемонстрировать приемы и методы, которые вы только что освоили. Вы начинаете со сценария командной оболочки, но очень скоро вы будете делать то же самое на языке программирования С, добавлять базу данных и т.д.
Требования.
Предположим, что у вас есть разнообразная коллекция компакт-дисков. Для того чтобы облегчить себе жизнь, вы собираетесь разработать и реализовать программу управления компакт-дисками. Электронный каталог представляется идеальным проектом для реализации, когда вы учитесь программированию в ОС Linux.
Вначале вы хотите, по меньшей мере, хранить некоторые основные сведения о каждом компакт-диске, такие как название, музыкальный стиль и исполнитель или композитор. Возможно, вам также хотелось бы запоминать некоторую простую информацию о дорожках. Вы хотите иметь возможность находить любое музыкальное произведение из хранящихся на компакт-диске, но не какие-то подробности, касающиеся дорожек. Для придания законченности мини-приложению вам хотелось бы иметь возможность в самом приложении вводить, обновлять и удалять любую часть информации.
Проектирование.
Поиск и отображение данных — заставляют предполагать, что адекватным решением будет простое меню. Все данные, которые следует хранить, — текстовые, и, полагая, что ваша коллекция компакт-дисков не слишком велика, для управления ею не потребуется сложная база данных, подойдут простые текстовые файлы. Сохранение информации в текстовых файлах позволит сделать приложение простым, и если ваши требования изменятся, всегда легче манипулировать текстовыми файлами, чем какими бы то ни было еще. И, в крайнем случае, вы сможете применить редактор для ввода и удаления данных вручную, а не писать для этого специальную программу.
Необходимо принять важное проектное решение, касающееся способа хранения данных. Достаточно одного файла? Если да, то какой у него должен быть формат? Большая часть информации, которую вы собираетесь хранить, за исключением данных о дорожках, вводится однократно для каждого компакт-диска (мы пока оставим в стороне вариант наличия на одном CD произведений разных композиторов и исполнителей). И практически на всех компакт-дисках много дорожек.
Нужно ли ограничить количество дорожек на одном компакт-диске, которые можно хранить? Это ограничение кажется лишним, поэтому сразу отбросим его.
Если вы допускаете, что на компакт-диске может быть разное количество дорожек, у вас есть три варианта:
□ использовать один файл с одной строкой для "заголовочной" типовой информации и n строк для сведений о дорожках на каждом компакт-диске;
□ поместить всю информацию о каждом компакт-диске в одну строку, разрешая ей продолжаться то тех пор, пока вся информация о дорожках диска не будет сохранена;
□ отделить заголовочную информацию от данных о дорожках и для каждого типа информации использовать отдельный файл.
Только третий вариант позволит нам легко изменять формат файлов, что потребуется, если вы когда-либо захотите превратить вашу базу данных в реляционную (более подробную информацию об этом см. в главе 7), поэтому выберем этот вариант.
Далее нужно решить, какие данные помещать в файлы.
Сначала вы выбираете для заголовка каждого компакт-диска хранение следующей информации:
□ номер компакт-диска в каталоге;
□ название;
□ музыкальный стиль (классика, рок, поп, джаз и т.д.);
□ композитор или исполнитель.
О дорожках вы будете хранить две характеристики:
□ номер дорожки;
□ ее название.
Для объединения двух файлов вы должны сопоставить данные о дорожках с остальной информацией о компакт-диске. Для этого будет использоваться номер компакт-диска в каталоге. Поскольку он уникален для каждого диска, он будет появляться однократно в файле с заголовками и один раз для каждой дорожки в файле с данными о дорожках.
В табл. 2.22 показан пример файла с заголовочными данными, а соответствующий ему файл с данными о дорожках может выглядеть так, как представлено в табл. 2.23.
Таблица 2.22
Catalog | Title | Type | Composer |
---|---|---|---|
CD123 | Cool sax | Jazz | Bix |
CD234 | Classic violin | Classical | Bach |
CD345 | Hits99 | Pop | Various |
Таблица 2.23
Catalog | Track No. | Title |
---|---|---|
CD123 | 1 | Some jazz |
CD123 | 2 | More jazz |
CD234 | 1 | Sonata in D minor |
CD345 | 1 | Dizzy |
Два файла объединены общим полем Catalog (Каталог). Следует помнить о том, что обычно на одну строку файла с заголовочной информацией приходится много строк в файле с данными о дорожках.
Последнее, что мы должны решить, — способ разделения элементов данных. Поля фиксированной ширины, обычные в реляционных базах, — не всегда самый удобный вариант. Другой распространенный способ, применяемый в данном примере, — запятая (т. е. файл со значениями, разделенными запятыми, или CSV-файл).
В упражнении 2.23 только для того, чтобы вы окончательно не запутались, применяются следующие функции:
□ get_return();
□ get_confirm();
□ set_menu_choice();
□ insert_title();
□ insert_track();
□ add_record_tracks();
□ add_records();
□ find_cd();
□ update_cd();
□ count_cds();
□ remove_records();
□ list_tracks().
Упражнение 2.23. Приложение для работы с коллекцией компакт-дисков.
1. Сначала в примере сценария как всегда стоит строка, обеспечивающая его выполнение как сценария командной оболочки, за которой следует некоторая информация об авторских правах:
#!/bin/bash
# Очень простой пример сценария командной оболочки для управления
# коллекцией компакт-дисков.
# Copyright (С) 1996-2007 Wiley Publishing Inc.
# Это свободно распространяемое программное обеспечение;
# вы можете распространять эту программу и/или изменять ее
# в соответствии с положениями GNU General Public License,
# документа, опубликованного фондом Free Software Foundation;
# либо версии 2 этой лицензии или (по вашему выбору)
# любой более свежей версии.
# Эта программа распространяется в надежде на ее полезность,
# но WITHOUT ANY WARRANTY, (без каких-либо гарантий);
# даже без предполагаемой гарантии MERCHANTABILITY
# or FITNESS FOR A PARTICULAR PURPOSE (годности
# ее для продажи или применения для определенной цели).
# Более подробную информацию см. в GNU General Public License.
# Вы должны были получить копию GNU General Public License
# вместе с этой программой;
# если нет, пишите в организацию Free Software Foundation,
# Inc. no адресу: 675 Mass Ave, Cambridge, MA 02139, USA.
2. Теперь убедитесь, что установлены некоторые глобальные переменные, которые будут использоваться во всем сценарии. Задайте заголовочный файл, файл с данными о дорожках и временный файл и перехватите нажатие комбинации клавиш <Ctrl>+<C> для того, чтобы удалить временный файл, если пользователь прервет выполнение сценария.
menu_choice=""
current cd=""
title_file="title.cdb"
tracks_file="tracks.cdb"
temp_file=/tmp/cdb.$$
trap 'rm -f $temp_file' EXIT
3. Определите ваши функции так, чтобы сценарий, выполняясь с первой строки, мог найти все определения функций до того, как вы попытаетесь вызвать любую из них в первый раз. Для того чтобы не повторять один и тот же программный код в нескольких местах, сначала вставьте две функции, служащие простыми утилитами:
get_return() (
echo -е "Press return \с"
read x
return 0
}
get_confirm() (
echo -e "Are you sure? \c"
while true do
read x
case "$x" in
y | yes | Y | Yes | YES )
return 0;;
n | no | N | No | NO )
echo
echo "Cancelled"
return 1;;
*)
echo "Please enter yes or no" ;;
esac
done
}
4. Теперь вы дошли до основной, формирующей меню функции set_menu_choice. Содержимое меню изменяется динамически, добавляя дополнительные пункты при выборе компакт-диска.
set_menu_choice() {
clear
echo "Options :-"
echo
echo " a) Add new CD"
echo " f) Find CD"
echo " c) Count the CDs and tracks in the catalog"
if [ "$cdcatnum" != "" ]; then
echo " 1) List tracks on $cdtitle"
echo " r) Remove $cdtitle"
echo " u) Update track information for $cdtitle"
fi
echo " q) Quit" echo
echo -e "Please enter choice then press return \c"
read menu_choice
return
}
Примечание. Имейте в виду, что команда echo -е не переносится в некоторые командные оболочки.5. Далее идут две очень короткие функции, insert_title и insert_track, для пополнения файлов базы данных. Несмотря на то, что некоторые программисты ненавидят однострочные функции вроде этих, они помогают сделать понятнее другие функции.
За ними следует более длинная функция add_record_track, использующая эти функции. В данной функции применяется проверка на соответствие шаблону, чтобы исключить ввод запятых (поскольку мы. используем запятые для разделения полей), и арифметические операции для увеличения номера текущей дорожки на 1, когда вводятся данные о новой дорожке.
insert_title() {
echo $* >> $title_file
return
}
insert_track() {
echo $* >> $tracks_file
return
}
add_record_tracks() {
echo "Enter track information for this CD"
echo "When no more tracks enter q"
cdtrack=1
cdttitle=""
while [ "$cdttitle" != "q" ]
do
echo -e "Track $cdtrack, track title? \c"
read tmp
cdttitle=${tmp%%, *}
if [ "$tmp" != "$cdttitle" ]; then
echo "Sorry, no commas allowed"
continue
fi
if [ -n "$cdttitle" ] ; then
if [ "$cdttitle" ! = "q" ]; then
insert_track $cdcatnum, $cdtrack, $cdttitle
fi
else
cdtrack=$((cdtrack-1))
fi
cdtrack=$((cdtrack+1))
done
}
6. Функция add_records позволяет вводить основную информацию о новом компакт-диске.
add_records() {
# Подсказка для начала ввода информации
echo -е "Enter catalog name \с"
read tmp
cdcatnum=${tmp%%, *}
echo -e "Enter title \c"
read tmp
cdtitle=${tmp%%, *}
echo -e "Enter type \c"
read tmp
cdtype=${tmp%%, *}
echo -e "Enter artist/composer \c"
read tmp
cdac=${tmp%%, *}
# Проверяет, хочет ли пользователь ввести информацию
echo About to add new entry
echo "$cdcatnum $cdtitle $cdtype $cdac"
# Если получено подтверждение, добавляет данные в конец файла.
# с заголовками
if get_confirm ; then
insert_title $cdcatnum, $cdtitle, $cdtype, $cdac
add_record_tracks
else
remove_records
fi
return
}
7. Функция find_cd с помощью команды grep ищет текст с названием компакт-диска в файле с заголовочной информацией. Вам нужно знать, сколько раз была найдена строка, а команда grep только вернет значение, указывающее на то, что строка не была найдена или была найдена многократно. Для решения этой проблемы сохраните вывод в файл, отводящий по одной строке на каждое найденное совпадение, а затем сосчитайте количество строк в файле.
У команды счетчика слов, wc, в выводе есть пробельный символ, разделяющий количества строк, слов и символов в файле. Используйте синтаксическую запись $(wc -l $temp_file) для извлечения первого параметра в выводе и переноса его в переменную linesfound. Если бы вам был нужен другой следующий далее параметр, нужно было бы воспользоваться командой set для установки значений переменных-параметров оболочки из вывода команды.
Изменив значение переменной IFS (Internal Field Separator, внутренний разделитель полей) на запятую, вы сможете разделить поля, разграниченные запятыми. Альтернативный вариант — применить команду cut.
find_сd() {
if [ "$1" = "n" ]; then
asklist=n
else
asklist=y
fi
cdcatnum=""
echo -e "Enter a string to search for in the CD titles \c"
read searchstr
if [ "$searchstr" = "" ]; then
return 0
fi
grep "$searchstr" $title_file > $temp_file
set $(wc -l $temp_file)
linesfound=$1
case "$linesfound" in
0)
echo "Sorry, nothing found"
get_return
return 0 ;;
1) ;;
2)
echo "Sorry, not unique."
echo "Found the following"
cat $temp_file
get_return
return 0
esac
IFS=", "
read cdcatnum cdtitle cdtype cdac < $temp_file
IFS=" "
if [ -z "$cdcatnum" ]; then
echo "Sorry, could not extract catalog field from $temp_file"
get_return
return 0
fi
echo
echo Catalog number: $cdcatnum echo Title: $cdtitle
echo Type: $cdtype
echo Artist/Composer: $cdac
echo
get_return
if [ "$asklist" = "y" ]; then
echo -e "View tracks for this CD? \c"
read x
if [ "$x" = "y" ]; then
echo
list_tracks
echo
fi
fi
return 1
}
8. Функция update_cd позволит вам повторно ввести сведения о компакт-диске. Учтите, что вы ищите (с помощью команды grep) строки, начинающиеся ( ^) с подстроки $cdcatnum, за которой следует ", " и должны заключить подстановку значения $cdcatnum в {}. Таким образом, вы сможете найти запятую без специального пробельного символа между ней и номером в каталоге. Эта функция также использует {} для образования блока из нескольких операторов, которые должны выполняться, если функция get_confirm вернет значение true.
update_cd() {
if [ -z "$cdcatnum" ]; then
echo "You must select a CD first"
find_cd n
fi
if [ -n "$cdcatnum" ]; then
echo "Current tracks are :-"
list_tracks
echo
echo "This will re-enter the tracks for $cdtitle"
get_confirm && {
grep -v "^${cdcatnum}, " $tracks_file > $temp_file
mv $temp_file $tracks_file
echo
add_record_tracks
}
fi
return
}
9. Функция count_cds дает возможность быстро пересчитать содержимое базы данных.
count_cds() {
set $(wc -l $title_file)
num_titles=$1
set $(wc -l $tracks_file)
num_tracks=$1
echo found $num_titles CDs, with a total of $num_tracks tracks
get_return
return
}
10. Функция remove_records удаляет элементы из файлов базы данных с помощью команды grep -v, удаляющей все совпадающие строки. Учтите, что нужно применять временный файл.
Если вы попытаетесь применить команду:
grep -v "^$cdcatnum" > $title_file
файл $title_file станет пустым благодаря перенаправлению вывода > до того, как команда grep выполнится, поэтому она будет читать уже пустой файл.
remove_records() {
if [ -z "$cdcatnum" ]; then
echo You must select a CD first find_cd n
fi
if [ -n "$cdcatnum" ]; then
echo "You are about to delete $cdtitle"
get_confirm && {
grep -v "^${cdcatnum}, " $title_file > $temp_file
mv $temp_file $title_file
grep -v "^${cdcatnum}, " $tracks_file > $temp_file
mv $temp_file $tracks_file
cdcatnum=""
echo Entry removed
}
get_return
fi
return
}
11. Функция list_tracks снова использует команду grep для извлечения нужных вам строк, команду cut для доступа к отдельным полям и затем команду more для постраничного вывода. Если вы посмотрите, сколько строк на языке С займет повторная реализация этих 20 необычных строк кода, то поймете, каким мощным средством может быть командная оболочка.
list_tracks() {
if [ "$cdcatnum" = "" ]; then
echo no CD selected yet
return
else
grep "^${cdcatnum}, " $tracks_file > $temp_file
num_tracks=${wc -l $temp_file}
if [ "$num_tracks" = "0" ]; then
echo no tracks found for $cdtitle
else
{
echo
echo "$cdtitle :-"
echo
cut -f 2- -d , $temp_file
echo
} | ${PAGER:-more}
fi
fi
get_return
return
}
12. Теперь, когда все функции определены, можно вводить основную процедуру. Первые несколько строк просто приводят файлы в известное состояние; затем вы вызываете функцию формирования меню set_menu_choice и действуете в соответствии с ее выводом.
Если выбран вариант quit (завершение), вы удаляете временный файл, выводите сообщение и завершаете сценарий с успешным кодом завершения.
rm -f $temp_file
if [ ! -f $title_file ]; then
touch $title_file
fi
if [ ! -f $tracks_file ]; then
touch $tracks_file
fi
# Теперь непосредственно приложение
clear
echo
echo
echo "Mini CD manager" sleep 1
quit=n
while [ "$quit" != "y" ]; do
set_menu_choice
case "$menu_choice" in
a) add_records;;
r) remove records;;
f) find_cd y;;
u) update_cd;;
c) count_cds;;
l) list_tracks;;
b)
echo
more $title_file
echo
get return;;
q | Q ) quit=y;;
*) echo "Sorry, choice not recognized";;
esac
done
# Убираем и покидаем
rm -f $temp_file echo "Finished"
exit 0
Замечания, касающиеся приложения.
Команда trap в начале сценария предназначена для перехвата нажатия пользователем комбинации клавиш <Ctrt>+<C>. Им может быть сигнал EXIT или INT, в зависимости от настроек терминала.
Существуют другие способы реализации выбора пункта меню, особенно конструкция select в оболочках bash и ksh (которая, тем не менее, не определена в стандарте X/Open). Она представляет собой специализированный селектор пунктов меню. Проверьте ее на практике, если ваш сценарий может позволить себе быть немного менее переносимым. Для передачи пользователям многострочной информации можно также воспользоваться встроенными документами.
Возможно, вы заметили, что нет проверки первичного ключа, когда создается новая запись; новый код просто игнорирует последующие названия с тем же кодом, но включает их дорожки в перечень первого названия:
1 First CD Track 1
2 First CD Track 2
1 Another CD
2 With the same CD key
Мы оставляем это и другие усовершенствования в расчете на ваше воображение и творческие способности, которые проявятся при корректировке вами программного кода в соответствии с требованиями GPL.
Резюме.
В этой главе вы увидели, что командная оболочка — это мощный язык программирования со своими функциональными возможностями. Ее способность легко вызывать программы и затем обрабатывать их результат делают оболочку идеальным средством для решения задач, включающих обработку текста и файлов.
Теперь, если вам понадобится небольшая утилита, подумайте, сможете ли вы решить вашу проблему, комбинируя множество команд ОС Linux в сценарии командной оболочки. Вы будете поражены, увидев, как много вспомогательных программ можно написать без использования компилятора.
Глава 3. Работа с файлами.
В этой главе будут рассматриваться файлы и каталоги ОС Linux и способы работы с ними. Вы научитесь создавать файлы, открывать и читать их, писать в них и удалять их. Вы также узнаете, как программы могут обрабатывать каталоги (например, создавать, просматривать и удалять их). После сделанного в предыдущей главе отступления, посвященного командным оболочкам, теперь вы начнете программировать на языке С.
Прежде чем перейти к способам обработки файлового ввода/вывода в системе Linux, мы дадим краткий обзор понятий, связанных с файлами, каталогами и устройствами. Для управления файлами и каталогами вам придется выполнять системные вызовы (аналог Windows API в системах UNIX и Linux), но, кроме того, для обеспечения более эффективного управления файлами существует большой набор библиотечных функций стандартной библиотеки ввода/вывода (stdio).
Большую часть главы мы посвятим работе с различными вызовами, необходимыми для обработки файлов и каталогов. Таким образом, в данной главе будут обсуждаться разные темы, связанные с файлами:
□ файлы и устройства;
□ системные вызовы;
□ библиотечные функции;
□ низкоуровневый доступ к файлу;
□ управление файлами;
□ стандартная библиотека ввода/вывода;
□ форматированный ввод и вывод;
□ сопровождение файлов и каталогов;
□ просмотр каталогов;
□ ошибки;
□ файловая система /proc;
□ более сложные приемы — fcntl и mmap.
Структура файла в Linux.
Вы можете спросить: "Зачем вы останавливаетесь на структуре файла? Я уже знаком с ней." Дело в том, что в среде Linux, как и UNIX, файлы особенно важны, поскольку они обеспечивают простую и согласованную взаимосвязь со службами операционной системы и устройствами. В ОС Linux файл — это все что угодно. Ну, или почти все!
Это означает, что в основном программы могут обрабатывать дисковые файлы, последовательные порты, принтеры и другие устройства точно так же, как они используют файлы. Мы расскажем о некоторых исключениях, таких как сетевые подключения, в главе 15, но в основном вы должны будете применять пять базовых функций: open, close, read, write и ioctl.
Каталоги — тоже специальный тип файлов. В современных версиях UNIX, включая Linux, даже суперпользователь не пишет непосредственно в них. Обычно все пользователи для чтения каталогов применяют интерфейс opendir/readdir, и им нет нужды знать подробности реализации каталогов в системе. Позже в этой главе мы вернемся к специальным функциям работы с каталогами.
Действительно, в ОС Linux почти все представлено в виде файлов или может быть доступно с помощью специальных файлов. И основная идея сохраняется даже, несмотря на то, что существуют в силу необходимости небольшие отличия от известных и любимых вами традиционных файлов. Давайте рассмотрим особые случаи, о которых мы уже упоминали.
Каталоги.
Помимо содержимого у файла есть имя и набор свойств, или "административная информация", т.е. дата создания/модификации файла и права доступа к нему. Свойства хранятся в файловом индексе (inode), специальном блоке данных файловой системы, который также содержит сведения о длине файла и месте хранения файла на диске. Система использует номер файлового индекса; для нашего удобства структуру каталога также называют файлом.
Каталог — это файл, содержащий номера индексов и имена других файлов. Каждый элемент каталога — ссылка на файловый индекс; удаляя имя файла, вы удаляете ссылку. (Номер индекса файла можно увидеть с помощью команды ln -i.) Применяя команду ln, вы можете создать ссылки на один и тот же файл в разных каталогах.
Когда вы удаляете файл, удаляется элемент каталога для этого файла, и количество ссылок на файл уменьшается на единицу. Данные файла могут быть все еще доступны благодаря другим ссылкам на этот же файл. Когда число ссылок на файл (число, идущее после прав доступа в команде ls -l) становится равно нулю, индекс файла и блоки данных, на которые он ссылается, больше не используются и помечаются как свободные.
Файлы помещаются в каталоги, которые могут содержать подкаталоги. Так формируется хорошо знакомая иерархия файловой системы. Пользователь, скажем neil, обычно хранит файлы в исходном (home) каталоге, возможно /home/neil, с подкаталогами для хранения электронной почты, деловых писем, служебных программ и т.д. Имейте в виду, что у многих командных оболочек систем UNIX и Linux есть отличное обозначение для указания начала пути в вашем исходном каталоге: символ "тильда" (~). Для другого пользователя наберите ~user. Как вы знаете, исходные каталоги пользователей — это, как правило, подкаталоги каталога более высокого уровня, создаваемого специально для этой цели, в нашем случае это каталог /home.
Примечание. К сожалению, функции стандартной библиотеки при указании имени файла как параметра не понимают сокращенного обозначения с помощью тильды, поэтому в ваших программах следует всегда явно задавать полное имя файла.Каталог /home в свою очередь является подкаталогом корневого каталога /, расположенного на верхнем уровне иерархии и содержащего все системные файлы и подкаталоги. В корневой каталог обычно включен каталог /bin для хранения системных программ (бинарных файлов), каталог /etc, предназначенный для хранения системных файлов конфигурации, и каталог /lib для хранения системных библиотек. Файлы, представляющие физические устройства и предоставляющие интерфейс для этих устройств, принято помещать в каталог /dev. На рис. 3.1 показана в качестве примера часть типичной файловой системы Linux. Мы рассмотрим структуру файловой системы Linux более подробно в главе 18, когда будем обсуждать стандарт файловой системы Linux (Linux File System Standard).

Рис. 3.1
Файлы и устройства.
Даже физические устройства очень часто представляют (отображают) с помощью файлов. Например, будучи суперпользователем, вы можете смонтировать дисковод IDE CD-ROM как файл:
# mount -t iso9660 /dev/hdc /mnt/cdrom
# cd /mnt/cdrom
который выбирает устройство CD-ROM (в данном случае вторичное ведущее (secondary master) устройство IDE, которое загружается как /dev/hdc во время начального запуска системы; у устройств других типов будут другие элементы каталога /dev) и монтирует его текущее содержимое как файловую структуру в каталоге /mnt/cdrom. Затем вы перемещаетесь по каталогам компакт-диска как обычно, конечно за исключением того, что их содержимое доступно только для чтения.
В системах UNIX и Linux есть три важных файла устройств: /dev/console, /dev/tty и /dev/null.
dev/console.
Это устройство представляет системную консоль. На него часто отправляются сообщения об ошибках и диагностическая информация. У всех систем UNIX есть выделенный терминал или экран для получения сообщений консоли. Иногда он может быть выделенным печатающим терминалом. На современных рабочих станциях и в ОС Linux обычно это активная виртуальная консоль, а под управлением графической среды X Window это устройство станет специальным окном консоли на экране.
/dev/tty.
Специальный файл /dev/tty — это псевдоним (логическое устройство) управляющего терминала (клавиатуры и экрана или окна) процесса, если таковой есть. (Например, у процессов и сценариев, автоматически запускаемых системой, не будет управляющего терминала, следовательно, они не смогут открыть файл /dev/tty.)
Там где этот файл, /dev/tty может применяться, он позволяет программе писать непосредственно пользователю независимо от того, какой псевдотерминал или аппаратный терминал он использует. Это полезно при перенаправлении стандартного вывода. Примером может служить отображение содержимого длинного каталога в виде группы страниц с помощью команды ls -R | more, в которой у программы more есть пользовательская подсказка для каждой новой страницы вывода. Вы узнаете больше о файле /dev/tty в главе 5.
Учтите, что существует только одно устройство /dev/console, и в то же время может существовать много разных физических устройств, к которым можно обратиться с помощью файла dev/tty.
/dev/null.
Файл /dev/null — это фиктивное устройство. Весь вывод, записанный на это устройство, отбрасывается. Когда устройство читается, немедленно возвращается конец файла, поэтому данное устройство можно применять с помощью команды cp как источник пустых файлов. Нежелательный вывод очень часто перенаправляется на dev/null.
$ echo do not want to see this >/dev/null
$ cp /dev/null empty_file
Примечание. Другой способ создания пустых файлов — применение команды touch <имя файла>, изменяющей время модификации файла или создающей новый файл при отсутствии файла с заданным именем. Хотя она и не очищает содержимое обрабатываемого файла.В каталоге /dev можно найти и другие устройства, такие как дисководы жестких дисков и флоппи-дисководы, коммуникационные порты, ленточные накопители, дисководы CD-ROM, звуковые карты и некоторые устройства, представляющие внутреннюю структуру системы. Есть даже устройство /dev/zero, действующее как источник нулевых байтов для создания файлов, заполненных нулями. Для доступа к некоторым из этих устройств вам понадобятся права супер пользователя; обычные пользователи не могут писать программы, непосредственно обращающиеся к низкоуровневым устройствам, таким как накопители жестких дисков. Имена файлов устройств могут быть в разных системах различными. В дистрибутивах ОС Linux обычно есть приложения, выполняемые от имени суперпользователя и управляющие устройствами, которые иначе будут недоступны, например, mount для монтируемых пользователями файловых систем.
Устройства делятся на символьные и блочные. Отличие заключается в том, что к некоторым устройствам следует обращаться поблочно. Обычно только блочные устройства, такие как жесткие диски, поддерживают определенный тип файловой системы.
В этой главе мы сосредоточимся на дисковых файлах и каталогах. Другому устройству, пользовательскому терминалу, будет посвящена глава 5.
Системные вызовы и драйверы устройств.
Вы можете обращаться к файлам и устройствам и управлять ими, применяя небольшой набор функций. Эти функции, известные как системные вызовы, непосредственно представляются системой UNIX (и Linux) и служат интерфейсом самой операционной системы.
В сердце операционной системы, ее ядре, есть ряд драйверов устройств. Они представляют собой коллекцию низкоуровневых интерфейсов для управления оборудованием системы. Например, в ней есть драйвер устройства для ленточного накопителя, который знает, как запустить ленту, перемотать ее вперед и назад, прочитать ее и записать на нее и т.д. Ему известно, что на ленту следует писать данные блоками определенного размера. Поскольку ленты — по природе своей устройства с последовательным доступом, драйвер не может обращаться непосредственно к блокам ленты, сначала он должен перемотать ленту до нужного места. Точно так же низкоуровневый драйвер накопителя жесткого диска будет записывать на диск в каждый момент времени только целое число дисковых секторов, но сможет прямо обратиться к любому нужному блоку диска, поскольку диск — это устройство с произвольным доступом.
Для формирования одинакового интерфейса драйверы устройств включают в себя все аппаратно-зависимые свойства. Уникальные аппаратные средства обычно доступны через системный вызов ioctl (I/O control, управление вводом/выводом).
Файлы устройств из каталога /dev используются одинаково: они могут открываться, читаться, на них можно записывать и их можно закрывать. Например, один и тот вызов open, используемый для доступа к обычному файлу, применяется для обращения к пользовательскому терминалу, принтеру или ленточному накопителю.
К низкоуровневым функциям или системным вызовам, используемым для обращения к драйверам устройств, относятся следующие:
□ open — открывает файл или устройство;
□ read — читает из открытого файла или устройства;
□ write — пишет в файл или устройство;
□ close — закрывает файл или устройство;
□ ioctl — передает управляющую информацию драйверу устройства.
Системный вызов ioctl применяется для аппаратно-зависимого управления (как альтернатива стандартного ввода/вывода), поэтому он у каждого устройства свой. Например, вызов ioctl может применяться для перемотки ленты в ленточном накопителе или установки характеристик управления потоками последовательного порта. Этим объясняется необязательная переносимость ioctl с машины на машину. Кроме того, у каждого драйвера определен собственный набор команд ioctl.
Этот системный вызов, как и другие, обычно описывается в разделе 2 интерактивного справочного руководства. Прототипы функций со списком параметров и типом возвращаемого функцией значения, используемые в системных вызовах, а также связанные с ними директивы #define с определением констант представлены в файлах include. Нужные для каждого системного вызова дополнения будут подключаться с описаниями отдельных вызовов.
Библиотечные функции.
Проблема использования низкоуровневых системных вызовов непосредственно для ввода и вывода заключается в том, что они могут быть очень неэффективны. Почему? Ответ может быть следующим.
□ При выполнении системных вызовов существуют эксплуатационные издержки. Поэтому системные вызовы требуют больше затрат по сравнению с библиотечными функциями, т.к. ОС Linux вынуждена переключаться с выполнения вашего программного кода на собственный код ядра и затем возвращаться к выполнению вашей программы. Было бы неплохо стараться свести к минимуму применение системных вызовов в программе и заставлять каждый такой вызов выполнять максимально возможный объем работы, например, считывать и записывать за один раз большие объемы данных, а не одиночные символы.
□ У оборудования есть ограничения, накладываемые на размер блока данных, которые могут быть считаны или записаны в любой конкретный момент времени. У ленточных накопителей, например, часто есть размер блока для записи, скажем 10 Кбайт, поэтому, если вы попытаетесь записать количество информации, не кратное 10 Кбайт, накопитель переместит ленту к следующему блоку в 10 Кбайт, оставив на ленте пустоты.
Для формирования высокоуровневого интерфейса для устройств и дисковых файлов дистрибутив Linux (и UNIX) предоставляет ряд стандартных библиотек. Они представляют собой коллекции функций, которые вы можете включать в свои программы для решения подобных проблем. Хорошим примером может послужить стандартная библиотека ввода/вывода, обеспечивающая буферизованный вывод. Вы сможете эффективно записывать блоки данных разных размеров, применяя библиотечные функции, которые будут выполнять низкоуровневые системные вызовы, снабжая их полными блоками, как только данные станут доступны. Это существенно снижает издержки системных вызовов.
Библиотечные функции, как правило, описываются в разделе 3 интерактивного справочного руководства и часто снабжаются стандартным файлом директивы include, связанным с ними, например, файл stdio.h для стандартной библиотеки ввода/вывода.
Для обобщения материала последних нескольких разделов на рис. 3.2 приведена схема системы Linux, на которой показано, где расположены различные функции работы с файлами относительно пользователя, драйверов устройств, ядра системы и оборудования.

Рис. 3.2
Низкоуровневый доступ к файлам.
У каждой выполняющейся программы, называемой процессом, есть ряд связанных с ней дескрипторов файлов. Существуют короткие целые (small integer) числа, которые можно использовать для обращения к открытым файлам и устройствам. Количество дескрипторов зависит от конфигурации системы. Когда программа запускается, у нее обычно уже открыты три подобных дескриптора. К ним относятся следующие:
□ 0 — стандартный ввод;
□ 1 — стандартный вывод;
□ 2 — стандартный поток ошибок.
Вы можете связать с файлами и устройствами другие дескрипторы файлов, используя системный вызов open, который уже обсуждался вкратце. Дескрипторы файлов, открытые автоматически, уже позволяют вам создавать простые программы с помощью вызова write.
write.
Системный вызов write предназначен для записи из buf первых nbytes байтов в файл, ассоциированный с дескриптором fildes. Он возвращает количество реально записанных байтов, которое может быть меньше nbytes, если в дескрипторе файла обнаружена ошибка или дескриптор файла, расположенный на более низком уровне драйвера устройства, чувствителен к размеру блока. Если функция возвращает 0, это означает, что ничего не записано; если она возвращает -1, в системном вызове write возникла ошибка, которая описывается в глобальной переменной errno,
Далее приведена синтаксическая запись.
#include <unistd.h>
size_t write(int fildes, const void *buf, size_t nbytes);
Благодаря полученным знаниям вы можете написать свою первую программу, simple_write.c:
#include <unistd.h>
#include <stdlib.h>
int main() {
if ((write(1, "Here is some data\n", 18)) != 18)
write(2, "A write error has occurred on file descriptor 1\n", 46);
exit(0);
}
Эта программа просто помещает сообщение в стандартный вывод. Когда она завершается, все открытые дескрипторы файлов автоматически закрываются, и вам не нужно закрывать их явно. Но в случае буферизованного вывода это не так.
$ ./simple_write
Here is some data
$
И еще одно маленькое замечание: вызов write может сообщить о том, что записал меньше байтов, чем вы просили. Это не обязательно ошибка. В ваших программах вам придется для выявления ошибок проверить переменную errno и еще раз вызвать write для записи оставшихся данных.
read.
Системный вызов read считывает до nbytes байтов данных из файла, ассоциированного с дескриптором файла fildes, и помещает их в область данных buf. Он возвращает количество действительно прочитанных байтов, которое может быть меньше требуемого количества. Если вызов read возвращает 0, ему нечего считывать; он достиг конца файла. Ошибка при вызове заставляет его вернуть -1.
#include <unistd.h>
size_t read(int fildes, void *buf, size_t nbytes);
Программа simple_read.c копирует первые 128 байтов стандартного ввода в стандартный вывод. Она копирует все вводимые данные, если их меньше 128 байтов.
#include <unistd.h>
#include <stdlib.h>
int main() {
char buffer[128];
int nread;
nread = read(0, buffer, 128);
if (nread == -1)
write(2, "A read error has occurred\n", 26);
if ((write(1, buffer, nread)) != nread)
write(2, "A write error has occurred\n", 27);
exit(0);
}
Если вы выполните программу, то получите следующий результат:
$ echo hello there | ./simple_read
hello there
$ ./simple_read < draft1.txt
Files
In this chapter we will be looking at files and directories and how to
manipulate them. We will learn how to create files, $
Первое выполнение программы с помощью команды echo формирует некоторый ввод программы, который по каналу передается в вашу программу. Во втором выполнении вы перенаправляете ввод из файла draft1.txt. В этом случае вы видите первую часть указанного файла, появляющуюся в стандартном выводе.
Примечание. Обратите внимание на то, что знак подсказки или приглашения командной оболочки появляется в конце последней строки вывода, поскольку в этом примере 128 байтов не формируют целое число строк.open.
Для создания дескриптора нового файла вы должны применить системный вызов open.
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
int open(const char *path, int oflags);
int open(const char *path, int oflags, mode_t mode);
Примечание. Строго говоря, для использования вызова open вы не должны включать файлы sys/types.h и sys/stat.h в системах, удовлетворяющих стандартам POSIX, но они могут понадобиться в некоторых системах UNIX.Не вдаваясь в подробности, скажем, что вызов open устанавливает путь к файлу или устройству. Если установка прошла успешно, он возвращает дескриптор файла, который может применяться в системных вызовах read, write и др. Дескриптор файла уникален и не используется совместно другими процессами, которые могут в данный момент выполняться. Если файл открыт одновременно в двух программах, они поддерживают отдельные дескрипторы файла. Если они обе пишут в файл, то продолжат запись с того места, где остановились. Их данные не чередуются, но данные одной программы могут быть записаны поверх данных другой. У каждой программы свое представление о том, какая порция файла (каково смещение текущей позиции в файле) прочитана или записана. Вы можете помешать нежелательным накладкам такого сорта с помощью блокировки файла, которая будет обсуждаться в главе 7.
Имя открываемого файла или устройства передается как параметр path; параметр oflags применяется для указания действий, предпринимаемых при открытии файла.
Параметр oflags задается как комбинация обязательного режима доступа к файлу и других необязательных режимов. Системный вызов open должен задавать один из режимов доступа к файлу, указанных в табл. 3.1.
Таблица 3.1
Режим | Описание |
---|---|
О_RDONLY | Открытие только для чтения |
О_WRONLY | Открытие только для записи |
O_RDWR | Открытие для чтения и записи |
Вызов может также включать в параметр oflags комбинацию (с помощью побитовой операции OR) следующих необязательных режимов:
□ O_APPEND — помещает записываемые данные в конец файла;
□ O_TRUNC — задает нулевую длину файла, отбрасывая существующее содержимое;
□ O_CREAT — при необходимости создает файл с правами доступа, заданными в параметре mode;
□ O_EXCL — применяется с режимом O_CREAT, который гарантирует, что вызывающая программа создаст файл. Вызов open атомарный, т.е. он выполняется только одним вызовом функции. Это предотвращает одновременное создание файла двумя программами. Если файл уже существует, open завершится неудачно.
Другие возможные значения параметра oflags описаны на странице интерактивного справочного руководства, посвященной open; ее можно найти в разделе 2 руководства (примените команду man 2 open).
Вызов open возвращает новый дескриптор файла (всегда неотрицательное целое) в случае успешного завершения или -1 в случае неудачи, в последнем случае open также задает глобальную переменную errno,чтобы показать причину неудачи. Мы рассмотрим errno более подробно в одном из последующих разделов. У нового дескриптора файла всегда наименьший неиспользованный номер дескриптора, свойство, которое может оказаться очень полезным в некоторых обстоятельствах. Например, если программа закрывает свой стандартный вывод, а затем снова вызывает open, будет повторно использован дескриптор файла с номером 1 и стандартный вывод будет успешно перенаправлен в другой файл или на другое устройство.
Существует также системный вызов creat, стандартизованный POSIX, но он применяется не часто. Он не только создает файл, как можно ожидать; но также и открывает его. Такой вызов эквивалентен вызову open с параметром oflags, равным O_CREAT|О_WRONLY|O_TRUNC.
Количество файлов, одновременно открытых в любой выполняющейся программе, ограничено. Предельное значение обычно определяется константой OPEN_MAX в файле limits.h и меняется от системы к системе, но стандарт POSIX требует, чтобы оно было не меньше 16. Это значение само по себе может быть ограничено в соответствии с предельными значениями локальной системы, поскольку программа не сможет всегда иметь возможность держать открытыми такое количество файлов. В ОС Linux это предельное значение можно изменять во время выполнения и поэтому OPEN_MAX уже не константа. Как правило, ее начальное значение равно 256.
Исходные права доступа.
Когда вы создаете файл, применяя флаг O_CREAT в системном вызове open, вы должны использовать форму с тремя параметрами. Третий параметр mode формируется из флагов, определенных в заголовочном файле sys/stat.h и соединенных поразрядной операцией OR. К ним относятся:
□ S_IRUSR — право на чтение, владелец;
□ S_IWUSR — право на запись, владелец;
□ S_IXUSR — право на выполнение, владелец;
□ S_IRGRP — право на чтение, группа;
□ S_IWGRP — право на запись, группа;
□ S_IXGRP — право на выполнение, группа;
□ S_IROTH — право на чтение, остальные;
□ S_IWOTH — право на запись, остальные;
□ S_IXOTH — право на выполнение, остальные.
Например, вызов
open("myfile", O_CREAT, S_IRUSR|S_IXOTH);
в результате приведет к созданию файла с именем myfile с правом на чтение для владельца и правом на выполнение для остальных и только с этими правами доступа.
$ ls -ls myfile
0 -r-------х 1 neil software 0 Sep 22 08:11 myfile*
Есть пара факторов, способных повлиять на права доступа к файлу. Во-первых, заданные права применяются, только если файл создается. Во-вторых, на права доступа к созданному файлу оказывает воздействие маска пользователя (заданная командой командной оболочки, umask). Значение параметра mode, заданное в вызове open, на этапе выполнения объединяется с помощью операции AND с инвертированной маской пользователя. Например, если заданы маска пользователя 001 и в параметре mode флаг S_IXOTH, у созданного файла не будет права на выполнение для "остальных", т.к. маска пользователя указывает на то, что это право не должно предоставляться. Флаги в вызовах open и creat являются на самом деле запросами на установку прав доступа. Будут ли предоставлены запрошенные права, зависит от значения umask во время выполнения.
umask.
umask — это системная переменная, содержащая маску для прав доступа к файлу, которые будут применяться при создании файла. Вы можете изменить значение переменной, выполнив команду umask, предоставляющую новое значение. Значение этой переменной представляет собой трёхзнаковое восьмеричное число. Каждая цифра — результат объединения с помощью операций OR значений 1, 2 или 4 (табл. 3.2). Отдельные цифры указывают на права доступа "пользователя", "группы" и "остальных" соответственно.
Таблица 3.2
Цифра | Значение | Смысл |
---|---|---|
1 | 0 | Никакие права пользователя не отвергнуты |
4 | Право пользователя на чтение отвергается | |
2 | Право пользователя на запись отвергается | |
1 | Право пользователя на выполнение отвергается | |
2 | 0 | Никакие права группы не отвергнуты |
4 | Право группы на чтение отвергается | |
2 | Право группы на запись отвергается | |
1 | Право группы на выполнение отвергается | |
3 | 0 | Никакие права остальных не отвергнуты |
4 | Право остальных на чтение отвергается | |
2 | Право остальных на запись отвергается | |
1 | Право остальных на выполнение отвергается |
Например, для блокирования права "группы" на запись и выполнение и права "остальных" на запись переменная umask должна была бы быть следующей (табл. 3.3).
Таблица 3.3
Цифра | Значение |
---|---|
1 | 0 |
2 | 2 |
1 | |
3 | 2 |
Значения каждой цифры объединяются операциями OR, поэтому для получения значения второй цифры нужна операция 2 | 1, дающая в результате 3. Результирующее значение umask — 032.
Когда вы создаете файл с помощью системного вызова open или creat, параметр mode сравнивается с текущим значением переменной umask. Любой бит, установленный в параметре mode и одновременно в переменной umask, удаляется. В результате пользователи могут настроить свое окружение, например, потребовав не создавать никаких файлов с правом на запись для остальных, даже если программа, создающая файл, требует предоставить такое право. Это не мешает программе или пользователю впоследствии применить команду chmod (или системный вызов chmod в программе), чтобы добавить право на запись для остальных, но поможет защитить пользователей, избавив их от необходимости проверять и задавать права доступа для всех новых файлов.
close.
Системный вызов close применяется для разрыва связи файлового дескриптора fildes с его файлом. Дескриптор файла после этого может использоваться повторно. Вызов возвращает 0 в случае успешного завершения и -1 при возникновении ошибки.
#include <unistd.h>
int close (int fildes);
Примечание. В некоторых случаях проверка возвращаемого значения вызова close бывает очень важна. Некоторые файловые системы, особенно с сетевой структурой, могут не сообщать об ошибке записи в файл до тех пор, пока файл не будет закрыт, потому что при выполнении записи могло отсутствовать подтверждение действительной записи данных.ioctl.
Системный вызов ioctl напоминает набор всякой всячины. Он предоставляет интерфейс для управления поведением устройств и их дескрипторов и настройки базовых сервисов. У терминалов, дескрипторов файлов, сокетов и даже ленточных накопителей могут быть определенные для них вызовы ioctl и вам необходимо обращаться за подробной информацией к страницам справочного руководства, относящимся к конкретным устройствам. В стандарте POSIX определены только вызовы ioctl для потоков, которые не обсуждаются в этой книге. Далее приведена синтаксическая запись вызова.
#include <unistd.h>
int ioctl(int fildes, int cmd, ...)
Вызов ioctl выполняет операцию, указанную в аргументе cmd, над объектом, заданным в дескрипторе fildes. У вызова может быть необязательный третий аргумент, зависящий от функций, поддерживаемых конкретным устройством.
Например, следующий вызов ioctl в ОС Linux включает световые индикаторы клавиатуры (LEDs).
ioctl(tty_fd, KDSETLED, LED_NUM|LED_CAP|LED_SCR);
Выполните упражнения 3.1 и 3.2.
Упражнение 3.1. Программа копирования файла.
Теперь вы знаете достаточно о системных вызовах open, read и write, чтобы написать простенькую программу copy_system.c для посимвольного копирования одного файла в другой.
В данной главе мы проделаем это несколькими способами для того, чтобы сравнить эффективность разных методов. Для краткости предположим, что входной файл существует, а выходной — нет, и что все операции чтения и записи завершаются успешно. Конечно, в реальных программах вам придется убедиться в том, что эти предположения верны!
1. Сначала вам нужно создать тестовый входной файл размером, скажем, 1 Мбайт и именем file.in.
2. Далее откомпилируйте программу copy_system.c.
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
int main() {
char c;
int in, out;
in = open("file.in", O_RDONLY);
put = open("file.out", O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR);
while(read(in, &c, 1) == 1) write(out, &c, 1);
exit(0);
}
Примечание. Имейте в виду, что строка #include <unistd.h> должна быть первой, поскольку она определяет флаги, касающиеся соответствия стандарту POSIX и способные повлиять на другие включенные в #include файлы.3. Выполнение программы даст результат, похожий на следующий:
$ TIMEPORMAT="" time ./copy_system
4.67user 146.90system 2:32.57elapsed 99%CPU
...
$ ls -ls file.in file.out
1029 -rw-r--r-- 1 neil users 1048576 Sep 17 10:46 file.in
1029 -rw------- 1 neil users 1048576 Sep 17 10:51 file.out
Как это работает
Вы используете команду time для определения времени выполнения программы. В ОС Linux переменная TIMEFORMAT применяется для переопределения принятого по умолчанию в стандарте POSIX формата вывода времени, в который не включено время использования ЦПУ. Как видите, что в этой очень старой системе входной файл file.in размером 1 Мбайт был успешно скопирован в файл file.out, созданный с правами на чтение/запись только для владельца. Копирование заняло две с половиной минуты и затратило фактически все доступное время ЦПУ. Программа так медлительна потому, что вынуждена была выполнить более двух миллионов системных вызовов.
В последние годы ОС Linux продемонстрировала огромные успехи в повышении производительности системных вызовов и файловой системы. Для сравнения аналогичный тест с применением ядра 2.6 занял чуть менее 14 секунд:
$ TIMEFORMAT="" time ./copy_system
2.08user 10.59system 0:13.74elapsed 92%CPU
...
Упражнение 3.2. Вторая версия программы кодирования файла.
Вы можете добиться лучших результатов, копируя блоки большего размера. Взгляните на модифицированную программу copy_block.c, которая копирует файл блоками в 1 Кбайт и снова использует системные вызовы.
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
int main() {
char block[1024];
int in, out;
int nread;
in = open("file.in", O_RDONLY);
out = open("file.out", O_WRONLY|O_CREAT, S_IRUSR|S_IWUSR);
while((nread = read(in, block, sizeof(block))) > 0)
write(out, block, nread);
exit(0);
}
Теперь испытайте программу, но сначала удалите старый выходной файл.
$ rm file.out
$ TIMEFORMAT="" time ./copy_block
0.00user 0.02system 0:00.04elapsed 78%CPU
...
Как это работает
Теперь программа выполняется только сотые доли секунды, поскольку ей требуется около 2000 системных вызовов. Конечно, это время очень зависит от системы, но оно показывает, что системные вызовы сопряжены с поддающимися измерению издержками, поэтому их применение стоит оптимизировать.
Другие системные вызовы для управления файлами.
Существует ряд других системных вызовов, оперирующих низкоуровневыми дескрипторами файлов. Они позволяют программе контролировать использование файла, возвращая информацию о его состоянии,
lseek.
Системный вызов lseek задает указатель текущей позиции чтения/записи дескриптора файла, т.е. вы можете применять его для установки в файле места, с которого будет происходить следующее считывание или на которое будет производиться следующая запись. Вы можете задать указатель на абсолютную позицию файла или позицию, относительно текущего положения указателя или конца файла.
#include <unistd.h>
#include <sys/types.h>
off_t lseek(int fildes, off_t offset, int whence);
Параметр offset применяется для указания позиции, а параметр whence определяет способ применения offset и может принимать следующие значения:
□ SEEK_SET — offset задает абсолютную позицию;
□ SEEK_CUR — offset задается относительно текущей позиции;
□ SEEK_END — offset задается относительно конца файла.
Вызов lseek возвращает величину параметра offset в байтах, измеряемую от начала файла, для которого установлен указатель, или -1 в случае неудачного завершения. Тип данных off_t, применяемый для параметра offset в операциях поиска, — зависящий от реализации тип integer (целое), определенный в файле sys/types.h.
fstat, stat и lstat.
Системный вызов fstat возвращает информацию о состоянии файла, ассоциированного с открытым дескриптором файла. Эта информация записывается в структуру buf, адрес которой передается как параметр.
Далее приведена синтаксическая запись вызовов.
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
int fstat(int fildes, struct stat *buf);
int stat(const char *path, struct stat *buf);
int lstat(const char *path, struct stat *buf);
Примечание. Учтите, что включение файла sys/types.h не обязательное, но мы рекомендуем включать его при использовании системных вызовов, поскольку некоторые из их определений применяют для стандартных типов псевдонимы, которые могут измениться когда-нибудь. Родственные функции stat и lstat возвращают информацию о состоянии названного файла. Они возвращают те же результаты за исключением того, что файл является символической ссылкой. Вызов lstat возвращает данные о самой ссылке, а вызов stat — о файле, на который ссылка указывает.Элементы вызываемой структуры stat могут меняться в разных UNIX-подобных системах, но обязательно включают перечисленные в табл. 3.4 элементы.
Таблица 3.4
Элемент структуры stat | Описание |
---|---|
st_mode | Права доступа к файлу и сведения о типе файла |
st_ino | Индекс, ассоциированный с файлом |
st_dev | Устройство, на котором размещен файл |
st_uid | Идентификатор (user identity) владельца файла |
st_gid | Идентификатор группы (group identity) владельца файла |
st_atime | Время последнего обращения |
st_ctime | Время последнего изменения прав доступа, владельца, группы или объема |
st_mtime | Время последней модификации содержимого |
st_nlink | Количество жестких ссылок на файл |
У флагов st_mode, возвращаемых в структуре stat, также есть ряд ассоциированных макросов в заголовочном файле sys/stat.h. В эти макросы включены имена флагов для прав доступа и типов файлов и некоторые маски, помогающие проверять специфические типы и права.
Флаги прав доступа такие же, как в системном вызове open, описанном ранее. Для флагов типов файла включены следующие имена:
□ S_IFBLK — блочное устройство;
□ S_IFDIR — каталог;
□ S_IFCHR — символьное устройство;
□ S_IFIFO — FIFO (именованный канал);
□ S_IFREG — обычный файл;
□ S_IFLNK — символическая ссылка.
Для других флагов режима файла включены следующие имена:
□ S_ISUID — элемент получает setUID при выполнении;
□ S_ISGUID — элемент получает setGID при выполнении.
Для масок, интерпретирующих флаги st_mode, включены следующие имена:
□ S_IFMT — тип файла;
□ S_IRWXU — права пользователя на чтение/запись/выполнение;
□ S_IRWXG — права группы на чтение/запись/выполнение;
□ S_IRWXO — права остальных на чтение/запись/выполнение.
Существует ряд макросов, помогающих определить типы файлов. Они просто сравнивают надлежащим образом установленные флаги режима файла с подходящим флагом, типа устройства. К ним относятся следующие:
□ S_ISBLK — проверка для блочного файла;
□ S_ISCHR — проверка для символьного файла;
□ S_ISDIR — проверка для каталога;
□ S_ISFIFO — проверка для FIFO;
□ S_ISREG — проверка для обычного файла;
□ S_ISLNK — проверка для символической ссылки.
Например, для проверки того, что файл не является каталогом и у него есть права на выполнение только для владельца и больше никаких других прав, вы можете воспользоваться следующим тестом;
struct stat statbuf;
mode_t modes;
stat("filename", &statbuf);
modes = statbuf.st_mode;
if (!S_ISDIR(modes) && (modes & S_IRWXU) = S_IXUSR)
...
dup и dup2.
Системные вызовы dup позволяют дублировать дескриптор файла, предоставляя два или несколько разных дескрипторов, обращающихся к одному и тому же файлу. Эта возможность может применяться для чтения и записи в разные части файла. Системный вызов dup дублирует файловый дескриптор fildes и возвращает новый дескриптор. Системный вызов dup2 умело копирует один дескриптор файла в другой, задавая дескриптор, применяемый для копии.
Далее приведена синтаксическая запись для вызовов.
#include <unistd.h>
int dup(int fildes);
int dup2(int fildes, int fildes2);
Эти вызовы могут оказаться полезными в случае нескольких процессов, взаимодействующих через именованные каналы. Более глубоко мы рассмотрим системные вызовы dup в главе 13.
Стандартная библиотека ввода/вывода.
Стандартная библиотека ввода/вывода (stdio) и ее заголовочный файл stdio.h предоставляют универсальный интерфейс для системных вызовов ввода/вывода нижнего уровня. Библиотека, теперь часть языка С стандарта ANSI, в отличие от системных вызовов, с которыми вы встречались ранее, включает много сложных функций для форматирования вывода и просмотра ввода. Она также обеспечивает необходимые условия буферизации для устройств.
Во многих случаях эта библиотека используется так же, как низкоуровневые дескрипторы файлов. Вы должны открыть файл для установления пути доступа. Это действие возвращает значение, применяемое как параметр в других функциях библиотеки ввода/вывода. Эквивалент низкоуровневого дескриптора файла называется потоком и реализуется как указатель на структуру FILE*.
Примечание. Не путайте эти потоки файлов с потоками ввода/вывода в языке С++ и механизмом STREAMS, описывающим взаимодействие процессов и введенным в системе AT&T UNIX System V Release 3, который не рассматривается в данной книге. Для получения дополнительной информации о средствах STREAMS обратитесь к спецификации X/Open (по адресу http://www.opengroup.org) и руководству по программированию AT&T STREAMS Programming Guide, поставляемому с системой System V.Три файловых потока открываются автоматически при старте программы. К ним относятся stdin, stdout и stderr. Эти потоки объявлены в файле stdio.h и представляют вывод, ввод и стандартный поток ошибок, которым соответствуют низкоуровневые файловые дескрипторы 0, 1 и 2.
В данном разделе мы рассмотрим следующие функции:
□ fopen, fclose;
□ fread, fwrite;
□ fflush;
□ fseek;
□ fgetc, getc, getchar;
□ fputc, putc, putchar;
□ fgets, gets;
□ printf, fprintf и sprintf;
□ scanf, fscanf и sscanf;
□ fopen.
fopen.
Библиотечная функция f open — это аналог низкоуровневого системного вызова open. Она используется в основном для файлов и терминального, ввода и вывода. Там, где нужно явное управление устройствами, больше подойдут системные вызовы, поскольку они устраняют потенциальные нежелательные побочные эффекты применения библиотек, например, в случае буферизации ввода/вывода.
Далее приведена синтаксическая запись функции:
#include <stdio.h>
FILE *fopen(const char *filename, const char *mode);
Функция fopen открывает файл, заданный в параметре filename, и ассоциирует с ним поток. Параметр mode описывает, как файл должен быть открыт. Он задается одной из следующих строк:
□ " r" или " rb" — открыть только для чтения;
□ " w" или " wb" — открыть для записи, укоротить до нулевой длины;
□ " а" или " ab" — открыть для записи, дописывать в конец файла;
□ " r+" или " rb+" или " r+b" — открыть для изменения (чтение и запись);
□ " w+" или " wb+" или " w+b" — открыть для изменения, укоротить до нулевой длины;
□ " a+" или " ab+" или " а+b" — открыть для изменения, дописывать в конец файла. Символ b означает, что файл бинарный, а не текстовый.
Примечание. В отличие от MS-DOS, системы UNIX и Linux не делают различий между текстовыми и бинарными файлами. UNIX и Linux обрабатывают их одинаково с эффективностью обработки бинарных файлов. Важно также учесть, что параметр mode должен быть строкой, а не символом. Всегда применяйте двойные кавычки, а не апострофы.В случае успешного завершения функция fopen возвращает ненулевой указатель на структуру FILE*. В случае сбоя она вернет значение NULL, определенное в файле stdio.h.
Количество доступных потоков ограничено, как и число дескрипторов файлов. Реальное предельное значение содержится в определенной в файле stdio.h константе FOPEN_MAX и всегда не менее 8, а в ОС Linux обычно 16.
fread.
Библиотечная функция fread применяется для чтения данных из файлового потока. Данные считываются из потока stream в буфер данных, заданный в параметре ptr. Функции fread и fwrite имеют дело с записями данных. Записи описываются размером size и количеством передаваемых записей nitems. Функция возвращает количество записей (а не байтов), успешно считанных в буфер данных. При достижении конца файла может быть возвращено меньше записей, чем nitems, вплоть до нуля.
Далее приведена синтаксическая запись функции:
#include <stdio.h>
size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);
Как и в других функциях стандартного ввода/вывода, записывающих данные в буфер, выделять место для данных и проверять ошибки должен программист. См. также функции ferror и feof далее в этой главе.
fwrite.
Интерфейс библиотечной функции fwrite аналогичен интерфейсу функции fread. Она принимает записи данных из заданного буфера данных и записывает их в поток вывода. Функция возвращает количество успешно записанных записей.
Далее приведена синтаксическая запись функции:
#include <stdio.h>
size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);
Примечание. Имейте в виду, что функции fread и fwrite не рекомендуется применять со структурированными данными. Частично проблема заключается в том, что файлы, записанные функцией fwrite, могут быть непереносимыми между машинами с разной архитектурой.fclose.
Библиотечная функция fclose закрывает заданный поток stream, заставляя записать все незаписанные данные. Важно применять функцию fclose, поскольку библиотека stdio будет использовать буфер для данных. Если программе нужна уверенность в том, что все данные записаны, следует вызвать fclose. Имейте в виду, что функция fclose вызывается автоматически для всех файловых потоков, которые все еще открыты к моменту нормального завершения программы, но при этом у вас, конечно же, не будет возможности проверить ошибки, о которых сообщает fclose.
Далее приведена синтаксическая запись функции:
#include <stdio.h>
int fclose(FILE* stream);
fflush.
Библиотечная функция fflush вызывает немедленную запись всех данных файлового потока, ждущих выполнения операции записи. Вы можете применять ее, например, чтобы убедиться, что интерактивное приглашение отправлено на терминал до того, как делается попытка считать ответ. Эта функция также полезна, если вы хотите, прежде чем продолжить выполнение, убедиться в том, что важные данные помещены на диск. Ее можно применять в некоторых случаях при отладке программы, чтобы быть уверенным в том, что программа действительно записывает данные, а не зависла. При вызове функции fclose выполняется неявная операция fflush, поэтому перед fclose не нужно вызывать функцию fflush.
Далее приведена синтаксическая запись функции:
#include <stdio.h>
int fflush(FILE *stream);
fseek.
Функция fseek — это эквивалент для файлового потока системного вызова lseek. Она задает в stream позицию для следующей операции чтения этого потока или записи в него. Значения и смысл параметров offset и whence такие же, как у ранее описанных одноименных параметров вызова lseek. Но там, где lseek возвращает off_t, функция fseek возвращает целое число: 0, если выполнилась успешно, и -1 при аварийном завершении с ошибкой, указанной в переменной errno. Какое поле деятельности для стандартизации!
Далее приведена синтаксическая запись функции:
#include <stdio.h>
int fseek(FILE *stream, long int offset, int whence);
fgetc, getc и getchar.
Функция fgetc возвращает из файлового потока следующий байт как символ. Когда она достигает конца файла или возникает ошибка, функция возвращает EOF. Для того чтобы различить эти два случая, следует применять функции ferror или feof.
Далее приведена синтаксическая запись функций:
#include <stdio.h>
int fgetc(FILE *stream);
int getc(FILE *stream);
int getchar();
Функция getc эквивалентна fgetc за исключением того, что может быть реализована как макрос. В этом случае аргумент stream может определяться несколько раз, поэтому он лишен побочных эффектов (например, не затронет переменные). К тому же вы не можете гарантировать возможности применения адреса getc как указателя функции.
Функция getchar эквивалентна вызову функции getc(stdin) и читает следующий символ из стандартного ввода.
fputc, putc и putchar.
Функция fputc записывает символ в файловый поток вывода. Она возвращает записанное значение или EOF в случае аварийного завершения.
#include <stdio.h>
int fputc(int с, FILE *stream); int putc(int c, FILE *stream); int putchar(int c);
Как и в случае функций fgetc/getc, функция putc — эквивалент fputc, но может быть реализована как макрос.
Функция putchar — то же самое, что вызов putc(с, stdout), записывающий один символ в стандартный вывод. Имейте в виду, что функция putchar принимает, а функция getchar возвращает символы как данные типа int, а не char. Это позволяет индикатору конца файла ( EOF) принимать значение -1, лежащее вне диапазона кодов символов.
fgets и gets.
Функция fgets читает строку из файла ввода stream.
#include <stdio.h>
char *fgets(char *s, int n, FILE *stream);
char *gets(char *s);
Функция fgets пишет символы в строку, заданную указателем s, до тех пор, пока не встретится новая строка, либо не будет передано n-1 символов, либо не будет достигнут конец файла. Любая встретившаяся новая строка передается в строку, принимающую символы, и добавляется завершающий нулевой байт \0. Любой вызов передает максимум n-1 символов, т.к. должен быть вставлен нулевой байт, обозначающий конец строки и увеличивающий общее количество до n байтов.
При успешном завершении функция fgets возвращает указатель на строку s. Если поток указывает на конец файла, она устанавливает индикатор EOF для потока и возвращает пустой указатель. Если возникает ошибка чтения, fgets возвращает пустой указатель и устанавливает значение переменной errno, соответствующее типу ошибки.
Функция gets аналогична fgets за исключением того, что она читает из стандартного ввода и отбрасывает любые обнаруженные обозначения новой строки. Функция добавляет завершающий нулевой байт в принимающую строку.
Примечание. Учтите, что функция gets не ограничивает количество символов, которые могут передаваться, поэтому она может переполнить свой пересылочный буфер. По этой причине вам следует избегать применения этой функции и заменять ее функцией fgets. Многие проблемы безопасности порождены функциями в программах, сделанных для переполнения буфера тем или иным способом. Это одна из таких функций, поэтому будьте осторожны!Форматированные ввод и вывод.
Для создания вывода управляемого вида существует ряд библиотечных функций, с которыми вы, возможно, знакомы, если программируете на языке С. К ним относятся функция printf и родственные функции для вывода значений в файловый поток, а также scanf и другие функции для чтения значений из файлового потока.
printf, fprintf и sprintf.
Семейство функций printf форматирует и выводит переменное число аргументов разных типов. Способ их представления в потоке вывода управляется параметром format, являющимся строкой с обычными символами и кодами, называемыми спецификаторами преобразований, указывающими, как и куда выводить остальные аргументы.
#include <stdio.h>
int printf(const char *format, ...);
int sprintf(char *s, const char *format, ...);
int fprintf(FILE * stream, const char *format, ...);
Функция printf выводит результат в стандартный вывод. Функция fprintf выводит результат в заданный файловый поток stream. Функция sprintf записывает результат и завершающий нулевой символ в строку s, передаваемую как параметр. Эта строка должна быть достаточно длинной, чтобы вместить весь вывод функции.
У семейства printf есть и другие члены, обрабатывающие свои аргументы различными способами. См. подробную информацию на страницах интерактивного руководства.
Обычные символы передаются в вывод без изменений. Спецификаторы преобразований заставляют функцию printf выбирать и форматировать дополнительные аргументы, передаваемые как параметры. Спецификаторы всегда начинаются с символа %. Далее приведен простой пример:
printf("Some numbers: %d, %d, and &d\n", 1, 2, 3);
Он порождает в стандартном выводе следующую строку.
Some numbers: 1, 2, and 3
Для вывода символа % следует применять последовательность %%, чтобы не путать его со спецификатором преобразования.
Далее перечислены наиболее часто применяемые спецификаторы преобразований:
□ %d, %i — выводить целое как десятичное число;
□ %о, %x — выводить целое как восьмеричное, шестнадцатеричное число;
□ %с — выводить символ;
□ %s — выводить строку;
□ %f — выводить число с плавающей точкой (одинарной точности);
□ %e — выводить число с двойной точностью в формате фиксированной длины;
□ %g — выводить число двойной точности в общем формате.
Очень важно, чтобы число и тип аргументов, передаваемых функции printf, соответствовали спецификаторам преобразования в строке format. Необязательный спецификатор размера применяется для обозначения типа целочисленных аргументов.
Он может быть равен h, например, %hd для обозначения типа short int (короткие целые), или l, например, %ld для обозначения типа long int (длинные целые). Некоторые компиляторы могут проверять эти установки printf, но они ненадежны. Если вы применяете компилятор GNU gcc, можно вставить для этого в команду компиляции опцию -Wformat.
Далее приведен еще один пример:
char initial = 'А';
char *surname = "Matthew";
double age = 13.5;
printf("Hello Mr %c %s, aged %g\n", initial, surname, age);
Будет выводиться следующая информация:
Hello Mr A Matthew, aged 13.5
Вы можете добиться большего при выводе элементов с помощью спецификаторов полей. Они расширяют возможности спецификаторов преобразований, управляя расположением элементов при выводе. Обычно задается количество десятичных разрядов для числа с плавающей точкой или величина пробельных отступов, обрамляющих строку.
Спецификаторы полей задаются в виде чисел, следующих в спецификаторах преобразований непосредственно за знаком %. В табл. 3.5 приведены дополнительные примеры использования спецификаторов преобразований и результирующий вывод. Для большей ясности мы применяем знак вертикальной черты, чтобы показать границы вывода.
Таблица 3.5
Формат | Аргумент | Вывод |
---|---|---|
%10s | "Hello" | | Hello| |
%-10s | "Hello" | |Hello | |
%10d | 1234 | | 1234| |
%-10d | 1234 | |1234 | |
%010d | 1234 | |0000001234| |
%10.4f | 12.34 | | 12.3400| |
%*s | 10, "Hello" | | Hello| |
Все приведенные примеры выводятся в поле шириной 10 символов. Обратите внимание на то, что отрицательная ширина поля означает выравнивание элемента по левому краю в пределах поля. Переменная ширина поля обозначается символом "звездочка" ( *). В этом случае следующий аргумент применяется для задания ширины. Ведущий ноль указывает на вывод элемента с ведущими нулями. В соответствии со стандартом POSIX функция printf не обрезает поля; наоборот она расширяет поле, чтобы вместить в него аргумент. Например, если вы попытаетесь вывести строку большей длины, чем заданное поле, ширина поля будет увеличена (табл. 3.6).
Таблица 3.6
Формат | Аргумент | Вывод |
---|---|---|
%10s | "HelloTherePeeps" | |HelloTherePeeps| |
Функции семейства printf возвращают целое число, равное количеству выведенных символов. В случае функции sprintf в него не включается завершающий нуль-символ. При наличии ошибок эти функции возвращают отрицательное значение и задают переменную errno.
scanf, fscanf и sscanf.
Семейство функций scanf действует аналогично функциям группы printf за исключением того, что эти функции читают элементы из потока и помещают их в переменные, адреса которых им передаются как параметры-указатели. Для управления преобразованиями ввода функции применяют строку format аналогичным образом и используют многие спецификаторы преобразований функций группы printf.
#include <stdio.h>
int scanf(const char *format, ...);
int fscanf(FILE *stream, const char *format, ...);
int sscanf(const char *s, const char *format, ...);
Очень важно, чтобы переменные, используемые для хранения значений, считываемых функциями scanf, имели корректный тип и точно соответствовали строке формата. Если это не так, используемая память может быть искажена и программа может завершиться аварийно. При этом не будет обнаружено никаких ошибок компиляции. Если повезет, вы можете получить предупреждающее сообщение!
Строка format функции scanf и других функций этого семейства, как и в случае функции printf, содержит как обычные символы, так и спецификаторы преобразований. Но обычные символы применяются для задания символов, которые должны присутствовать во вводе.
Рассмотрим простой пример:
int num;
scanf("Hello %d", &num);
Вызов функции scanf будет успешным, только если следующие пять символов в стандартном вводе — Hello. Затем, если следующие символы формируют распознаваемое десятичное число, оно будет считано и присвоено переменной num. Пробел в строке формата при вводе применяется для игнорирования во вводном файле всех пробельных символов (пробелы, табуляции, переводы страницы и переходы на новую строку) между спецификаторами преобразований. Это означает, что вызов, scanf будет успешным и поместит 1234 в переменную num в случае следующих двух вариантов ввода.
Hello 1234
Hellol234
Пробельные символы обычно игнорируются во вводе, когда начинается преобразование. Это означает, что строка формата %d будет продолжать чтение из вводного файла, пропуская пробелы и переходы на новую строку до тех пор, пока будет продолжаться цифровая последовательность. Если ожидаемые символы отсутствуют, преобразование аварийно завершается и выполнение функции прекращается.
Примечание. Если не соблюдать осторожность, могут возникнуть проблемы. В вашей программе может появиться бесконечный цикл, если во вводе оставить нецифровой символ при считывании целых чисел.К другим спецификаторам преобразований относятся следующие:
□ %d — считывание десятичного целого;
□ %o, %x — считывание восьмеричного, шестнадцатеричного целого;
□ %f, %e, %g — считывание числа с плавающей запятой;
□ %c — считывание символа (пробельный символ не пропускается);
□ %s — считывание строки;
□ %[] — считывание множества символов (см. последующее обсуждение);
□ %% — считывание знака %.
Как и в случае printf, у спецификаторов преобразований функции scanf есть ширина поля, ограничивающая объем ввода. Спецификатор размера ( h для коротких или l для длинных целых) показывает, короче или длиннее стандартного получаемый аргумент. Таким образом, %hd обозначает число типа short int, %ld — число типа long int и %lg — число с плавающей точкой двойной точности.
Спецификатор, начинающийся со звездочки, указывает на то, что элемент игнорируется. Это значит, что информация не сохраняется, и, следовательно, для ее получения не нужна переменная.
Применяйте спецификатор %c для чтения одиночного символа во вводе. Он не пропускает начальные пробельные символы.
Используйте спецификатор %s для чтения строк, но будьте осторожны. Он пропускает ведущие пробельные символы, но останавливается перед первым пробельным символом, встретившимся в строке, поэтому лучше применять его для чтения слов, а не целых строк. Кроме того, длина строки, которую он может прочесть, ограничивается только спецификатором ширины поля, поэтому принимающая строка должна быть достаточной для хранения самой длинной строки из вводного потока.
Лучше применять спецификатор ширины поля или комбинацию функций fgets и sscanf для считывания строки ввода, а затем просматривать ее. Это защитит от возможных переполнений буфера, которые может спровоцировать злонамеренный пользователь.
Применяйте спецификатор %[] для чтения строки, составленной из символов, включенных в множество. Формат %[A-Z] будет читать строку из прописных букв латинского алфавита. Если в множестве первый символ — знак вставки ( ^), то спецификатор считывает строку, состоящую из символов, не входящих в множество. Итак, для того чтобы прочитать строку с пробелами, но остановиться на первой запятой, примените спецификатор %[^, ].
Если задана следующая строка ввода:
Hello, 1234, 5.678, X, string to the end of the line
приведенный далее вызов scanf корректно считает четыре элемента:
char s[256];
int n;
float f;
char c;
scanf("Hello, %d, %g, %c, %[^\n]", &n, &f, &c, s);
Функции семейства scanf возвращают количество успешно считанных элементов. Оно может быть нулевым, если сбой возник при чтении первого элемента. Если достигнут конец ввода прежде, чем найдено соответствие первому элементу, возвращается EOF. Если в файловом потоке возникает ошибка чтения, устанавливается флаг ошибки потока и тип ошибки задается в переменной errno. Более подробную информацию см. в разд. "Ошибки потока" далее в этой главе.
Функция scanf и другие члены семейства, как правило, не высоко ценятся в основном по трем причинам:
□ традиционно их реализации полны ошибок;
□ в использовании эти функции не гибки;
□ они могут привести к созданию программного кода, в котором трудно решить, что подвергать синтаксическому анализу.
В качестве альтернативы попытайтесь применять другие функции, такие как fread или fgets, для чтения строк ввода, а затем воспользуйтесь строковыми функциями для разделения введенной строки на нужные элементы.
Другие потоковые функции.
В библиотеке stdio существует ряд других функций, использующих потоки как параметры или стандартные потоки stdin, stdout, stderr:
□ fgetpos — возвращает текущую позицию в файловом протоке;
□ fsetpos — устанавливает текущую позицию в файловом потоке;
□ ftell — возвращает величину текущего смещения файла в потоке;
□ rewind — сбрасывает текущую позицию файла в потоке и переводит ее в начало файла;
□ freopen — повторно использует файловый поток;
□ setvbuf — задает схему буферизации для потока;
□ remove — эквивалент функции unlink, до тех пор пока параметр path не является каталогом, в этом случае она эквивалентна функции rmdir.
Эти библиотечные функции описаны на страницах интерактивного справочного руководства в разделе 3.
Вы можете использовать функции обработки файловых потоков для повторной реализации с их помощью программы копирования файлов. Взгляните на программу copy_stdio.c в упражнении 3.3.
Упражнение 3.3. Третья версия программы копирования файлов.
Эта программа очень похожа на предыдущие версии, но посимвольное копирование выполняется с помощью вызовов функций, заданных в файле stdio.h:
#include <stdio.h>
#include <stdlib.h>
int main() {
int c;
FILE *in, *out;
in = fopen("file.in", "r");
out = fopen("file.out", "w");
while((c = fgetc(in)) != EOF) fputc(c, out);
exit(0);
}
Выполнив эту программу, как прежде, вы получите:
$ TIMEFORMAT="" time ./copy_stdio
0.06user 0.02system 0:00.11elapsed 81%CPU
Как это работает
На этот раз программа выполняется 0,11 с, не так быстро, как низкоуровневая блочная версия, но значительно быстрее другой посимвольной версии. Это произошло потому, что библиотека stdio поддерживает внутренний буфер в структуре FILE, и низкоуровневые системные вызовы выполняются, только когда буфер заполняется. Не ленитесь экспериментировать, тестируя программный код построчного и блочного копирования с помощью stdio, чтобы увидеть, как они действуют в случае проверенных нами трех примеров.
Ошибки потока.
Для обозначения ошибок многие функции библиотеки stdio применяют значения за пределами допустимых, например, пустые указатели или константу EOF. В этих случаях ошибка указывается во внешней переменной errno.
#include <errno.h>
extern int errno;
Примечание. Имейте в виду, что многие функции могут изменять значение errno. Оно достоверно, только когда функция закончилась неудачно. Вам следует проверять это значение сразу же, как функция сообщила о сбое. Прежде чем использовать его, скопируйте это значение в другую переменную, поскольку функции вывода, такие как fprintf, могут сами изменять errno.Вы можете также запросить состояние файлового потока, чтобы выяснить, возникла ли ошибка или достигнут конец файла.
#include <stdio.h>
int ferror(FILE *stream);
int feof(FILE *stream);
void clearerr(FILE *stream);
Функция ferror проверяет индикатор ошибок потока и возвращает ненулевое значение, если индикатор установлен, и ноль в противном случае.
Функция feof проверяет индикатор конца файла в потоке и возвращает ненулевое значение, если индикатор установлен, или ноль в противном случае. Применяйте ее следующим образом:
if (feof(some_stream))
/* Мы в конце */
Функция clearerr очищает индикаторы конца файла и ошибки для потока, на который указывает параметр stream. Она не возвращает никакого значения, и для нее не определены никакие ошибки. Вы можете применять эту функцию для сброса состояния ошибки в потоках. Примером может быть возобновление записи в поток после разрешения проблемы, связанной с ошибкой "disk full" (диск заполнен).
Потоки и дескрипторы файлов.
Каждый файловый поток ассоциирован с низкоуровневым дескриптором файла. Вы можете смешивать операции низкоуровневого ввода/вывода с высокоуровневыми потоковыми операциями, но это, как правило, неразумно, потому что трудно предсказать эффект от применения буферизации.
#include <stdio.h>
int fileno(FILE *stream);
FILE *fdopen(int fildes, const char *mode);
Вы можете определить, какой низкоуровневый дескриптор файла применяется для файлового потока, вызвав функцию fileno. Она возвращает дескриптор файла для заданного потока или -1 в случае сбоя. Эта функция полезна при необходимости низкоуровневого доступа к открытому потоку, например для вызова функции fstat применительно к этому потоку.
Можно создать новый поток файла на основе дескриптора файла, открытого только для чтения, применив функцию fdopen. По существу, эта функция предоставляет буферы stdio для уже открытого файлового дескриптора, это может быть самый легкий вариант объяснения ее назначения.
Функция fdopen действует так же, как функция fopen, но в отличие от имени файла она принимает в качестве параметра низкоуровневый дескриптор файла. Это может пригодиться, если вы используете вызов open для создания файла, может быть для более тонкого управления правами доступа, но хотите применить поток для записи в файл. Параметр mode такой же, как у функции fopen и должен быть совместим с режимами доступа к файлу, установленными при первоначальном открытии файла. Функция fdopen возвращает новый файловый поток или NULL в случае неудачного завершения.
Ведение файлов и каталогов.
Стандартные библиотеки и системные вызовы обеспечивают полный контроль над созданием и ведением файлов и каталогов.
chmod.
С помощью системного вызова chmod вы можете изменять права доступа к файлу или каталогу. Он лежит в основе программы командной оболочки chmod.
Далее приведена синтаксическая запись вызова:
#include <sys/stat.h>
int chmod(const char *path, mode_t mode);
Права доступа к файлу, заданному параметром path, изменяются в соответствии со значением параметра mode. Режим файла mode задается как в системном вызове open с помощью поразрядной операции OR, формирующей требуемые права доступа. Если программе не даны соответствующие полномочия, только владелец файла и суперпользователь могут изменять права доступа к файлу.
chown.
Суперпользователь может изменить владельца файла с помощью системного вызова chown.
#include <sys/types.h> #include <unistd.h>
int chown(const char *path, uid_t owner, gid_t group);
В вызове применяются числовые значения идентификаторов (ID) нового пользователя и группы (взятые из системных вызовов getuid и getgid) и системная величина, используемая для ограничения пользователей, имеющих разрешение изменять владельца файла. Владелец и группа файла изменяются, если заданы соответствующие полномочия.
Примечание. Стандарт POSIX в действительности допускает существование систем, в которых несуперпользователи могут изменять права владения файлом. Все "правильные" с точки зрения POSIX системы не допускают этого, но строго говоря, это расширение стандарта (в FIPS 151-2). Все виды систем, с которыми мы имеем дело в этой книге, подчиняются спецификации XSI (X/Open System Interface) и соблюдают на деле правила владения.unlink, link и symlink.
С помощью вызова unlink вы можете удалить файл.
Системный вызов unlink удаляет запись о файле в каталоге и уменьшает на единицу счетчик ссылок на файл. Он возвращает 0, если удаление ссылки прошло успешно, и -1 в случае ошибки. Для выполнения вызова у вас должны быть права на запись и выполнение в каталоге, хранящем ссылку на файл.
#include <unistd.h>
int unlink(const char *path);
int link(const char *path1, const char *path2);
int symlink(const char *path1, const char *path2);
Если счетчик становится равен нулю и файл не открыт ни в одном процессе, он удаляется. В действительности элемент каталога всегда удаляется немедленно, а место, занятое содержимым файла, не очищается до тех пор, пока последний процесс (если таковой существует) не закроет файл. Этот вызов использует программа rm. Дополнительные ссылки, предоставляющие альтернативные имена файла, обычно создаются программой ln. Вы можете программно создать новые ссылки на файл с помощью системного вызова link.
Примечание. Создание файла с помощью вызова open и последующее обращение к unlink для этого файла — трюк, применяемый некоторыми программистами для создания временных или транзитных файлов. Эти файлы доступны программе, только пока они открыты; и будут удалены автоматически, когда программа завершится, и файлы будут закрыты.Системный вызов link создает новую ссылку на существующий файл path1. Новый элемент каталога задается в path2. Символические ссылки можно создавать аналогичным образом с помощью системного вызова symlink. Имейте в виду, что символические ссылки на файл не увеличивают значение счетчика ссылок и таким образом, в отличие от обычных (жестких) ссылок, не мешают удалению файла.
mkdir и rmdir.
Вы можете создавать и удалять каталоги, применяя системные вызовы mkdir и rmdir.
#include <sys/types.h>#include <sys/stat.h>
int mkdir(const char *path, mode_t mode);
Системный вызов mkdir используется для создания каталогов и эквивалентен программе mkdir. Вызов mkdir формирует новый каталог с именем, указанным в параметре path. Права доступа к каталогу передаются в параметре mode и задаются как опция о O_CREAT в системном вызове open и также зависят от переменной umask.
#include <unistd.h>
int rmdir(const char *path);
Системный вызов rmdir удаляет каталоги, но только если они пустые. Программа rmdir использует этот системный вызов для выполнения аналогичной работы.
chdir и getcwd.
Программа может перемещаться по каталогам во многом так же, как пользователь перемещается по файловой системе. Как вы применяете в командной оболочке команду cd для смены каталога, так и программа может использовать системный вызов chdir.
#include <unistd.h>
int chdir(const char *path);
Программа может определить свой текущий рабочий каталог, вызвав функцию getcwd.
#include <unistd.h>
char *getcwd(char *buf, size_t size);
Функция getcwd записывает имя текущего каталога в заданный буфер buf. Она возвращает NULL, если имя каталога превысит размер буфера (ошибка ERANGE), заданный в параметре size. В случае успешного завершения она возвращает buf.
Функция getcwd может также вернуть значение NULL, если во время выполнения программы каталог удален ( EINVAL) или изменились его права доступа ( EACCESS).
Просмотр каталогов.
Широко распространенная проблема систем Linux — просмотр каталогов, т.е. определение файлов, размещенных в конкретном каталоге. В программах командной оболочки она решается легко — просто скомандуйте оболочке выполнить подстановку в выражении с метасимволами. В прошлом в разных вариантах UNIX был разрешен программный доступ к низкоуровневой структуре файловой системы. Вы все еще можете открывать каталог как обычный файл и непосредственно считывать элементы каталога, но разные структуры файловых систем и реализации сделали такой подход непереносимым с машины на машину. Был разработан стандартный комплект библиотечных функций, существенно упрощающий просмотр каталогов.
Функции работы с каталогами объявлены в заголовочном файле dirent.h. В них используется структура DIR как основа обработки каталогов. Указатель на эту структуру, называемый потоком каталога ( DIR*), действует во многом так же, как действует поток файла ( FILE*) при работе с обычным файлом. Элементы каталога возвращаются в структурах dirent, также объявленных в файле dirent.h, поскольку никому не следует изменять поля непосредственно в структуре DIR.
Мы рассмотрим следующие функции:
□ opendir, closedir;
□ readdir;
□ telldir;
□ seekdir;
□ closedir.
opendir.
Функция opendir открывает каталог и формирует поток каталога. Если она завершается успешно, то возвращает указатель на структуру DIR, которая будет использоваться для чтения элементов каталога.
#include <sys/types.h>
#include <dirent.h>
DIR *opendir(const char *name);
В случае неудачи функция opendir возвращает пустой указатель. Имейте в виду, что для доступа к самому каталогу поток каталога использует низкоуровневый дескриптор файла, поэтому opendir может дать сбой, если открыто слишком много файлов.
readdir.
Функция readdir возвращает указатель на структуру, содержащую следующий элемент каталога в потоке каталога dirp. Успешные вызовы readdir возвращают следующие элементы каталогов. При возникновении ошибки и в конце каталога readdir возвращает NULL. Системы, удовлетворяющие стандарту POSIX, возвращая NULL, не меняют переменную errno в случае достижения конца каталога и устанавливают ее значение, если обнаружена ошибка.
#include <sys/types.h>
#include <dirent.h>
struct dirent *readdir(DIR *dirp);
Просмотр каталога с помощью функции readdir не гарантирует формирование списка всех файлов (и подкаталогов) в каталоге, если в это время выполняются другие процессы, создающие и удаляющие файлы в каталоге.
В состав структуры dirent, содержащей реквизиты элемента каталога, входят следующие компоненты.
□ ino_t d_ino — индекс файла;
□ char d_name[] — имя файла.
Для выяснения других реквизитов файла в каталоге вам необходимо вызвать stat, который мы обсуждали ранее.
telldir.
Функция telldir возвращает значение, регистрирующее текущую позицию в потоке каталога. Вы можете использовать ее в последующих вызовах функции seekdir для переустановки просмотра каталога, начиная с текущей позиции.
#include <sys/types.h>
#include <dirent.h>
long int telldir(DIR *dirp);
seekdir.
Функция seekdir устанавливает указатель на элемент каталога в потоке каталога, заданном в параметре dirp. Значение параметра loc, применяемого для установки позиции, следует получить из предшествующего вызова функции telldir.
#include <sys/types.h>
#include <dirent.h>
void seekdir (DIR *dirp, long int loc);
closedir.
Функция closedir закрывает поток каталога и освобождает ресурсы, выделенные ему. Она возвращает 0 в случае успеха и -1 при наличии ошибки.
#include <sys/types.h>
#include <dirent.h>
int closedir(DIR *dirp);
В приведенной далее программе printdir.c (упражнение 3.4) вы соберете вместе множество функций обработки файлов для создания простого перечня содержимого каталога. Каждый файл представлен отдельной строкой. У каждого подкаталога есть имя, за которым следует слэш, и файлы, содержащиеся в подкаталоге, выводятся с отступом шириной в четыре пробела.
Программа превращает каталог в подкаталоги, чтобы у найденных файлов были пригодные для использования имена, т.е. они могут передаваться непосредственно в функцию opendir. Программа будет давать сбои при просмотре структур с большим числом уровней вложенности, поскольку есть ограничение на разрешенное число открытых потоков каталогов.
Мы могли бы сделать программу более универсальной, принимая в качестве аргумента командной строки начальную точку просмотра.
Для того чтобы познакомиться с методами повышения универсальности программ, посмотрите исходный код таких утилит Linux, как ls и find.
Упражнение 3.4. Программа просмотра каталога.
1. Начните с соответствующих заголовочных файлов и функции printdir, которая выводит содержимое текущего каталога. Она будет рекурсивно вызываться для вывода подкаталогов, применяя параметр depth для задания отступа.
#include <unistd.h>
#include <stdio.h>
#include <dirent.h>
#include <string.h>
#include <sys/stat.h>
#include <stdlib.h>
void printdir(char *dir, int depth) {
DIR *dp;
struct dirent *entry;
struct stat statbuf;
if ((dp = opendir(dir)) == NULL) {
fprintf(stderr, "cannot open directory: %s\n", dir);
return;
}
chdir(dir);
while((entry = readdir(dp)) != NULL) {
lstat(entry->d_name, &statbuf);
if (S_ISDIR(statbuf.st_mode)) {
/* Находит каталог, но игнорирует . и .. */
if (strcmp(".", entry->d_name) == 0 || strcmp("..", entry->d_name) == 0)
continue;
printf("%*s%s/\n", depth, "", entry->d_name);
/* Рекурсивный вызов с новый отступом */
printdir(entry->d_name, depth+4);
} else printf("%*s%s\n", depth, " ", entry->d_name);
}
chdir("..");
closedir(dp);
}
2. Теперь переходите к функции main.
int main() {
/* Обзор каталога /home */
printf("Directory scan of /home:\n");
printdir("/home", 0);
printf("done.\n");
exit(0);
}
Программа просматривает исходные каталоги и формирует вывод, похожий на приведенный далее (отредактированный для краткости). Для того чтобы заглянуть в каталоги других пользователей, вам могут понадобиться права доступа суперпользователя.
$ ./printdir
Directory scan of /home:
neil/
.Xdefaults
.Xmodmap
.Xresources
.bash_history
.bashrc
.kde/
share/
apps/
konqueror/
dirtree/
public_html.desktop
toolbar/
bookmarks.xml
konq_history
kdisplay/
color-schemes/
BLP4e/
Gnu_Public_License
chapter04/
argopt.с
args.с
chapter03/
file.out
mmap.с
printdir
done.
Как это работает
Большинство операций сосредоточено в функции printdir. После некоторой начальной проверки ошибок с помощью функции opendir, проверяющей наличие каталога, printdir выполняет вызов функции chdir для заданного каталога. До тех пор пока элементы, возвращаемые функцией readdir, не нулевые, программа проверяет, не является ли очередной элемент каталогом. Если нет, она печатает элемент-файл с отступом, равным depth.
Если элемент — каталог, вы встречаетесь с рекурсией. После игнорирования элементов . и .. (текущего и родительского каталогов) функция printdir вызывает саму себя и повторяет весь процесс снова. Как она выбирается из этих повторений? Как только цикл while заканчивается, вызов chdir("..") возвращает программу вверх по дереву каталогов, и предыдущий перечень можно продолжать. Вызов closedir(dp) гарантирует, что количество открытых потоков каталогов не больше того, которое должно быть.
Для того чтобы составить представление об окружении в системе Linux, обсуждаемом в главе 4, познакомьтесь с одним из способов, повышающих универсальность программы. Рассматриваемая программа ограничена, потому что привязана каталогу /home. Следующие изменения в функции main могли бы превратить эту программу в полезный обозреватель каталогов:
int main(int argc, char* argv[]) {
char *topdir = ".";
if (argc >= 2) topdir = argv[1];
printf("Directory scan of %s\n", topdir);
printdir(topdir, 0);
printf("done.\n");
exit(0);
}
Три строки изменены и пять добавлено, но это уже универсальная утилита с необязательным параметром, содержащим имя каталога, по умолчанию равным текущему каталогу. Вы можете выполнять ее с помощью следующей командной строки:
$ ./printdir2 /usr/local | more
Вывод будет разбит на страницы, и пользователь сможет листать их. Таким образом, у него появится маленький удобный универсальный обозреватель дерева каталогов. Приложив минимум усилий, вы могли бы добавить статистический показатель использования пробелов, предельную глубину отображения и т.д.
Ошибки.
Как вы видели, многие системные вызовы и функции, описанные в этой главе, могут завершиться аварийно по ряду причин. Когда это происходит, они указывают причину сбоя, задавая значение внешней переменной errno. Многие стандартные библиотеки используют эту переменную как стандартный способ оповещения о возникших проблемах. Стоит повторить, что программа должна проверять переменную errno сразу же после возникновения проблемы в функции, поскольку errno может быть изменена следующей вызванной функцией, даже если она завершилась нормально.
Имена констант и варианты ошибок перечислены в заголовочном файле errno.h. К ним относятся следующие:
□ EPERM — Operation not permitted (операция не разрешена);
□ ENOENT — No such file or directory (нет такого файла или каталога);
□ EINTR — Interrupted system call (прерванный системный вызов);
□ EIO — I/O Error (ошибка ввода/вывода);
□ EBUSY — Device or resource busy (устройство или ресурс заняты);
□ EEXIST — File exists (файл существует);
□ EINVAL — Invalid argument (неверный аргумент);
□ EMFILE — Too many open files (слишком много открытых файлов);
□ ENODEV — No such device (нет такого устройства);
□ EISDIR — Is a directory (это каталог);
□ ENOTDIR — Isn't a directory (это не каталог).
Есть пара полезных функций, сообщающих об ошибках при их возникновении: strerror и perror.
strerror.
Функция strerror преобразует номер ошибки в строку, описывающую тип возникшей ошибки. Она может быть полезна для регистрации условий, вызывающих ошибку.
Далее приведена ее синтаксическая запись:
#include <string.h>
char *strerror(int errnum);
perror.
Функция perror также превращает текущую ошибку в виде, представленном в переменной errno, в строку и выводит ее в стандартный поток ошибок. Ей предшествует сообщение, заданное в строке s (если указатель не равен NULL), за которым следуют двоеточие и пробел.
Далее приведена синтаксическая запись функции:
#include <stdio.h>
void perror(const char *s);
Например, вызов
perror("program");
может дать следующий результат в стандартном потоке ошибок:
program: Too many open files
Файловая система procfs.
Ранее в этой главе мы уже писали о том, что ОС Linux обрабатывает многие вещи как файлы, и в файловой системе есть ряд элементов для аппаратных устройств. Эти файлы /dev применяются для доступа к оборудованию особыми методами с помощью низкоуровневых системных вызовов.
Программные драйверы, управляющие оборудованием, часто могут настраиваться определенными способами или сообщать информацию. Например, контроллер жесткого диска может настраиваться на применение определенного режима DMA. Сетевая карта может обладать функциональными возможностями для оповещения об установке высокоскоростного дуплексного соединения.
В прошлом для связи с драйверами устройств применялись утилиты общего назначения. Например, hdparm использовалась для настройки некоторых параметров диска, a ifconfig могла сообщить сетевую статистику. В недавнем прошлом появилась тенденция, направленная на обеспечение более подходящего способа доступа к информации драйвера и, как расширение, включающая взаимодействие с различными элементами ядра Linux.
ОС Linux предоставляет специальную файловую систему procfs, которая обычно доступна в виде каталога /proc. Она содержит много специальных файлов, обеспечивающих высокоуровневый доступ к информации драйвера и ядра. Приложения, выполняющиеся с корректными правами доступа, могут читать эти файлы для получения информации и записывать в них устанавливаемые параметры.
Набор файлов в каталоге /proc меняется от системы к системе, и с каждым новым выпуском Linux появляются новые файлы, дополнительные драйверы и средства поддержки файловой системы procfs. В этом разделе мы рассмотрим некоторые из самых широко распространенных файлов и кратко обсудим их применение.
В перечень каталога /proc на компьютере, использовавшемся для написания этой главы, включены следующие элементы:
1/ 10514/ 20254/ 6/ 9057/ 9623/ ide/ mtrr
10359/ 10524/ 29/ 698/ 9089/ 9638/ interrupts net/
10360/ 10530/ 983/ 699/ 9118/ acpi/ iomem partitions
10381/ 10539/ 3/ 710/ 9119/ asound/ ioports scsi/
10438/ 10541/ 30/ 711/ 9120/ buddyinfo irq/ self@
10441/ 10555/ 3069/ 742/ 9138/ bus/ kallsyms slabinfo
10442/ 10688/ 3098/ 7808/ 9151/ cmdline kcore splash
10478/ 10689/ 3099/ 7813/ 92/ config.gz keys stat
10479/ 10784/ 31/ 8357/ 9288/ cpuinfo key-users swaps
10482/ 113/ 3170/ 8371/ 93/ crypto kmsg sys/
10484/ 115/ 3171/ 840/ 9355/ devices loadavg sysrq-trigger
10486/ 116/ 3177/ 8505/ 9407/ diskstats locks sysvipc/
10495/ 1167/ 32288/ 8543/ 9457/ dma mdstat tty/
10497/ 1168/ 3241/ 8547/ 9479/ driver/ meminfo uptime
Во многих случаях файлы могут только читаться и дают информацию о состоянии. Например, /proc/cpuinfo предоставляет сведения о доступных процессорах:
$ cat /proc/cpuinfo
processor : 0
vendor_id : GenuineIntel
cpu family : 15
model : 2
model name : Intel(R) Pentium(R) 4 CPU 2.66GHz
stepping : 8
cpu MHz : 2665.923
cache size : 512 KB
fdiv_bug : no
hlt_bug : no
f00f_bug : no
coma_bug : no
fpu : yes
fpu_exception : yes
cpuid level : 2
wp : yes
flags : fpu vme de pse tsc msr рае mce cx8 apic sep mtrr pge mca cmov
pat pse36 clflush dts acpi mmx fxsr sse sse2 ss up
bogomips : 5413.47
clflush size : 64
Файлы /proc/meminfo и /ргос/version предоставляют данные об использовании оперативной памяти и версии ядра соответственно:
$ cat /proc/meminfo
MemTotal: 776156 kB
MemFree: 28528 kB
Buffers: 191764 kB
Cached: 369520 kB
SwapCached: 20 kB
Active: 406912 kB
Inactive: 274320 kB
HighTotal: 0 kB
HighFree: 0 kB
LowTotal: 776156 kB
LowFree: 28528 kB
SwapTotal: 1164672 kB
SwapFree: 1164652 kB
Dirty: 68 kB
Writeback: 0 kB
AnonPages: 95348 kB
Mapped: 49044 kB
Slab: 57848 kB
SReclaimable: 48008 kB
SUnreclaim: 9840 kB
PageTables: 1500 kB
NFS_Unstable: 0 kB
Bounce: 0 kB
CommitLimit: 1552748 kB
Committed_AS: 189680 kB
VmallocTotal: 245752 kB
VmallocUsed: 10572 kB
VmallocChunk: 234556 kB
HugePages_Total: 0
HugePages_Free: 0
HugePages_Rsvd: 0
Hugepagesize: 4096 kB
$ cat /proc/version
Linux version 2.6.20.2-2-default (geeko@buildhost) (gcc version 4.1.3 20070218 (prerelease) (SUSE Linux)) #1 SMP Fri Mar 9 21:54:10 UTC 2007
Информация, выводимая этими файлами, генерируется при каждом чтении файла. Поэтому повторное чтение файла meminfo в более поздний момент времени даст результаты с точностью до секунд.
Получить дополнительную информацию от специальных функций ядра можно в подкаталогах каталога /proc. Например, статистику использования сетевых сокетов вы можете узнать из /proc/net/sockstat:
$ cat /proc/net/sockstat
sockets: used 285
TCP: inuse 4 orphan 0 tw 0 alloc 7 mem 1
UDP: inuse 3
UDPLITE: inuse 0
RAW: inuse 0
FRAG: inuse 0 memory 0
В некоторые элементы каталога /proc можно производить запись, а не только читать их. Например, общее количество файлов, которые могут быть открыты одновременно всеми выполняющимися программами, — это параметр ядра Linux. Текущее значение можно прочитать из /proc/sys/fs/file-max:
$ cat /proc/sys/fs/file-max
76593
В данном случае задана величина 76593. Если вам нужно увеличить это значение, вы можете сделать это, записав его в тот же файл. Это действие может потребоваться при выполнении специального комплекса программ, например, системы управления базой данных, которая использует много таблиц, что потребует одновременного открытия большого числа файлов.
Примечание. Для записи в файлы /proc требуются права доступа суперпользователя. При записи в эти файлы нужно быть предельно внимательным; при записи неподходящих данных возможно возникновение серьезных проблем, включая крах системы и потерю данных.Для увеличения предельного значения одновременно обрабатываемых в системе файлов до 80000 вы можете просто записать новое предельное значение в файл file-max.
# echo 80000 >/proc/sys/fs/file-max
Теперь, повторно прочитав файл, вы увидите новое значение:
$ cat /proc/sys/fs/file-max
80000
Подкаталоги каталога /proc с числовыми именами применяются для обеспечения доступа к информации о выполняющихся программах. В главе 11 вы узнаете больше о том, что программы выполняются как процессы.
Сейчас только отметьте, что у каждого процесса есть уникальный идентификатор: число в диапазоне от 1 до почти 32 000. Команда ps предоставляет список выполняющихся в данный момент процессов. Например, когда писалась эта глава:
neil@susel03:~/BLP4e/chapter03> ps -а
PID TTY TIME CMD
9118 pts/1 00:00:00 ftp
9230 pts/1 00:00:00 ps
10689 pts/1 00:00:01
bash neil@susel03:~/BLP4e/chapter03>
Вы видите несколько сеансов терминалов, запустивших командную оболочку bash и сеанс передачи файла, выполняющий программу ftp. Просмотрев каталог /proc, вы получите более подробную информацию о сеансе ftp.
В данном случае для ftp задан идентификатор процесса 9118, поэтому вы должны заглянуть в каталог /proc/9118 для получения подробной информации о нем:
$ ls -l /proc/9118
total 0
0 dr-xr-xr-x 2 neil users 0 2007-05-20 07:43 attr
0 -r-------- 1 neil users 0 2007-05-20 07:43 auxv
0 -r--r--r-- 1 neil users 0 2007-05-20 07:35 cmdline
0 -r--r--r-- 1 neil users 0 2007-05-20 07:43 cpuset
0 lrvxrwxrwx 1 neil users 0 2007-05-20 07:43 cwd -> /home/neil/BLP4e/chapter03
0 -r-------- 1 neil users 0 2007-05-20 07:43 environ
0 lrwxrwxrwx 1 neil users 0 2007-05-20 07:43 exe -> /usr/bin/pftp
0 dr-x------ 2 neil users 0 2007-05-20 07:19 fd
0 -rw-r--r-- 1 neil users 0 2007-05-20 07:43 loginuid
0 -r--r--r-- 1 neil users 0 2007-05-20 07:43 maps
0 -rw------- 1 neil users 0 2007-05-20 07:43 mem
0 -r--r--r-- 1 neil users 0 2007-05-20 07:43 mounts
0 -r-------- 1 neil users 0 2007-05-20 07:43 mountstats
0 -rw-r--r-- 1 neil users 0 2007-05-20 07:43 oom_adj
0 -r--r--r-- 1 neil users 0 2007-05-20 07:43 oom_score
0 lrwxrwxrwx 1 neil users 0 2007-05-20 07:43 root -> /
0 -rw------- 1 neil users 0 2007-05-20 07:43 seccomp
0 -r--r--r-- 1 neil users 0 2007-05-20 07:43 smaps
0 -r--r--r-- 1 neil users 0 2007-05-20 07:33 stat
0 -r--r--r-- 1 neil users 0 2007-05-20 07:43 statm
0 -r--r--r-- 1 neil users 0 2007-05-20 07:33 status
0 dr-xr-xr-x 3 neil users 0 2007-05-20 07:43 task
0 -r--r--r-- 1 neil users 0 2007-05-20 07:43 wchan
В данном перечне вы видите разные специальные файлы, способные сообщить вам, что происходит с процессом.
Можно сказать, что выполняется программа /usr/bin/pftp, и ее текущий рабочий каталог — home/neil/BLP4e/chapter03. Есть возможность прочитать другие файлы из этого каталога, чтобы увидеть командную строку, применяемую для запуска программы, а также ее окружение. Файлы cmdline и environ предоставляют эту информацию в виде последовательности нуль-терминированных строк, поэтому вам следует соблюдать осторожность при их просмотре. Более подробно окружение ОС Linux мы обсудим в главе 4.
$ od -с /proc/9118/cmdline
0000000 f t p \0 1 9 2 . 1 6 8 . 0 . 1 2
0000020 \0
0000021
Из полученного вывода видно, что ftp была запущена из командной строки ftp 192.163.0.12.
Подкаталог fd предоставляет информацию об открытых дескрипторах файлов, используемых процессом. Эти данные могут быть полезны при определении количества файлов, одновременно открытых программой. На каждый открытый дескриптор приходится один элемент; имя его соответствует номеру дескриптора. В нашем случае, как мы и ожидали, у программы ftp есть открытые дескрипторы 0, 1, 2 и 3. Они включают стандартные дескрипторы ввода, вывода и потока ошибок плюс подключение к удаленному серверу.
$ ls /proc/9118/fd
0 1 2 3
Более сложные приемы: fcntl и mmap.
Теперь мы коснемся приемов, которые вы можете пропустить, поскольку они редко используются. Признавая это, мы помещаем их в книгу просто для вашего сведения, потому что применение описываемых средств может предоставить простые решения для замысловатых проблем.
fcntl.
Системный вызов fcntl предоставляет дополнительные методы обработки низкоуровневых дескрипторов файлов:
#include <fcntl.h>
int fcntl(int fildes, int cmd);
int fcntl(int fildes, int cmd, long arg);
С помощью системного вызова fcntl вы можете выполнить несколько разнородных операций над открытыми дескрипторами файлов, включая их дублирование, получение и установку флагов дескрипторов файлов, получение и установку флагов состояния файла и управление блокировкой файла (advisory file locking).
Различные операции выбираются разными значениями параметра команды cmd, как определено в файле fcntl.h. В зависимости от выбранной команды системному вызову может потребоваться третий параметр arg.
□ fcntl(fildes, F_DUPFD, newfd) — этот вызов возвращает новый дескриптор файла с числовым значением, равным или большим целочисленного параметра newfd. Новый дескриптор — копия дескриптора fildes. В зависимости от числа открытых файлов и значения newfd этот вызов может быть практически таким же, как вызов dup(fildes).
□ fcntl(fildes, F_GETFD) — этот вызов возвращает флаги дескриптора файла, как определено в файле fcntl.h. К ним относится FD_CLOEXEC, определяющий, закрыт ли дескриптор файла после успешного вызова одного из системных вызовов семейства exec.
□ fcntl(fildes, F_SETFD, flags) — этот вызов применяется для установки флагов дескриптора файла, как правило, только FD_CLOEXEC.
□ fcntl(fildes, F_GETFL) и fcntl(fildes, F_SETFL, flags) — эти вызовы применяются, соответственно, для получения и установки флагов состояния файла и режимов доступа. Вы можете извлечь режимы доступа к файлу с помощью маски O_ACCMODE, определенной в файле fcntl.h. Остальные флаги включают передаваемые значения в третьем аргументе вызову open с использованием O_CREAT. Учтите, что вы не можете задать все флаги. В частности, нельзя задать права доступа к файлу с помощью вызова fcntl.
Вызов fcntl также позволяет реализовать блокировку файла. См. более подробную информацию в разделе 2 интерактивного справочного руководства или главу 7, в которой мы обсуждаем блокировку файлов.
mmap.
Система UNIX предоставляет полезное средство, позволяющее программам совместно использовать память, и, к счастью, оно включено в версию 2.0 и более поздние версии ядра Linux. Функция mmap (для отображения памяти) задает сегмент памяти, который может читаться двумя или несколькими программами и в который они могут записывать данные. Изменения, сделанные одной программой, видны всем остальным.
Вы можете применить то же самое средство для работы с файлами, заставив все содержимое файла на диске выглядеть как массив в памяти. Если файл состоит из записей, которые могут быть описаны структурами на языке С, вы сможете обновлять файл с помощью методов доступа к массиву структур.
Это становится возможным благодаря применению сегментов виртуальной памяти с набором особых прав доступа. Чтение из сегмента и запись в него заставляет операционную систему читать соответствующую часть файла на диске и писать данные в нее.
Функция mmap создает указатель на область памяти, ассоциированную с содержимым файла, доступ к которому осуществляется через открытый дескриптор файла.
#include <sys/mman.h>
void *mmap(void *addr, size_t len, int prot, int flags, int fildes, off_t off);
Изменить начальную позицию порции данных файла, к которым выполняется обращение через совместно используемый сегмент, можно, передавая параметр off. Открытый дескриптор файла задается в параметре fildes. Объем данных, к которым возможен доступ (т. е. размер сегмента памяти), указывается в параметре len.
Параметр addr можно использовать для запроса конкретного адреса памяти. Если он равен нулю, результирующий указатель формируется автоматически. Последний вариант рекомендуется, потому что в противном случае трудно добиться переносимости; диапазоны доступных адресов в разных системах отличаются.
Параметр prot используется для установки прав доступа к сегменту памяти. Он представляет собой результат поразрядной операции or, примененной к следующим константам:
□ PROT_READ — сегмент может читаться;
□ PROT_WRITE — в сегмент можно писать;
□ PROT_EXEC — сегмент может выполняться;
□ PROT_NONE — к сегменту нет доступа.
Параметр flags контролирует, как изменения, сделанные программой в сегменте, отражаются в других местах; его возможные значения приведены в табл. 3.7.
Таблица 3.7
Константа | Описание |
---|---|
MAP_PRIVATE | Сегмент частный, изменения локальные |
MAP_SHARED | Изменения сегмента переносятся в файл |
MAP_FIXED | Сегмент должен располагаться по заданному адресу addr |
Функция msync вызывает запись изменений в части или во всем сегменте памяти обратно а отображенный файл (или считывание из файла).
#include <sys/mman.h>
int msync(void *addr, size_t len, int flags);
Корректируемая часть сегмента задается передачей начального адреса addr и размера len. Параметр flags управляет способом выполнения корректировки с помощью вариантов, приведенных в табл. 3.8.
Таблица 3.8
Константа | Описание |
---|---|
MS_ASYNC | Выполнять запись асинхронно |
MS_SYNC | Выполнять запись синхронно |
MS_INVALIDATE | Обновить другие отражения этого файла так, чтобы они содержали изменения, внесенные этим вызовом |
Функция munmap освобождает сегмент памяти.
#include <sys/mman.h>
int munmap(void *addr, size_t len);
В программе mmap.с из упражнения 3.5 показан файл из структур, которые будут корректироваться с помощью функции mmap и обращений в стиле массива. Ядро Linux версий, меньших 2.0, не полностью поддерживает применение функции mmap. Программа работает корректно в системе Sun Solaris и других системах.
Упражнение 3.5. Применение функции mmap.
1. Начните с определения структуры RECORD и создайте NRECORDS вариантов, в каждый из которых записывается собственный номер. Они будут добавлены в конец файла records.dat.
#include <unistd.h>
#include <stdio.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <stdlib.h>
typedef struct {
int integer;
char string[24];
} RECORD;
#define NRECORDS (100)
int main() {
RECORD record, *mapped;
int i, f;
FILE *fp;
fp = fopen("records.dat", "w+");
for (i=0; i<NRECORDS; i++) {
record.integer = i;
sprintf(record.string, "RECORD-%d", i);
fwrite(&record, sizeof(record), 1, fp);
}
fclose(fp);
2. Далее измените целое значение записи с 43 на 143 и запишите его в строку 43-й записи.
fp = fopen("records.dat", "r+");
fseek(fp, 43*sizeof(record), SEEK_SET);
fread(&record, sizeof(record), 1, fp);
record.integer =143;
sprintf(record.string, "RECORD-%d", record.integer);
fseek(fp, 43*sizeof(record), SEEK_SET);
fwrite(&record, sizeof(record), 1, fp);
fclose(fp);
3. Теперь отобразите записи в память и обратитесь к 43-й записи для того, чтобы изменить целое на 243 (и обновить строку записи), снова используя отображение в память.
f = open("records.dat", O_RDWR);
mapped = (RECORD *)mmap(0, NRECORDS*sizeof(record),
PROT_READ|PROT_WRITE, MAP_SHARED, f, 0);
mapped[43].integer = 243;
sprintf(mapped[43].string, "RECORD-%d", mapped[43].integer);
msync((void *)mapped, NRECORDS*sizeof(record), MS_ASYNC);
munmap((void *)mapped, NRECORDS*sizeof(record));
close(f);
exit(0);
}
В главе 13 вы встретитесь с еще одним средством совместного использования памяти — разделяемой памятью System V.
Резюме.
В этой главе вы увидели, как ОС Linux обеспечивает прямой доступ к файлам и устройствам, как на этих низкоуровневых функциях строятся библиотечные функции, предоставляющие гибкие решения программных проблем. В результате вы смогли написать довольно мощную процедуру просмотра каталога с помощью нескольких строк программного кода.
Вы также узнали об обработке файлов и каталогов достаточно для того, чтобы превратить "сырое" приложение для работы с компакт-дисками, созданное в конце главы 2, в программу на языке С, применяющую более структурированное решение на базе файлов. Но на этом этапе вы не можете расширить функциональные возможности программы, поэтому мы отложим ее переработку до того времени, когда вы научитесь управлять экраном и клавиатурой, которые будут предметами обсуждения следующих двух глав.
Глава 4. Окружение Linux.
Когда вы пишете программу для ОС Linux (или UNIX и UNIX-подобных систем), следует принимать во внимание то, что программа будет выполняться в многозадачной среде или многозадачном окружении. Это означает, что много программ будет выполняться одновременно и совместно использовать ресурсы компьютера, такие как память, дисковое пространство и циклы центрального процессора. Может даже существовать несколько экземпляров одной и той же программы, выполняющихся одновременно. Важно, чтобы эти программы не мешали друг другу, знали о своем окружении и могли действовать надлежащим образом, избегая конфликтов, таких как попытка писать в один и тот же файл одновременно с другой программой.
В этой главе рассматривается окружение, в котором действуют программы, как они его используют для получения информации об условиях функционирования и как пользователи программ могут изменять их поведение. В частности, в данной главе рассматриваются следующие темы:
□ передача аргументов в программы;
□ переменные окружения;
□ определение текущего времени;
□ временные файлы;
□ получение информации о пользователе и рабочем компьютере;
□ формирование и настройка регистрируемых сообщений;
□ выявление ограничений, накладываемых системой.
Аргументы программы.
Когда в ОС Linux или UNIX выполняется программа на языке С, она начинается с функции main. В таких программах функция main объявляется следующим образом:
int main(int argc, char *argv[])
Здесь argc — это счетчик аргументов программы, a argv — массив символьных строк, представляющих сами аргументы.
Вы можете встретить программы на языке С для ОС Linux, просто объявляющие функцию main как
main()
Этот вариант тоже работает, поскольку по умолчанию возвращаемому функцией значению будет назначен тип int, а формальные параметры, которые в функции не применяются, не нуждаются в объявлении. Параметры argc и argv остаются на своем месте, но если вы не объявляете их, то и не можете их использовать.
Каждый раз, когда операционная система запускает новую программу, параметры argc и argv устанавливаются и передаются функции main. Обычно эти параметры предоставляются другой программой, часто командной оболочкой, которая запросила у операционной системы запуск новой программы. Оболочка принимает заданную командную строку, разбивает её на отдельные слова и использует их для заполнения массива argv. Помните о том, что до установки параметров argc и argv командная оболочка Linux обычно выполняет раскрытие метасимволов в аргументах, содержащих имена файлов, в то время как оболочка MS-DOS рассчитывает на то, что программы примут аргументы с метасимволами и выполнят собственную постановку.
Например, если мы дадим командной оболочке следующую команду:
$ myprog left right 'and center'
программа myprog запустит функцию main с приведенными далее параметрами.
argc: 4
argv: {"myprog", "left", "right", "and center"}
Обратите внимание на то, что аргумент-счётчик содержит имя программы и в массив argv оно включено как первый элемент argv[0]. Поскольку в команде оболочки мы применили кавычки, четвертый аргумент представляет собой строку, содержащую пробелы.
Вам все это знакомо, если вы программировали на языке С стандарта ISO/ANSI, Аргументы функции main соответствуют позиционным параметрам в сценариях командной оболочки: $0, $1 и т.д. Язык ISO/ANSI С заявляет, что функция main должна возвращать значение типа int, спецификация X/Open содержит явное объявление, данное ранее.
Аргументы командной строки удобны для передачи данных программам. Например, вы можете применить их в приложениях баз данных для передачи имени базы данных, которую хотите использовать, что позволит вам применить одну и ту же программу для работы с несколькими базами данных. Многие утилиты также используют аргументы командной строки для изменения собственного поведения или установки опций. Вы обычно задаете эти так называемые флаги или переключатели с помощью аргументов командной строки, начинающихся со знака "дефис". Например, программа sort принимает переключатель для изменения обычного порядка сортировки на обратный:
$ sort -r файл
Опции командной строки используются очень широко, и согласованное их применение будет реальной помощью тем, кто станет использовать вашу программу. В прошлом у каждой утилиты был свой подход к формированию опций командной строки, что приводило к некоторой путанице. Например, взгляните на то, каким способом приведенные далее команды принимают параметры:
$ tar cvfB /tmp/file.tar 1024
$ dd if=/dev/fd0 of=/trap/file.dd bs=18k
$ ps ax
$ gcc --help
$ ls -lstr
$ ls -l -s -t -r
Мы рекомендуем в ваших приложениях все переключатели командной строки начинать с дефиса и делать их односимвольными, состоящими из одной буквы или цифры. При необходимости опции, не содержащие последующих аргументов, могут группироваться вместе после общего дефиса. Таким образом, два только что приведенных примера с командой ls соответствуют нашим рекомендациям. За каждой опцией может следовать любое необходимое ей значение как отдельный аргумент. Пример с программой dd нарушает наше правило, поскольку использует многосимвольные опции, которые начинаются совсем не с дефисов ( if=/dev/fd0): в примере с программой tar опции полностью оторваны от своих значений! Целесообразно добавлять более длинные и информативные имена переключателей как альтернативу односимвольных вариантов и использовать двойной дефис для их выделения. Таким образом, у нас могут быть два варианта опции получения помощи: -h и --help.
Еще один недостаток некоторых программ — создание опции +x (например) для выполнения функции, противоположной -х. В главе 2 мы применяли команду set -о xtrace для включения отслеживания действий командной оболочки и команду set +о xtrace для выключения этого режима.
Вы, вероятно, можете сказать, что запомнить порядок и назначение всех этих программных опций достаточно трудно без необходимости освоения вызывающих идиосинкразию форматов. Часто единственный выход — применение опции -h (от англ. help) или страниц интерактивного справочного руководства ( man), если программист предоставил одну из этих возможностей. Чуть позже в этой главе мы покажем, что функция getopt предоставляет изящное решение этих проблем. А сейчас, тем не менее, в упражнении 4.1 давайте посмотрим, как передаются аргументы программы.
Упражнение 4.1. Аргументы программы.
Далее приведена программа args.c, проверяющая собственные аргументы.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
int arg;
for (arg = 0; arg < argc; arg++) {
if (argv[arg][0] == '-')
printf("option: %s\n", argv[arg]+1);
else
printf("argument %d: %s\n", arg, argv[arg]);
}
exit(0);
}
Когда вы выполните эту программу, она просто выведет свои аргументы и определит опции. Суть в том, что программа принимает строковый аргумент и необязательный аргумент с именем файла, вводимый опцией -f. Могут быть определены и другие опции.
$ ./args -i -lr 'hi there' -f fred.c
argument 0: ./args
option: i
option: lr
argument 3: hi there option: f
argument 5: fred.с
Как это работает
Программа просто использует аргумент-счетчик argc для задания цикла, просматривающего все аргументы программы. Она находит опции поиском начального дефиса.
В данном примере, если мы предполагаем, что доступны опции -l и -r, то упускаем тот факт, что группа -lr, возможно, должна интерпретироваться так же, как -l и -r.
В стандарте X/Open (который можно найти по адресу http://opengroup.org/) определено стандартное применение опций командной строки (Utility Syntax Guidelines, руководство по синтаксису утилит) и стандартный программный интерфейс для представления переключателей командной строки в программах на языке С: функция getopt.
getopt.
Для того чтобы вам легче было следовать правилам, приведенным в этих руководствах, ОС Linux предлагает очень простое в применении средство getopt, поддерживающее использование опций со значениями и без них.
#include <unistd.h>
int getopt(int argc, char *const argv[], const char *optstring);
extern char *optarg;
extern int optind, opterr, optopt;
Функция getopt принимает параметры argc и argv в том виде, в каком они передаются функции main в программе, и строку спецификатора опций, которая сообщает getopt, какие опции определены для программы и есть ли у них связанные с ними значения. optstring — это просто список символов, каждый из которых представляет односимвольную опцию. Если за символом следует двоеточие, это означает, что у опции есть ассоциированное значение, которое будет принято как следующий аргумент. Команда getopt оболочки bash выполняет аналогичную функцию.
Например, для обработки предыдущего примера можно было бы применить следующий вызов:
getopt(argc, argv, "if:lr");
В нем учтены простые опции -i, -l, -r и -f, за которыми последует аргумент с именем файла. Вызов команды с теми же параметрами, но указанными в другом порядке, изменит поведение. Вы сможете попробовать сделать это, когда получите пример кода из упражнения 4.2.
Результат, возвращаемый функцией getopt, — символ следующей опции, хранящийся в массиве argv (если он есть). Вызывайте getopt повторно для поочередного получения каждой опции. Функция ведет себя следующим образом.
□ Если опция принимает значение, на него указывает внешняя переменная optarg.
□ Функция getopt вернет -1, когда не останется опций для обработки. Специальный аргумент -- заставит getopt прекратить перебор опций.
□ Функция getopt вернет ?, если есть нераспознанная опция, которую она сохранит во внешней переменной optopt.
□ Если опции требуется значение (например, в нашем примере опции -f) и не задана никакая величина, getopt обычно возвращает ?. Если поместить двоеточие как первый символ в строке опций, при отсутствии заданной величины функция getopt вернет : вместо ?.
Во внешней переменной optind хранится номер следующего обрабатываемого аргумента. Функция getopt использует ее, чтобы знать, как далеко она продвинулась. Программы редко нуждаются в установке этой переменной. Когда все аргументы с опциями обработаны, переменная optind указывает, где в конце массива argv можно найти оставшиеся аргументы.
Некоторые версии функции getopt прекратят выполнение при обнаружении первого аргумента не опции, вернув значение -1 и установив переменную optind. Другие, например предлагаемые в ОС Linux, могут обрабатывать опции, где бы они ни встретились в аргументах программы. Учтите, что в данном случае getopt фактически перепишет массив argv так, что все аргументы не опции будут собраны вместе, начиная с элемента массива argv[optind]. В случае версии GNU функции getopt ее поведение определяется переменной окружения POSIXLY_CORRECT. Если переменная установлена, getopt остановится на первом аргументе не опции. Кроме того, некоторые реализации getopt выводят сообщения об ошибке для незнакомых опций. Имейте в виду, что в стандарте POSIX написано о том, что если переменная opterr не равна нулю, функция getopt выведет сообщение об ошибке в stderr.
Итак, выполните упражнение 4.2.
Упражнение 4.2. Функция getopt.
В этом упражнении вы используете функцию getopt; назовите новую программу argopt.c.
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
int opt;
while ((opt = getopt(argc, argv, ":if:lr")) != -1) {
switch(opt) {
case 'i':
case 'l':
case 'r':
printf("option: %c\n", opt);
break;
case 'f':
printf("filename: %s\n", optarg);
break;
case ':':
printf("option needs a value\n");
break;
case '?':
printf("unknown option: %c\n", optopt);
break;
}
}
for (; optind < argc; optind++)
printf("argument: %s\n", argv[optind]);
exit(0);
}
Теперь, когда вы выполните программу, то увидите, что все аргументы командной строки обрабатываются автоматически:
$ ./argopt -i -lr 'hi there' -f fred.с -q
option: i
option: l
option: r
filename: fred.c
unknown option: q
argument: hi there
Как это работает
Программа многократно вызывает функцию getopt для обработки аргументов-опций до тех пор, пока не останется ни одного, в этот момент getopt вернет -1. Для каждой опции выбирается подходящее действие, включая обработку неизвестных опций и пропущенных значений. Если у вас другая версия getopt, то вы получите вывод, слегка отличающийся от показанного, — особенно сообщения об ошибках — но смысл будет понятен.
Когда все опции обработаны, программа просто выводит оставшиеся аргументы, как и раньше, но начиная с номера, хранящегося в переменной optind.
getopt_long.
Многие приложения Linux принимают более информативные аргументы, чем использованные в предыдущем примере односимвольные опции. Библиотека С проекта GNU содержит версию функции getopt, названную getopt_long, которая принимает так называемые длинные аргументы, которые вводятся с помощью двойного дефиса.
Рассмотрим упражнение 4.3.
Упражнение 4.3. Функция getopt_long.
Примените функцию getopt_long для создания новой версии примера программы, которая может вызываться с использованием длинных эквивалентов опций, например, следующих:
$ ./longopt --initialize --list 'hi there' --file fred.c -q
option: i
option: l
filename: fred.c
./longopt: invalid option --q
unknown option: q
argument: hi there
На самом деле и новые длинные опции, и исходные односимвольные можно смешивать. Длинным опциям также можно давать сокращенные названия, но они
должны отличаться от односимвольных опций. Длинные опции с аргументом можно задавать как единый аргумент в виде --опция= значение, как показано далее:
$ ./longopt --init -l --file=fred.с 'hi there'
option: i
option: l
filename: fred.с
argument: hi there
Далее приведена новая программа longopt.c, полученная из программы argopt.c с изменениями, обеспечивающими поддержку длинных опций, которые в тексте программы выделены цветом.
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#define _GNU_SOURCE
#include <getopt.h>
int main(int argc, char *argv[]) {
int opt;
struct option_longopts[] = {
{"initialize", 0. NULL, 'i'},
{"file" 1, NULL, 'f'},
{"list", 0, NULL, 'l'},
{0, 0, 0, 0}};
while ((opt = getopt_long(argc, argv, ":if:lr, longopts, NULL)) != -1) {
switch(opt) {
case 'i':
case 'l':
case 'r':
printf("option: %c\n", opt);
break;
case 'f':
printf("filename: %s\n", optarg);
break;
case ':':
printf("option needs a value\n");
break;
case '?':
printf("unknown option: %c\n", optopt);
break;
}
}
for (; optind < argc; optind++)
printf("argument: %s\n", argv[optind]);
exit(0);
}
Как это работает
Функция getopt_long принимает два дополнительных параметра по сравнению с функцией getopt. Первый из них — массив структур, описывающий длинные опции и сообщающий функции getopt_long способ их обработки. Второй дополнительный параметр — адрес переменной, которая может использоваться как вариант optind, предназначенный для длинных опций; для каждой распознанной длинной опции ее номер в массиве длинных опций может быть записан в эту переменную. В данном примере вам не нужна эта информация, поэтому вы используете NULL в качестве значения второго дополнительного параметра.
Массив длинных опций состоит из ряда структур типа struct option, в каждой из которых описано требуемое поведение длинной опции. Массив должен заканчиваться структурой, содержащей все нули.
Структура длинной опции определена в заголовочном файле getopt.h и должна подключаться с помощью константы _GNU_SOURCE, определенной для того, чтобы разрешить использование функции getopt_long.
struct option {
const char *name;
int has_arg;
int *flag;
int val;
};
Элементы структуры описаны в табл. 4.1.
Таблица 4.1.
Параметр опции | Описание |
---|---|
name | Название длинной опции. Сокращения будут приниматься до тех пор, пока они не создадут путаницы при определении названий других опций |
has_arg | Принимает ли эта опция аргумент. Задайте 0 для опций без аргументов, 1 для опций, у которых должно быть значение, и 2 для опций с необязательным аргументом |
flag | Задайте NULL, чтобы getopt_long вернула при обнаружении данной опции значение, заданное в val. В противном случае getopt_long возвращает 0 и записывает значение val в переменную, на которую указывает flag |
val | Значение getopt_long для данной опции, предназначенное для возврата |
Для получения сведений о других опциях, связанных с расширениями функции getopt в проекте GNU и родственных функциях, см. страницы интерактивного справочного руководства к функции getopt.
Переменные окружения.
Мы обсуждали переменные окружения в главе 2. Это переменные, которые могут использоваться для управления поведением сценариев командной оболочки и других программ. Вы также можете применять их для настройки пользовательской среды. Например, у каждого пользователя есть переменная окружения HOME, определяющая его исходный каталог, стандартное место старта его или ее сеанса. Как вы видели, просмотреть переменные окружения можно из строки приглашения командной оболочки:
$ echo $НОМЕ
/home/neil
Вы также можете воспользоваться командой оболочки set для получения списка всех переменных окружения.
В спецификации UNIX определено множество стандартных переменных окружения, применяемых для самых разных целей, включая тип терминала, имена редакторов, установленных по умолчанию, названия часовых поясов и т.д. Программа на языке С может получить доступ к переменным окружения с помощью функций putenv и getenv.
#include <stdlib.h>
char *getenv(const char *name);
int putenv(const char *string);
Окружение состоит из строк вида имя=значение. Функция getenv ищет в окружении строку с заданным именем и возвращает значение, ассоциированное с этим именем. Она вернет NULL, если требуемая переменная не существует. Если переменная есть, но ее значение не задано, функция getenv завершится успешно и вернет пустую строку, в которой первый байт равен NULL. Строка, возвращаемая getenv, хранится в статической памяти, принадлежащей функции, поэтому для ее дальнейшего использования вы должны скопировать эту строку в другую, поскольку она может быть перезаписана при последующих вызовах функции getenv.
Функция putenv принимает строку вида имя=значение и добавляет ее в текущее окружение. Она даст сбой и вернет -1, если не сможет расширить окружение из-за нехватки свободной памяти. Когда это произойдет, переменной errno будет присвоено значение ENOMEM.
В упражнении 4.4 вы напишете программу для вывода значения любой выбранной вами переменной окружения. У вас также будет возможность задать значение, если вы укажете второй аргумент программы.
Упражнение 4.4. Функции getenv и putenv.
1. Первые несколько строк после объявления функции main гарантируют корректный вызов программы environ.c с только одним или двумя аргументами:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main(int argc, char *argv[]) {
char *var, *value;
if (argc == 1 || argc > 3) {
fprintf(stderr, "usage: environ var [value]\n");
exit(1);
}
2. Сделав это, вы извлекаете значение переменной из окружения с помощью функции getenv:
var = argv[1];
value = getenv(var);
if (value)
printf("Variable %s has value %s\n", var, value);
else
printf("Variable %s has no value\n", var);
3. Далее проверьте, был ли при вызове программы указан второй параметр. Если был, вы задаете значение этого аргумента, конструируя строку вида имя=значение и затем вызывая функцию putenv:
if (argc == 3) {
char *string;
value = argv[2];
string = malloc(strlen(var)+strlen(value)+2);
if (!string} {
fprintf(stderr, "out of memory\n");
exit(1);
}
strcpy(string, var);
strcat(string, "=");
strcat(string, value);
printf("Calling putenv with: %s\n", string);
if (putenv(string) != 0) {
fprintf(stderr, "putenv failed\n");
free(string);
exit(1);
}
4. В заключение вы узнаете новое значение переменной, вызвав функцию getenv еще раз:
value = getenv(var);
if (value)
printf("New value of %s is %s\n", var, value);
else
printf("New value of %s is null??\n", var);
}
exit(0);
}
Когда вы выполните эту программу, то сможете увидеть и задать переменные окружения:
$ ./environ НОМЕ
Variable HOME has value /home/neil
$ ./environ FRED
Variable FRED has no value
$ ./environ FRED hello
Variable FRED has no value
Calling putenv with: FRED=hello
New value of FRED is hello
$ ./environ FRED
Variable FRED has no value
Обратите внимание на то, что окружение локально по отношению к программе. Изменения, которые вы делаете в программе, не отражаются вне ее, поскольку значения переменных не передаются из дочернего процесса (вашей программы) в родительский (командную оболочку).
Применение переменных окружения.
Программы часто применяют переменные окружения для изменения способа своей работы. Пользователи могут задать значения этих переменных окружения либо в их стандартном окружении с помощью файла .profile, читаемого их регистрационной командной оболочкой, использующей специальный файл запуска (rc) оболочки, либо заданием переменных в командной строке командной оболочки. Например,
$ ./environ FRED
Variable FRED has no value
$ FRED=hello ./environ FRED
Variable FRED has value hello
Командная оболочка принимает начальные присвоения значений переменным как временные изменения переменных окружения. Во второй части предыдущего примера программа environ выполняется в окружении, где у переменной FRED есть значение.
Например, в будущей версии приложения, управляющего базой данных компакт-дисков, вы сможете изменить переменную окружения, скажем CDDB, обозначающую базу данных, которую нужно использовать. Каждый пользователь затем сможет задать собственное значение по умолчанию или применить команду оболочки для задания значения при очередном выполнении приложения:
$ CDDB=mycds; export CDDB
$ cdapp
или
$ CDDB=mycds cdapp
Примечание. Переменные окружения — противоречивое благо, и их следует применять с осторожностью. Эти переменные более "закрыты" от пользователя, чем опции командной строки, и это может затруднить отладку. По смыслу переменные окружения подобны глобальным переменным, поэтому они могут изменять поведение программы, что порой приводит к неожиданным результатам.Переменная environ.
Как вы уже знаете, окружение программы формируется из строк вида имя=значение. Этот массив строк становится доступен программе непосредственно из переменной environ, которая объявляется, как
#include <stdlib.h>
extern char **environ;
Выполните упражнение 4.5.
Упражнение 4.5. Переменная environ.
Далее приведена программа showenv.c, использующая переменную environ для вывода переменных окружения.
#include <stdlib.h>
#include <stdio.h>
extern char **environ;
int main() {
char **env = environ;
while (*env) {
printf("%s\n", *env);
env++;
}
exit(0);
}
Когда вы выполните программу в системе Linux, то получите нечто, похожее на следующий вывод, который немного сокращен. Количество, порядок отображения и значения этих переменных зависят от версии операционной системы, применяемой командной оболочки и настроек пользователя в момент выполнения программы.
$ ./showenv
HOSTNAME=tilde.provider.com
LOGNAME=neil
MAIL=/var/spool/mail/neil
TERM=xterm
HOSTTYPE=i386
PATH=/usr/local/bin:/bin:/usr/bin:
HOME=/usr/neil
LS_OPTIONS=-N --color=tty -T 0
SHELL=/bin/bash
OSTYPE=Linux
...
Как это работает
Для вывода всего окружения программа в цикле обращается к переменной environ — массиву нуль-терминированных строк.
Время и дата.
Программе часто полезно иметь возможность определить время и дату. Возможно, она хочет зарегистрировать длительность собственного выполнения или ей нужно изменять свое поведение в определенные моменты времени. Например, игра может отказываться запускаться в рабочие часы или программа резервного копирования по расписанию хочет дождаться ранних часов, прежде чем начать резервное копирование в автоматическом режиме.
Примечание. Во всех системах UNIX применяется одна и та же точка отсчета времени и дат: полночь по Гринвичу (GMT) на 1 января 1970 г. Это "начало эпохи UNIX", и ОС Linux — не исключение. Время в системе Linux измеряется в секундах, начиная с этого момента времени. Такой способ обработки аналогичен принятому в системе MS-DOS за исключением того, что эпоха MS-DOS началась в 1980 г. В других системах применяют точки отсчета иных эпох.Время задается с помощью типа time_t. Это целочисленный тип, достаточный для хранения дат и времени в секундах. В Linux-подобных системах это тип long integer (длинное целое), определенный вместе с функциями, предназначенными для обработки значений времени, в заголовочном файле time.h.
Примечание. Не думайте, что для хранения времени достаточно 32 битов. В системах UNIX и Linux, использующих 32-разрядный тип time_t, временное значение "будет превышено" в 2038 г. Мы надеемся, что к тому времени системы перейдут на тип time_t, содержащий более 32 битов. Недавнее широкое внедрение 64-разрядных процессоров превращает это практически в неизбежность.#include <time.h>
time_t time(time_t *tloc);
Вы можете найти низкоуровневое значение времени, вызвав функцию time, которая вернет количество секунд с начала эпохи (упражнение 4.6). Она также запишет возвращаемое значение по адресу памяти, на который указывает параметр tloc, если он — непустой указатель.
Упражнение 4. Функция time.
Далее для демонстрации функции time приведена простая программа envtime.c.
#include <time.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main() {
int i;
time_t the_time;
for (i = 1; i <= 10; i++) {
the_time = time((time_t *)0);
printf("The time is %ld\n", the_time);
sleep(2);
}
exit(0);
}
Когда вы запустите программу, она будет выводить низкоуровневое значение времени каждые 2 секунды в течение 20 секунд.
$ ./anytime
The time is 1179643852
The time is 1179643854
The time is 1179643856
The time is 1179643858
The time is 1179643860
The time is 1179643862
The time is 1179643864
The time is 1179643866
The time is 1179643868
The time is 1179643870
Как это работает
Программа вызывает функцию time с пустым указателем в качестве аргумента, которая возвращает время и дату как количество секунд. Программа засыпает на две секунды и повторяет вызов time в целом 10 раз.
Использование времени и даты в виде количества секунд, прошедших с начала 1970 г., может быть полезно для измерения длительности чего-либо. Вы сможете сосчитать простую разность значений, полученных из двух вызовов функции time. Однако комитет, разрабатывавший стандарт языка ISO/ANSI С, в своих решениях не указал, что тип time_t будет применяться для определения произвольных интервалов времени в секундах, поэтому была придумана функция difftime, которая вычисляет разность в секундах между двумя значениями типа time_t и возвращает ее как величину типа double:
#include <time.h>
double difftime(time_t time1, time_t time2);
Функция difftime вычисляет разницу между двумя временными значениями и возвращает величину, эквивалентную выражению время1–время2, как число с плавающей точкой. В ОС Linux значение, возвращаемое функцией time, — это количество секунд, которое может обрабатываться, но для максимальной переносимости следует применять функцию difftime.
Для представления времени и даты в более осмысленном (с человеческой точки зрения) виде мы должны преобразовать значение времени в понятные время и дату. Для этого существуют стандартные функции.
Функция gmtime подразделяет низкоуровневое значение времени на структуру, содержащую более привычные поля:
#include <time.h>
struct tm *gmtime(const time_t timeval)
В структуре tm, как минимум, определены элементы, перечисленные в табл. 4.2.
Таблица 4.2
Элемент tm | Описание |
---|---|
int tm_sec | Секунды, 0–61 |
int tm_min | Минуты, 0–59 |
int tm_hour | Часы, 0–23 |
int tm_mday | День в месяце, 1–31 |
int tm_mon | Месяц в году, 0–11 (January (январь) соответствует 0) |
int tm_year | Годы, начиная с 1900 г. |
int tm_wday | День недели, 0–6 (Sunday (воскресенье) соответствует 0) |
int tm_yday | День в году, 0–365 |
int tm_isdst | Действующее летнее время |
Диапазон элемента tm_sec допускает появление время от времени корректировочной секунды или удвоенной корректировочной секунды.
Выполните упражнение 4.7.
Упражнение 4.7. Функция gmtime.
Далее приведена программа gmtime.с, выводящая текущие время и дату с помощью структуры tm и функции gmtime.
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
int main() {
struct tm *tm_ptr;
time_t the_time;
(void)time(&the_time);
tm_ptr = gmtime(&the_time);
printf("Raw time is %ld\n", the_time);
printf("gmtime gives:\n");
printf("date: %02d/%02d/%02d\n",
tm_ptr->tm_year, tm_ptr->tm_mon+1, tm_ptr->tm_mday);
printf("time: %02d:%02d:%02d\n",
tm_ptr->tm_hour, tm_ptr->tm_min, tm_ptr->tm_sec);
exit(0);
}
Выполнив эту программу, вы получите хорошее соответствие текущим времени и дате:
$ ./gmtime; date
Raw time is 1179644196
gmtime gives:
date: 107/05/20
time: 06:56:36
Sun May 20 07:56:37 BST 2007
Как это работает
Программа вызывает функцию time для получения машинного представления значения времени и затем вызывает функцию gmtime для преобразования его в структуру с удобными для восприятия значениями времени и даты. Она выводит на экран полученные значения с помощью функции printf. Строго говоря, выводить необработанное значение времени таким способом не следует, потому что наличие типа длинного целого не гарантировано во всех системах. Если сразу же после вызова функции gmtime выполнить команду date, можно сравнить оба вывода.
Но здесь у вас возникнет небольшая проблема. Если вы запустите эту программу в часовом поясе, отличном от Greenwich Mean Time (время по Гринвичу) или у вас действует летнее время, как у нас, вы заметите, что время (и, возможно, дата) неправильное. Все дело в том, что функция gmtime возвращает время по Гринвичу (теперь называемое Universal Coordinated Time (всеобщее скоординированное время) или UTC). Системы Linux и UNIX поступают так для синхронизации всех программ и систем в мире. Файлы, созданные в один и тот же момент в разных часовых поясах, будут отображаться с одинаковым временем создания. Для того чтобы посмотреть местное время, следует применять функцию localtime.
#include <time.h>
struct tm *localtime(const time_t *timeval);
Функция localtime идентична функции gmtime за исключением того, что она возвращает структуру, содержащую значения с поправками на местный часовой пояс и действующее летнее время. Если вы выполните программу gmtime, но замените все вызовы функции gmtime на вызовы localtime, в отчете программы вы увидите правильные время и дату.
Для преобразования разделенной на элементы структуры tm в общее внутреннее значение времени можно применить функцию mktime:
#include <time.h>
time_t mktime(struct tm *timeptr);
Функция mktime вернет -1, если структура не может быть представлена как значение типа time_t.
Для вывода программой date "дружественных" (в противоположность машинному) времени и даты можно воспользоваться функциями asctime и ctime:
#include <time.h>
char *asctime(const struct tm *timeptr);
char *ctime(const time_t *timeval);
Функция asctime возвращает строку, представляющую время и дату, заданные tm-структурой timeptr. У возвращаемой строки формат, подобный приведенному далее:
Sun Jun 9 12:34:56 2007\n\0
У нее всегда фиксированный формат длиной 26 символов. Функция ctime эквивалентна следующему вызову:
asctime(localtime(timeval))
Она принимает необработанное машинное значение времени и преобразует его в местное время.
А теперь выполните упражнение 4.8.
Упражнение 4.8. Функция ctime.
В этом примере благодаря приведенному далее программному коду вы увидите функцию ctime в действии.
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
int main() {
time_t timeval;
(void)time(&timeval);
printf ("The date is: %s", ctime(&timeval));
exit(0);
}
Откомпилируйте и затем запустите на выполнение ctime.c, и вы увидите нечто похожее на приведенные далее строки:
$ ./ctime
The date is: Sat Jun 9 08:02:08 2007.
Как это работает
Программа ctime.c вызывает функцию time для получения машинного значения времени и дает возможность функции ctime выполнить всю тяжелую работу по преобразованию этого значения в удобочитаемую строку, которую потом и выводит на экран.
Для лучшего управления точным форматированием времени и даты ОС Linux и современные UNIX-подобные системы предоставляют функцию strftime. Она довольно похожа на функцию sprintf для дат и времени и действует аналогичным образом:
#include <time.h>
size_t strftime(char *s, size_t maxsize, const char *format, struct tm *timeptr);
Функция strftime форматирует время и дату, представленные в структуре tm, на которую указывает параметр, timeptr, и помещает результат в строку s. Эта строка задается длиной maxsize (как минимум) символов. Строка format применяется для управления символами, записываемыми в строку. Как и в функции printf, она содержит обычные символы, которые будут переданы в строку, и спецификаторы преобразований для форматирования элементов времени и даты. В табл. 4.3 перечислены используемые спецификаторы преобразований.
Таблица 4.3
Спецификатор преобразования | Описание |
---|---|
%a | Сокращенное название дня недели |
%А | Полное название дня недели |
%b | Сокращенное название месяца |
%B | Полное название месяца |
%c | Дата и время |
%d | День месяца, 01–31 |
%H | Час, 00–23 |
%I | Час по 12-часовой шкале, 01–12 |
%j | День в году, 001–366 |
%m | Номер месяца в году, 01–12 |
%M | Минуты, 00–59 |
%p | a.m. (до полудня) или p.m. (после полудня) |
%S | Секунды, 00–59 |
%u | Номер дня недели, 1–7 (1 соответствует понедельнику) |
%U | Номер недели в году, 01–53 (воскресенье — первый день недели) |
%V | Номер недели в году, 01–53 (понедельник — первый день недели) |
%w | Номер дня недели, 0–6 (0 соответствует воскресенью) |
%x | Дата в региональном формате |
%X | Время в региональном формате |
%y | Номер года, меньший 1900 |
%Y | Год |
%Z | Название часового пояса |
%% | Символ % |
Таким образом, обычная дата, такая же, как полученная из программы date, соответствует следующей строке формата функции strftime:
"%a %b %d %Н: %М: %S %Y"
Для облегчения чтения дат можно использовать функцию strptime, принимающую строку с датой и временем и формирующую структуру tm с теми же датой и временем:
#include <time.h>
char *strptime(const char *buf, const char *format, struct tm *timeptr);
Строка format конструируется точно так же, как одноименная строка функции strftime. Функций strptime действует аналогично функции sscanf: она сканирует строку в поиске опознаваемых полей и записывает их в переменные. В данном случае это элементы структуры tm, которая заполняется в соответствии со строкой format. Однако спецификаторы преобразований для strptime немного мягче спецификаторов функции strftime. Так, в функции strptime разрешены как сокращенные, так и полные названия дней и месяцев. Любое из этих представлений будет соответствовать спецификатору %a функции strptime. Кроме того, в то время как функция strftime для представления чисел, меньших 10, всегда применяет ведущие нули, strptime считает их необязательными.
Функция strptime возвращает указатель на символ, следующий за последним, обработанным в процессе преобразования. Если она встречает символы, которые не могут быть преобразованы, в этой точке преобразование просто прекращается. Для того чтобы убедиться в том, что в структуру tm записаны значимые данные, вызывающей программе следует проверять, достаточно ли символов строки принято и обработано.
Рассмотрим работу функций на примере (упражнение 4.9).
Упражнение 4.9. Функции strftime и strptime.
Обратите внимание на выбор спецификаторов преобразований, использованных в следующей программе:
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
int main() {
struct tm *tm_ptr, timestruct;
time_t the_time;
char buf[256];
char *result;
(void)time(&the_time);
tm_ptr = localtime(&the_time);
strftime(buf, 256, "%A %d %B, %I:%S %p", tm_ptr);
printf("strftime gives: %s\n", buf);
strcpy(buf, "Thu 26 July 2007, 17:53 will do fine");
printf("calling strptime with: %s\n", buf);
tm_ptr = ×truct;
result = strptime(buf, "%a %d %b %Y, %R", tm_ptr);
printf("strptime consumed up to: %s\n", result);
printf("strptime gives:\n");
printf ("date: %02d/%02d/%02d\n",
tm_ptr->tm_year % 100, tm_ptr->tm_mon+1, tm_ptr->tm_mday);
printf("time: %02d:%02d\n",
tm_ptr->tm_hour, tm->ptr->tm_min);
exit(0);
}
Когда вы откомпилируете и выполните программу strftime.c, то получите следующий результат:
$ ./strftime
strftime gives: Saturday 09 June, 08:16 AM
calling strptime with: Thu 26 July 2007, 17:53 will do fine
strptime concurred up to: will do fine
strptime gives:
date: 07/07/26
time: 17:53
Как это работает
Программа strftime получает текущее местное время с помощью вызовов функций time и localtime. Затем она преобразует его в удобочитаемую форму с помощью функции strftime с подходящим аргументом форматирования. Для демонстрации применения функции strptime программа задает строку, содержащую дату и время, затем вызывает strptime для извлечения необработанных значений времени и даты и выводит их на экран. Спецификатор преобразования %R функции strptime — это сокращенное обозначение комбинации %Н:%M.
Важно отметить, что для успешного просмотра даты функции strptime необходима точная строка формата. Обычно она не может точно обработать даты, считываемые из строк, введенных пользователями, до тех пор, пока не будет строго выверен формат.
Возможно, при компиляции программы strftime.c вы получите предупреждение компилятора. Причина в том, что по умолчанию в библиотеке GNU не объявлена функция strptime. Для устранения проблемы следует явно запросить средства стандарта X/Open, добавив следующую строку перед заголовочным файлом time.h:
#define _XOPEN_SOURCE
Временные файлы.
Зачастую программы нуждаются в возможности использования временного хранилища в виде файлов. В них могут храниться промежуточные результаты вычислений, или резервные копии файлов, сделанные перед выполнением критических операций. Например, приложение для работы с базой данных может применять временный файл при удалении записей. В файле собираются элементы базы данных, нуждающиеся в сохранении, и затем в конце процесса временный файл становится новой базой данных, а исходная база данных удаляется.
У столь популярных временных файлов есть скрытый недостаток. Вы должны следить за тем, чтобы приложения выбирали уникальное имя для временного файла. Если это условие не соблюдается, могут возникнуть проблемы. Поскольку ОС Linux — многозадачная система, другая программа может выбрать то же самое имя, и обе будут мешать друг другу.
Уникальное имя файла генерируется с помощью функции tmpnam:
#include <stdio.h>
char *tmpnam(char *s);
Функция tmpnam возвращает допустимое имя файла, не совпадающее с именем любого из существующих файлов. Если строка s не равна NULL, в нее будет записано имя файла. Последующие вызовы функции tmpnam будут перезаписывать статическую память, используемую для возвращаемых значений, поэтому важно применять строковый параметр, если функция должна вызываться многократно. Длина строки полагается равной, как минимум, L_tmpnam (обычно около 20) символам. Функция tmpnam может вызываться в одной программе до TMP_MAX (не менее нескольких тысяч) раз, и каждый раз она будет генерировать уникальное имя файла.
Если, временный файл предполагается использовать немедленно, вы можете одновременно назвать его и открыть с помощью функции tmpfile. Это важно, т.к. другая программа может создать файл с именем таким же, как значение, возвращенное функцией tmpnam. Функция tmpfile устраняет эту проблему полностью.
#include <stdio.h>
FILE* tmpfile(void);
Функция tmpfile возвращает указатель потока, ссылающийся на уникальный временный файл. Файл открыт для чтения и записи (с помощью fopen с флагом w+) и будет автоматически удален, когда закроются все ссылки на него.
В случае возникновения ошибки tmpfile вернет указатель NULL и задаст значение переменной errno.
Давайте посмотрим эти две функции в действии:
#include <stdio.h>
#include <stdlib.h>
int main() {
char tmpname[L_tmpnam];
char* filename;
FILE *tmpfp;
filename = tmpnam(tmpname);
printf("Temporary file name is: %s\n", filename);
tmpfp = tmpfile();
if (tmpfp) printf("Opened a temporary file OK\n");
else perror("tmpfile");
exit(0);
}
Когда вы откомпилируете и выполните программу tmpnam.с, то увидите уникальное имя файла, сгенерированное функцией tmpnam:
$ ./tmpnam
Temporary file name is: /tmp/file2S64zc
Opened a temporary file OK
Как это работает
Программа вызывает функцию tmpnam для генерации уникального имени временного файла. Если вы хотите его использовать, нужно быстро его открыть, чтобы минимизировать риск того, что другая программа откроет файл с тем же именем. Вызов функции tmpfile одновременно создает и открывает временный файл, тем самым устраняя этот риск. При компиляции программы, использующей функцию tmpnam, компилятор GNU С может вывести предупреждение о применении этой функции.
В некоторых версиях UNIX предлагается другой способ генерации имен временных файлов — с помощью функций mktemp и mkstemp. Они поддерживаются и ОС Linux и аналогичны функции tmpnam за исключением того, что вы должны задать шаблон имени временного файла, который предоставляет некоторые дополнительные возможности управления местом хранения и именем файла.
#include <stdlib.h>
char *mktemp(char *template);
int mkstemp(char *template);
Функция mktemp создает уникальное имя файла на основе заданного шаблона template. Аргумент template должен быть строкой с шестью завершающими символами Х. mktemp заменяет эти символы Х уникальной комбинацией символов, допустимых в именах файлов. Она возвращает указатель на сгенерированную строку или NULL при невозможности сформировать уникальное имя.
Функция mkstemp аналогична функции tmpfile: она создает и открывает временный файл. Имя файла генерируется так же, как в функции mktemp, но возвращенный результат — открытый низкоуровневый дескриптор файла.
Примечание. В ваших собственных программах следует всегда применять функции "создать и открыть" tmpfile и mkstemp вместо функций tmpnam и mktemp.Информация о пользователе.
Все программы в ОС Linux за исключением программы init, запускаются другими программами или пользователями. В главе 11 вы узнаете больше о взаимодействии выполняющихся программ или процессов. Пользователи чаще всего запускают программы из командной оболочки, реагирующей на их команды. Вы видели, что в программе можно определить собственное окружение, просматривая переменные окружения и читая системные часы. Программа может также выяснить данные о пользователе, применяющем ее.
Когда пользователь регистрируется в системе Linux, у него или у нее есть имя пользователя и пароль. После того как эти данные проверены, пользователю предоставляется командная оболочка. В системе у пользователя также есть уникальный идентификатор пользователя, называемый UID (user identifier). Каждая программа, выполняемая Linux, запускается от имени пользователя и имеет связанный с ней UID.
Вы можете настроить выполнение программ так, как будто они запускаются другим пользователем. Если у программы есть свой набор прав доступа для UID, она будет выполняться от имени владельца исполняемого файла. Когда выполнена команда su, программа действует так, как будто она запущена суперпользователем. Затем она проверяет право доступа пользователя, изменяет UID на идентификатор назначенной учетной записи и запускает регистрационную командную оболочку данной учетной записи. Этот прием позволяет программе выполняться от имени другого пользователя и часто используется системными администраторами для выполнения задач технического обслуживания системы.
Поскольку UID — это ключевой параметр для идентификации пользователя, начнем с него.
У UID есть свои тип uid_t, определенный в файле sys/types.h. Обычно это короткое целое (small integer). Одни идентификаторы пользователя заранее определены системой, другие создаются системным администратором, когда новые пользователи становятся известны системе. Как правило, идентификаторы пользователей имеют значения, большие 100.
#include <sys/types.h>
#include <unistd.h>
uid_t getuid (void);
char *getlogin(void);
Функция getuid возвращает UID, с которым связана программа. Обычно это UID пользователя, запустившего программу.
Функция getlogin возвращает регистрационное имя, ассоциированное с текущим пользователем.
Системный файл /etc/passwd содержит базу данных, имеющую дело с учетными записями пользователей. Он состоит из строк по одной на каждого пользователя, в каждую строку включены имя пользователя, зашифрованный пароль, идентификатор пользователя (UID), идентификатор группы (GID), полное имя, исходный каталог и командная оболочка, запускаемая по умолчанию. Далее приведен пример такой строки:
neil:zBqxfqedfpk:500:100:Neil Matthew:/home/neil:/bin/bash
Если вы пишете программу, которая определяет UID пользователя, запустившего ее, то можете расширить ее возможности и заглянуть в файл passwd для выяснения регистрационного имени пользователя и его полного имени. Мы не рекомендуем делать это, потому что современные UNIX-подобные системы уходят от применения файлов учетных записей пользователей для повышения безопасности системы. Многие системы, включая Linux, имеют возможность использовать файлы теневых паролей (shadow password), совсем не содержащие пригодной информации о зашифрованных паролях (она часто хранится в файле /etc/shadow, которые обычные пользователи не могут читать). По этой причине определен ряд функций для предоставления эффективного программного интерфейса, позволяющего получать эту пользовательскую информацию.
#include <sys/types.h>
#include <pwd.h>
struct passwd *getpwuid(uid_t uid);
struct passwd *getpwnam(const char *name);
Структура базы данных учетных записей пользователей passwd определена в файле pwd.h и включает элементы, перечисленные в табл. 4.4.
Таблица 4.4
Элемент passwd | Описание |
---|---|
char *pw_name | Регистрационное имя пользователя |
uid_t pw_uid | Номер UID |
gid_t pw_gid | Номер GID |
char *pw_dir | Исходный каталог пользователя |
char *pw_gecos | Полное имя пользователя |
char *pw_shell | Командная оболочка пользователя, запускаемая по умолчанию |
В некоторых системах UNIX может использоваться другое имя для поля с полным именем пользователя: в одних системах это pw_gecos, как в ОС Linux, в других — pw_comment. Это означает, что мы не можем рекомендовать его использование. Обе функции (и getpwuid, и getpwnam) возвращают указатель на структуру passwd, соответствующую пользователю. Пользователь идентифицируется по UID в функции getpwuid и по регистрационному имени в функции getpwnam. В случае ошибки обе функции вернут пустой указатель и установят переменную errno.
Выполните упражнение 4.11.
Упражнение 4.11. Информации о пользователе.
В этом упражнении показана программа user.c, извлекающая некоторую информацию о пользователе из базы данных учетных записей.
#include <sys/types.h>
#include <pwd.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main() {
uid_t uid;
gid_t gid;
struct passwd *pw;
uid = getuid();
gid = getgid();
printf("User is %s\n", getlogin());
printf("User IDs: uid=%d, gid=%d\n", uid, gid);
pw = getpwuid(uid);
printf(
"UID passwd entry:\n name=%s, uid=%d, gid=%d, home=%s, shell=%s\n",
pw->pw_name, pw->pw_uid, pw->pw_gid, pw->pw_dir, pw->pw_shell);
pw = getpwnam("root");
printf("root passwd entry:\n");
printf("name=%s, uid=%d, gid=%d, home=%s, shell=%s\n",
pw->pw_name, pw->pw_uid, pw->pw_gid, pw->pw_dir, pw->pw_shell);
exit(0);
}
Программа предоставит следующий вывод, который может слегка отличаться в разных версиях Linux и UNIX:
$ ./user
User is neil
User IDs: uid=1000, gid=100
UID passwd entry:
name=neil, uid=1000, gid=100, home=/home/neil, shell=/bin/bash
root passwd entry:
name=root, uid=0, gid=0, home=/root, shell=/bin/bash
Как это работает
Эта программа вызывает функцию getuid для получения UID текущего пользователя, Этот UID применяется в функции getpwuid для получения подробной информации из файла учетных записей пользователей. В качестве альтернативы мы показываем, как для извлечения информации о пользователе можно задать в функции getpwnam имя пользователя root.
Примечание.
В исходном коде Linux вы сможете найти в команде id еще один пример-использования функции getuid.
Для просмотра всех данных файла учетных записей пользователей можно воспользоваться функцией getpwent. Она последовательно выбирает строки файла.
#include <pwd.h>
#include <sys/types.h>
void endpwent(void);
struct passwd *getpwent(void);
void setpwent(void);
Функция getpwent возвращает поочередно информацию о каждом пользователе. Когда не остается ни одного, она возвращает пустой указатель. Для прекращения обработки файла, когда просмотрено достаточно элементов, вы можете применить функцию endpwent. Функция setpwent переустанавливает позицию указателя в файле учетных записей пользователей для начала нового просмотра при следующем вызове функции getpwent. Эти функции действуют так же, как функции просмотра каталога opendir, readdir и closedir, обсуждавшиеся в главе 3.
Идентификаторы пользователя и группы (эффективный или действующий и реальный) можно получить с помощью других реже используемых функций:
#include <sys/types.h>
#include <unistd.h>
uid_t geteuid(void);
gid_t getgid(void);
gid_t getegid(void);
int setuid(uid_t uid);
int setgid(gid_t gid);
Подробную информацию об идентификаторах группы и эффективных идентификаторах пользователей следует искать на страницах интерактивного справочного руководства системы, хотя, быть может, вы решите, что вам вообще не следует манипулировать ими.
Примечание. Только суперпользователь может вызывать функции setuid и setgid.Информация о компьютере.
Программа может установить некоторые подробные сведения о компьютере, на котором выполняется, так же, как она определяет информацию о пользователе. Подобную информацию предоставляет команда uname, в программе на языке С можно использовать для получения этих данных одноименный системный вызов — прочтите о нем в разделе системных вызовов интерактивного справочного руководства (раздел 2) с помощью команды man 2 uname.
Сведения о рабочем компьютере могут оказаться полезными в ряде ситуаций. Вы можете захотеть настроить поведение программы в зависимости от сетевого имени машины, на которой она выполняется, скажем, на студенческом компьютере или машине администратора. Для соблюдения лицензионных соглашений вам может потребоваться ограничить выполнение программы одной машиной. Все это означает, что вам нужен способ определения компьютера, на котором выполняется программа.
Если в системе установлены сетевые компоненты, вы очень легко можете получить сетевое имя компьютера с помощью функции gethostname:
#include <unistd.h>
int gethostname(char *name, size_t namelen);
Эта функция записывает сетевое имя машины в строку name. Предполагается, что длина строки, как минимум, namelen символов. Функция gethostname возвращает 0 в случае успешного завершения и -1 в противном случае.
Более подробную информацию о рабочем компьютере можно получить с помощью системного вызова uname.
#include <sys/utsname.h>
int uname(struct utsname *name);
Функция uname записывает информацию о компьютере в структуру, на которую указывает параметр name. Структура типа utsname, определенная в файле sys/utsname.h, обязательно должна включать элементы, перечисленные в табл. 4.5.
Таблица 4.5
Элемент структуры utsname | Описание |
---|---|
char sysname[] | Имя операционной системы |
char nodename[] | Имя компьютера |
char release[] | Номер выпуска (релиза) системы |
char version[] | Номер версии системы |
char machine[] | Аппаратный тип |
В случае успешного завершения функция uname возвращает неотрицательное целое и в противном случае с установленной переменной errno для обозначения любой возникшей ошибки.
Выполните упражнение 4.12.
Упражнение 4.12. Информации о компьютере.
Далее приведена программа hostget.c, извлекающая некоторые сведения о рабочем компьютере.
#include <sys/utsname.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main() {
char computer[256];
struct utsname uts;
if (gethostname(computer, 255) != 0 || uname(&uts) < 0) {
fprintf(stderr, "Could not get host information\n");
exit(1);
}
printf("Computer host name is %s\n", computer);
printf("System is %s on %s hardware\n", uts.sysname, uts.machine);
printf("Nodename is %s\n", uts.nodename);
printf("Version is %s, %s\n", uts.release, uts.version);
exit(0);
}
Она отобразит следующие зависящие от ОС Linux данные. Если ваша машина включена в сеть, то вы увидите расширенное имя компьютера, включающее обозначение сети:
$ ./hostget
Computer host name is suse103
System is Linux on i686 hardware
Nodename is suse103
Version is 2.6.20.2-2-default, #1 SMP Fri Mar 9 21:54:10 UTC 2007
Как это работает
Эта программа вызывает функцию gethostname для получения имени рабочего компьютера. В приведенном примере это имя — suse103. Более подробную информацию об этом компьютере на базе Intel Pentium 4 с ОС Linux возвращает системный вызов uname. Учтите, что формат возвращаемых строк зависит от реализации, например, строка с версией системы содержит дату компиляции ядра.
Примечание. Другой пример применения функции uname вы можете найти в исходном коде Linux для команды uname, которая использует эту функцию.Уникальный идентификатор каждого рабочего компьютера можно получить с помощью функции gethostid.
#include <unistd.h>
long gethostid(void);
Функция gethostid предназначена для возврата уникального значения, характеризующего рабочий компьютер. Менеджеры, следящие за соблюдением лицензионных соглашений, применяют ее для того, чтобы обеспечить функционирование программного обеспечения только на машинах с действующими лицензиями. На рабочих станциях Sun она возвращает номер, установленный в постоянной памяти во время изготовления компьютера и, таким образом, уникальный для системного оборудования. Другие системы, например Linux, возвращают значение на базе интернет-адреса машины, обычно не слишком безопасного для проверки лицензионных прав.
Ведение системных журналов.
Многие приложения нуждаются в регистрации своей деятельности. Системные программы очень часто выводят сообщения на консоль или записывают их в регистрационный системный журнал. В этих сообщениях могут регистрироваться ошибки, предупреждения или более общая информация о состоянии системы. Например, программа su может зафиксировать тот факт, что пользователь пытался получить привилегии супер пользователя и потерпел неудачу.
Очень часто зарегистрированные сообщения записываются в системные файлы в каталоге, предоставляемом для этой цели. Это может быть каталог /usr/admor/var/log. При типичной установке ОС Linux все системные сообщения содержатся в файле /var/log/messages, в файл /var/log/mail включены другие регистрируемые сообщения от почтовой системы, а в файле /var/log/debug могут храниться отладочные сообщения. Проверить конфигурацию своей системы можно в файле /etc/syslog.conf или /etc/syslog-ng/syslog-ng.conf в зависимости от версии Linux.
Далее приведены некоторые примеры зарегистрированных сообщений.
Mar 2 6 18:25:51 suse103 ifstatus: eth0 device: Advanced Micro Devices [AMD] 79c970 [PCnet32 LANCE] (rev 10)
Mar 26 18:25:51 suse103 ifstatus: eth0 configuration: eth-id-00:0c:29:0e:91:72
...
May 20 06:56:56 suse103 SuSEfirewall2: Setting up rules from /etc/sysconfig/SuSEfirewall2
...
May 20 06:56:57 suse103 SuSEfirewall2: batch committing
...
May 20 06:56:57 suse103 SuSEfirewall2: Firewall rules successfully set
...
Jun 9 09:11:14 suse103 su: (to root) neil on /dev/pts/18 09:50:35
В этом выводе показаны виды регистрируемых сообщений. Несколько первых отправлены непосредственно ядром Linux во время его загрузки и обнаружения установленного оборудования. Брандмауэр сообщает о своей перенастройке. И наконец, программа su извещает о том, что доступ с учетной записью суперпользователя получен пользователем neil.
Примечание. Для просмотра регистрируемых сообщений вы можете запросить права суперпользователя.Некоторые системы UNIX не предоставляют файлов с удобными для чтения сообщениями, но они снабжают администраторов средствами для чтения базы данных системных событий. См. подробности в системной документации.
Несмотря на то, что формат и хранение системных сообщений могут отличаться, метод формирования сообщений стандартный. В спецификации UNIX представлен доступный всем программам интерфейс формирования регистрируемых сообщений с помощью функции syslog.
#include <syslog.h>
void syslog(int priority, const char *message, arguments...);
Функция syslog посылает регистрируемое сообщение средству ведения системного журнала (logging facility). У каждого сообщения есть аргумент priority, полученный поразрядной операцией OR из степени важности сообщения (severity level) и типа программы, формирующей сообщение (facility value). Степень важности определяет необходимые действия, а тип программы фиксирует инициатора сообщения.
Типы программ (из файла syslog.h) включают константу LOG_USER, применяемую для обозначения сообщения, пришедшего из приложения пользователя (по умолчанию), и константы LOG_LOCAL0, LOG_LOCAL1, ..., LOG_LOCAL7, зарезервированные для локального администратора.
В табл. 4.6 перечислены степени важности сообщений в порядке убывания приоритета.
Таблица 4.6
Приоритет | Описание |
---|---|
LOG_EMERG | Кризисная ситуация |
LOG_ALERT | Проблема с высоким приоритетом, например, повреждение базы данных |
LOG_CRIT | Критическая ошибка, например, повреждение оборудования |
LOG_ERR | Ошибки |
LOG_WARNING | Предупреждение |
LOG_NOTICE | Особые обстоятельства, требующие повышенного внимания |
LOG_INFO | Информационные сообщения |
LOG_DEBUG | Отладочные сообщения |
В зависимости от настройки системы сообщения типа LOG_EMER могут пересылаться всем пользователям системы, сообщения LOG_ALERT могут отправляться по электронной почте администратору, сообщения LOG_DEBUG могут игнорироваться, а сообщения других типов могут записываться в файл. Вы можете написать программу, которая применяет средство регистрации сообщений, просто вызывая функцию syslog, когда вы хотите создать регистрируемое сообщение.
У сообщения, создаваемого syslog, есть заголовок и тело сообщения. Заголовок создается из индикатора типа программы, формирующей сообщение, и даты и времени. Тело сообщения создается из параметра message, передаваемого функции syslog, который действует как строка format функции printf. Остальные аргументы syslog используются в соответствии со спецификаторами преобразований в стиле функции printf, заданными в строке message. Дополнительно может применяться спецификатор %m для включения строки сообщения об ошибке, ассоциированной с текущим значением переменной errno. Эта возможность может оказаться полезной для регистрации сообщений об ошибках.
Выполните упражнение 4.13.
Упражнение 4.13. Применение функции syslog.
В этой программе осуществляется попытка открыть несуществующий файл.
#include <syslog.h>
#include <stdio.h>
#include <stdlib.h>
int main() {
FILE *f;
f = fopen("not_here", "r");
if (!f) syslog(LOG_ERR|LOG_USER, "oops - %m\n");
exit(0);
}
Когда вы откомпилируете и выполните программу syslog.с, то не увидите никакого вывода, но в конце файла /var/log/messages теперь содержится следующая строка:
Jun 9 09:24:50 suse103 syslog: oops — No such file or directory
Как это работает
В данной программе вы пытаетесь открыть файл, которого нет. Когда попытка заканчивается неудачно, вы вызываете функцию syslog для записи случившегося в системный журнал.
Обратите внимание на то, что регистрируемое сообщение не указывает, какая программа вызвала средство регистрации; оно просто констатирует тот факт, что была вызвана функция syslog с сообщением. Спецификатор преобразования %m был заменен описанием ошибки, в данном случае сообщающим об отсутствии файла. Это гораздо полезнее, чем простой отчет, содержащий внутренний номер ошибки.
В файле syslog.h определены и другие функции, применяемые для изменения поведения средств ведения системных журналов.
К ним относятся следующие функции:
#include <syslog.h> void closelog(void);
void openlog(const char *ident, int logopt, int facility);
int setlogmask(int maskpri);
Вы можете изменить способ представления ваших регистрируемых сообщений, вызвав функцию openlog. Это позволит задать строку ident, которая будет добавляться к вашим регистрируемым сообщениям. Вы можете применять ее для индикации программы, создавшей сообщение. Параметр facility записывает текущий принятый по умолчанию тип программы, формирующей сообщение, который будет использоваться в последующих вызовах syslog. По умолчанию устанавливается значение LOG_USER. Параметр logopt настраивает поведение будущих вызовов функции syslog. Он представляет собой результат поразрядной операции OR нулевого или большего числа параметров, приведенных в табл. 4.7.
Таблица 4.7
Параметр logopt | Описание |
---|---|
LOG_PID | Включает в сообщения идентификатор процесса, уникальный номер, выделяемый системой каждому процессу |
LOG_CONS | Посылает сообщения на консоль, если они не могут быть записаны |
LOG_ODELAY | Открывает средство регистрации сообщений при первом вызове функции syslog |
LOG_NDELAY | Открывает средство регистрации сообщений немедленно, не дожидаясь первого регистрируемого сообщения |
Функция openlog выделит и откроет дескриптор файла, который будет применяться для записи в программе ведения системного журнала. Вы сможете закрыть его, вызвав функцию closelog. Имейте в виду, что вам не нужно вызывать функцию openlog перед вызовом syslog, потому что последняя при необходимости самостоятельно откроет средство ведения системного журнала.
Вы можете управлять приоритетом регистрируемых вами сообщений с помощью установки маски регистрации, используя функцию setlogmask. Все будущие вызовы syslog с разными приоритетами, не заданными в маске регистрации, будут отброшены, таким образом, вы сможете, например, использовать маску для отключения сообщений типа LOG_DEBUG без необходимости изменять тело программы.
Вы можете создать маску для регистрируемых сообщений, используя значение LOG_MASK(priority), создающее маску только для одного приоритета, или значение LOG_UPTO(priority), создающее маску для всех приоритетов вплоть до заданного.
Выполните упражнение 4.14.
Упражнение 4.14. Маска регистрации (logmask).
В этом примере вы увидите logmask в действии.
#include <syslog.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main() {
int logmask;
openlog("logmask", LOG_PID|LOG_CONS, LOG_USER);
syslog(LOG_INFO, "informative message, pid = %d", getpid());
syslog(LOG_DEBUG, "debug message, should appear");
logmask = setlogmask(LOG_UPTO(LOG_NOTICE));
syslog(LOG_DEBUG, "debug message, should not appear");
exit(0);
}
Программа logmask.c ничего не выводит, но в типичной системе Linux вы увидите в файле /var/log/messages, ближе к концу, следующую строку:
Jun 9 09:28:52 suse103 logmask[19339] : informative message, pid = 19339
Файл, настроенный на получение регистрируемых сообщений об отладке (в зависимости от настройки регистрации, это чаще всего файл /var/log/debug или иногда файл /var/log/messages), должен содержать следующую строку:
Jun 9 09:28:52 susel03 logmask[19339]: debug message, should appear
Как это работает
Программа инициализирует средство ведения системного журнала, названное logmask, и запрашивает включение идентификатора процесса в регистрируемые сообщения. Информирующее сообщение записывается в файл /var/log/messages, а отладочное сообщение — в файл /var/log/debug. Второе отладочное сообщение не появляется, потому что вы вызвали функцию setlogmask с игнорированием всех сообщений с приоритетом ниже LOG_NOTICE. (Учтите, что этот метод не работает в ранних вариантах ядра Linux.)
Если в установленную у вас систему не включена регистрация отладочных сообщений или она настроена иначе, отладочные сообщения могут не появляться. Для разблокирования всех отладочных сообщений и для получения подробностей настройки см. системную документацию, посвященную функции syslog или syslog-ng.
Программа logmask.c также использует функцию getpid, которая, наряду с тесно связанной с ней функцией getppid, определена следующим образом:
#include <sys/types.h>
#include <unistd.h>
pid_t getpid(void);pid_t getppid(void);
Функции возвращают идентификаторы вызвавшего и родительского процессов. Дополнительную информацию об идентификаторах процессов (PID) см. в главе 11.
Ресурсы и ограничения.
Программы, выполняющиеся в системе Linux, зависят от ограниченности ресурсов. Это могут быть физические ограничения, накладываемые оборудованием (например, памятью), ограничения, связанные с системной политикой (например, разрешенное время процессора) или ограничения реализации (такие как размер типа integer или максимально допустимое количество символов в имени файла). В спецификацию UNIX включены некоторые из этих ограничений, которые может определять приложение. Дальнейшее обсуждение ограничений и последствия их нарушений см. в главе 7.
В заголовочном файле limits.h определены многие именованные константы, представляющие ограничения, налагаемые операционной системой (табл. 4.8).
Таблица 4.8
Ограничительная константа | Назначение |
---|---|
NAME_MAX | Максимальное число символов в имени файла |
CHAR_BIT | Количество разрядов в значении типа char |
CHAR_MAX | Максимальное значение типа char |
INT_MAX | Максимальное значение типа int |
Существует множество других ограничений, полезных приложению, поэтому следует ознакомиться с заголовочными файлами установленной у вас версии системы.
Примечание. Имейте в виду, что константа NAME_MAX зависит от файловой системы. Для разработки легко переносимого кода следует применять функцию pathconf. Дополнительную информацию о ней см. на страницах интерактивного справочного руководства.В заголовочном файле sys/resource.h представлены определения операций над ресурсами. К ним относятся функции для считывания и установки предельных значений для разрешенного размера программы, приоритета выполнения и файловых ресурсов.
#include <sys/resource.h>
int getpriority(int which, id_t who);
int setpriority(int which, id_t who, int priority);
int getrlimit(int resource, struct rlimit *r_limit);
int setrlimit(int resource, const struct rlimit *r_limit);
int getrusage(int who, struct rusage *r_usage);
Здесь id_t — это целочисленный тип, применяемый для идентификаторов пользователя и группы. Структура rusage, указанная в файле sys/resource.h, используется для определения времени центрального процессора (ЦП), затраченного текущей программой. Она должна содержать, как минимум, два элемента (табл. 4.9).
Таблица 4.9
Элемент структуры rusage | Описание |
---|---|
struct timeval ru_utime | Время, использованное пользователем |
struct timeval ru_stime | Время, использованное системой |
Структура timeval определена в файле sys/time.h и содержит поля tv_sec и tv_usec, представляющие секунды и микросекунды соответственно.
Время ЦП, потребляемое программой, делится на время пользователя (время, затраченное самой программой на выполнение собственных инструкций) и системное время (время ЦП, потребляемое операционной системой в интересах программы, т.е. время, затраченное на системные вызовы, выполняющие ввод и вывод или другие системные функции).
Функция getrusage записывает данные о времени ЦП в структуру rusage, на которую указывает параметр r_usage. Параметр who может быть задан одной из констант, приведенных в табл. 4.10.
Таблица 4.10
Константа who | Описание |
---|---|
RUSAGE_SELF | Возвращает данные о потреблении только для текущей программы |
RUSAGE_CHILDREN | Возвращает данные о потреблении и для дочерних процессов |
Мы будем обсуждать дочерние процессы и приоритеты задач в главе 11, но для полноты картины мы здесь упоминаем об их причастности к потреблению системных ресурсов. Пока достаточно сказать, что у каждой выполняющейся программы есть ассоциированный с ней приоритет, и чем выше приоритет программы, тем больше ей выделяется доступного времени ЦП.
Примечание. Обычные пользователи могут только снижать приоритеты своих программ, а не повышать их.Приложения могут определять и изменять свои (и чужие) приоритеты с помощью функций getpriority и setpriority. Процесс, исследуемый или изменяемый с помощью этих функций, может быть задан идентификатором процесса, группы или пользователя. Параметр which описывает, как следует интерпретировать параметр who (табл. 4.11).
Таблица 4.11
Параметр which | Описание |
---|---|
PRIO_PROCESS | who — идентификатор процесса |
PRIO_PGRP | who — идентификатор группы |
PRIO_USER | who — идентификатор пользователя |
Итак, для определения приоритета текущего процесса вы можете выполнить следующий вызов:
priority = getpriority(PRIO_PROCESS, getpid());
Функция setpriority позволяет задать новый приоритет, если это возможно.
По умолчанию приоритет равен 0. Положительные значения приоритета применяются для фоновых задач, которые выполняются, только когда нет задачи с более высоким приоритетом, готовой к выполнению. Отрицательные значения приоритета заставляют программу работать интенсивнее, выделяя большие доли доступного времени ЦП. Диапазон допустимых приоритетов — от -20 до +20. Часто это приводит к путанице, поскольку, чем выше числовое значение, тем ниже приоритет выполнения.
Функция getpriority возвращает установленный приоритет в случае успешного завершения или -1 с переменной errno, указывающей на ошибку. Поскольку значение -1 само по себе обозначает допустимый приоритет, переменную errno перед вызовом функции getpriority следует приравнять нулю и при возврате из функции проверить, осталась ли она нулевой. Функция setpriority возвращает 0 в случае успешного завершения и -1 в противном случае.
Предельные величины, заданные для системных ресурсов, можно прочитать и установить с помощью функций getrlimit и setrlimit. Обе они для описания ограничений ресурсов используют структуру общего назначения rlimit. Она определена в файле sys/resource.h и содержит элементы, перечисленные в табл. 4.12.
Таблица 4.12
Элемент rlimit | Описание |
---|---|
rlim_t rlim_cur | Текущее, мягкое ограничение |
rlim_t rlim_max | Жесткое ограничение |
Определенный выше тип rlim_t — целочисленный тип, применяемый для описания уровней ресурсов. Обычно мягкое ограничение — это рекомендуемое ограничение, которое не следует превышать; нарушение этой рекомендации может вызвать возврат ошибок из библиотечных функций. При превышении жесткого ограничения система может попытаться завершить программу, отправив ей сигнал, например, сигнал SIGXCPU при превышении ограничения на потребляемое время ЦП и сигнал SIGSEGV при превышении ограничения на объем данных. В программе можно самостоятельно задать для любых значений собственные мягкие ограничения, не превышающие жесткого ограничения. Допустимо уменьшение жесткого ограничения. Увеличить его может только программа, выполняющаяся с правами суперпользователя.
Ограничить можно ряд системных ресурсов. Эти ограничения описаны в параметре resource функций rlimit и определены в файле sys/resource.h, как показано в табл. 4.13.
Таблица 4.13
Параметр resource | Описание |
---|---|
RLIMIT_CORE | Ограничение размера файла дампа ядра, в байтах |
RLIMIT_CPU | Ограничение времени ЦП, в секундах |
RLIMIT_DATA | Ограничение размера сегмента data(), в байтах |
RLIMIT_FSIZE | Ограничение размера файла, в байтах |
RLIMIT_NOFILE | Ограничение количества открытых файлов |
RLIMIT_STACK | Ограничение размера стека, в байтах |
RLIMIT_AS | Ограничение доступного адресного пространства (стек и данные), в байтах |
В упражнении 4.15 показана программа limits.c, имитирующая типичное приложение. Она также задает и нарушает ограничения ресурсов.
Упражнение 4.16. Ограничения ресурсов.
1. Включите заголовочные файлы для всех функций, которые вы собираетесь применять в данной программе:
#include <sys/types.h> \
#include <sys/resource.h>
#include <sys/time.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
2. Функция типа void записывает 10 000 раз строку во временный файл и затем выполняет некоторые арифметические вычисления для загрузки ЦП:
void work() {
FILE *f;
int i;
double x = 4.5;
f = tmpfile();
for (i = 0; i < 10000; i++) {
fprintf(f, "Do some output\n");
if (ferror(f)) {
fprintf(stderr, "Error writing to temporary file\n");
exit(1);
}
}
for (i = 0; i < 1000000; i++) x = log(x*x + 3.21);
}
3. Функция main вызывает функцию work, а затем применяет функцию getrusage для определения времени ЦП, использованного work. Эта информация выводится на экран:
int main() {
struct rusage r_usage;
struct rlimit r_limit;
int priority;
work();
getrusage(RUSAGE_SELF, &r_usage);
printf("CPU usage: User = %ld.%06ld, System = %ld.%06ld\n",
r_usage.ru_utime.tvsec, rusage.ru_utime.tv_usec,
r_usage.ru_stime.tv_sec, r_usage.ru_stime.tv_usec);
4. Далее она вызывает функции getpriority и getrlimit для выяснения текущего приоритета и ограничений на размер файла соответственно:
priority = getpriority(PRIO_PROCESS, getpid());
printf("Current priority = %d\n", priority);
getrlimit(RLIMIT_FSIZE, &r_limit);
printf("Current FSIZE limit: soft = %ld, hard = %ld\n",
r_limi t.rlim_cur, r_limit.rlim_max);
5. В заключение задайте ограничение размера файла с помощью функции setrlimit и снова вызовите функцию work, которая завершится с ошибкой, т.к. попытается создать слишком большой файл:
r_limit.rlim_cur = 2048;
r_limit.rlim_max = 4096;
printf("Setting a 2K file size limit\n");
setrlimit(RLIMIT_FS1ZE, &r_limit);
work();
exit(0);
}
Выполнив эту программу, вы сможете увидеть, сколько затрачено времени ЦП, и текущий приоритет, с которым программа выполняется. После того как будет задан предельный размер файла, программа не сможет записать во временный файл более 2048 байтов.
$ cc -о limits limits.с -lm
$ ./limits
CPU usage: User = 0.140008, System = 0.020001
Current priority = 0
Current FSIZE limit: soft = -1, hard = -1
Setting a 2K file size limit
File size limit exceeded
Вы можете изменить приоритет программы, запустив ее с помощью команды nice. Далее показано, как меняется приоритет на значение +10, и в результате программа выполняется немного дольше.
$ nice ./limits
CPU usage: User = 0.152009, System = 0.020001
Current priority = 10
Current FSIZE limit: soft = -1, hard = -1
Setting a 2K file size limit
File size limit exceeded
Как это работает
Программа limits вызывает функцию work для имитации операций типичной программы. Она выполняет некоторые вычисления и формирует вывод, в данном случае около 150 Кбайт записывается во временный файл. Программа вызывает функции управления ресурсами для выяснения своего приоритета и ограничений на размер файла. В данном случае ограничения размеров файлов не заданы, поэтому можно создавать файл любого размера (если позволяет дисковое пространство). Затем программа задает свое ограничение размера файла, равное примерно 2 Кбайт, и снова пытается выполнить некоторые действия. На этот раз функция work завершается неудачно, поскольку не может создать такой большой временный файл.
Примечание. Ограничения можно также наложить на программу, выполняющуюся в отдельной командной оболочке с помощью команды ulimit оболочки bash.В приведенном примере сообщение об ошибке "Error writing to temporary file" ("Ошибка записи во временный файл") не выводится. Это происходит потому, что некоторые системы (например, Linux 2.2 и более поздние версии) завершают выполнение программы при превышении ограничения ресурса. Делается это с помощью отправки сигнала SIGXFSZ. В главе 11 вы узнаете больше о сигналах и способах их применения. Другие системы, соответствующие стандарту POSIX, заставляют функцию, превысившую ограничение, вернуть ошибку.
Резюме.
В этой главе вы посмотрели на окружение системы Linux и познакомились с условиями выполнения программ. Вы узнали об аргументах командной строки и переменных окружения — и те, и другие могут применяться для изменения стандартного поведения программы и предоставляют подходящие программные опции.
Вы увидели, как программа может воспользоваться библиотечными функциями для обработки значений даты и времени и получить сведения о себе, пользователе и компьютере, на котором она выполняется.
Программы в ОС Linux, как правило, должны совместно использовать дорогостоящие ресурсы, поэтому в данной главе рассматриваются способы определения имеющихся ресурсов и управления ими.
Глава 5. Терминалы.
В этой главе вы познакомитесь с некоторыми улучшениями, которые вам, возможно, захочется внести в базовое приложение из главы 2. Его, быть может, самый очевидный недостаток — пользовательский интерфейс; он достаточно функционален, но не слишком элегантен. Теперь вы узнаете, как сделать более управляемым терминал пользователя, т. е. ввод с клавиатуры и вывод на экран. Помимо этого вы научитесь обеспечивать написанным вами программам возможность получения вводимых данных от пользователя даже при наличии перенаправления ввода и гарантировать вывод данных в нужное место на экране.
Несмотря на то, что заново реализованное приложение для управления базой данных компакт-дисков не увидит свет до конца главы 7, его основы вы заложите в этой главе. Глава 6 посвящена curses, которые представляют собой вовсе не древнее проклятие, а библиотеку функций, предлагающих программный код высокого уровня для управления отображением на экране терминала. Попутно вы узнаете чуть больше о размышлениях прежних профи UNIX, познакомившись с основными принципами систем Linux и UNIX и понятием терминала. Низкоуровневый доступ, представленный в этой главе, быть может именно то, что вам нужно. Большая часть того, о чем мы пишем здесь, хорошо подходит для программ, выполняющихся в окне консоли, таких как эмуляторы терминала KDE's Konsole, GNOME's gnome-terminal или стандартный X11 xterm.
В этой главе вы, в частности, узнаете о:
□ чтении с терминала и записи на терминал;
□ драйверах терминала и общем терминальном интерфейсе (General Terminal Interface, GTI);
□ структуре типа termios;
□ выводе терминала и базе данных terminfo;
□ обнаружении нажатия клавиш.
Чтение с терминала и запись на терминал.
В главе 3 вы узнали, что, когда программа запускается из командной строки, оболочка обеспечивает присоединение к ней стандартных потоков ввода и вывода. Вы получаете возможность взаимодействия с пользователем простым применением подпрограмм getchar и printf для чтения из стандартного потока ввода и записи в стандартный поток вывода.
В упражнении 5.1 в программе menu1.c вы попытаетесь переписать на языке С подпрограммы формирования меню, использующие только эти две функции.
Упражнение 5.1. Подпрограммы формирования меню на языке C.
1. Начните со следующих строк, определяющих массив, который будет использоваться как меню, и прототип (описание) функции getchoice:
#include <stdio.h>
#include <stdlib.h>
char *menu[] = {
"a — add new record", "d — delete record", "q - quit", NULL,
};
int getchoice(char *greet, char *choices[]);
2. Функция main вызывает функцию getchoice с образцом пунктов меню menu:
int main() {
int choice = 0;
do {
choice = getchoice("Please select an action", menu);
printf("You have chosen: %c\n", choice);
} while (choice != 'q');
exit(0);
}
3. Теперь важный фрагмент кода — функция, которая и выводит на экран меню и считывает ввод пользователя:
int getchoice(char *greet, char *choices[]) {
int chosen = 0;
int selected;
char **option;
do {
printf("Choice: %s\n", greet);
option = choices;
while (*option) {
printf("%s\n", *option);
option++;
}
selected = getchar();
option = choices;
while (*option) {
if (selected == *option[0]) {
chosen = 1;
break;
}
option++;
}
if (!chosen) {
printf("Incorrect choice, select again\n");
}
} while (!chosen);
return selected;
}
Как это работает
Функция getchoice выводит на экран приглашение для ввода greet и меню choices и просит пользователя ввести первый символ выбранного пункта. Далее выполняется цикл до тех пор, пока функция getchar не вернет символ, совпадающий с первой буквой одного из элементов массива option.
Когда вы откомпилируете и выполните программу, то обнаружите, что она ведет себя не так, как ожидалось. Для того чтобы продемонстрировать возникающую проблему, далее приведен вариант диалога на экране терминала.
$ ./menu1
Choice: Please select an action
a — add new record
d — delete record
q — quit
a
You have chosen: a
Choice: Please select an action
a — add new record
d — delete record
q — quit
Incorrect choice, select again
Choice: Please select an action
а — add new record
d — delete record
q — quit
q
You have chosen: q $
Для того чтобы сделать выбор, пользователь должен последовательно нажать клавиши <А>, <Enter>, <Q>, <Enter>. Здесь возникают, как минимум, две проблемы; самая серьезная заключается в том, что вы получаете сообщение "Incorrect choice" ("Неверный выбор") после каждого корректного выбора. Кроме того, вы еще должны нажать клавишу <Enter> (или <Return>), прежде чем программа считает введенные данные.
Сравнение канонического и неканонического режимов.
Обе эти проблемы тесно связаны. По умолчанию ввод терминала не доступен программе до тех пор, пока пользователь не нажмет клавишу <Enter> или <Return>. В большинстве случаев это достоинство, поскольку данный способ позволяет пользователю корректировать ошибки набора с помощью клавиш <Backspace> или <Delete>. Только когда он остается доволен увиденным на экране, пользователь нажимает клавишу <Enter>, чтобы ввод стал доступен программе.
Такое поведение называется каноническим или стандартным режимом. Весь ввод обрабатывается как последовательность строк. Пока строка ввода не завершена (обычно с помощью нажатия клавиши <Enter>), интерфейс терминала управляет всеми нажатыми клавишами, включая <Backspace>, и приложение не может считать ни одного символа.
Прямая противоположность — неканонический режим, в котором приложение получает больше возможностей контроля над обработкой вводимых символов. Мы еще вернемся к этим двум режимам немного позже в этой главе.
Помимо всего прочего, обработчик терминала в ОС Linux помогает превращать символы прерываний в сигналы (например, останавливающие выполнение программы, когда вы нажмете комбинацию клавиш <Ctrl>+<C>), он также может автоматически выполнить обработку нажатых клавиш <Backspace> и <Delete> и вам не придется реализовывать ее в каждой написанной вами программе. О сигналах вы узнаете больше в главе 11.
Итак, что же происходит в данной программе? ОС Linux сохраняет ввод до тех пор, пока пользователь не нажмет клавишу <Enter>, и затем передает в программу символ выбранного пункта меню и следом за ним код клавиши <Enter>. Каждый раз, когда вы вводите символ пункта меню, программа вызывает функцию getchar, обрабатывает символ и снова вызывает getchar, немедленно возвращающую символ клавиши <Enter>.
Символ, который на самом деле видит программа, — это не символ ASCII возврата каретки CR (десятичный код 13, шестнадцатеричный 0D), а символ перевода строки LF (десятичный код 10, шестнадцатеричный 0A). Так происходит потому, что на внутреннем уровне ОС Linux (как и UNIX) всегда применяет перевод строки для завершения текстовых строк, т. е. в отличие от других ОС, таких как MS-DOS, использующих комбинацию символов возврата каретки и перевода строки, ОС UNIX применяет, для обозначения новой строки только символ перевода строки. Если вводное или выводное устройство посылает или запрашивает и символ возврата каретки, в ОС Linux об этом заботится обработчик терминала. Если вы привыкли работать в MS-DOS или других системах, это может показаться странным, но одно из существенных преимуществ заключается в отсутствии в ОС Linux реальной разницы между текстовыми и бинарными файлами. Символы возврата каретки обрабатываются, только когда вы вводите или выводите их на терминал или некоторые принтеры и плоттеры.
Вы можете откорректировать основной недостаток вашей подпрограммы меню, просто игнорируя дополнительный символ перевода строки с помощью программного кода, подобного приведенному далее:
do {
selected = getchar();
} while (selected == '\n');
Он решает непосредственно возникшую проблему, и вы увидите вывод, подобный приведенному далее:
$ ./menu1
Choice: Please select an action
a — add new record
d — delete record
q — quit
a
You have chosen: a
Choice: Please select an action
a — add new record
d — delete record
q — quit
q
You have chosen: q $
Мы вернемся позже ко второй проблеме, связанной с необходимостью нажимать клавишу <Enter>, и более элегантному решению для обработки символа перевода строки.
Обработка перенаправленного вывода.
Для программ, выполняющихся в ОС Linux, даже интерактивных, характерно перенаправление своего ввода и вывода как в файлы, так и в другие программы. Давайте рассмотрим поведение вашей программы при перенаправлении ее вывода в файл.
$ ./menu1 > file
a
q
$
Такой результат можно было бы считать успешным, потому что вывод перенаправлен в файл вместо терминала. Однако бывают случаи, когда нужно помешать такому исходу событий или отделить приглашения или подсказки, которые пользователь должен видеть, от остального вывода, благополучно перенаправляемого в файл.
О перенаправлении стандартного вывода можно судить по наличию низкоуровневого дескриптора файла, ассоциированного с терминалом. Эту проверку выполняет системный вызов isatty. Вы просто передаете ему корректный дескриптор файла, и он проверяет, связан ли этот дескриптор в данный момент с терминалом.
#include <unistd.h>
int isatty(int fd);
Системный вызов isatty возвращает 1, если открытый дескриптор файла fd связан с терминалом, и 0 в противном случае.
В данной программе используются файловые потоки, но isatty оперирует только дескрипторами файлов. Для выполнения необходимого преобразования вам придется сочетать вызов isatty с подпрограммой fileno, обсуждавшейся в главе 3.
Что вы собираетесь делать, если стандартный вывод stdout перенаправлен? Просто завершить программу — не слишком хорошо, потому что у пользователя нет возможности выяснить, почему программа аварийно завершила выполнение. Вывод сообщения в stdout тоже не поможет, поскольку оно будет перенаправлено с терминала. Единственное решение — записать сообщение в стандартный поток ошибок stderr, который не перенаправляется командой оболочки > file (упражнение 5.2).
Упражнение 5.2. Проверка для выявления перенаправления вывода.
Внесите следующие изменения в директивы включения заголовочных файлов и функцию main программы menu1.с из упражнения 5.1. Назовите новый файл menu2.c.
#include <unistd.h>
...
int main() {
int choice = 0;
if (!isatty(fileno(stdout))) {
fprintf(stderr, "You are not a terminal!\n");
exit(1);
}
do {
choice = getchoice("Please select an action", menu);
printf("You have chosen: %c\n", choice);
} while (choice != 'q');
exit(0);
}
Теперь посмотрите на следующий пример вывода:
$ ./menu2
Choice: Please select an action
a — add new record
d — delete record
q — quit
q
You have chosen: q $ ./menu2 > file
You are not a terminal! $
Как это работает
В новом фрагменте программного кода функция isatty применяется для проверки связи стандартного вывода с терминалом и прекращения выполнения программы при отсутствии этой связи. Это тот же самый тест, который командная оболочка использует для решения, нужно ли выводить строки приглашения. Возможно и довольно обычно перенаправление и stdout, и stderr с терминала на другое устройство. Вы можете направить поток ошибок в другой файл:
$ ./menu2 >file 2>file.error
$
или объединить оба выводных потока в одном файле:
$ ./menu2 >file 2>&1
$
(Если вы не знакомы с перенаправлением вывода, прочтите еще раз главу 2, в которой мы более подробно рассматриваем синтаксические правила, связанные с ним.) В данном случае вам нужно отправить сообщение непосредственно на терминал пользователя.
Диалог с терминалом.
Если нужно защитить части вашей программы, взаимодействующие с пользователем, от перенаправления, но разрешить его для других входных и выходных данных, вы должны отделить общение с пользователем от потоков stdout и stderr. Это можно сделать, непосредственно считывая данные с терминала и прямо записывая данные на терминал. Поскольку ОС Linux с самого начала создавалась, как многопользовательская система, включающая, как правило, множество терминалов, как непосредственно подсоединенных, так и подключенных по сети, как вы сможете определить тот терминал, который следует использовать?
К счастью, Linux и UNIX облегчают жизнь, предоставляя специальное устройство /dev/tty, которое всегда является текущим терминалом или сеансом работы в системе (login session). Поскольку ОС Linux все интерпретирует как файлы, вы можете выполнять обычные файловые операции для чтения с устройства /dev/tty и записи на него.
В упражнении 5.3 вы исправите программу выбора пункта меню так, чтобы можно было передавать параметры в подпрограмму getchoice и благодаря этому лучше управлять выводом. Назовите ее menu3.c.
Упражнение 5.3. Применение /dev/tty.
Загрузите файл menu2.c и измените программный код так, чтобы входные и выходные данные приходили с устройства /dev/tty и направлялись на это устройство.
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
char *menu[] = {
"a — add new record", "d — delete record", "q - quit", NULL,
};
int getchoice(char* greet, char* choices[], FILE* in, FILE* out);
int main() {
int choice = 0;
FILE* input;
FILE* output;
if (!isatty(fileno(stdout))) {
fprintf(stderr, "You are not a terminal, OK.\n");
}
input = fopen("/dev/tty", "r");
output = fopen("/dev/tty", "w");
if (!input || !output) {
fprintf(stderr, "Unable to open /dev/tty\n");
exit(1);
}
do {
choice = getchoice("Please select an action", menu, input, output);
printf("You have chosen: %c\n", choice);
} while (choice != 'q');
exit(0);
}
int getchoice(char* greet, char *choices[], FILE* in, FILE *out) {
int chosen = 0;
int selected;
char **option;
do {
fprintf(out, "Choice: %s\n", greet);
option = choices;
while (*option) {
fprintf(out, "%s\n", *option);
option++;
}
do {
selected = fgetc(in);
} while(selected == '\n');
option = choices;
while (*option) {
if (selected == *option[0]) {
chosen = 1;
break;
}
option++;
}
if (!chosen) {
fprintf(out, "Incorrect choice, select again\n");
}
} while (!chosen);
return selected;
}
Теперь, когда вы выполните программу с перенаправленным выводом, вы сможете увидеть строки приглашения, а стандартный вывод программы (обозначающий выбранные пункты меню) перенаправляется в файл, который можно просмотреть позже:
$ ./menu3 > file
You are not a terminal, OK.
Choice: Please select an action
a — add new record
d — delete record
q — quit
d
Choice: Please select an action
a — add new record
d - delete record
q — quit
q
$ cat file
You have chosen: d
You have chosen: q
Драйвер терминала A и общий терминальный интерфейс.
Иногда программе нужно более мощные средства управления терминалами, чем простые файловые операции. ОС Linux предоставляет ряд интерфейсов, позволяющих управлять поведением драйвера терминала и обеспечивающих больше возможностей управления вводом и выводом терминала.
Обзор.
Как показано на рис. 5.1, вы можете управлять терминалом с помощью вызовов набора функций общего терминального интерфейса (General Terminal Interface, GTI), разделяя их на применяемые для чтения и для записи. Такой подход сохраняет ясность интерфейса данных (чтение/запись), позволяя при этом искусно управлять поведением терминала. Нельзя сказать, что терминальный интерфейс ввода/вывода очень понятен — он вынужден иметь дело с множеством разнообразных физических устройств.

Рис. 5.1
В терминологии UNIX управляющий интерфейс устанавливает "порядок обслуживания линий", обеспечивающий программе ощутимую гибкость в задании поведения драйвера терминала.
К основным функциям, которыми вы можете управлять, относятся следующие:
□ редактирование строки — применение для редактирования клавиши <Backspace>;
□ буферизация — считывание символов сразу или после настраиваемой задержки;
□ отображение — управление отображением так же, как при считывании паролей;
□ CR/LF — отображение для ввода и вывода: что происходит при выводе символа перевода строки (\n);
□ скорости передачи данных по линии — редко применяется для консоли ПК, эти скорости очень важны для модемов и терминалов на линиях последовательной передачи.
Аппаратная модель.
Перед тем как подробно рассматривать общий терминальный интерфейс, очень важно проанализировать аппаратную модель, предназначенную для управления.
Концептуальная схема (физическая модель на некоторых старых узлах UNIX подобна данной) включает машину с ОС UNIX, подключенную через последовательный порт с модемом и далее по телефонной линии с другим модемом к удаленному терминалу (рис. 5.2). На деле это просто вариант установки, применявшийся некоторыми малыми провайдерами интернет-услуг "на заре туманной юности" Интернета. Эта модель отдаленно напоминает организацию "клиент — сервер", при использовании которой программа выполняется на большом компьютере, а пользователи работают на терминалах ввода/вывода.

Рис. 5.2
Если вы работаете на ПК под управлением ОС Linux, эта модель может показаться чересчур сложной. Однако, поскольку у обоих авторов есть модемы, мы можем при желании использовать программу эмуляции терминала, например, minicom для запуска удаленного сеанса работы в системе на любой другой машине, подобной этой, с помощью пары модемов и телефонной линии связи. Конечно, сегодня быстрый широкополосный доступ вытеснил из потребления эту рабочую модель, но она до сих пор не лишена некоторых достоинств.
Преимущество применения этой аппаратной модели заключается в том, что в большинстве реальных ситуаций возникает потребность в некотором сокращенном варианте этого наиболее сложного случая. Удовлетворить эти потребности будет гораздо легче, если приведенная модель сохранит подобные функциональные возможности.
Структура типа termios.
Тип termios — стандартный интерфейс, заданный стандартом POSIX и похожий на интерфейс termio системы System V. Интерфейс терминала управляется значениями в структуре типа termios и использует небольшой набор вызовов функций. И то и другое определено в заголовочном файле termios.h.
Примечание. Программы, применяющие вызовы функций, определенных в файле termios.h, нуждаются в компоновке с соответствующей библиотекой функций. Ею может быть в зависимости от установленной у вас системы просто стандартная библиотека С или библиотека curses. При необходимости во время компиляции примеров этой главы добавьте аргумент -lcurses в конец строки команды компиляции. В некоторых более старых системах Linux библиотека curses представлена в версии, известной под названием "new curses". В этих случаях имя библиотеки и аргумент компоновки становятся ncurses и -lncurses соответственно.Значения, которые можно изменять для управления терминалом, разделены на группы, относящиеся к следующим режимам:
□ ввод;
□ вывод;
□ управление;
□ локальный;
□ специальные управляющие символы.
Минимальная структура типа termios обычно объявляется следующим образом (хотя в стандарте X/Open разрешено включение дополнительных полей):
#include <termios.h>
struct termios {
tcflag_t c_iflag;
tcflag_t c_oflag;
tcflag_t c_cflag;
tcflag_t c_lflag;
cc_t c_cc[NCCS];
};
Имена элементов структуры соответствуют пяти типам параметров из предыдущего перечня.
Инициализировать структуру типа termios для терминала можно, вызвав функцию tcgetattr со следующим прототипом или описанием:
#include <termios.h>
int tcgetattr(int fd, struct termios *termios_p);
Этот вызов записывает текущие значения переменных интерфейса терминала в структуру, на которую указывает параметр termios_p. Если впоследствии эти значения будут изменены, вы сможете перенастроить интерфейс терминала с помощью функции tcsetattr следующим образом:
#include <termios.h>
int tcsetattr(int fd, int actions, const struct termios *termios_p);
Поле actions функции tcsetattr управляет способом внесения изменений. Есть три варианта:
□ TCSANOW — изменяет значения сразу;
□ TSCADRAIN — изменяет значения, когда текущий вывод завершен;
□ TCSAFLUSH — изменяет значения, когда текущий вывод завершен, но отбрасывает любой ввод, доступный в текущий момент и все еще не возвращенный вызовом read.
Примечание. Учтите, что для программ очень важно восстановить настройки терминала, действующие до начала выполнения программы. За первоначальное сохранение значений и их восстановление после завершения выполнения всегда отвечает программа.Теперь рассмотрим более подробно режимы и связанные с ними вызовы функций. Некоторые характеристики режимов довольно специализированные и редко применяются, поэтому мы остановимся только на основных. Если вы хотите знать больше, просмотрите страницы интерактивного справочного руководства вашей системы либо скопируйте стандарт POSIX или X/Open.
Наиболее важный режим, который следует принять во внимание при первом прочтении, — локальный (local). Канонический и неканонический режимы — решение второй проблемы в вашем первом приложении: пользователь должен нажимать клавишу <Enter> или <Return> для чтения программой входных данных. Вам следует заставить программу ждать всю строку ввода или набрасываться на ввод, как только он набран на клавиатуре.
Режимы ввода.
Режимы ввода управляют тем, как обрабатывается ввод (символы, полученные драйвером терминала от последовательного порта или клавиатуры) до передачи его в программу. Вы управляете вводом, устанавливая флаги в элементе c_iflag структуры termios. Все флаги определены как макросы и могут комбинироваться с помощью поразрядной операции OR. Это свойственно всем режимам терминала.
В элементе c_iflag могут применяться следующие макросы:
□ BRKINT — генерирует прерывание, когда в линии связи обнаруживается разрыв (потеря соединения);
□ IGNBRK — игнорирует разрывы соединения в линии связи;
□ ICRNL — преобразует полученный символ возврата каретки в символ перехода на новую строку;
□ IGNCR — игнорирует полученные символы возврата каретки;
□ INLCR — преобразует полученные символы перехода на новую строку в символы возврата каретки;
□ IGNPAR — игнорирует символы с ошибками четности;
□ INCPK — выполняет контроль четности у полученных символов;
□ PARMRK — помечает ошибки четности;
□ ISTRIP — обрезает (до семи битов) все входные символы;
□ IXOFF — включает программное управление потоком при вводе;
□ IXON — включает программное управление потоком при выводе.
Примечание. Если флаги BRKINT и IGNBRK не установлены, сбой на линии связи считывается как символ NULL (0x00).Вам не придется часто изменять режимы ввода, поскольку обычно стандартные значения — наиболее подходящие, и поэтому мы больше не будем их обсуждать.
Режимы вывода.
Эти режимы управляют способом обработки выводимых символов, т.е. тем, как символы, полученные от программы, обрабатываются перед передачей на последовательный порт или экран. Как и следовало ожидать, многие из них — оборотная сторона режимов ввода. Есть несколько дополнительных флагов, которые связаны в основном с разрешениями для медленных терминалов, которым требуется время для обработки таких символов, как возвраты каретки. Почти все они либо избыточны (поскольку терминалы стали быстрее) или лучше обрабатываются с помощью базы данных характеристик терминала terminfo, которую вы примените позже в этой главе.
Вы управляете режимами вывода, устанавливая флаги элемента c_oflag структуры типа termios. В элементе c_oflag могут применяться следующие макросы:
□ OPOST — включает обработку вывода;
□ ONLCR — преобразует в символ перевода строки пару символов возврат каретки/перевод строки;
□ OCRNL — преобразует любой символ возврата каретки в выводе в символ перевода строки;
□ ONOCR — не выводит символ возврата каретки в столбце 0;
□ ONLRET — символ перехода на новую строку выполняет возврат каретки;
□ OFILL — посылает символы заполнения для формирования задержки;
□ OFDEL — применяет символ DEL как заполнитель вместо символа NULL;
□ NLDLY — выбор задержки для символа перехода на новую строку;
□ CRDLY — выбор задержки для символа возврата каретки;
□ TABDLY — выбор задержки для символа табуляции;
□ BSDLY — выбор задержки для символа Backspace;
□ VTDLY — выбор задержки для символа вертикальной табуляции;
□ FFDLY — выбор задержки для символа прокрутки страницы.
Примечание. Если флаг OPOST не установлен, все остальные флаги игнорируются.Режимы вывода тоже обычно не используются, поэтому мы не будем их обсуждать в дальнейшем.
Режимы управления.
Эти режимы управляют аппаратными характеристиками терминала. Вы задаете режимы управления, устанавливая флаги элемента c_cflag структуры типа termios, включающие следующие макросы:
□ CLOCAL — игнорирует управление линиями с помощью модема;
□ CREAD — включает прием символов;
□ CS5 — использует пять битов в отправляемых и принимаемых символах;
□ CS6 — использует шесть битов в отправляемых и принимаемых символах;
□ CS7 — использует семь битов в отправляемых и принимаемых символах;
□ CS8 — использует восемь битов в отправляемых и принимаемых символах;
□ CSTOPB — устанавливает два стоповых бита вместо одного;
□ HUPCL — выключает управление линиями модема при закрытии;
□ PARENB — включает генерацию и проверку четности;
□ PARODD — применяет контроль нечетности вместо контроля четности.
Примечание. Если драйвер терминала обнаруживает, что последний дескриптор файла, ссылающийся на терминал, закрыт и при этом флаг HUPCL установлен, он устанавливает линии управления модема в состояние останова (hang-up).Режимы управления применяются в основном при подключении к модему последовательной линии связи, хотя их можно использовать и при диалоге с терминалом. Обычно легче изменить настройку терминала, чем изменять стандартное поведение линий связи с помощью режимов управления структуры termios.
Локальные режимы.
Эти режимы управляют разнообразными характеристиками терминала. Вы можете задать локальный режим, устанавливая флаги элемента c_iflag структуры termios с помощью следующих макросов:
□ ECHO — включает локальное отображение вводимых символов;
□ ECHOE — выполняет комбинацию Backspace, Space, Backspace при получении символа ERASE (стереть);
□ ECHOK — стирает строку при получении символа KILL;
□ ECHONL — отображает символы перехода на новую строку;
□ ICANON — включает стандартную обработку ввода (см. текст, следующий за данным перечнем);
□ IEXTEN — включает функции, зависящие от реализации;
□ ISIG — включает генерацию сигналов;
□ NOFLSH — отключает немедленную запись очередей;
□ TOSTOP — посылает сигнал фоновым процессам при попытке записи.
Два самых важных флага в этой группе — ECHO, позволяющий подавлять отображение вводимых символов, и ICANON, переключающий терминал в один из двух различных режимов обработки принимаемых символов. Если установлен флаг ICANON, говорится, что строка в каноническом режиме, если нет, то строка в неканоническом режиме.
Специальные управляющие символы.
Специальные управляющие символы — это коллекция символов подобных символам от комбинации клавиш <Ctrl>+<C>, действующих особым образом, когда пользователь вводит их. В элементе c_cc структуры termios содержатся символы, отображенные на поддерживаемые функции. Позиция каждого символа (его номер в массиве) определяется макросом, других ограничений для управляющих символов не задано.
Массив c_cc используется двумя очень разными способами, зависящими от того, установлен для терминала канонический режим (т.е. установлен флаг ICANON в элементе c_lflag структуры termios) или нет.
Важно понять, что в двух разных режимах есть некоторое взаимное наложение при применении номеров элементов массива. По этой причине никогда не следует смешивать значения для этих двух режимов.
Для канонического режима применяются следующие индексы:
□ VEOF — символ EOF;
□ VEOL — дополнительный символ конца строки EOL;
□ VERASE — символ ERASE;
□ VINTR — символ прерывания INTR;
□ VKILL — символ уничтожения KILL;
□ VQUIT — символ завершения QUIT;
□ VSUSP — символ приостанова SUSP;
□ VSTART — символ запуска START;
□ VSTOP — символ останова STOP.
Для канонического режима применяются следующие индексы:
□ VINTR — символ INTR;
□ VMIN — минимальное значение MIN;
□ VQUIT — символ QUIT;
□ VSUSP — символ SUSP;
□ VTIME — время ожидания TIME;
□ VSTART — символ START;
□ VSTOP — символ STOP.
Символы.
Поскольку для более сложной обработки вводимых символов специальные символы и неканонические значения очень важны, мы описываем их в табл. 5.1.
Таблица 5.1
Символ | Описание |
---|---|
INTR | Заставляет драйвер терминала отправить сигнал SIGINT процессам, подключенным к терминалу. Мы обсудим сигналы более подробно в главе 11 |
QUIT | Заставляет драйвер терминала отправить сигнал SIGQUIT процессам, подключенным к терминалу |
ERASE | Заставляет драйвер терминала удалить последний символ в строке |
KILL | Заставляет драйвер терминала удалить всю строку |
EOF | Заставляет драйвер терминала передать все символы строки во ввод, считываемый приложением. Если строка пустая, вызов read вернет ноль символов, как будто он встретил на конец файла |
EOL | Действует как ограничитель строки в дополнение к более привычному символу перехода на новую строку |
SUSP | Заставляет драйвер терминала послать сигнал SIGSUSP процессам, подключенным к терминалу. Если ваша система UNIX поддерживает управление заданиями, текущее приложение будет приостановлено |
STOP | Действует как "прерыватель потока", т. е. прекращает дальнейший вывод на терминал. Применяется для поддержки управления потоком XON/XOFF и обычно задается как ASCII-символ XOFF (<Ctrl>+<S>) |
START | Возобновляет вывод после символа STOP, часто ASCII-символ XON |
Значения TIME и MIN.
Значения TIME и MIN применяются только в неканоническом режиме и действуют вместе для управления считыванием входных данных. Вместе они управляют действиями при попытке программы прочесть дескриптор файла, ассоциированный с терминалом.
Возможны четыре варианта.
□ MIN = 0 и TIME = 0. В этом случае вызов read всегда завершается сразу же. Если какие-то символы доступны, они будут возвращены, если нет, то read вернет ноль, и никакие символы не будут считаны.
□ MIN = 0 и TIME > 0. В этом случае вызов read завершится, когда все доступные символы будут считаны или когда пройдет TIME десятых долей секунды. Если нет прочитанных символов из-за превышения отпущенного времени, read вернет 0. В противном случае он вернет количество прочитанных символов.
□ MIN > 0 и TIME = 0. В этом случае вызов read будет ждать до тех пор, пока можно будет считать MIN символов, и затем вернет это количество символов. В случае конца файла возвращается 0.
□ MIN > 0 и TIME > 0. Это самый сложный случай. После вызова read ждет получения символа. Когда первый символ получен, каждый раз при получении последующего символа запускается межсимвольный таймер (или перезапускается, если он уже был запущен). Вызов read завершится, когда либо можно будет считать MIN символов, либо межсимвольное время превысит TIME десятых долей секунды. Это может пригодиться для подсчета разницы между единственным нажатием клавиши <Esc> и запуском функциональной клавиатурной escape-последовательности. Тем не менее следует знать, что сетевые соединения или высокая загрузка процессора могут полностью стереть такие полезные сведения о времени.
Установив неканонический режим и используя значения MIN и TIME, программы могут выполнять посимвольную обработку ввода.
Доступ к режимам терминала из командной оболочки.
Если вы хотите просмотреть параметры termios, находясь в командной оболочке, примените следующую команду для получения их списка:
$ stty -a
На установленных у авторов системах Linux, обладающих структурами termios с некоторыми расширениями по сравнению со стандартными, получен следующий вывод:
speed 38400 baud; rows 24; columns 80; line = 0;
intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = <undef>;
eol2 = <undef>; swtch = <undef>; start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R;
werase = ^W; lnext = ^V; flush = ^O, min = 1; time = 0;
-parenb -parodd cs8 -hupcl -cstopb cread -clocal -crtscts
-ignbrk -brkint -ignpar -parmirk -inpck -istrip -inlcr -igncr icrnl -ixon -ixoff
-iuclc -ixany -imaxbe1 iutf8
opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel n10 cr0 tab0 bs0 vt0 ff0
isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt
echoctl echoke
Среди прочего, как видите, символ EOF — это <Ctrl>+<D>, и включено отображение. Экспериментируя с установками терминала, легко получить в результате терминал в нестандартном режиме, что затруднит его дальнейшее использование. Есть несколько способов справиться с этой трудностью.
□ Первый способ — применить следующую команду, если ваша версия stty поддерживает ее:
$ stty sane
Если вы потеряли преобразование клавиши возврата каретки в символ перехода на новую строку (который завершает строку), возможно, потребуется ввести stty sane, но вместо нажатия клавиши <Enter> нажать комбинацию клавиш <Ctrl>+<J> (которая обозначает переход на новую строку).
□ Второй способ — применить команду stty -g и записать текущие установки stty в форму, готовую к повторному считыванию. В командной строке вы можете набрать следующее:
$ stty -g > save_stty
...
<эксперименты с параметрами>
...
$ stty $(cat save_stty)
В финальной команде stty вам все еще придется использовать комбинацию клавиш <Ctrl>+<J> вместо клавиши <Enter>. Ту же самую методику можно применить и в сценариях командной оболочки.
save_stty="$(stty -g)"
<изменение stty-параметров>
stty $save_stty
□ Если вы все еще в тупике, третий способ — перейти на другой терминал, применить команду ps для поиска оболочки, которую вы сделали непригодной, и затем использовать команду kill hup <id процесса> для принудительного завершения этой командной оболочки. Поскольку перед выводом регистрационного приглашения параметры stty всегда восстанавливаются, у вас появится возможность нормально зарегистрироваться в системе еще раз.
Задание режимов терминала из командной строки.
Вы также можете применять команду stty для установки режимов терминалов непосредственно из командной строки.
Для установки режима, в котором ваш сценарий командной оболочки сможет выполнять посимвольное считывание, вы должны отключить канонический режим и задать 1 и 0. Команда будет выглядеть следующим образом:
$ stty -icanon min 1 time 0
Теперь терминал будет считывать символы немедленно, вы можете попробовать выполнить еще раз первую программу menu1. Вы увидите, что она работает, как первоначально и предполагалось.
Вы также могли бы улучшить вашу попытку проверки пароля (см. главу 2), отключив отображение перед приглашением ввести пароль. Команда, выполняющая это действие, должна быть следующей:
$ stty -echo
Примечание. Не забудьте применить команду stty echo для возврата отображения после ваших экспериментов!Скорость терминала.
Последняя функция, обслуживаемая структурой termios, — манипулирование скоростью линии передачи. Для этой скорости не определен отдельный элемент структуры; она управляется вызовами функций. Скорости ввода и вывода обрабатываются отдельно.
Далее приведены четыре прототипа вызовов:
#include <termios.h>
speed_t cfgetispeed(const struct termios *);
speed_t cfgetospeed(const struct termios *);
int cfsetispeed(struct termios *, speed_t speed);
int cfsetospeed(struct termios *, speed_t speed);
Обратите внимание на то, что они воздействуют на структуру termios, а не непосредственно на порт. Это означает, что для установки новой скорости вы должны считать текущие установки с помощью функции tcgetattr, задать скорость, применив приведенные вызовы, и затем записать структуру termios обратно с помощью функции tcsetattr. Скорость линии передачи изменится только после вызова tcsetattr.
В вызовах перечисленных функций допускается задание разных значений скорости speed, но к основным относятся следующие константы:
□ B0 — отключение терминала;
□ B1200 — 1200 бод;
□ B2400— 2400 бод;
□ B9600 — 9600 бод;
□ B19200 — 19 200 бод;
□ B38400 — 38 400 бод.
Не существует скоростей выше 38 400 бод, задаваемых стандартом, и стандартного метода обслуживания последовательных портов на более высоких скоростях.
Примечание. В некоторых системах, включая Linux, для выбора более высоких скоростей определены константы В57600, B115200 и В230400. Если вы пользуетесь более старой версией ОС Linux и эти константы недоступны, можно применить команду setserial для получения нестандартных скоростей 57 600 и 115 200. В этом случае указанные скорости будут использоваться при выборе константы B38400. Оба эти метода непереносимы, поэтому применяйте их с осторожностью.Дополнительные функции.
Есть небольшое число дополнительных функций для управления терминалами. Они работают непосредственно с дескрипторами файлов без необходимости считывания и записывания структур типа termios.
#include <termios.h>
int tcdrain(int fd);
int tcflow(int fd, int flowtype);
int tcflush(int fd, int in_out_selector);
Функции предназначены для следующих целей:
□ tcdrain — заставляет вызвавшую программу ждать до тех пор, пока не будет отправлен весь поставленный в очередь вывод;
□ tcflow — применяется для приостановки или возобновления вывода;
□ tcflush — может применяться для отказа от входных или выходных данных либо и тех, и других.
Теперь, когда мы уделили довольно много внимания структуре termios, давайте рассмотрим несколько практических примеров. Возможно, самый простой из них — отключение отображения при чтении пароля (упражнение 5.4). Это делается сбрасыванием флага echo.
Упражнение 5.4. Программа ввода пароля с применение termios.
1. Начните вашу программу password.с со следующих определений:
#include <termios.h>
#include <stdio.h>
#include <stdlib.h>
#define PASSWORD_LEN 8
int main() {
struct termios initialrsettings, newrsettings;
char password[PASSWORD_LEN + 1];
2. Далее добавьте строку, считывающую текущие установки из стандартного ввода и копирующую их в только что созданную вами структуру типа termios:
tcgetattr(fileno(stdin), &initialrsettings);
3. Создайте копию исходных установок, чтобы восстановить их в конце. Сбросьте флаг ECHO в переменной newrsettings и запросите у пользователя его пароль:
newrsettings = initialrsettings;
newrsettings.с_lflag &= ~ЕСНО;
printf("Enter password: ");
4. Далее установите атрибуты терминала в newrsettings и считайте пароль. И наконец, восстановите первоначальные значения атрибутов терминала и выведите пароль на экран, чтобы свести на нет все предыдущие усилия по обеспечению безопасности:
if (tcsetattr(fileno(stdin), TCSAFLUSH, &newrsettings) != 0) {
fprintf(stderr, "Could not set attributes\n");
} else {
fgets(password, PASSWORD_LEN, stdin);
tcsetattr(fileno(stdin), TCSANOW, &initialrsettings);
fprintf(stdout, "\nYou entered %s\n", password);
}
exit(0);
}
Когда вы выполните программу, то увидите следующее:
$ ./password
Enter password: You entered hello
$
Как это работает
В этом примере слово hello набирается на клавиатуре, но не отображается на экране в строке приглашения Enter password:. Никакого вывода нет до тех пор, пока пользователь не нажмет клавишу <Enter>.
Будьте осторожны и изменяйте с помощью конструкции X&=~FLAG (которая очищает бит, определенный флагом FLAG в переменной X) только те флаги, которые вам нужно изменить. При необходимости можно воспользоваться конструкцией X|=FLAG для установки одиночного бита, определяемого FLAG, хотя в предыдущем примере она не понадобилась.
Для установки атрибутов применяется действие TCSAFLUSH для очистки буфера клавиатуры, символов, которые пользователи вводили до того, как программа подготовилась к их считыванию. Это хороший способ заставить пользователей не начинать ввод своего пароля, пока не отключено отображение. Перед завершением программы вы также восстанавливаете первоначальные установки.
Другой распространенный пример использования структуры termios — перевод терминала в состояние, позволяющее вам считывать каждый набранный символ (упражнение 5.5). Для этого отключается канонический режим и используются параметры MIN и TIME.
Упражнение 5.5. Считывание каждого символа.
Применяя только что полученные знания, вы можете изменить программу menu. Приведенная далее программа menu4.c базируется на программе menu3.c и использует большую часть кода из файла password.с, включенного в нее. Внесенные изменения выделены цветом и объясняются в пунктах описания.
1. Прежде всего, вам следует, включить новый заголовочный файл в начало программы:
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <termios.h>
char *menu[] = {
"a — add new record",
"d — delete record",
"q - quit",
NULL,
};
2. Затем нужно объявить пару новых переменных в функции main:
int getchoice(char *greet, char *choices[], FILE *in, FILE *out);
int main() {
int choice = 0;
FILE *input;
FILE *output;
struct termios initial_settengs, new_settings;
3. Перед вызовом функции getchoice вам следует изменить характеристики терминала, этим определяется место следующих строк:
if (!isatty(fileno(stdout))) {
fprintf(stderr, "You are not a terminal, OK.\n");
}
input = fopen("/dev/tty", "r");
output = fopen("/dev/tty", "w");
if (!input || !output) {
fprintf(stderr, "Unable to open /dev/tty\n");
exit(1);
}
tcgetattr(fileno(input), &initial_settings);
new_settings = initial_settings;
new_settings.c_lfag &= ~ICANON;
new_settings.c_lflag &= ~ECHO;
new_settings.c_cc[VMIN] = 1;
new_settings.c_cc[VTIME] = 0;
new_settings.c_lflag &= ~ISIG;
if (tcsetattr(fileno(input), TCSANOW, &new_settings) != 0) {
fprintf(stderr, "could not set attributes\n");
}
4. Перед завершением вы также должны вернуть первоначальные значения:
do {
choice = getchoice("Please select an action", menu, input, output);
printf("You have chosen: %c\n", choice);
} while (choice != 'q');
tcsetattr(fileno(input), TCSANOW, &initial_settings);
exit(0);
}
5. Теперь, когда вы в неканоническом режиме, необходимо проверить на соответствие возвраты каретки, поскольку стандартное преобразование CR (возврат каретки) в LF (переход на новую строку) больше не выполняется:
int getchoice (char *greet, char *choices[], FILE *in, FILE *out) {
int chosen = 0;
int selected;
char **option;
do {
fprintf(out, "Choice: %s\n", greet);
option = choices;
while (*option) {
fprintf(but, "%s\n", *option);
option++;
}
do {
selected = fgetc(in);
} while (selected == '\n' || selected == '\r');
option = choices;
while (*option) {
if (selected == *option[0]) {
chosen = 1;
break;
}
option++;
}
if (!chosen) {
fprintf(out, "Incorrect choice, select again\n");
}
} while(!chosen);
return selected;
}
Пока вы не устроите все иначе, теперь, если пользователь нажмет в вашей программе комбинацию клавиш <Ctrl>+<C>, программа завершится. Вы можете отключить обработку этих специальных символов, очистив флаг ISIG в локальных режимах. Для этого в функцию main включается следующая строка:
new_settings.c_lflag &= ~ISIG;
Если вы внесете эти изменения в вашу программу меню, то будете получать немедленный отклик, и вводимый вами символ не будет отображаться на экране.
$ ./menu4
Choice: Please select an action
a — add new record
d — delete record
q — quit
You have chosen: a
Choice: Please select an action
a — add new record
d — delete record
q — quit
You have chosen: q $
Если вы нажмете комбинацию клавиш <Ctrl>+<C>, символ будет передан прямо в программу и будет истолкован, как неверный выбор.
Вывод терминала.
С помощью структуры типа termios вы управляли вводом с клавиатуры, но было бы хорошо иметь такой же уровень управления выходными данными, отображаемыми на экране терминала. В начале главы вы применяли функцию printf для вывода символов на экран, не имея при этом возможности помещать их в определенное место экрана.
Тип терминала.
Во многих системах UNIX применяются терминалы, несмотря на то, что сегодня во многих случаях "терминал" может на самом деле быть ПК, выполняющим программу эмуляции терминала или терминальным приложением в оконной среде, таким как xterm в графической оболочке X11.
Исторически существовало очень большое число аппаратных терминалов разных производителей. Несмотря на то, что почти все они применяют escape-последовательности (строки символов, начинающиеся с escape-символа) для управления положением курсора и другими атрибутами, такими как жирное начертание или мерцание, способы реализации управления при этом слабо стандартизованы. У некоторых старых моделей терминалов также разные характеристики прокрутки экрана, который может очищаться или не очищаться, когда посылается символ Backspace, и т.д.
Примечание. Существует стандарт ANSI для набора escape-последовательностей (в основном базирующихся на последовательностях, применяемых в серии VT-терминалов компании Digital Equipment Corporation, но не идентичных им). Многие терминальные программы обеспечивают эмуляцию стандартного аппаратного терминала, часто VT100, VT220 или ANSI, а иногда и других типов.Такое разнообразие аппаратных моделей терминалов было бы огромной проблемой для программистов, пытающихся написать программы управления экраном, выполняющиеся на терминалах разных типов. Например, терминал ANSI применяет последовательность символов Escape, [, A для перемещения курсора вверх на одну строку. Терминал ADM-За (очень распространенный несколько лет назад) использует один управляющий символ от комбинации клавиш <Ctrl>+<K>.
Написание программы, имеющей дело с терминалами разнообразных типов, которые могут быть подключены в системе UNIX, кажется крайне устрашающей задачей. Такой программе понадобится разный программный код для терминала каждого типа.
Как ни странно, решение существует в пакете, известном как terminfo. Вместо необходимости обслуживания любого типа терминала в каждой программе, ей достаточно просмотреть базу данных типов терминалов для получения корректной информации. В большинстве современных систем UNIX, включая Linux, эта база данных объединена с другим пакетом, названным curses, о котором вы узнаете в следующей главе.
Для применения функций terminfo вы, как правило, должны подключить заголовочный файл curses.h пакета curses и собственный заголовочный файл term.h пакета terminfo. В некоторых системах Linux вам, возможно, придется применять реализацию curses, известную как ncurses, и включить файл ncurses.h для предоставления прототипов вашим функциям terminfo.
Установите тип вашего терминала.
Окружение ОС Linux содержит переменную TERM, которая хранит тип используемого терминала. Обычно она устанавливается системой автоматически во время регистрации в системе. Системный администратор может задать тип терминала по умолчанию для каждого непосредственно подключенного терминала и может сформировать подсказку с типом терминала для удаленных сетевых пользователей. Значение TERM может быть передано rlogin через telnet.
Пользователь может запросить командную оболочку о соображениях системы по поводу используемого им или ею терминала:
$ echo $TERM
xterm
$
В данном случае оболочка выполняется из программы, называемой xterm — эмулятора терминала для графической оболочки X Window System, или программы, обеспечивающей "такие же функциональные возможности, как KDE's Konsole или GNOME's gnome-terminal.
Пакет terminfo содержит базу данных характеристик и управляющих escape-последовательностей для большого числа терминалов и предоставляет единообразный программный интерфейс для их использования. Отдельная программа, таким образом, сможет извлечь выгоду от применения новых моделей терминалов по мере расширения базы данных и не заботиться о поддержке множества разных терминалов.
Характеристики терминалов в terminfo описываются с помощью атрибутов. Они хранятся в наборе откомпилированных файлов terminfo, которые обычно находятся в каталогах /usr/lib/terminfo или /usr/share/terminfo. Для каждого терминала (и многих принтеров, которые тоже могут быть заданы в terminfo) есть файл, в котором определены характеристики терминала и способ доступа к его функциям. Для того чтобы не создавать слишком большого каталога, реальные файлы хранятся в подкаталогах, имена которых — первый символ типа терминала. Так определение терминала VT100 можно найти в файле …terminfo/v/vt100.
Файлы terminfo пишутся по одному на каждый тип терминала в исходном формате, пригодном (или почти пригодном!) для чтения, который затем компилируется командой tic в более компактный и эффективный формат, используемый прикладными программами. Странно, стандарт X/Open ссылается на описания исходного и откомпилированного формата, но не упоминает команду tic, необходимую для реального преобразования исходного формата в откомпилированный. Для вывода пригодной для чтения версии откомпилированного элемента набора terminfo можно использовать программу infocmp.
Далее приведен пример файла terminfo для терминала VT100:
$ infocmp vt100
vt100|vt100-am|dec vt100 (w/advanced video),
am, mir, msgr, xenl, xon, cols#80, it#8, lines#24, vt#3,
acsc=``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~,
bel=^G, blink=\E[5m$<2>, bold=\E[1m$<2>,
clear=\E[H\E[J$<50>, cr=\r, csr=\E[%i%p1%d;%p2%dr,
cub=\E[%p1%dD, cub1=\b, cud=\E[%p1%dB, cud1=\n,
cuf=\E[%p1%dC, cuf1=\E[C$<2>,
cup=\E[%i%p1%d; %p2%dH$<5>, cuu=\E[%p1%dA,
cuu1=\E[A$<2>, ed=\E[J$<50>, el=\E[K$<3>,
el1=\E[1K$<3>, enacs=\E(B\E)0, home=\E[H, ht=\t,
hts=\EH, ind=\n, ka1=\EOq, ka3=\EOs, kb2=\EOr, kbs=\b,
kc1=\EOp, kc3=\EOn, kcub1=\EOD, kcud1=\EOB,
kcuf1=\EOC, kcuu1=\EOA, kent=\EOM, kf0=\EOy, kf1=\EOP,
kf10=\EOx, kf2=\EOQ, kf3=\EOR, kf4=\EOS, kf5=\EOt,
kf6=\EOu, kf7=\EOv, kf8=\EOl, kf9=\EOw, rc=\E8,
rev=\E[7m$<2>, ri=\EM$<5>, rmacs=^O, rmkx=\E[?11\E>,
rmso=\E[m$<2>, rmul=\E[m$<2>,
rs2=\E>\E[?31\E[?41\E[?51\E[?7h\E[?8h, sc=\E7,
sgr=\E[0%?%p1%p6%|%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;m%?%p9%t^N%e^O%;,
sgr0=\E[m^0$<2>, smacs=^N, smkx=\E[?1h\E=,
smso=\E[1;7m$<2>; smul=\E[4m$<2>, tbc=\E[3g,
Каждое определение в terminfo состоит из трех типов элементов. Каждый элемент называется capname (имя характеристики) и определяет характеристику терминала.
Булевы или логические характеристики просто обозначают наличие или отсутствие поддержки терминалом конкретного свойства. Например, булева характеристика xon присутствует, если терминал поддерживает управление потоком XON/XOFF.
Числовые характеристики определяют размеры или объемы, например lines — это количество строк на экране, a cols — количество столбцов. Число отделяется от имени характеристики символом #. Для описания терминала с 80 столбцами и 24 строками следует написать cols#80, lines#24.
Строковые характеристики немного сложнее. Они применяются для двух разных типов характеристик: определения строк вывода, необходимых для доступа к функциям терминала, и определения строк ввода, которые будут получены, когда пользователь нажмет определенные клавиши, обычно функциональные или специальные клавиши на цифровой клавиатуре. Некоторые строковые параметры очень просты, например el, что означает "стереть до конца строки". Для того чтобы сделать это на терминале VT100, потребуется escape-последовательность Esc, [, K. В исходном формате terminfo это записывается как е1=\Е[K.
Специальные клавиши определены аналогичным образом. Например, функциональная клавиша <F1> на терминале VT100 посылает последовательность Esc, O, P, которая определяется как kf1=\EOP.
Все несколько усложняется, если escape-последовательности требуются какие-либо параметры. Большинство терминалов могут перемещать курсор в заданные строку и столбец. Ясно, что неразумно хранить отдельную характеристику для каждой точки экрана, в которую можно переместить курсор, поэтому применяется общая строковая характеристика с параметрами, определяющими значения, которые вставляются при использовании характеристики. Например, терминал VT100 использует последовательность Esc, [, <row>, <col>, H для перемещения курсора в заданную позицию. В исходном формате terminfo это записывается довольно устрашающе: cup=\E[%i%p1%d;%p2%dH$<5>.
Эта строка означает следующее:
□ \E — послать escape-символ;
□ [ — послать символ [;
□ %i — дать приращение аргументам;
□ %p1 — поместить первый аргумент в стек;
□ %d — вывести число из стека как десятичное;
□ ; — послать символ ;;
□ %р2 — поместить второй аргумент в стек;
□ %d — вывести число из стека как десятичное;
□ H —послать символ H.
Данная запись кажется сложной, но позволяет задавать параметры в строгом порядке, не зависящем от порядка, в котором терминал ожидает их появления в финальной escape-последовательности. Приращение аргументов %i необходимо, поскольку стандартная адресация курсора задается, начиная от верхнего левого угла экрана (0, 0), а терминал VT100 обозначает начальную позицию курсора как (1, 1). Заключительные символы $<5> означают, что для обработки терминалом перемещения курсора требуется задержка, эквивалентная времени вывода пяти символов.
Примечание. Мы могли бы описывать огромное множество характеристик, но, к счастью, в основном системы UNIX и Linux приходят с большинством предопределенных терминалов. Если нужно добавить новую модель терминала, вы можете найти полный список характеристик на странице интерактивного справочного руководства, посвященной terminfo. Лучше всего начать с поиска включенного в базу данных терминала, похожего на ваш новый, и затем создания описания новой модели как вариации существующего, т. е. осуществить последовательный просмотр характеристик, одну за другой, и исправление нуждающихся в корректировке.Применение характеристик terminfo.
Теперь, когда вы знаете, как определить характеристики терминала, нужно научиться обращаться к ним. Когда используется terminfo, прежде всего вам нужно задать тип терминала, вызвав функцию setupterm. Она инициализирует структуру TERMINAL для текущего типа терминала. После этого вы сможете запрашивать характеристики терминала и применять его функциональные возможности. Делается это с помощью вызова setupterm, подобного приведенному далее:
#include <term.h>
int setupterm(char *term, int fd, int *errret);
Библиотечная функция setupterm задает текущий тип терминала в соответствии с заданным параметром term. Если term — пустой указатель, применяется переменная окружения TERM. Открытый дескриптор файла, предназначенный для записи на терминал, должен передаваться в параметре fd. Результат функции хранится в целой переменной, на которую указывает errret, если это не пустой указатель. Могут быть записаны следующие значения:
□ -1 — нет базы данных terminfo;
□ 0 — нет совпадающего элемента в базе данных terminfo;
□ 1 — успешное завершение.
Функция setupterm возвращает константу OK в случае успешного завершения и ERR в случае сбоя. Если на параметр errret установлен как пустой указатель, setupterm выведет диагностическое сообщение и завершит программу в случае своего аварийного завершения, как в следующем примере:
#include <stdio.h>
#include <term.h>
#include <curses.h>
#include <stdlib.h>
int main() {
setupterm("unlisted", fileno(stdout), (int *)0);
printf("Done.\n");
exit(0);
}
Результат выполнения этой программы в вашей системе может не быть точной копией приведенного далее, но его смысл будет вполне понятен. " Done." не выводится, поскольку функция setupterm после своего аварийного завершения вызвала завершение программы:
$ cc -о badterm badterm.с -lncurses
$ ./badterm
'unlisted': unknown terminal type.
$
Обратите внимание на строку компиляции в примере: в этой системе Linux мы используем реализацию ncurses библиотеки curses со стандартным заголовочным файлом, находящимся в стандартном каталоге. В таких системах вы можете просто включить файл curses.h и задать -lncurses для библиотеки.
В функции выбора пункта меню хорошо было бы иметь возможность очищать экран, перемещать курсор по экрану и записывать его положение на экране. После вызова функции setupterm вы можете обращаться к характеристикам базы данных terminfo с помощью вызовов трех функций, по одной на каждый тип характеристики:
#include <term.h>
int tigetflag(char *capname);
int tigetnum(char *capname);
char *tigetstr(char *capname);
Функции tigetflag, tigetnum и tigetstr возвращают значения характеристик terminfo булева или логического, числового и строкового типов соответственно. В случае сбоя (например, характеристика не представлена) tigetflag вернет -1, tigetnum — -2, a tigetstr — (char*)-1.
Вы можете применять базу данных terminfo для определения размера экрана терминала, извлекая характеристики cols и lines с помощью следующей программы sizeterm.c:
#include <stdio.h>
#include <term.h>
#include <curses.h>
#include <stdlib.h>
int main() {
int nrows, ncolumns;
setupterm(NULL, fileno(stdout), (int *)0);
nrows = tigetnum("lines");
ncolumns = tigetnum("cols");
printf("This terminal has %d columns and %d rows\n", ncolumns, nrows);
exit(0);
}
$ echo $TERM
vt100
$ ./sizeterm
This terminal has 80 columns and 24 rows
Если запустить эту программу в окне рабочей станции, вы получите результат, отражающий размер текущего окна:
$ echo $TERM
xterm
$ ./sizeterm
This terminal has 88 columns and 40 rows
$
Если применить функцию tigetstr для получения характеристики перемещения курсора ( cup) терминала типа xterm, вы получите параметризованный ответ: \Е[%p1%d;%p2%dH.
Этой характеристике требуются два параметра: номер строки и номер столбца, в которые перемещается курсор. Обе координаты измеряются, начиная от нулевого значения в левом верхнем углу экрана.
Вы можете заменить параметры в характеристике реальными значениями с помощью функции tparm. До девяти параметров можно заменить значениями и получить в результате применяемую escape-последовательность символов.
#include <term.h>
char *tparm(char *cap, long p1, long p2, ..., long p9);
После формирования escape-последовательности с помощью tparm, ее нужно отправить на терминал. Для корректной обработки этой последовательности не следует пересылать строку на терминал с помощью функции printf. Вместо нее примените одну из специальных функций, обеспечивающих корректную обработку любых задержек, необходимых для завершения операции, выполняемой терминалом. К ним относятся следующие:
#include <term.h>
int putp(char *const str);
int tputs(char *const str, int affcnt, int (*putfunc)(int));
В случае успешного завершения функция putp вернет константу OK,в противном случае — ERR. Эта функция принимает управляющую строку терминала и посылает ее в стандартный вывод stdout.
Итак, для перемещения в строку 5 и столбец 30 на экране можно применить блок программного кода, подобный приведенному далее:
char *cursor;
char *esc_sequence;
cursor = tigetstr("cup");
esc_sequence = tparm(cursor, 5, 30);
putp(esc_sequence);
Функция tputs предназначена для ситуаций, в которых терминал не доступен через стандартный вывод stdout, и позволяет задать функцию, применяемую для вывода символов. Она возвращает результат заданной пользователем функции putfunc. Параметр affcnt предназначен для обозначения количества строк, подвергшихся изменению. Обычно он устанавливается равным 1. Функция, используемая для вывода строки, должна иметь те же параметры и возвращать тип значения как у функции putfunc. В действительности putp(string) эквивалентна вызову tputs (string, 1, putchar). В следующем примере вы увидите применение функции tputs, используемой с функцией вывода, определенной пользователем.
Имейте в виду, что в некоторых старых дистрибутивах Linux последний параметр функции tputs определен как int (*putfunc)(char), что заставит вас изменить определение функции char_to_terminal из упражнения 5.6.
Примечание. Если вы обратитесь к страницам интерактивного справочного руководства за информацией о функции tparm и характеристиках терминалов, то можете встретить функцию tgoto. Причина, по которой мы не используем эту функцию, хотя она, очевидно, предлагает более легкий способ перемещения курсора, заключается в том, что она не включена в стандарт X/Open (Single UNIX Specification Version 2) по данным издания 1997 г. Следовательно, мы не рекомендуем применять любую из этих функций в ваших новых программах.Вы почти готовы добавить обработку экрана в вашу функцию выбора пункта меню. Единственно, что осталось, — очистить экран просто с помощью свойства clear. Некоторые терминалы не поддерживают характеристику clear, которая помещает курсор в левый верхний угол экрана. В этом случае вы можете поместить курсор в левый верхний угол и применить команду ed — удалить до конца экрана.
Для того чтобы собрать всю полученную информацию вместе, напишем окончательную версию примера программы выбора пункта меню screenmenu.c, в которой вы "нарисуете" варианты пунктов меню на экране для того, чтобы пользователь выбрал нужный пункт (упражнение 5.6).
Упражнение 5.6. Полное управление терминалом.
Вы можете переписать функцию getchoice из программы menu4.c для предоставления полного управления терминалом. В этом листинге функция main пропущена, потому что она не меняется. Другие отличия от программы menu4.c выделены цветом.
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <termios.h>
#include <term.h>
#include <curses.h>
static FILE* output_stream = (FILE *)0;
char *menu[] = {
"a — add new record",
"d — delete record",
"q - quit",
NULL,
};
int getchoice(char *greet, char *choices[], FILE *in, FILE *out);
int char_to_terminal(int_char_to_write);
int main() {
...
}
int getchoice(char *greet, char* choices[], FILE[]* in, FILE* out) {
int chosen = 0;
int selected;
int screenrow, screencol = 10;
char **option;
char* cursor, *clear;
output_stream = out;
setupterm(NULL, fileno(out), (int*)0);
cursor = tigetstr("cup");
clear = tigetstr("clear");
screenrow =4;
tputs(clear, 1, (int*)char_to_terminal);
tputs(tparm(cursor, screenrow, screencol), 1, char_to_terminal);
fprintf(out, "Choice: %s", greet);
screenrow += 2;
option = choices;
while (*option) {
ftputs(tparm(cursor, screenrow, screencol), 1, char_to_terminal);
fprintf(out, "%s", *option);
screenrow++;
option++
}
fprintf(out, "\n");
do {
fflush(out);
selected = fgetc(in);
option = choices;
while (*option) {
if (selected == *option[0]) {
chosen = 1;
break;
}
option++;
}
if (!chosen) {
tputs(tparm(cursor, screenrow, screencol), 1, char_to_terminal);
fprintf(out, "Incorrect choice, select again\n");
}
} while (!chosen);
tputs(clear, 1, char_to_terminal);
return selected;
}
int char_to_terminal(int char_to_write) {
if (output_stream) putc(char_to_write, output_stream);
return 0;
}
Сохраните эту программу как menu5.с.
Как это работает
Переписанная функция getchoice выводит то же меню, что и в предыдущих примерах, но подпрограммы вывода изменены так, чтобы можно было воспользоваться характеристиками из базы данных terminfo. Если вы хотите видеть на экране сообщение "You have chosen:" дольше, чем одно мгновение перед очисткой экрана и подготовкой его к следующему выбору пункта меню, добавьте в функцию main вызов sleep:
do {
choice = getchoice("Please select an action", menu, input, output);
printf("\nYou have chosen: %c\n", choice);
sleep(1);
} while (choice != 'q');
Последняя функция в этой программе char_to_terminal включает в себя вызов функции putc, которую мы упоминали в главе 3.
В завершение этой главы бегло рассмотрим пример определения нажатий клавиш.
Обнаружение нажатий клавиш.
Пользователи, программировавшие в ОС MS-DOS, часто ищут в ОС Linux эквивалент функции kbhit, которая определяет, была ли нажата клавиша, без реального ее считывания. К сожалению, их поиски оказываются безуспешными, поскольку прямого аналога нет. Программисты в среде UNIX не ощущают этого отсутствия, т.к. UNIX запрограммирована так, что программы очень редко (если когда-либо вообще) озабочены ожиданием события. Поскольку это обычный способ применения kbhit, ее нехватка редко ощущается в системах UNIX и Linux.
Однако, когда вы переносите программы из MS-DOS, часто удобно эмулировать функцию kbhit, которую можно применять на деле в неканоническом режиме ввода (упражнение 5.7).
Упражнение 5.7. Исключительно ваша собственная kbhit.
1. Начните со стандартной заголовочной информации и пары структур для установки параметров терминала. peek_character применяется для проверки нажатия клавиши. Далее описываются функции, которые будут использоваться позже:
#include <stdio.h>
#include <stdlib.h>
#include <termios.h>
#include <term.h>
#include <curses.h>
#include <unistd.h>
static struct termios initial_settings, new_settings;
static int peek_character = -1;
void init_keyboard();
void close_keyboard();
int kbhit();
int readch();
2. Функция main вызывает функцию init_keyboard для настройки терминала, затем выполняет цикл один раз в секунду, каждый раз вызывая в нем функцию kbhit. Если нажата клавиша <q>, функция close_keyboard восстанавливает нормальный режим и программа завершается:
int main() {
int ch = 0;
init_keyboard();
while (ch != 'q') {
printf("looping\n");
sleep(1);
if (kbhit()) {
ch = readch();
printf("you hit %c\n", ch);
}
}
close_keyboard();
exit(0);
}
3. Функции init_keyboard и close_keyboard настраивают терминал в начале и конце программы:
void init_keyboard() {
tcgetattr(0, &initial_settings);
new_settings = initial_settings;
new_settings.c_lflag &= ~ICANON;
new_settings.c_lflag &= ~ECHO;
new_settings.c_lflag &= ~ISIG;
new_settings.c_cc[VMIN] = 1;
new_settings.c_cc[VTIME] = 0;
tcsetattr(0, TCSANOW, &new_settings);
}
void close_keyboard() {
tcsetattr(0, TCSANOW, &initial_settings);
}
4. Теперь функция, проверяющая нажатие клавиши:
int kbhit() {
char ch;
int nread;
if (peek_character != -1) return 1;
new_settings.c_cc[VMIN] = 0;
tcsetattr(0, TCSANOW, &new_settings);
nread = read(0, sch, 1);
newrsettings.c_cc[VMIN] = 1;
tcsetattr(0, TCSANOW, &new_settings);
if (nread == 1) {
peek_character = ch;
return 1;
}
return 0;
}
5. Нажатый символ считывается следующей функцией readch, которая затем восстанавливает значение -1 переменной peek_character для выполнения следующего цикла:
int readch() {
char ch;
if (peek_character != -1) {
ch = peek_character;
peek_character = -1;
return ch;
}
read(0, &ch, 1);
return ch;
}
Когда вы выполните программу (kbhit.c), то получите следующий вывод:
$ ./kbhit
looping
looping
looping
you hit h
looping
looping
looping
you hit d
looping
you hit q
$
Как это работает
Терминал настраивается в функции init_keyboard на считывание одного символа ( MIN=1, TIME=0). Функция kbhit изменяет это поведение на проверку ввода и его немедленный возврат ( MIN=0, TIME=0) и затем восстанавливает исходные установки перед завершением.
Обратите внимание на то, что вы должны считать символ нажатой клавиши, но сохраняете его локально, готовые вернуть символ в вызывающую программу по ее требованию.
Виртуальные консоли.
ОС Linux предоставляет средство, называемое виртуальными консолями. Экран, клавиатуру и мышь одного ПК может использовать ряд терминальных устройств, доступных на этом компьютере. Обычно установка ОС Linux рассчитана на использование от 8 до 12 виртуальных консолей. Виртуальные консоли становятся доступными благодаря символьным устройствам /dev/ttyN, где N — номер, начинающийся с 1.
Если вы регистрируетесь в вашей системе Linux в текстовом режиме, как только система активизируется, вам будет предложено регистрационное приглашение. Далее вы регистрируетесь с помощью имени пользователя и пароля. В этот момент используемое вами устройство — первая виртуальная консоль, терминальное устройство /dev/tty1.
С помощью команд who и ps вы можете увидеть, кто зарегистрировался и какие командная оболочка и программы выполняются на этой виртуальной консоли:
$ who
neil tty1 Mar 8 18:27
$ ps -e
PID TTY TIME CMD
1092 tty1 00:00:00 login
1414 tty1 00:00:00 bash
1431 tty1 00:00:00 emacs
Из этого укороченного вывода видно, что пользователь neil зарегистрировался и запустил редактор Emacs на консоли ПК, устройстве /dev/tty1.
Обычно ОС Linux запускается с процессом getty, выполняющимся на первых шести виртуальных консолях, поэтому есть возможность зарегистрироваться шесть раз, используя одни и те же экран, клавиатуру и мышь. Увидеть эти процессы можно с помощью и команды ps:
$ ps -а
PID TTY TIME CMD
1092 tty1 00:00:00 login
1093 tty2 00:00:00 mingetty
1094 tty3 00:00:00 mingetty
1095 tty4 00:00:00 mingetty
1096 tty5 00:00:00 mingetty
1097 tty6 00:00:00 mingetty
В этом выводе представлен стандартный вариант программы getty для обслуживания консоли в системе SUSE, mingetty, выполняющийся на пяти следующих виртуальных консолях и ожидающий регистрации пользователя.
Переключаться между виртуальными консолями можно с помощью комбинации клавиш <Ctrl>+<Alt>+<FN>, где N — номер виртуальной консоли, на которую вы хотите переключиться. Таким образом, для того чтобы перейти на вторую виртуальную консоль, нажмите <Ctrl>+<Alt>+<F2>, и <Ctrl>+<Alt>+<F1>, чтобы вернуться на первую консоль. (При переключении из регистрации в текстовом режиме, а не графическом, также работает комбинация клавиш <Ctrl>+<FN>.)
Если в Linux запущена регистрация в графическом режиме, либо с помощью программы startx илн менеджера экранов xdm, на первой свободной консоли, обычно /dev/tty7, стартует графическая оболочка X Window System. Переключиться с нее на текстовую, консоль вы сможете с помощью комбинации клавиш <Ctrl>+<Alt>+<FN>, а вернуться с помощью <Ctrl>+<Alt>+<F7>.
В ОС Linux можно запустить более одного сеанса X. Если вы сделаете это, скажем, с помощью следующей команды
$ startx -- :1
Linux запустит сервер X на следующей свободной виртуальной консоли, в данном случае на /dev/tty8, и переключаться между ними вы сможете с помощью комбинаций клавиш <Ctrl>+<Alt>+<F8> и <Ctrl>+<Alt>+<F7>.
Во всех остальных отношениях виртуальные консоли ведут себя как обычные терминалы, описанные в этой главе. Если процесс обладает достаточными правами, виртуальные консоли можно открывать, считывать с них данные, писать на них информацию точно так же, как в случае обычного терминала.
Псевдотерминалы.
У многих UNIX-подобных систем, включая Linux, есть средство, именуемое псевдотерминалом. Это устройства, очень похожие на терминалы, которые мы использовали в данной главе, за исключением того, что у них нет связанного с ними оборудования. Они могут применяться для предоставления терминалоподобного интерфейса другим программам.
Например, с помощью псевдотерминалов возможно создание двух программ, играющих друг с другом в шахматы, не взирая на тот факт, что сами по себе программы проектировались для взаимодействия посредством терминала с человеком-игроком. Приложение, действующее как посредник, передает ходы одной программы другой и обратно. Оно применяет псевдотерминалы, чтобы обмануть программы и заставить их вести себя нормально при отсутствии терминала.
Одно время реализация псевдотерминалов (если вообще существовала) сильно зависела от конкретной системы. Сейчас они включены в стандарт Single UNIX Specification (единый стандарт UNIX) как UNIX98 Pseudo-Terminals (псевдотерминалы стандарта UNIX98) или PTY.
Резюме.
В этой главе вы узнали о трех аспектах управления терминалом. В начале главы рассказывалось об обнаружении перенаправления и способах прямого диалога с терминалом в случае перенаправления дескрипторов стандартных файлов. Вы посмотрели на аппаратную модель терминала и немного познакомились с его историей. Затем вы узнали об общем терминальном интерфейсе и структуре termios, предоставляющей в ОС Linux возможность тонкого управления и манипулирования терминалом. Вы также увидели, как применять базу данных terminfo и связанные с ней функции для управления в аппаратно-независимом стиле выводом на экран, и познакомились с приемами мгновенного обнаружения нажатий клавиш. В заключение вы узнали о виртуальных консолях и псевдотерминалах.
Глава 6. Управление текстовыми экранами с помощью библиотеки curses.
В главе 5 вы узнали, как улучшить управление вводом символов и как обеспечить вывод символов способом, не зависящим от особенностей конкретного терминала. Проблема использования общего терминального интерфейса (GTI или termios) и манипулирование escape-последовательностями с помощью tparm и родственных функций заключается в необходимости применения большого объема программного кода низкого уровня. Для многих программ предпочтительней интерфейс высокого уровня. Мы хотели бы иметь возможность просто рисовать на экране и применять библиотеку функций для автоматического отслеживания аппаратных характеристик терминала.
В этой главе вы узнаете именно о такой библиотеке, называемой curses. Стандарт curses очень важен как компромисс между простыми "строковыми" программами и полностью графическими (которые обычно труднее программировать) программами в графической оболочке X Window System, такими как GTK+/GNOME и Qt/KDE, В ОС Linux есть библиотека svgatib (Super VGA Library, библиотека низкоуровневой графики), но она не является стандартной библиотекой UNIX, поэтому обычно не доступна в других UNIX-подобных операционных системах.
Библиотека curses применяется во многих полноэкранных приложениях как довольно легкий и аппаратно-независимый способ разработки полноэкранных, хотя и символьных программ. Такие программы почти всегда легче писать с помощью библиотеки curses, чем непосредственно применять escape-последовательности. Эта библиотека также может управлять клавиатурой, обеспечивая легкий в использовании, не блокирующий режим ввода символов.
Вы можете столкнуться с тем, что несколько примеров из этой главы не всегда будут отображаться на простой консоли Linux так, как вы ожидали. Бывают случаи, когда сочетание библиотеки curses и определения консоли терминала получается немного не согласованным и приводит в результате к несколько странным компоновкам при использовании curses. Но если для отображения вывода применить графическую оболочку X Window System и окно xterm, все встанет на свои места.
В этой главе обсуждаются следующие темы:
□ применение библиотеки curses:
□ основные идеи curses;
□ управление базовыми вводом и выводом;
□ использование множественных окон;
□ применение режима дополнительной клавиатуры (keypad mode);
□ добавление цвета.
Мы закончим главу переработкой на языке С программы, управляющей коллекцией компакт-дисков, подытожив все, чему вы научились к этому моменту.
Компиляция с библиотекой curses.
Библиотека curses получила свое название благодаря способности оптимизировать перемещение курсора и минимизировать необходимые обновления экрана, а следовательно, уменьшить количество символов, нуждающихся в пересылке на текстовый терминал. Несмотря на то, что сейчас количество символов вывода гораздо менее важно, чем во времена неинтеллектуальных терминалов и низкоскоростных модемов, библиотека curses выжила как полезное дополнение к набору инструментов программиста.
Поскольку curses — это библиотека, для ее применения необходимо включить в программу заголовочный файл, объявления функций и макросы из соответствующей системной библиотеки. Существует несколько разных реализаций библиотеки curses. Первоначальная версия появилась в системе BSD UNIX и затем была включена в разновидности UNIX стиля System V прежде, чем была стандартизована группой X/Open. Система Linux использует вариант ncurses ("new curses") — свободно распространяемую версию System V Release 4.0 curses, разработанную для Linux. Эта реализация хорошо переносится на другие версии UNIX, хотя и содержит несколько непереносимых дополнительных функций. Есть даже версии библиотеки для MS-DOS и Windows. Если вы увидите, что библиотека curses, поставляемая с вашей версией системы UNIX, не поддерживает некоторые функции, попытайтесь получить копию альтернативной библиотеки ncurses. Обычно пользователи ОС Linux обнаруживают уже установленную библиотеку ncurses или, по крайней мере, ее компоненты, необходимые для выполнения программ на базе библиотеки curses. Если инструментальные библиотеки для нее заранее не установлены в вашем дистрибутиве (нет файла curses.h или файла библиотеки curses для редактирования связей), для большинства основных дистрибутивов их всегда можно найти в виде стандартного пакета с именем наподобие ibncurses5-dev.
Примечание. В стандарте X/Open определены два варианта curses: базовый и расширенный. Расширенный вариант библиотеки curses содержит разнородную кучу дополнительных функций, включая ряд функций для обработки многостолбцовых символов и подпрограммы управления цветом. Кроме приведенного далее в этой главе описания способов управления цветом, мы будем в основном привязаны к функциям базовой версии библиотеки.При компиляции программ, использующих curses, следует подключить заголовочный файл curses.h и на этапе редактирования связей саму библиотеку с помощью аргумента -lcurses. Во многих системах Linux вы можете применять просто библиотеку curses, а потом обнаружить, что на самом деле вы пользуетесь усовершенствованной, более новой реализацией ncurses.
Для того чтобы проверить, как установлена библиотека curses в вашей системе, выполните команду
ls -l /usr/include/*curses.h
для просмотра заголовочных файлов и
ls -l /usr/lib/lib*curses*
для проверки библиотечных файлов. Если вы увидите, что curses.h и ncurses.h — прямо связанные файлы, и существует файл библиотеки ncurses, то у вас есть возможность компилировать файлы из этой главы с помощью следующей команды:
$ gcc program. с -о program -lcurses
Если установка curses в вашей системе не использует автоматически ncurses, вы сможете явно задать использование ncurses, включив файл ncurses.h вместо файла curses.h и выполнив следующую команду:
$ gcc -I/usr/include/ncurses program.с -о program -lncurses
в которой опция -I задает каталог для поиска заголовочного файла.
Примечание. В загружаемом коде сценария Makefile предполагается, что в установленной у вас системе по умолчанию применяется библиотека curses, поэтому вы должны заменить его или откомпилировать вручную, если в вашей системе это не так.Если вы точно не знаете, как установлена библиотека curses в вашей системе, обратитесь к страницам интерактивного справочного руководства, посвященным ncurses, или просмотрите другую интерактивную документацию; обычное место ее хранения — каталог /usr/share/doc/, в котором вы найдете каталог curses или ncurses часто с присоединенным в конце номером версии.
Терминология библиотеки curses и общие представления.
Подпрограммы curses действуют на экранах, в окнах и вложенных окнах или подокнах. Экран — это устройство (обычно экран терминала, но может быть и экран эмулятора терминала xterm), на который вы записываете информацию. Он занимает все доступное пространство дисплея этого устройства, Если экран — окно терминала в графическом окне, то он представляет собой совокупность всех доступных символьных позиций в окне терминала. Всегда существует, по крайней мере, одно окно curses с именем stdscr, совпадающее по размеру с физическим экраном. Вы можете создавать дополнительные окна с размером, меньшим, чем размер экрана. Окна могут накладываться друг на друга и иметь много вложенных окон, но каждое из них всегда должно находиться внутри родительского окна.
Библиотека curses поддерживает две структуры данных, действующие как отображение экрана терминала: stdscr и curscr. Структура stdscr, наиболее важная из двух, обновляется, когда функции curses формируют вывод. Структура данных stdscr — "стандартный экран". Она действует во многом так же, как стандартный вывод stdout из библиотеки stdio. Эта структура — стандартное окно вывода в программах, использующих библиотеку curses. Структура curscr похожа на stdscr, но хранит внешний вид отображаемого в текущий момент экрана. Вывод, записанный в структуру stdscr, не появляется на экране до тех пор, пока программа не вызовет функцию refresh, в которой библиотека curses сравнивает содержимое stdscr (как должен выглядеть экран) со второй структурой curscr (как выглядит экран в данный момент). Затем curses использует различия между этими двумя структурами для обновления экрана.
Некоторым программам с использованием curses нужно знать, что библиотека поддерживает структуру stdscr, которая применяется в нескольких функциях curses как параметр. Однако действительная структура stdscr реализуется по-разному, и к ней никогда не следует обращаться напрямую. У программ с использованием curses практически нет нужды в применении структуры curscr.
Таким образом, процесс вывода символов в программе с применением curses выглядит следующим образом:
1. Используется функция библиотеки curses для обновления логического экрана.
2. Запрашивается у библиотеки curses обновление физического экрана с помощью функции refresh.
Преимущество двухшагового подхода помимо большей легкости при программировании — очень эффективный вариант обновления экрана curses. Это может быть не столь важно для экрана консоли, но становится существенным показателем, если программа выполняется через медленное сетевое соединение.
Программа с использованием curses выполнит множество вызовов функций вывода на логический экран, возможно, перемещая курсор по всему экрану для того, чтобы достичь нужной позиции вывода текста или рисования линий и рамок. На каком-то этапе пользователю потребуется увидеть весь этот вывод. Когда это произойдет (обычно во время вызова функции refresh), библиотека curses найдет оптимальный способ формирования физического экрана, соответствующего логическому. Применяя нужные характеристики терминала и оптимизируя перемещения курсора, curses часто обновляет экран, выводя гораздо меньше символов по сравнению со всеми операциями записи на экран, если бы они выполнялись немедленно.
Макет логического экрана — это символьный массив, упорядоченный по строкам и столбцам, с начальной позицией экрана (0, 0) в левом верхнем углу (рис. 6.1).

Рис. 6.1
Во всех функциях библиотеки curses применяются координаты со значением у (строки) перед значением х (столбцы). Каждая позиция хранит не только символ, расположенный в этом месте экрана, но и его атрибуты. Атрибуты, которые можно отобразить, зависят от физических характеристик терминала, но, как правило, они включают жирное начертание и подчеркивание символа. На консолях Linux вам также доступны негативное изображение и цвет, о которых речь пойдет далее в этой главе.
Поскольку библиотека curses нуждается в создании и удалении некоторых временных структур данных, все программы с использованием curses должны инициализировать библиотеку перед применением и затем разрешить ей восстановить первоначальные установки после ее применения. Делается это с помощью вызовов пары функций: initscr и endwin (упражнение 6.1).
Упражнение 6.1. Программа с использованием curses, выводящая приветствие.
В этом примере вы напишите очень простую использующую curses программу screen1.c, чтобы показать эти и другие базовые функции в действии. Далее будут описаны их прототипы.
1. Вставьте заголовочный файл curses.h и в функцию main, включите вызовы для инициализации и возврата в исходное состояние библиотеки curses:
#include <unistd.h>
#include <stdlib.h>
#include <curses.h>
int main() {
initscr();
...
endwin();
exit(EXIT_SUCCESS);
}
2. Внутрь поместите код для перемещения курсора в точку (5, 15) на логическом экране, выведите приветствие "Hello World" и обновите реальный экран. В заключение примените вызов sleep(2) для того, чтобы приостановить выполнение программы на две секунды и просмотреть вывод на экран перед ее завершением:
move(5, 15);
printw("%s", "Hello World");
refresh();
sleep(2);
Пока программа выполняется, вы видите фразу "Hello World" в левом верхнем квадранте пустого экрана (рис. 6.2).

Рис. 6.2
Как это работает
Эта программа инициализирует библиотеку curses, перемещает курсор в заданную точку экрана и отображает некоторый текст. После короткой паузы она закрывает библиотеку и завершается.
Экран.
Как: вы уже видели, все программы с использованием curses должны начинаться с вызова функции initscr и заканчиваться вызовом функции endwin. Далее приведены их описания из заголовочного файла.
#include <curses.h>
WINDOW *initscr(void);
int endwin(void);
Функция initscr должна вызываться только один раз в каждой программе. В случае успешного завершения она возвращает указатель на структуру stdscr. Если функция заканчивается аварийно, она просто выводит диагностическое сообщение об ошибке и вызывает завершение программы.
Функция endwin возвращает константу OK в случае успешного завершения и err в случае неудачи. Вы можете вызвать ее для того, чтобы покинуть curses, а позже возобновить функционирование библиотеки curses, вызвав clearok(stdscr, 1) и refresh. Это позволит библиотеке совершенно забыть, как выглядит физический экран, и заставит ее выполнить полное обновление экрана.
Вывод на экран.
Для обновления экрана предоставляется несколько базовых функций.
#include <curses.h>
int addch(const chtype char_to_add);
int addchstr(chtype *const string_to_add);
int printw(char *format, ...);
int refresh(void);
int box(WINDOW *win_ptr, chtype vertical_char, chtype horizontal_char);
int insch(chtype char_to_insert);
int insertln(void);
int delch(void);
int deleteln(void);
int beep(void);
int flash(void);
У библиотеки curses есть свой символьный тип данных chtype, который может содержать больше разрядов, чем стандартный тип char. В стандартной версии ncurses для ОС Linux chtype на самом деле — синоним стандартного типа unsigned long.
Функции addch и addchstr вставляют заданные символ или строку в текущую позицию на экране. Функция printw форматирует строку так же, как функция printf, и помещает в текущую позицию на экране. Функция refresh вызывает обновление физического экрана, возвращая OK в случае успеха и ERR при возникновении ошибки. Функция box позволяет нарисовать рамку вокруг окна.
Примечание. В стандартной библиотеке curses вы можете применять только "обычные" символы для рисования горизонтальных и вертикальных линий. В расширенной версии библиотеки можно использовать два определения, ASC_VLINE и ACS_HLINE, для вывода символов вертикальных и горизонтальных линий соответственно, которые позволят нарисовать внешне более привлекательную рамку. Для этого ваш терминал должен поддерживать символы псевдографики. Обычно они лучше отображаются в окне эмулятора xterm, чем на стандартной консоли, но их поддержка полна корректировок или "заплат", поэтому мы полагаем, что вы откажетесь от их применения, если важна переносимость вашей программы.Функция insch вставляет символ, сдвигая имеющиеся символы вправо. При этом не определено, что произойдет в конце строки, результат зависит от используемого терминала. Функция insertln вставляет пустую строку, перемещая имеющиеся строки на одну вниз. Функции delch и deleteln аналогичны функциям insert.
Для получения звука можно вызвать функцию beep. Немногие терминалы не способны издавать звуки, в этом случае некоторые установки библиотеки curses при вызове beep заставят экран мигать. Если вы работаете в густонаселенном офисе и звуковые сигналы могут издавать многие компьютеры, возможно, вы сочтете мигание предпочтительным режимом. Как и ожидалось, функция flash вызывает мигание экрана, если это невозможно, она попробует заставить терминал издать звуковой сигнал взамен.
Считывание с экрана.
Вы можете считывать символы с экрана, хотя эта функциональная возможность применяется нечасто, поскольку гораздо легче отслеживать то, что выводится. Если вам все-таки это потребуется, выполняйте считывание с помощью следующих функций:
#include <curses.h>
chtype inch(void);
int instr(char *string);
int innstr(char *string, int number_of_characters);
Функция inch должна быть всегда доступна, а функции instr и innstr не всегда поддерживаются. Функция inch возвращает символ из текущей позиции курсора на экране и данные о его атрибутах. Обратите внимание на то, что функция возвращает значение не char, a chtype, в то время как функции instr и innstr пишут в массивы с элементами типа char.
Очистка экрана.
Существует четыре основных способа очистки области экрана:
#include <curses.h>
int erase (void);
int clear(void);
int clrtobot(void);
int clrtoeol(void);
Функция erase записывает пробелы во все позиции экрана. Функция clear, как и erase, очищает экран, но вызывает перерисовку экрана с помощью внутреннего вызова низкоуровневой функции clear ok, которая выполняет последовательность очистки экрана и новое отображение экрана при следующем вызове refresh.
Функция clear обычно применяет команду терминала, которая очищает весь экран, а не пытается стереть текущие непробельные символы во всех точках экрана. Это делает функцию clear надежным средством очистки экрана. Сочетание функции clear с последующей функцией refresh может обеспечить удобную команду перерисовки экрана в том случае, когда изображение на экране беспорядочно или испорчено каким-либо образом.
Функция clrtobot очищает экран, начиная с текущей позиции курсора и далее до конца экрана, а функция clrtoeol очищает экран, начиная с текущей позиции курсора до конца строки, в которой находится курсор.
Перемещение курсора.
Для перемещения курсора применяется единственная функция с дополнительной командой, управляющей положением курсора после обновления экрана.
#include <curses.h>
int move(int new_y, int new_x);
int leaveok(WINDOW *window_ptr, bool leave_flag);
Функция move просто переносит позицию логического курсора в заданное место на экране. Напоминаем о том, что начало экранных координат (0, 0) находится в левом верхнем углу экрана. В большинстве версий библиотеки curses две глобальные целочисленные переменные, LINES и COLUMNS, определяют размер физического экрана и могут применяться для определения максимально допустимых значений параметров new_y и new_x. Вызов move сам по себе не приводит к перемещению физического курсора. Он только изменяет позицию на логическом экране, в которой появится следующий вывод. Если вы хотите, чтобы экранный курсор переместился немедленно после вызова функции move, вставьте следом за ним вызов функции refresh.
Функция leaveok устанавливает флаг, управляющий положением курсора на физическом экране после его обновления. По умолчанию флаг равен false, и после вызова refresh аппаратный курсор остается в той же точке экрана, что и логический курсор. Если флаг равен true, аппаратный курсор можно оставить в случайно выбранной точке экрана. Как правило, значение, устанавливаемое по умолчанию, предпочтительней, т.к. курсор остается в не лишенной смысла позиции.
Атрибуты символов.
У всех символов, обрабатываемых curses, могут быть определенные атрибуты, управляющие способом отображения символа на экране при условии, что оборудование, применяемое для их отображения, поддерживает требуемый атрибут. Определены следующие атрибуты: A_BLINK, A_BOLD, A_DIM, A_REVERSE, A_STANDOUT и A_UNDERLINE. Вы можете использовать перечисленные далее функции для установки атрибутов по одному или все вместе.
#include <curses.h>
int attron(chtype attribute);
int attroff(chtype attribute);
int attrset(chtype attribute);
int standout(void);
int standend(void);
Функция attrset устанавливает атрибуты curses, функции attron и attroff включают и отключают заданные атрибуты, не портя остальные, а функции standout и standend обеспечивают более выразительный режим выделения или "лучший из всех" режим. На большинстве терминалов выбирается инверсия.
Выполните упражнение 6.2.
Упражнение 6.2. Перемещение, вставка и атрибуты.
Теперь, когда вы знаете больше об управлении экраном, можно испытать более сложный пример moveadd.c. Вы включите несколько вызовов функций refresh и sleep в этот пример, чтобы на каждом шаге видеть, как выглядит экран. Обычно программы с использованием библиотеки curses стараются обновлять экран как можно реже, поскольку это не слишком высокопроизводительная операция. Программный код написан с некоторой долей искусственности для обеспечения большей наглядности.
1. Для начала вставьте несколько заголовочных файлов, определите несколько символьных массивов и указатель на них, а затем инициализируйте структуры библиотеки curses:
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <curses.h>
int main() {
const char witch_one[] = " First Witch ";
const char witch_two[] = " Second Witch ";
const char *scan_ptr;
initscr();
2. Теперь для трех начальных текстовых фрагментов, которые появляются на экране через определенные интервалы, включите и отключите соответствующие флаги атрибутов;
move(5, 15);
attron(A_BOLD);
printw("%s", "Macbeth");
attroff(A_BOLD);
refresh();
sleep(1);
move(8, 15);
attron(A_STANDOUT);
printw("%s", "Thunder and Lightning");
attroff(A_STANDOUT);
refresh();
sleep(1);
move(10, 10);
printw("%s", "When shall we three meet again");
move(11, 23);
printw("%s", "In thunder, lightning, or in rain ?");
move(13, 10);
printw("%s", "When the hurlyburly's done, ");
move(14, 23);
printw("%s", "When the battle's lost and won.");
refresh();
sleep(1);
3. Действующие лица идентифицированы, и их имена выводятся посимвольно:
attron(A_DIM);
scan_ptr = witch_one + strlen(witch_one) - 1;
while (scan_ptr != witch_one) {
move(10, 10);
insch(*scan_ptr--);
}
scan_ptr = witch_two + strlen(witch_two) - 1;
while (scan_ptr != witch_two) {
move(13, 10);
insch(*scan_ptr--);
}
attroff(A_DIM);
refresh();
sleep(1);
4. В заключение переместите курсор в правый нижний угол экрана, а затем подготовьте и выполните завершение:
move(LINES - 1, COLS - 1);
refresh();
sleep(1);
endwin();
exit(EXIT_SUCCESS);
}
Когда вы выполните программу, заключительный экран будет выглядеть так, как показано на рис. 6.3. К сожалению, снимок экрана не дает полного впечатления и не показывает курсор, установленный в правом нижнем углу экрана. Эмулятор xterm может быть более подходящей средой для точного отображения программ, чем обычная консоль.

Рис. 6.3
Как это работает
После инициализации некоторых переменных и экрана с помощью библиотеки curses вы применили функции move для перемещения курсора по экрану. Посредством функций attron и attroff вы управляли атрибутами текста, выводимого в заданную точку экрана. Далее перед закрытием библиотеки curses и завершением программа продемонстрировала, как вставлять символы функцией insch.
Клавиатура.
Наряду с предоставлением интерфейса, облегчающего управление экраном, библиотека curses также предлагает средства, облегчающие управление клавиатурой.
Режимы клавиатуры.
Процедуры считывания с клавиатуры управляются режимами. Режимы устанавливаются с помощью следующих функций:
#include <curses.h>
int echo(void);
int noecho(void);
int cbreak(void);
int nocbreak(void);
int raw(void);
int noraw(void);
Функции echo и noecho просто включают и отключают отображение символов, набираемых на клавиатуре. Оставшиеся четыре функции управляют тем, как символы, набранные на терминале, становятся доступны программе с применением curses. Для того чтобы понять функцию cbreak, необходимо иметь представление о стандартном режиме ввода. Когда программа, использующая библиотеку curses, стартует с вызова функции initscr, устанавливается режим ввода, называемый режимом с обработкой (cooked mode). Это означает построчную обработку, т.е. ввод становится доступен программе после нажатия пользователем клавиши <Enter> (или <Return> на некоторых клавиатурах). Специальные символы на клавиатуре включены, поэтому набор соответствующих клавиатурных последовательностей может сгенерировать сигнал в программе. Управление потоком, если терминал запускается с терминала, также включено. Вызывая функцию cbreak, программа может установить режим ввода cbreak, в котором символы становятся доступными программе сразу после их набора, а не помещаются в буфер и передаются программе только после нажатия клавиши <Enter>. Как и в режиме с обработкой, специальные символы клавиатуры действуют, а простые клавиши, например <Backspace>, передаются для обработки непосредственно в программу, поэтому если вы хотите, чтобы нажатие клавиши <Backspace> приводило к привычным действиям, то вы должны запрограммировать их самостоятельно.
Вызов функции raw отключает обработку специальных символов, поэтому становится невозможной генерация сигналов или управление потоком с помощью набранных на клавиатуре специальных символьных последовательностей. Вызов функции nocbreak возвращает режим ввода в режим с обработкой символов, но режим обработки специальных символов не изменяет; вызов noraw восстанавливает и режим с обработкой, и обработку специальных символов.
Клавиатурный ввод.
Чтение с клавиатуры — очень простая операция. К основным функциям чтения относятся следующие:
#include <curses.h>
int getch(void);
int getstr(char *string);
int getnstr(char *string, int number_of_characters);
int scanw(char *format, ...);
Все они действуют подобно своим аналогам, не входящим в библиотеку curses, getchar, gets и scanf. Обратите внимание на то, что у функции getstr нет возможности ограничить длину возвращаемой строки, поэтому применять ее следует с большой осторожностью. Если ваша версия библиотеки curses поддерживает функцию getnstr, позволяющую ограничить количество считываемых символов, всегда применяйте ее вместо функции getstr. Это очень напоминает поведение функций gets и fgets, с которыми вы познакомились в главе 3.
В упражнении 6.3 для демонстрации управления клавиатурой приведен пример короткой программы ipmode.c.
Упражнение 6.3. Режим клавиатуры и ввод.
1. Наберите программу и включите в нее начальные вызовы библиотеки curses:
#include <unistd.h>
#include <stdlib.h>
#include <curses.h>
#include <string.h>
#define PW_LEN 256
#define NAME_LEN 256
int main() {
char name[NAME_LEN];
char password[PW_LEN];
const char *real_password = "xyzzy";
int i = 0;
initscr();
move(5, 10);
printw("%s", "Please login:");
move(7, 10);
printw("%s", "User name: ");
getstr(name);
move(9, 10);
printw("%s", "Password: ");
refresh();
2. Когда пользователь вводит свой пароль, необходимо остановить отображение символов на экране. Далее сравните введенный пароль со строкой xyzzy:
cbreak();
noecho();
memset(password, '\0', sizeof(password));
while (i < PW_LEN) {
password[i] = getch();
if (password[i] == '\n') break;
move(8, 20 + i);
addch('*');
refresh();
i++;
}
3. В заключение восстановите отображение символов и выведите сообщение об успешном или неудачном завершении:
echo();
nocbreak();
move(11, 10);
if (strncmp(real_password, password, strlen(real_password)) == 0)
printw("%s", "Correct");
else printw("%s", "Wrong");
printw("%s", " password");
refresh();
sleep(2);
endwin();
exit(EXIT_SUCCESS);
}
Как это работает
Остановив отображение клавиатурного ввода и установив режим cbreak, вы выделяете область памяти, готовую к приему пароля. Каждый введенный символ пароля немедленно обрабатывается, и на экран выводится * в следующей позиции курсора. Вам необходимо каждый раз обновлять экран и сравнивать с помощью функции strcmp две строки: введенный и реальный пароли.
Примечание. Если вы пользуетесь очень старой версией библиотеки curses, вам, возможно, понадобится выполнить дополнительный вызов функции refresh перед вызовом функции getstr. В библиотеке ncurses вызов getstr обновляет экран автоматически.Окна.
До сих пор вы использовали терминал как средство полноэкранного вывода. Это вполне подходит для маленьких простых программ, но библиотека curses идет гораздо дальше. Вы можете на физическом экране одновременно отображать множество окон разных размеров. Многие из описанных в этом разделе функций поддерживаются в терминах стандарта X/Open так называемой "расширенной" версией curses. Но поскольку они поддерживаются библиотекой ncurses, не велика проблема сделать их доступными на большинстве платформ. Пора идти дальше и применить множественные окна. Вы увидите, как обобщаются до сих пор использовавшиеся команды и применяются в сценариях с множественными окнами.
Структура WINDOW.
Несмотря на то, что мы уже упоминали стандартный экран stdscr, пока у вас не было необходимости в его применении, поскольку почти все рассматриваемые до сих пор функции полагали, что они работают на экране stdscr, и не требовалось передавать его как параметр.
stdscr — это специальный случай структуры WINDOW, как stdout — специальный случай файлового потока. Обычно структура WINDOW объявляется в файле curses.h и, несмотря на то, что ее просмотр может быть очень поучителен, программы никогда не используют эту структуру напрямую, т.к. она может различаться в разных реализациях.
Вы можете создать и уничтожить окно с помощью вызовов функций newwin и delwin:
#include <curses.h>
WINDOW *newwin(int num_of_lines, int num_of_cols, int start_y, int start_x);
int delwin(WINDOW *window_to_delete);
Функция newwin создает новое окно в позиции экрана ( start_y, int start_x) и с заданным. количеством строк и столбцов. Она возвращает указатель на новое окно или NULL, если создать окно невозможно. Если вы хотите, чтобы правый нижний угол нового окна совпадал с правым нижним углом экрана, можно задать нулевое количество строк и столбцов. Все окна должны располагаться в пределах экрана. Функция newwin завершится аварийно, если какая-либо часть окна окажется за пределами экрана. Новое окно, созданное newwin, абсолютно независимо от всех уже имеющихся окон. По умолчанию оно помещается поверх существующих окон, скрывая (но не изменяя) их содержимое.
Функция delwin удаляет окно, созданное ранее с помощью функции newwin. Поскольку при вызове newwin, по всей вероятности, выделяется память, следует всегда удалять окна, когда в них больше нет нужды.
Примечание. Следите за тем, чтобы никогда не было попыток удалить собственные окна библиотеки curses: stdscr и curscr!Когда новое окно создано, как записать в него информацию? У всех уже рассмотренных функций есть универсальные версии, действующие в заданных окнах, и для удобства в них также включено перемещение курсора.
Универсальные функции.
Вы уже применяли функции addch и printw для вставки символов на экран. К этим функциям, как и ко многим другим, может быть добавлен префикс либо w для окна, либо mv для перемещения курсора, либо mvw для перемещения и окна. Если вы посмотрите заголовочный файл большинства версий библиотеки curses, то увидите, что многие функции, применявшиеся до сих пор, — простые макросы ( #defines), вызывающие эти более универсальные функции.
Когда добавляется префикс w, в начало списка аргументов должен быть вставлен указатель типа WINDOW. Когда добавляется префикс mv, в начало списка нужно вставить два дополнительных параметра, координаты y и х. Они задают позицию на экране, в которой выполняется операция, у и х — относительные координаты окна, точка (0, 0) находится в левом верхнем углу окна, а не экрана.
Когда добавляется префикс mvw, необходимо передавать в функцию три дополнительных параметра: указатель WINDOW и значения у и х. Как ни странно, указатель WINDOW всегда в списке предшествует экранным координатам, несмотря на то, что, судя по префиксу, у и х должны быть первыми.
Далее для примера приведен полный набор прототипов для семейств функций addch и printw.
#include <curses.h>
int addch(const chtype char);
int waddch(WINDOW *window_pointer, const chtype char);
int mvaddch(int y, int x, const chtype char);
int mvwaddch(WINDOW *window_pointer, int y, int x, const chtype char);
int printw(char *format, ...);
int wprintw(WINDOW *window_pointer, char *format, ...);
int mvprintw(int y, int x, char *format, ...);
int mvwprintw(WINDOW *window_pointer, int y, int x, char *format, ...);
У многих других функций, например inch, также есть варианты оконные и с перемещением курсора.
Перемещение и обновление окна.
Следующие команды позволят вам перемещать и перерисовывать окна:
#include <curses.h>
int mvwin(WINDOW *window_to move, int new_y, int new x);
int wrefresh(WINDOW *window_ptr);
int wclear(WINDOW *window_ptr);
int werase(WINDOW *window_ptr);
int touchwin(WINDOW *window_ptr);
int scrollok(WINDOW *window_ptr, bool scroll_flag);
int scroll(WINDOW *window_ptr);
Функция mvwin перемещает окно по экрану. Поскольку окно целиком должно располагаться в области экрана, функция mvwin завершится аварийно, если вы попытаетесь переместить окно так, что какая-то его часть выйдет за пределы экрана.
Функции wrefresh, wclear и werase — просто обобщения функций, с которыми вы встречались ранее; они только принимают указатель WINDOW, поэтому могут ссылаться на конкретное окно, а не на окно stdscr.
Функция touchwin довольно специальная. Она информирует библиотеку curses о том, что содержимое окна, на которое указывает ее параметр, было изменено. Это означает, что curses всегда будет перерисовывать такое окно при следующем вызове функции wrefresh, даже если вы на самом деле не меняли содержимое этого окна. Эта функция очень полезна для определения отображаемого окна при наличии нескольких перекрывающихся окон, загромождающих экран.
Две функции scroll управляют прокруткой окна. Функция scrollok при передаче логического значения true (обычно ненулевого) включает прокрутку окна. По умолчанию окна не прокручиваются. Функция scroll просто прокручивает окно на одну строку вверх. В некоторые реализации библиотеки curses входит и функция wsctl, которая также принимает количество строк для прокрутки, которое может быть и отрицательным числом. Мы вернемся к прокрутке немного позже в этой главе.
А теперь выполните упражнение 6.4.
Упражнение 6.4. Управление множественными окнами.
Теперь, зная, как управлять несколькими окнами, вы можете включить эти новые функции в программу multiw1.c. Для краткости проверка ошибок не приводится.
1. Как обычно, вставьте первыми отсортированные объявления:
#include <unistd.h>
#include <stdlib.h>
#include <curses.h>
int main() {
WINDOW *new_window_ptr;
WINDOW *popup_windov_ptr;
int x loop;
int y_loop;
char a_letter = 'a';
initscr();
2. Заполните базовое окно символами, обновляя физический экран, когда заполнен логический экран:
move(5, 5);
printw("%s", "Testing multiple windows");
refresh();
for (y_loop = 0; y_loop < LINES - 1; y_loop++) {
for (x_loop = 0; x_loop < COLS - 1; x_loop++) {
mvwaddch(stdscr, y_loop, x_loop, a_letter);
a_letter++;
if (a_letter > 'z') a_letter = 'a';
}
}
/* Обновление экрана */
refresh();
sleep(2);
3. Теперь создайте окно 10×20 и вставьте в него текст перед прорисовкой окна на экране:
new_window_ptr = newwin(10, 20, 5, 5);
mvwprintw(new_window_ptr, 2, 2, "%s", "Hello World");
mwwprintw(new_window_ptr, 5, 2, "%s",
"Notice how very long lines wrap inside the window");
wrefresh(new_window_ptr);
sleep(2);
4. Измените содержимое фонового окна. Когда вы обновите экран, окно, на которое указывает new_window_ptr, будет затемнено:
a_letter = '0';
for (y_1оор = 0; y_1оор < LINES - 1; y_1оор++) {
for (х_1оор = 0; xloop < COLS - 1; х_1оор++) {
mvwaddch(stdscr, y_loop, х_1оор, a_letter);
a_letter++;
if (a_letter > '9') a_letter = '0';
}
}
refresh();
sleep(2);
5. Если вы выполните вызов для обновления нового окна, ничего не изменится, поскольку вы не изменяли новое окно:
wrefresh(new_window_ptr);
sleep(2);
6. Но если вы сначала воспользуетесь функцией touchwin и заставите библиотеку curses думать, что окно было изменено, следующий вызов функции wrefresh снова отобразит новое окно на переднем плане.
touchwin(new_window_ptr);
wrefresh(new_window_ptr);
sleep(2);
7. Добавьте еще одно накладывающееся окно с рамкой вокруг него.
popup_window_ptr = newwin(10, 20, 8, 8);
box(popup_window_ptr, '|', '-');
mvwprintw(popup_window_ptr, 5, 2, "%s", "Pop Up Window!");
wrefresh(popup_window_ptr);
sleep(2);
8. Поиграйте с новыми всплывающими окнами перед их очисткой и удалением.
touchwin(new_window_ptr);
wrefresh(new_window_ptr);
sleep(2);
wclear(new_window_ptr);
wrefresh(new_window_ptr);
sleep(2);
delwin(new_window_ptr);
touchwin(popup_window_ptr);
wrefresh(popup_window_ptr);
sleep(2);
delwin(popup_window_ptr);
touchwin(stdscr);
refresh();
sleep(2);
endwin();
exit(EXIT_SUCCESS);
}
К сожалению, нет возможности продемонстрировать выполнение этого фрагмента в книге, но на рис. 6.4 показан снимок экрана после отображения первого всплывающего окна.

Рис. 6.4
После того как будет изменен фон и появится новое всплывающее окно, вы увидите экран, показанный на рис. 6.5.

Рис. 6.5
Как это работает
После обычной инициализации программа заполняет стандартный экран цифрами, чтобы легче было увидеть новые окна, вставляемые на передний план. Далее показано, как можно наложить на фон новое окно с включенным в него текстом, разбитым на строки в соответствии с шириной окна. Далее вы видите, как с помощью функции touchwin заставить curses перерисовать окно, даже если в нем ничего не менялось.
Затем перед закрытием curses и завершением программы вставляется второе окно, перекрывающее первое, чтобы показать, как библиотека curses может управлять перекрывающимися окнами.
Как видно из программного кода примера, при обновлении окон следует быть очень внимательным, чтобы они отображались в нужной очередности. Библиотека curses не хранит никаких сведений об иерархии окон, поэтому если вы попросите curses обновить несколько окон, управлять их иерархией придется вам.
Примечание. Для того чтобы библиотека curses отображала окна в нужном порядке, их следует обновлять в этом порядке. Один из способов добиться этого — сохранять все указатели ваших окон в массиве или списке, в которых поддерживается порядок их размещения, соответствующий порядку их появления на экране.Оптимизация обновлений экрана.
Как вы видели в примере из упражнения 6.4, обновление множественных окон требует некоторой ловкости, но не слишком обременительно. Но может возникнуть более серьезная проблема, если нуждающийся в обновлении терминал подключен через медленное сетевое соединение. К счастью, в наши дни с ней сталкиваются очень редко, но ее обработка настолько легка, что мы рассмотрим ее просто для полноты картины.
Задача состоит в минимизации количества символов, прорисовываемых на экране, поскольку при наличии медленных линий связи рисование на экране может оказаться утомительно долгим. Библиотека curses предлагает специальный метод обновления экрана с помощью пары функций wnoutrefresh и doupdate:
#include <curses.h>
int wnoutrefresh(WINDOW *window_ptr);
int doupdate(void);
Функция wnoutrefresh определяет, какие символы необходимо отправить на экран, но не отправляет их на самом деле. Функция doupdate действительно отправляет изменения на терминал. Если вы просто вызовите wnoutrefresh, а за ней тут же функцию doupdate, эффект будет такой же, как при вызове функции wrefresh. Однако если вы хотите перерисовать ряд окон, то можете вызвать функцию wnoutrefresh для каждого окна (конечно, в нужном порядке) и затем вызвать doupdate только после последнего вызова wnoutrefresh. Это позволит библиотеке curses выполнить расчеты, связанные с обновлением экрана, по очереди для каждого окна и только после этого вывести обновленный экран. Такой подход почти всегда позволяет curses минимизировать количество символов, нуждающихся в пересылке.
Вложенные окна.
Теперь, когда мы рассмотрели множественные окна, остановимся на специальном случае множественных окон, называемом вложенными окнами или подокнами. Создаются и уничтожаются вложенные окна с помощью следующих вызовов:
#include <curses.h>
WINDOW *subwin(WINDOW *parent, int num_of_lines, int num_of_cols,
int start_y, int start_x);
int delwin(WINDOW *window_to_delete);
У функции subwin почти такой же список параметров, как у функции newwin, и удаляются вложенные окна так же, как другие окна с помощью вызова delwin. Для записи во вложенные окна, как и в новые окна, вы можете применять ряд функций mvw. На самом деле большую часть времени вложенные окна ведут себя почти так же, как новые окна, но есть одно важное отличие: подокна самостоятельно не хранят отдельный набор экранных символов; они используют ту же область хранения символов, что и родительское окно, заданное при создании вложенного окна. Это означает, что любые изменения, сделанные во вложенном окне, вносятся и в лежащее в основании родительское окно, поэтому, когда подокно удаляется, экран не меняется.
На первый взгляд вложенные окна кажутся бесполезным экспериментом. Почему не изменять просто родительское окно? Основная сфера их применения — предоставление простого способа прокрутки другого окна. Потребность в прокрутке небольшой области экрана удивительно часто возникает при написании программ с использованием curses. Создав вложенное окно и прокручивая его, вы добьетесь желаемого результата.
Примечание. Одно ограничение, накладываемое на применение вложенных окон, заключается в необходимости перед обновлением экрана вызвать в приложении функцию touchwin для родительского окна.Выполните упражнение 6.5.
Упражнение 6.5. Вложенные окна.
Теперь, когда вы познакомились с новыми функциями, этот короткий пример покажет, как они действуют и чем отличаются от функций окна, применявшихся ранее.
1. Начальная секция кода программы subscl.c инициализирует отображение базового окна с некоторым текстом:
#include <unistd.h>
#include <stdlib.h>
#include <curses.h>
int main() {
WINDOW *sub_window_ptr;
int x_loop;
int y_loop;
int counter;
char a_letter = '1';
initscr();
for (y_loop = 0; y_loop < LINES - 1; y_loop++) {
for (x_loop = 0; x_loop < COLS - 1; x_loop++) {
mvwaddch(stdscr, y_loop, x_loop, a_letter);
a_letter++;
if (a_letter > '9') a_letter = '1';
}
}
2. Теперь создайте новое подокно с прокруткой. Как рекомендовалось, вам следует перед обновлением экрана "коснуться" родительского окна:
ub_window_ptr = subwin(stdscr, 10, 20, 10, 10);
scrollok(sub_window_ptr, 1);
touchwin(stdscr);
refresh();
sleep(1);
3. Сотрите содержимое вложенного окна, выведите в нем текст и обновите его. Прокрутка текста обеспечивается циклом:
werase(sub_window_ptr);
mvwprintw(sub_window_ptr, 2, 0, "%s", "This window will now scroll");
wrefresh(sub_window_ptr);
sleep(1);
for (counter = 1; counter < 10; counter++) {
wprintw(sub_window_ptr, "%s", "This text is both wrapping and \
scrolling.");
wrefresh(sub_window_ptr);
sleep(1);
}
4. Завершив цикл, удалите вложенное окно и обновите основной экран:
delwin(sub_window_ptr);
touchwin(stdscr);
refresh();
sleep(1);
endwin();
exit(EXIT_SUCCESS);
}
К концу программы вы увидите вывод, показанный на рис. 6.6.

Рис. 6.6
Как это работает
После присвоения указателю sub_window_ptr результата вызова subwin вы включаете прокрутку вложенного окна. Даже после удаления вложенного окна и обновления базового окна ( strdcr) текст на экране не меняется, поскольку вложенное окно на самом деле откорректировало символьные данные экрана strdcr.
Дополнительная клавиатура.
Вы уже познакомились с некоторыми средствами библиотеки curses для обработки клавиатурного ввода. У многих клавиатур, как минимум, есть клавиши управления курсором и функциональные клавиши. Кроме того, у многих клавиатур есть дополнительная клавиатура и другие клавиши, например, <Insert> и <Home>.
Для большинства терминалов расшифровка этих клавиш — серьезная проблема, потому что они посылают строку символов, начинающуюся с escape-символа. Дело не только в том, что приложению трудно отличить одиночное нажатие клавиши <Esc> от строки символов, появившейся в результате нажатия функциональной клавиши, оно еще должно справляться с терминалами разных типов, применяющими разные управляющие последовательности для одних и тех же логических клавиш.
К счастью, библиотека curses предоставляет элегантное решение для управления функциональными клавишами. Обычно в структуре terminfo для каждого терминала хранится последовательность, отправляемая каждой функциональной клавишей, и во включенном в программу файле curses.h для логических клавиш есть набор определений, начинающихся с префикса KEY_.
Когда curses стартует, преобразование последовательностей в логические клавиши отключено, и его следует включить вызовом функции keypad. Если вызов успешен, функция вернет OK, в противном случае ERR.
#include <curses.h>
int keypad(WINDOW *window_ptr, bool keypad_on);
Когда режим дополнительной клавиатуры включен с помощью вызова функции keypad с параметром keypad_on, равным true, библиотека curses принимает на себя обработку клавиатурных последовательностей, так что чтение с клавиатуры может вернуть не только нажатую клавишу, но и одно из определений вида KEY_ для логических клавиш.
Отметьте три незначительных ограничения, налагаемых при использовании режима дополнительной клавиатуры.
□ Распознавание escape-последовательностей требует разного времени, и многие сетевые протоколы сгруппируют символы в пакеты (что приведет к неверному распознаванию escape-последовательностей) или разделят их (что приведет к распознаванию последовательностей функциональных клавиш, как клавиши <Esc> и отдельных символов). Такое поведение чаще всего наблюдается в региональных сетях (Wide-Area Network, WAN) и других медленных линиях связи. Единственный выход — попытаться запрограммировать терминалы так, чтобы они отправляли единичные уникальные символы в ответ на нажатие каждой функциональной клавиши, используемой вами, хотя это ограничит количество управляющих символов.
□ Для того чтобы библиотека curses могла отличить нажатие клавиши <Esc> от клавиатурной последовательности, начинающейся с символа Esc, ей требуется ожидание в течение короткого промежутка времени. Иногда при включенном режиме дополнительной клавиатуры можно заметить легкую задержку при обработке клавиши <Esc>.
□ Библиотека curses не может обрабатывать неуникальные escape-последовательности. Если у вашего терминала есть две разные клавиши, отправляющие одну и ту же последовательность, библиотека просто не будет ее обрабатывать, поскольку не может решить, какую логическую клавишу следует вернуть.
Выполните упражнение 6.6.
Упражнение 6.6. Применение дополнительной клавиатуры.
Далее приведена короткая программа keypad.c, демонстрирующая применение режима дополнительной клавиатуры. После запуска программы нажмите клавишу <Esc> и отметьте незначительную задержку, в течение которой программа пытается понять: Esc — это начало управляющей последовательности или просто нажатие одной клавиши,
1. Инициализировав программу и библиотеку curses, включите режим дополнительной клавиатуры:
#include <unistd.h>
#include <stdlib.h>
#include <curses.h>
#define LOCAL_ESCAPE_KEY 27
int main() {
int key;
initscr();
crmode();
keypad(stdscr, TRUE);
2. Отключите отображение символов, чтобы помешать перемещению курсора при нажатии клавиш управления курсором. Экран очищается, и выводится некоторый текст. Программа ждет нажатия клавиши и до тех пор, пока не нажата клавиша <Q> или не возникла ошибка. Символ нажатой клавиши выводится на экран. Если нажатые клавиши соответствуют одной из последовательностей для дополнительной клавиатуры терминала, вместо символа выводится эта последовательность.
noecho();
clear();
mvprintw(5, 5, "Key pad demonstration. Press 'q' to quit");
move(7, 5);
refresh();
key = getch();
while (key != ERR && key i= 'q') {
move(7, 5);
clrtoeol();
if ((key >= 'A' && key <= 'Z') || (key >= 'a' && key <= 'z')) {
printw("Key was%c", (char)key);
} else {
switch(key) {
case LOCAL_ESCAPE_KEY:
printw("%s", "Escape key");
break;
case KEY_END:
printw("%s", "END key");
break;
case KEY_BEG:
printw("%s", "BEGINNING key");
break;
case KEY_RIGHT:
printw("%s", "RIGHT key");
break;
case KEY_LEFT:
printw("%s", "LEFT key");
break;
case KEY_UP:
printw("%s", "UP key");
break;
case KEY_DOWN:
printw("%s", "DOWN key");
break;
default:
printw("Unmatched — %d", key);
break;
} /* switch */
} /* else */
refresh();
key = getch();
} /* while */
endwin();
exit(EXIT_SUCCESS);
}
Как это работает
Включив режим дополнительной клавиатуры, вы увидите, как можно распознать различные функциональные клавиши на дополнительной клавиатуре, генерирующие escape-последовательности. Вы, возможно, сумеете заметить, что распознавание клавиши <Esc> немного медленнее, чем других клавиш.
Применение цвета.
В прошлом очень немногие терминалы ввода/вывода поддерживали цвета, поэтому у большей части самых старых версий библиотеки curses не было поддержки цветов. Цвета появились в библиотеке ncurses и других современных реализациях curses. К сожалению, на "неинтеллектуальный экран", первооснову библиотеки curses, повлиял API, и curses используют цвета очень ограниченным способом, отражающим слабые характеристики старых цветных терминалов.
Каждая символьная ячейка на экране может быть записана одним цветом из набора разных цветов на фоне одного цвета из набора различных цветов фона. Например, можно вывести зеленый текст на красном фоне.
Цветовая поддержка в библиотеке curses немного необычна, в том смысле, что цвет символа не определяется независимо от цвета фона. Вы должны задать цвет переднего плана и фона как пару, именуемую, что неудивительно, цветовой парой.
Прежде чем применять цвета в curses, нужно убедиться в том, что текущий терминал поддерживает цвета, и инициализировать подпрограммы управления цветом библиотеки curses. Для этого примените две функции: has_colors и start_color.
#include <curses.h>
bool has_colors(void);
int start_color(void);
Функция has_colors возвращает true, если терминал поддерживает цвета. Далее следует вызвать функцию start_color, которая вернет OK, если цветовая поддержка успешно инициализирована. После вызова start_color и инициализации цветов переменная COLOR_PAIRS принимает значение, равное максимальному количеству цветовых пар, которые может поддерживать терминал. Переменная COLORS определяет максимальное число доступных цветов, которых, как правило, восемь. Внутри компьютера числа от 0 до 63 действуют как уникальные ID для каждого из доступных цветов.
Прежде чем применять цвета как атрибуты, вы должны инициализировать цветовые пары, которые хотите использовать. Делается это с помощью функции init_pair. Обратиться к атрибутам, задающим цвет, можно с помощью функции COLOR_PAIR.
#include <curses.h>
int init_pair(short pair_number, short foreground, short background);
int COLOR_PAIR(int pair_number);
int pair_content(short pair_number, short *foreground, short *background);
В файле curses.h обычно определены некоторые базовые цвета, начинающиеся с префикса COLOR_. Дополнительная функция pair_content позволяет извлечь сведения о ранее определенной цветовой паре.
Для определения цветовой пары номер 1, как красный на зеленом, примените следующую строку:
init_pair(1, COLOR_RED, COLOR_GREEN);
Затем вы сможете получить доступ к этой цветовой паре, применив функцию COLOR_PAIR следующим образом:
wattron(window_ptr, COLOR_PAIR(1));
Она установит вывод в будущем на экран красных символов на зеленом фоне.
Поскольку COLOR_PAIR — это атрибут, вы можете комбинировать его с другими атрибутами. На ПК часто можно добиться на экране цветов повышенной яркости, объединив с помощью поразрядной операции OR атрибут COLOR_PAIR с дополнительным атрибутом A_BOLD:
wattron(window_ptr, COLOR_PAIR(1) | A_BOLD);
Давайте проверим эти функции в примере color.c (упражнение 6.7).
Упражнение 6.7. Цвета.
1. Сначала проверьте, поддерживает ли цвета терминал, используемый программой. Если да, то инициализируйте отображение цветов:
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <curses.h>
int main() {
int i;
initscr();
if (!has_colors()) {
endwin();
fprintf(stderr, "Error — no color support on this terminal\n");
exit(1);
}
if (start_color() != OK) {
endwin();
fprintf(stderr, "Error — could not initialize colors\n");
exit(2);
}
2. Теперь можно вывести допустимое количество цветов и цветовые пары. Создайте семь цветовых пар и выведите их по очереди на экран:
clear();
mvprintw(5, 5, "There are %d COLORS, and %d COLOR_PAIRS available", COLORS, COLOR_PAIRS);
refresh();
init_pair(1, COLOR_RED, COLOR_BLACK);
init_pair(2, COLOR_RED, COLOR_GREEN);
init_pair(3, COLOR_GREEN, COLOR_RED);
init_pair(4, COLOR_YELLOW, COLOR_BLUE);
init_pair(5, COLOR_BLACK, COLOR_WHITE);
init_pair(6, COLOR_MAGENTA, COLOR_BLUE);
init_pair(7, COLOR_CYAN, COLOR_WHITE);
for (i = 1; i <= 7; i++) {
attroff(A_BOLD);
attrset(COLOR_PAIR(i));
mvprintw(5 + i, 5, "Color pair %d", i);
attrset(COLOR_PAIR(i) | A_BOLD);
mwprintw(5 + i, 25, "Bold color pair %d", i);
refresh();
sleep(1);
}
endwin();
exit(EXIT_SUCCESS);
}
Выполнение примера приведет к выводу, показанному на рис. 6.7, за вычетом реальных цветов, которые не отображаются на черно-белом снимке экрана.

Рис. 6.7
Как это работает
После проверки того, что экран поддерживает управление цветами, программа инициализирует цветовую обработку и определяет ряд цветовых пар. Далее на экран выводится текст с использованием цветовых пар для того, чтобы продемонстрировать комбинации разных цветов на экране.
Переопределение цветов.
Как пережиток, оставшийся от старых неинтеллектуальных терминалов, которые могли отображать очень немного цветов в каждый момент времени, но позволяли настраивать текущую цветовую палитру, в библиотеке curses сохранилась возможность переопределения цветов с помощью функции init_color:
#include <curses.h>
int init_color(short color_number, short red, short green, short blue);
Она позволяет переопределить существующий цвет (в диапазоне от 0 до COLORS) новыми значениями яркости цвета из диапазона от 0 до 1000. Такой подход немного напоминает определение цветовых характеристик в графических файлах формата GIF.
Панели.
При написании более сложных программ с использованием curses порой бывает легче построить логический экран и затем позже вывести весь или часть экрана на физический экран. В некоторых случаях лучше иметь логический экран большего размера, чем физический экран и отображать только часть логического экрана в любой конкретный момент времени.
Это нелегко сделать с помощью функций библиотеки curses, с которыми вы познакомились к этому моменту, т.к. все окна должны быть не больше физического экрана. Библиотека curses предоставляет специальную структуру данных, панель (pad), для манипулирования данными логического экрана, которые не умещаются в стандартном окне.
Структура панели похожа на структуру WINDOW, и все функции библиотеки curses, написанные для работы с окнами, можно применять и к панелям. Но у панелей есть и собственные функции для создания и обновления.
Панели создаются во многом так же, как и обычные окна.
#include <curses.h>
WINDOW *newpad(int number_of_lines, int number_of_columns);
Обратите внимание на то, что возвращаемое значение — указатель на структуру типа WINDOW, такое же, как у функции newwin. Удаляются панели, как и окна, функцией delwin.
Но к панелям применяются другие подпрограммы обновления. Поскольку панель не привязана к конкретной точке экрана, вы должны задать область панели, которую хотите поместить на экран, и ее положение на экране. Делайте это с помощью функции prefresh.
#include <сигsеs.h>
int prefresh(WINDOW *pad_ptr, int pad_row, int pad_column, int screen_row_min, int screen_col_min, int screen_row_max, int screen_со1_max);
Функция выполняет запись области панели, начинающейся в точке ( pad_row, pad_column), в область экрана, определенную от ( screen_row_min, screen_col_min) до ( screen_row_max, screen_col_max).
Есть и дополнительная подпрограмма pnoutrefresh. Она действует так же, как функция wnoutrefresh, обеспечивая более производительное обновление экрана.
Давайте проверим это на практике с помощью программы pad.с (упражнение 6.8).
Упражнение 6.8. Применение панели.
1. В начале этой программы вы инициализируете структуру панели и затем формируете панель с помощью функции, которая возвращает указатель на нее. Вставьте символы, заполняющие структуру панели (панель на 50 символов шире и выше экрана терминала):
#include <unistd.h>
#include <stdlib.h>
#include <curses.h>
int main() {
WINDOW *pad_ptr;
int x, y;
int pad_lines;
int pad_cols;
char disp_char;
initscr();
pad_lines = LINES + 50;
pad_cols = COLS + 50;
pad_ptr = newpad(pad_lines, padcols);
disp_char = 'a';
for (x = 0; x < pad_lines; x++) {
for (у = 0; у < pad_cols; y++) {
mvwaddch(pad_ptr, x, y, disp_char);
if (disp_char == 'z') disp_char = 'a';
else disp_char++;
}
}
2. Теперь перед завершением программы нарисуйте разные области панели в разных местах экрана:
prefresh(pad_ptr, 5, 7, 2, 2, 9, 9);
sleep(1);
prefresh(pad_ptr, LINES + 5, COLS + 7, -5, 5, 21, 19);
sleep(1);
delwin(pad_ptr);
endwin();
exit(EXIT_SUCCESS);
}
Выполнив эту программу, вы увидите нечто подобное показанному на рис. 6.8.

Рис. 6.8
Приложение, управляющее коллекцией компакт-дисков.
Теперь, когда вы узнали о средствах, которые предлагает библиотека curses, можно разработать типовое приложение. Далее приведена его версия, написанная на языке С и использующая библиотеку curses. К достоинствам приложения относятся более четкое отображение информации на экране и применение окна с прокруткой для просмотра списков.
Все приложение занимает восемь страниц, поэтому мы разделили его на секции и отдельные функции внутри секций. Исходный код программы curses_app.c можно получить на Web-сайте издательства Wrox (http://www.wrox.com/WileyCDA/). Как и все программы из этой книги, оно подчиняется требованиям Общедоступной лицензии проекта GNU.
Примечание. Мы написали эту версию приложения для работы с базой данных компакт-дисков, используя информацию из предыдущих глав. Данное приложение — потомок оригинального сценария командной оболочки, приведенного в главе 2. Оно не перепроектировалось для написания на языке С, поэтому вы увидите в этой версии многие подходы, заимствованные из сценария. Учтите, что в этой реализации есть существенные ограничения, которые мы устраним в последующих модификациях.Мы разбили программный код этого приложения на несколько отдельных секций, которые обозначены заголовками последующих разделов. Соглашения, принятые для оформления этого программного кода, немного отличаются от оформления большинства программ в этой книге; здесь выделение цветом применяется только для обозначения вызовов других функций приложения.
Начало нового приложения для работы с коллекцией компакт-дисков.
Первая секция программного кода просто связана с объявлениями переменных и функций, которые вы будете применять позже, и инициализацией некоторых структур данных.
1. Включите в программу все приведенные заголовочные файлы и несколько глобальных переменных:
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <curses.h>
#define MAX_STRING 80 /* Самый длинный допустимый ответ */
#define MAX_ENTRY 1024 /* Самый длинный допустимый элемент БД */
#define MESSAGE_LINE 6 /* В этой строке разные сообщения */
#define ERROR LINE 22 /* Строка для вывода ошибок */
#define Q_LINE 20 /* Строка для вопросов */
#define PROMPT_LINE 18 /* Строка для вывода приглашения */
2. Теперь вам нужны глобальные переменные. Переменная current_cdis применяется для хранения названия текущего компакт-диска, с которым вы работаете в данный момент. Она инициализируется так, что первый символ равен NULL, чтобы показать, что компакт-диск не выбран. Символ завершения \0, строго говоря, не обязателен, но он гарантирует инициализацию переменной, что само по себе хорошая вещь. Переменная current_cat применяется для записи номера текущего компакт-диска в каталоге:
static char current_cd[MAX_STRING] = "\0";
static char current_cat[MAX_STRING];
3. Теперь объявите имена файлов. Для простоты в этой версии имена файлов фиксированные, как и имя временного файла.
Это может вызвать проблемы, если программа выполняется двумя пользователями в одном и том же каталоге. Лучше получать имена файлов базы данных как аргументы программы или из переменных окружения. Нам также потребуется улучшенный метод генерации уникального имени временного файла, для чего мы могли бы использовать функцию tmpnam из стандарта POSIX. Мы обратимся к решению многих из этих проблем в главе 8, когда применим СУРБД MySQL для хранения данных.
const char *title_file = "title.cdb";
const char *tracks_file = "tracks.cdb";
const char *temp_file = "cdb.tmp";
4. И наконец, прототипы функций:
void clear_all_screen(void);
void get_return(void);
int get_confirm(void);
int getchoice(char *greet, char *choices[]);
void draw_menu(char *options[], int highlight,
int start_row, int start_col);
void insert_title(char *cdtitle);
void get_string(char *string);
void add_record(void);
void count_cds(void);
void find_cd(void);
void list_tracks(void);
void remove_tracks(void);
void remove_cd(void);
void update_cd(void);
5. Прежде чем рассматривать их реализацию, введем некоторые структуры (на самом деле массив пунктов меню) для хранения меню. Когда выбирается пункт меню, возвращается первый символ выбранного пункта. Например, если это пункт меню add new CD (добавить новый CD), при его выборе будет возвращен символ а. Когда компакт-диск выбран, будет отображаться расширенное меню.
char *main_menu[] = {
"add new CD",
"find CD",
"count CDs and tracks in the catalog",
"quit",
0,
};
char *extended_menu[] = {
"add new CD",
"find CD",
"count CDs and tracks in the catalog",
"list tracks on current CD";
"remove current CD",
"update track information",
"quit",
0,
};
На этом инициализация закончена. Теперь можно переходить к функциям программы, но сначала необходимо составить общее представление о взаимосвязях всех 16 функций. Функции разделены на три программных секции:
□ отображение меню;
□ добавление компакт-дисков в базу данных;
□ извлечение и отображение данных компакт-диска.
Визуальное представление дано на рис. 6.9.

Рис. 6.9
Взгляд на функцию main.
Функция main позволяет выбирать пункты меню, пока не выбран вариант выхода из меню (quit). Далее приведен соответствующий код.
int main() {
int choice;
initscr();
do {
choice = getchoice("Options:", current_cd[0] ? extended_menu : main_menu);
switch (choice) {
case 'q':
break;
case 'a':
add_record();
break;
case 'c':
count_cds();
break;
case 'f':
find_cd();
break;
case 'l':
list_tracks();
break;
case 'r':
remove_cd();
break;
case 'u':
update_cd();
break;
}
} while (choice != 'q');
endwin();
exit(EXIT_SUCCESS);
}
Теперь давайте подробно рассмотрим функции, связанные с тремя секциями программы.
Формирование меню.
В этой секции рассматриваются три функции, относящиеся к пользовательскому интерфейсу программы.
1. Функция getchoice, вызываемая из функции main, — это основная функция данной секции. В функцию getchoice передается приглашение greet и указатель choices на базовое или расширенное меню (в зависимости от того, выбран ли компакт-диск). Вы также увидите, как main_menu или extended_menu передаются как параметры в описанную ранее функцию main.
int get_choice(char *greet, char* choises[]) {
static int selected_row = 0;
int max_row = 0;
int start_screenrow = MESSAGE_LINE, start_screencol = 10;
char **option;
int selected;
int key = 0;
option = choices;
while (*option) {
max_row++;
option++;
}
if (selected_row >= max_row)
selected_row = 0;
clear_all_screen();
mvprintw(start_screenrow - 2, start_screencol, greet);
keypad(stdscr, TRUE);
cbreak();
noecho();
key = 0;
while (key != 'q' && key != KEY_ENTER && key != '\n') {
if (key == KEY_UP) {
if (selected_row == 0) selected_row = max_row - 1;
else selected_row--;
}
if (key == KEY_DOWN) {
if (selected_row == (max_row - 1)) selected_row = 0;
else selected_row++;
}
selected = *choices[selected_row];
draw_menu(choices, selected_row, start_screen_row, start_screencol);
key = getch();
}
keypad(stdscr, FALSE);
nocbreak();
echo();
if (key == 'q') selected = 'q';
return(selected);
}
2. Обратите внимание на то, как две локальные функции clear_all_screen и draw_menu вызываются внутри функции getchoice. Первой рассмотрим функцию draw_menu:
void draw_menu(char* options[], int current_highlight, int start_row, int start_col) {
int current_row = 0;
char **option_ptr;
char *txt_ptr;
option_ptr = options;
while (*option_ptr) {
if (current_row == current_highlight) attron(A_STANDOUT);
txt_ptr = options[current_row];
txt_ptr++;
mvprintw(start_row + current_row, start_col, "%s", txt_ptr);
if (current_row == current_highlight) attroff(A_STANDOUT);
current_row++;
option_ptr++;
}
mvprintw(start_row + current_row + 3, start_col,
"Move highlight then press Return ");
refresh();
}
3. Далее рассмотрим функцию clear_all_screen, которая, как ни странно, очищает экран и перезаписывает заголовок. Если компакт-диск выбран, отображаются его данные:
void clear all_screen() {
clear();
mvprintw(2, 20, "%s", "CD Database Application");
if (current_cd[0]) {
mvprintw(ERROR_LINE, 0, "Current CD: %s: %s\n", current_cat, current_cd);
}
refresh();
}
Управление базой данных.
В этом разделе описаны функции пополнения или обновления базы данных компакт-дисков. Функции add_record, update_cd и remove_cd вызываются из функции main.
Добавление записей.
1. Добавьте сведения о новом компакт-диске в базу данных.
void add_record {
char catalog_number[MAX_STRING];
char cd_title[MAX_STRING];
char cd_type[MAX_STRING];
char cd_artist[MAX_STRING];
char cd_entry[MAX_STRING];
int screenrow = MESSAGE_LINE;
int screencol = 10;
clear_all_screen();
mvprintw(screenrow, screencol, "Enter new CD details");
screenrow += 2;
mvprintw(screenrow, screencol, "Catalog Number: " );
get_string(catalog_number);
screenrow++;
mvprintw(screenrow, screencol, " CD Title: ");
get_string(cd_title);
screenrow++;
mvprintw(screenrow, screencol, " CD Type: ");
get_string(cd_type);
screenrow++;
mvprintw(screenrow, screencol, " Artist: ");
get_string(cd_artist);
screenrow++;
mvprintw(PROMPT_LINE-2, 5, "About to add this new entry:");
sprintf(cd_entry, "%s, %s, %s, %s",
catalog_number, cd_title, cd_type, cd_artist);
mvprintw(PROMPT_LINE, 5, "%s", cd_entry);
refresh();
move(PROMPT_LINE, 0);
if (get_confirm()) {
insert_title(cd_entry);
strcpy(current_cd, cd_title);
strcpy(current_cat, catalog_number);
}
}
2. Функция get_string приглашает к вводу и считывает строку из текущей позиции экрана. Она также удаляет завершающую новую пустую строку:
void get_string(char* string) {
int len;
wgetnstr(stdscr, string, MAX_STRING);
len = strlen(string);
if (len > 0 && string[len - 1] == '\n') string[len - 1] = '\0';
}
3. Функция get_confirm запрашивает и считывает пользовательское подтверждение. Она читает введенную пользователем строку и проверяет, первый символ — Y или у. Если она обнаруживает другой символ, то не дает подтверждения.
int get_confirm() {
int confirmed = 0;
char first_char;
mvprintw(Q_LINE, 5, "Are you sure? ");
clrtoeol();
refresh();
cbreak();
first_char = getch();
if (first_char == 'Y' || first_char == 'y') {
confirmed = 1;
}
nocbreak();
if (!confirmed) {
mvprintw(Q_LINE, 1, " Cancelled");
clrtoeol();
refresh();
sleep(1);
}
return confirmed;
}
4. Последней рассмотрим функцию insert_title. Она вставляет в базу данных компакт-дисков заголовок, добавляя строку с заголовком в конец файла заголовков:
void insert_title(char* cdtitle) {
FILE *fp = fopen(title_file, "a");
if (!fp) {
mvprintw(ERROR_LINE, 0, "cannot open CD titles database");
} else {
fprintf(fp, "%s\n", cdtitle);
fclose(fp);
}
}
Обновление записей.
1. Продолжим рассмотрение других управляющих функций, вызываемых из функции main. Следующая из них — функция update_cd. Эта функция использует обведенное рамкой вложенное окно с прокруткой и нуждается в нескольких константах, которые объявляются как глобальные, поскольку они позже потребуются функции list_tracks.
#define BOXED_LINES 11
#define BOXED_ROWS 60
#define BOX_LINE_POS 8
#define BOX_ROW_POS 2
2. Функция update_cd позволяет пользователю заново ввести сведения о дорожках текущего компакт-диска. Удалив предыдущие записи о дорожках, она приглашает ввести новую информацию.
void update_cd() {
FILE *tracks_fp;
char track_name[MAX_STRING];
int len;
int track = 1;
int screen_line = 1;
WINDOW *box_window_ptr;
WINDOW *sub_window_ptr;
clear_all_screen();
mvprintw(PROMPT_LINE, 0, "Re-entering tracks for CD. ");
if (!get_confirm())
return;
move(PROMP_TLINE, 0);
clrtoeol();
remove_tracks();
mvprintw(MESSAGE_LINE, 0, "Enter a blank line to finish");
tracks_fp = fopen(tracks_file, "a");
Примечание. Листинг будет продолжен через минуту; мы хотим сделать краткую паузу, чтобы обратить ваше внимание на ввод данных в обрамленное окно с прокруткой. Хитрость заключается в формировании вложенного окна, рисовании рамки по его краю и создании внутри этого окна нового вложенного окна с прокруткой.box_window_ptr = subwin(stdscr, BOXED_LINES + 2, BOXED_ROWS + 2,
BOX_LINE_POS - 1, BOX_ROW_POS - 1);
if (!box_window_ptr) return;
box(box_window_ptr, ACS_VLINE, ACS_HLINE);
sub_window_ptr = subwin(stdscr, BOXED_LINES, BOXED_ROWS,
BOX_LINE_POS, BOX_ROW_POS);
if (!sub_window_ptr) return;
scrollok(sub_window_ptr, TRUE);
werase(sub_window_ptr);
touchwin(stdscr);
do {
mvwprintw(sub_window_ptr, screen_line++, BOX_ROW_POS + 2,
"Track %d: ", track);
clrtoeol();
refresh();
wgetnstr(sub_window_ptr, track_name, MAX_STRING);
len = strlen(track_name);
if (len > 0 && track_name[len - 1] = '\n')
track_name[len - 1] = '\0';
if (*track_name)
fprintf(tracks_fp, "%s, %d, %s\n", current_cat, track, track_name);
track++;
if (screen_line > BOXED__LINES - 1) {
/* время начать прокрутку */
scroll(sub_window_ptr);
screen_line--;
}
} while (*track_name);
delwin(sub_window_ptr);
fclose(tracks_fp);
}
Удаление записей.
1. remove_cd — последняя функция, вызываемая из функции main.
void remove_cd() {
FILE *titles_fp, *temp_fp;
char entry[MAX_ENTRY];
int cat_length;
if (current_cd[0] == '\0') return;
clear_all_screen();
mvprintw(PROMPT_LINE, 0, "About to remove CD %s: %s. ", current_cat, current_cd);
if (!get_confirm())
return;
cat_length = strlen(current_cat);
/* Файл заголовков копируется во временный, игнорируя данный CD */
titles_fp = fopen(title_file, "r");
temp_fp = fopen(temp_flie, "w");
while(fgets(entry, MAX_ENTRY, titles_fp)) {
/* Сравнивает номер в каталоге и копирует элемент, если не
найдено совпадение */
if (strncmp(current_cat, entry, cat_length) != 0)
fputs(entry, temp_fp);
}
fclose(titles_fp);
fclose(temp_fp);
/* Удаляет файл заголовков и переименовывает временный файл */
unlink(title_file);
rename(temp_file, title_file);
/* Теперь делает то же самое для файла дорожек */
remove_tracks();
/* Устанавливает 'None' для текущего CD */
current_cd[0] = '\0';
}
2. Теперь вам только нужен программный код функции remove_tracks, удаляющей дорожки текущего компакт-диска. Она вызывается двумя функциями — update_cd и remove_cd.
void remove_tracks() {
FILE *tracks_fp, *temp_fp;
char entry[MAX_ENTRY];
int cat_length;
if (current_cd[0] == '\0') return;
cat_length = strlen(current_cat);
tracks_fp = fopen(tracks_file, "r");
if (tracks_fp == (FILE *)NULL) return;
temp_fp = fopen(temp_file, "w");
while (fgets(entry, MAX_ENTRY, tracks_fp)) {
/* Сравнивает номер в каталоге и копирует элемент, если не
найдено совпадение */
if (strncmp(current_cat, entry, cat_length) != 0)
fputs(entry, temp_fp);
}
fclose(tracks_fp);
fclose(temp_fp);
/* Удаляет файл дорожек и переименовывает временный файл */
unlink(tracks_file);
rename(temp_file, tracks_file);
}
Запросы к базе данных компакт-дисков.
Теперь рассмотрим функции для доступа к данным, которые для упрощения доступа хранятся в паре простых файлов как поля, разделенные запятыми.
1. Страстным коллекционерам важно знать, каким богатством они обладают или сколько собрано. Следующая функция делает это превосходно; она просматривает базу данных, подсчитывая заголовки и дорожки.
void count_cds() {
FILE *titles_fp, *tracks_fp;
char entry[MAX_ENTRY];
int titles = 0;
int tracks = 0;
titles_fp = fopen(title_file, "r");
if (titles_fp) {
while (fgets(entry, MAX_ENTRY, titles_fp))
titles++;
fclose(titles_fp);
}
tracks_fp = fopen(tracks_file, "r");
if (tracks_fp) {
while (fgets(entry, MAX_ENTRY, tracks_fp))
tracks++;
fclose(tracks_fp);
}
mvprintw(ERROR_LINE, 0,
"Database contains %d titles, with a total of %d tracks.", titles, tracks);
get_return();
}
2. Вы потеряли аннотацию к вашему любимому компакт-диску? Не волнуйтесь! Если вы аккуратно ввели подробную информацию в базу данных, теперь можно найти перечень дорожек с помощью функции find_cd. Она предлагает ввести подстроку, совпадение с которой нужно искать в базе данных, и устанавливает в глобальную переменную current_cd заголовок найденного компакт-диска.
void find_cd() {
char match[MAX_STRING], entry[MAX_ENTRY];
FILE *titles_fp;
int count = 0;
char *found, *title, *catalog;
mvprintw(Q_LINE, 0, "Enter a string to search for in CD titles: ");
get_string(match);
titles_fp = fopen(title_file, "r");
if (titles_fp) {
while (fgets(entry, MAX_ENTRY, titles_fp)) {
/* Пропускает прежний номер в каталоге */
catalog = entry;
if (found == strstr(catalog, ", ")) {
*found = '\0';
title = found + 1;
/* Стирает следующую запятую в элементе, укорачивая его
только до заголовка */
if (found == strstr(title, ", ")) {
*found = '\0';
/* Теперь проверяет, есть ли совпадающая строка */
if (found == strstr(title, match)) {
count++;
strcpy(current_cd, title);
strcpy(current_cat, catalog);
}
}
}
}
fclose(titles_fp);
}
if (count != 1) {
if (count == 0) {
mvprintw(ERROR_LINE, 0, "Sorry, no matching CD found. ");
}
if (count > 1) {
mvprintw(ERROR_LINE, 0,
"Sorry, match is ambiguous: CDs found. ", count);
}
current_cd[0] = '\0';
get_return();
}
}
Хотя переменная catalog указывает на массив, больший чем current_cat, и могла бы переписать память, проверка в функции fgets препятствует этому.
3. Вам также нужно иметь возможность перечислить на экране дорожки выбранного компакт-диска. Для вложенных окон можно использовать директивы #define, применявшиеся в функции update_cd в предыдущем разделе.
void list_tracks() {
FILE *tracks_fp;
char entry[MAX_ENTRY];
int cat_length;
int lines_op = 0;
WINDOW *track_pad_ptr;
int tracks = 0;
int key;
int first_line = 0;
if (current_cd[0] == '\0') {
mvprintw(ERROR_LINE, 0, "You must select a CD first. ");
get_return();
return;
}
clear_all_screen();
cat_length = strlen(current_cat);
/* Сначала считает количество дорожек у текущего CD */
tracks_fp = fopen(tracks_file, "r");
if (!tracks_fp) return;
while (fgets(entry, MAX_ENTRY, tracks_fp)) {
if (strncmp(current_cat, entry, cat_length) == 0) tracks++;
}
fclose(tracks_fp);
/* Создает новую панель, гарантируя, что даже при наличии одной
дорожки панель достаточна большая, поэтому последующий вызов
prefresh() всегда будет допустим. */
track_pad_ptr = newpad(tracks + 1 + ВОХЕD_LINES, BOXED_ROWS + 1);
if (!track_pad_ptr) return;
tracks_fp = fopen(tracks_file, "r");
if (!tracks_fp) return;
mvprintw(4, 0, "CD Track Listing\n");
/* Записывает сведения о дорожке на панель */
while (fgets(entry, MAX_ENTRY, tracks_fp)) {
/* Сравнивает номер каталога и оставшийся вывод элемента */
if (strncmp(current_cat, entry, cat_length) == 0) {
mvwprintw(track_pad_ptr, lines_op++, 0, "%s", entry + cat_length + 1);
}
}
fclose(tracks_fp);
if (lines_op > BOXED_LINES) {
mvprintw(MESSAGE_LINE, 0,
"Cursor keys to scroll, RETURN or q to exit");
} else {
mvprintw(MESSAGE_LINE, 0, "RETURN or q to exit");
}
wrefresh(stdscr);
keypad(stdscr, TRUE);
cbreak();
noecho();
key = 0;
while (key != "q" && key != KEY_ENTER && key != '\n') {
if (key == KEY_UP) {
if (first_line > 0) first_line--;
}
if (key == KEY_DOWN) {
if (first_line + BOXED_LINES + 1 < tracks) first_line++;
}
/* Теперь рисует соответствующую часть панели на экране */
prefresh(track_pad_ptr, first_line, 0, BOX_LINE_POS, BOX_ROW_POS,
BOX_LINE_POS + BOXED_LINES, BOX_ROW_POS + BOXED_ROWS);
key = getch();
}
delwin(track_pad_ptr);
keypad(stdsсг, FALSE);
nocbreak();
echo();
}
4. В последних двух функциях вызывается функция get_return, которая приглашает к вводу и считывает символ возврата каретки, игнорируя другие символы.
void get_return() {
int ch;
mvprintw(23, 0, "is", " Press return ");
refresh();
while ((ch = getchar()) != '\n' && ch != EOF);
}
Если вы выполните эту программу, то увидите на экране нечто похожее на рис. 6.10.

Рис. 6.10
Резюме.
В этой главе вы изучили библиотеку curses. Она предлагает текстовым программам удобный способ управления экраном и считывания данных с клавиатуры. Хотя библиотека curses не обеспечивает такого уровня управления, как общий терминальный интерфейс (GTI) и прямой доступ к структуре terminfo, ею гораздо легче пользоваться. Если вы пишете полноэкранное текстовое приложение, стоит рассмотреть возможность применения в нем библиотеки curses для управления экраном и чтения данных с клавиатуры.
Глава 7. Управление данными.
В предыдущих главах мы касались темы ограниченности ресурсов. В этой главе мы собираемся рассмотреть сначала способы управления распределением ресурсов, затем методы обработки файлов, к которым обращается много пользователей примерно в одно и то же время, и наконец, одно средство, предоставляемое в системах Linux и позволяющее преодолеть ограничения простых файлов как среды хранения данных.
Мы можем представить все эти темы как три способа управления данными:
□ управление динамической памятью: что делать и что Linux не разрешит делать;
□ блокировка файлов: совместная блокировка, блокируемые области совместно используемых файлов и обход взаимоблокировок;
□ база данных dbm: базовая, основанная не на запросах SQL библиотека базы данных, присутствующая в большинстве систем Linux.
Управляемая память.
Во всех компьютерных системах память — дефицитный ресурс. Не важно, сколько памяти доступно, ее всегда не хватает. Кажется, совсем недавно считалось, что 256 Мбайт RAM вполне достаточно, а сейчас распространено мнение о том, что 2 Гбайт RAM — это обоснованное минимальное требование даже для настольных систем, а серверам полезно было бы иметь значительно больше.
У всех UNIX-подобных операционных систем, начиная с самых первых версий, был ясный подход к управлению памятью, который унаследовала ОС Linux, воплощающая стандарт X/Open. Приложениям в ОС Linux, за исключением нескольких специализированных встроенных приложений, никогда не разрешается напрямую обращаться к физической памяти. Приложению может казаться, что у него есть такая возможность, но самом деле это тщательно управляемая иллюзия.
Система Linux снабжает приложения четким представлением огромной прямо адресуемой области оперативной памяти. Кроме того, она обеспечивает защиту приложений друг от друга и позволяет им явно обращаться к объему памяти, большему, чем имеющаяся физическая память в машине, хорошо настроенной и имеющей достаточную область свопинга или подкачки.
Простое выделение памяти.
Вы можете выделить память с помощью вызова malloc из стандартной библиотеки С:
#include <stdlib.h>
void *malloc(size_t size);
Примечание. Имейте в виду, что ОС Linux (следующая требованиям стандарта X/Open) отличается от некоторых реализаций UNIX тем, что не требует включения специального заголовочного файла malloc.h. Кроме того, параметр size, задающий количество выделяемых байтов, — это не простой тип int, хотя обычно он задается типом беззнаковое целое (unsigned integer).В большинстве систем Linux вы можете выделять большой объем памяти. Давайте начнем с очень простой программы из упражнения 7.1, которая, тем не менее, выигрывает соревнование со старыми программами ОС MS-DOS, поскольку они не могут обращаться к памяти за пределами базовой карты памяти ПК объемом 640 Кбайт.
Упражнение 7.1. Простое распределение памяти.
Наберите следующую программу memory1.с:
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#define A_MEGABYTE (1024 * 1024)
int main() {
char *some_memory;
int megabyte = A_MEGABYTE;
int exit_code = EXIT_FAILURE;
some_memory = (char*)malloc(megabyte);
if (some_memory ! = NULL) {
sprintf(some_memory, "Hello World\n");
printf("%s", some_memory);
exit_code = EXIT_SUCCESS;
}
exit(exit_code);
}
Когда вы выполните эту программу, то получите следующий вывод:
$ ./memory1
Hello World
Как это работает
Данная программа запрашивает с помощью библиотечного вызова malloc указатель на один мегабайт памяти. Вы проверяете, успешно ли завершился вызов malloc, и используете часть памяти, чтобы продемонстрировать ее наличие. Когда вы выполните программу, то увидите вывод фразы "Hello World", показывающий, что malloc действительно вернул мегабайт используемой памяти. Мы не проверяем наличие мегабайта целиком; мы приняли на веру программный код malloc!
Поскольку функция malloc возвращает указатель типа void*, вы преобразуете результат в нужный вам указатель типа char*. Эта функция возвращает память, выровненную так, что она может быть преобразована в указатель любого типа.
Простое основание — современные системы Linux применяют 32-разрядные целые и 32-разрядные указатели, что позволяет задавать до 4 Гбайт. Эта способность задавать адреса с помощью 32-разрядного указателя без необходимости применения регистров сегментов или других приемов, называется простой 32-разрядной моделью памяти. Эта модель также используется и в 32-разрядных версиях ОС Windows ХР и Vista. Тем не менее, никогда не следует рассчитывать на 32-разрядные целые, поскольку все возрастающее количество 64-разрядных версий Linux находится в употреблении.
Выделение огромных объемов памяти.
Теперь, когда вы увидели, что ОС Linux преодолевает ограничения модели памяти ОС MS-DOS, давайте усложним ей задачу. Приведенная в упражнении 7.2 программа запрашивает выделение объема памяти, большего, чем физически есть в машине, поэтому можно предположить, что функция malloc начнет давать сбои при приближении к максимальному объему физической памяти, поскольку ядру и всем остальным выполняющимся процессам также нужна память.
Упражнение 7.2. Запрос на всю физическую память.
С помощью программы memory2.с мы собираемся запросить больше памяти, чем физически есть в машине. Вам нужно откорректировать определение PHY_MEM_MEGS в соответствии с физическими ресурсами вашего компьютера.
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#define A_MEGABYTE (1024 * 1024)
#define PHY_MEM_MEGS 1024 /* Откорректируйте это число
должным образом */
int main() {
char *some_memory;
size_t size_to_allocate = A_MEGABYTE;
int megs_obtained = 0;
while (megs_obtained < (PHY_MEM_MEGS * 2)) {
some_memory = (char *)malloc(size_to_allocate);
if (some_memory != NULL) {
megs_obtained++;
sprintf(somememory, "Hello World");
printf("%s — now allocated %d Megabytes\n", some_memory, megs_obtained);
} else {
exit(EXIT_FAILURE);
}
}
exit(EXIT_SUCCESS);
}
Далее приведен немного сокращенный вывод:
$ ./memory3
Hello World — now allocated 1 Megabytes
Hello World — now allocated 2 Megabytes
...
Hello World — now allocated 2047 Megabytes
Hello World — now allocated 2048 Megabytes
Как это работает
Программа очень похожа на предыдущий пример. Это просто циклы, запрашивающие все больше и больше памяти до тех пор, пока не будет выделено памяти вдвое больше, чем заданный вами с помощью корректировки определения PHY_MEM_MEGS объем памяти, имеющейся у вашего компьютера. Удивительно, что эта программа вообще работает, потому что мы, как оказалось, создали программу, которая использует каждый байт физической памяти на машине одного из авторов. Обратите внимание на то, что в нашем вызове malloc применяется тип size_t.
Другая интересная особенность заключается в том, что, по крайней мере, на данной машине программа выполняется в мгновение ока. Таким образом, мы не только вне сомнения использовали всю память, но и сделали это на самом деле очень быстро.
Продолжим исследование и посмотрим, сколько памяти мы сможем выделить на этой машине с помощью программы memory3.c (упражнение 7.3). Поскольку уже понятно, что система Linux способна очень умно обходиться с запросами памяти, мы каждый раз будем выделять память по 1 Кбайт и записывать данные в каждый полученный нами блок.
Упражнение 7.3. Доступная память.
Далее приведена программа memory3.c. По своей истинной природе она крайне недружественная по отношению к пользователю и может очень серьезно повлиять на многопользовательскую машину. Если вас беспокоит подобный риск, лучше совсем не запускать ее; если вы окажитесь от выполнения этой программы, усвоению материала это не повредит.
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#define ONE_K (1024)
int main() {
char *some_memory;
int size_to_allocate = ONE_K;
int megs_obtained = 0;
int ks_obtained = 0;
while (1) {
for (ks_obtained = 0; ks_obtained < 1024; ks_obtained++) {
some_memory = (char *)malloc(size_to_allocate);
if (some_memory == NULL) exit(EXIT_FAILURE);
sprintf(some_memory, "Hello World");
}
megs_obtained++;
printf("Now allocated %d Megabytes\n", megs_obtained);
}
exit(EXIT_SUCCESS);
}
На этот раз вывод, также сокращенный, выглядит следующим образом:
$ ./memory3
Now allocated 1 Megabytes
...
Now allocated 1535 Megabytes
Now allocated 1536 Megabytes
Out of Memory: Killed process 2365
Killed
После этого программа завершается. Она выполняется несколько секунд и существенно замедляется при приближении к размеру, равному объему физической памяти на компьютере, а также активно использует жесткий диск. Тем не менее программа выделяла и получала доступ к области памяти, большей по размеру объема физической памяти, которая была установлена на машине одного из авторов во время написания этой главы. В конце концов, система защищает себя от этой довольно агрессивной программы и уничтожает ее. В некоторых системах она может тихо закончить выполнение, когда функция malloc завершается аварийно.
Как это работает
Память, выделяемая приложению, управляется ядром системы Linux. Каждый раз, когда программа запрашивает память, пытается записывать в память или считывать из памяти, которая была выделена, ядро Linux решает, как обрабатывать этот запрос.
Сначала ядро может использовать свободную физическую память для удовлетворения запроса приложения на выделение памяти, но когда физическая память исчерпана, ядро начинает использовать так называемую область свопинга или подкачки. В ОС Linux это отдельная область диска, выделяемая во время инсталляции системы. Если вы знакомы с ОС Windows, функционирование области свопинга в Linux немного напоминает файл подкачки в Windows. Но в отличие от ОС Windows при написании программного кода не нужно беспокоиться ни о локальной, ни о глобальной динамической памяти (heap), ни о выгружаемых сегментах памяти — ядро Linux все организует для вас.
Ядро перемещает данные и программный код между физической памятью и областью свопинга так, что при каждом чтении из памяти или записи в нее данные кажутся находящимися в физической памяти, где бы они не находились на самом деле перед вашей попыткой обратиться к ним.
Говоря более профессиональным языком, система Linux реализует систему виртуальной памяти с подкачкой страниц по требованию. Вся память, видимая программами пользователя, — виртуальная, т. е. реально не существующая в физическом адресном пространстве, используемом программой. Система Linux делит всю память на страницы, обычно размером 4096 байтов. Когда программа пытается обратиться к памяти, выполняется преобразование виртуальной памяти в физическую, конкретный способ реализации которого и затрачиваемое на преобразование время зависят от конкретного оборудования, применяемого вами. Когда выполняется обращение к области памяти, физически нерезидентной, возникает ошибка страницы памяти и управление передается ядру.
Ядро Linux проверяет адрес, к которому обратилась программа, и, если это допустимый для нее адрес, определяет, какую страницу физической памяти сделать доступной. Затем оно либо выделяет память для страницы, если она еще не записывалась ни разу, либо, если страница хранится на диске в области свопинга, считывает страницу памяти, содержащую данные, в физическую память (возможно выгружая на диск имеющуюся в памяти страницу). Затем после преобразования адресов виртуальной памяти в соответствующие физические адреса ядро разрешает пользовательской программе продолжить выполнение. Приложениям в ОС Linux не нужно заботиться об этих действиях, поскольку их реализация полностью скрыта в ядре.
В итоге, когда приложение исчерпает и физическую память, и область свопинга или когда она превысит максимальный размер стека, ядро откажется выполнить запрос на дальнейшее выделение памяти, может завершить программу и выгрузить ее.
Примечание. Это поведение, сопровождающееся уничтожением процесса, отличается от поведения более старых версий Linux и множества других вариантов UNIX, в которых просто аварийно завершалась функция malloc. Называется оно уничтожением из-за нехватки памяти (out of memory (OOM) killer), и хотя может показаться чересчур радикальным, на самом деле служит разумным компромиссом между возможностью быстрого и эффективного выделения памяти процессам и необходимостью собственной защиты ядра от полного исчерпания ресурсов, что является серьезной проблемой.Но что это означает для прикладного программиста? В основном благую весть. Система Linux очень умело управляет памятью и позволяет приложениям использовать большие области памяти и даже очень большие единые блоки памяти. Но вы должны помнить о том, что выделение двух блоков памяти в результате не приведет к формированию одного непрерывно адресуемого блока памяти. Вы получите то, что просили: два отдельных блока памяти.
Означает ли этот, по-видимому, неограниченный источник памяти с последующим прерыванием и уничтожением процесса, что в проверке результата, возвращаемого функцией malloc, нет смысла? Конечно же нет. Одна из самых распространенных проблем в программах на языке С, использующих динамическую память, — запись за пределами выделенного блока. Когда это происходит, программа может не завершиться немедленно, но вы, вероятно, перезапишите некоторые внутренние данные, используемые подпрограммами библиотеки malloc.
Обычный результат — аварийное завершение последующих вызовов malloc не из- за нехватки памяти, а из-за повреждения структур памяти. Такие проблемы бывает трудно отследить, и чем быстрее в программах обнаружится ошибка, тем больше шансов найти причину. В главе 10, посвященной отладке и оптимизации, мы обсудим некоторые средства, которые могут помочь вам выявить проблемы, связанные с памятью.
Неправильное обращение к памяти.
Предположим, что вы хотите сделать что-то "плохое" с памятью. В упражнении 7.4 в программе memory4.c вы выделяете некоторую область памяти, а затем пытаетесь записать данные за пределами выделенной области.
Упражнение 7.4. Неправильное обращение к вашей памяти.
#include <stdlib.h>
#define ONE_K (1024)
int main() {
char *some_memory;
char *scan_ptr;
some_memory = (char *)malloc(ONE_K);
if (some_memory == NULL) exit(EXIT_FAILURE);
scan_ptr = some_memory;
while (1) {
*scan_ptr = '\0';
scan_ptr++;
}
exit(EXIT_SUCCESS);
}
Вывод прост:
$ ./memory4
Segmentation fault
Как это работает
Система управления памятью в ОС Linux защищает остальную систему от подобного некорректного использования памяти. Для того чтобы быть уверенной в том, что одна плохо ведущая себя программа (как эта) не сможет повредить любые другие программы, система Linux прекратила ее выполнение.
Каждая выполняющаяся в системе Linux программа видит собственную карту распределения памяти, которая отличается от карты распределения памяти любой другой программы. Только операционная система знает, как организована физическая память и не только управляет ею в интересах пользовательских программ, но также защищает их друг от друга.
Указатель null.
Современные системы Linux, в отличие от ОС MS-DOS, но подобно новейшим вариантам ОС Windows, надежно защищены от записи или чтения по адресу, на который ссылается пустой указатель ( null), хотя реальное поведение системы зависит от конкретной реализации.
Выполните упражнение 7.5.
Упражнение 7.5. Обращение по указателю null.
Давайте выясним, что произойдет, когда мы попытаемся обратиться к памяти по пустому или null-указателю в программе memory5a.c.
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
int main() {
char *some_memory = (char*)0;
printf("A read from null %s\n", some_memory);
sprintf(some_memory, "A write to null\n");
exit(EXIT_SUCCESS);
}
Будет получен следующий вывод:
$ ./memory5a
A read from null (null)
Segmentation fault
Как это работает
Первая функция printf пытается вывести строку, полученную от указателя null; далее sprintf пытается записать по указателю null. В данном случае Linux (под видом библиотеки GNU С) простила чтение и просто предоставила "магическую" строку, содержащую символы (null)\0. Система не столь терпима в случае записи и просто завершила программу. Такое поведение порой полезно при выявлении программных ошибок.
Если вы повторите попытку, но не будете использовать библиотеку GNU С, вы обнаружите, что безадресное чтение не разрешено. Далее приведена программа memory5b.c:
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
int main() {
char z = *(const char *)0;
printf("I read from location zero\n");
exit(EXIT_SUCCESS);
}
Вы получите следующий результат:
$ ./memory5b
Segmentation fault
В этот раз вы пытаетесь прочесть непосредственно из нулевого адреса. Между вами и ядром теперь нет GNU-библиотеки libc, и программа прекращает выполнение. Имейте в виду, что некоторые системы UNIX разрешают читать из нулевого адреса, ОС Linux этого не допускает.
Освобождение памяти.
До сих пор мы выделяли память и затем надеялись на то, что по завершении программы использованная нами память не будет потеряна, К счастью, система управления памятью в ОС Linux вполне способна с высокой степенью надежности гарантировать возврат памяти в систему по завершении программы. Но большинство программ просто не хотят распределять память, используют ее очень короткий промежуток времени и затем завершаются. Гораздо более распространено динамическое использование памяти по мере необходимости.
Программы, применяющие память на динамической основе, должны всегда возвращать неиспользованную память диспетчеру распределения памяти malloc с помощью вызова free. Это позволяет выделить блоки, нуждающиеся в повторном объединении, и дает возможность библиотеке malloc следить за памятью, вместо того, чтобы заставлять приложение управлять ею. Если выполняющаяся программа (процесс) использует, а затем освобождает память, эта освободившаяся память остается выделенной процессу. За кадром система Linux управляет блоками памяти, которые программист использует как набор физических "страниц" в памяти, размером 4 Кбайт каждая. Но если страница памяти в данный момент не используется, диспетчер управления памятью ОС Linux сможет переместить ее из оперативной памяти в область свопинга (это называется обменом страниц), где она слабо влияет на потребление ресурсов. Если программа пытается обратиться к данным на странице, которая была перенесена в область свопинга, Linux на очень короткое время приостанавливает программу, возвращает страницу обратно из области свопинга в физическую память и затем разрешает программе продолжить выполнение так, будто данные все время находились в оперативной памяти.
#include <stdlib.h>
void free(void *ptr_to_memory);
Вызов free следует выполнять только с указателем на память, выделенную с помощью вызова malloc, calloc или realloc. Очень скоро вы встретитесь с функциями calloc и realloc. А сейчас выполните упражнение 7.6.
Упражнение 7.6. Освобождение памяти.
Эта программа называется memory6.c.
#include <stdlib.h>
#include <stdio.h>
#define ONE_K (1024)
int main() {
char *some_memory;
int exit code = EXIT_FAILURE;
some_memory = (char*)malloc(ONE_K);
if (some_memory != NULL) {
free(some_memory);
printf("Memory allocated and freed again\n");
exit_code = EXIT_SUCCESS;
}
exit(exit_code);
}
Вывод программы следующий:
$ ./memory6
Memory allocated and freed again
Как это работает
Эта программа просто показывает, как вызвать функцию free с указателем, направленным на предварительно выделенную область памяти.
Примечание. Помните о том, что после вызова free для освобождения блока памяти этот блок больше не принадлежит процессу. Он больше не управляется библиотекой malloc. Никогда не пытайтесь читать из области памяти или писать в область памяти, для которой была вызвана функция free.Другие функции распределения памяти.
Две другие функции распределения или выделения памяти calloc и realloc применяются не так часто, как malloc и free.
Далее приведены их прототипы:
#include <stdlib.h>
void *calloc(size_t number_of_elements, size_t element_size);
void *realloc(void *existing_memozy, size_t new_size);
Несмотря на то, что функция calloc выделяет память, которую можно освободить с помощью функции free, ее параметры несколько отличаются от параметров функции malloc: она выделяет память для массива структур и требует задания количества элементов и размера каждого элемента массива как параметров. Выделенная память заполняется нулями; и если функция calloc завершается успешно, возвращается указатель на первый элемент. Как и в случае функции malloc, последовательные вызовы не гарантируют возврата непрерывной области памяти, поэтому вы не можете увеличить длину массива, созданного функцией calloc, просто повторным вызовом этой функции и рассчитывать на то, что второй вызов вернет память, добавленную в конец блока памяти, полученного после первого вызова функции.
Функция realloc изменяет размер предварительно выделенного блока памяти. Она получает в качестве параметра указатель на область памяти, предварительно выделенную функциями malloc, calloc или realloc, и уменьшает или увеличивает эту область в соответствии с запросом. Функция бывает вынуждена для достижения результата в перемещении данных, поэтому важно быть уверенным в том, что к памяти, выделенной после вызова realloc, вы всегда обращаетесь с помощью нового указателя и никогда не используете указатель, установленный ранее до вызова функции realloc.
Другая проблема, за которой нужно следить, заключается в том, что функция realloc возвращает пустой указатель при невозможности изменить размер блока памяти. Это означает, что в приложениях следует избегать кода, подобного приведенному далее:
my_ptr = malloc(BLOCK_SIZE);
...
my_ptr = realloc(my_ptr, BLOCK_SIZE * 10);
Если realloc завершится аварийно, она вернет пустой указатель; переменная my_ptr будет указывать в никуда и к первоначальной области памяти, выделенной функцией malloc, больше нельзя будет обратиться с помощью указателя my_ptr. Следовательно, было бы полезно сначала запросить новый блок памяти с помощью malloc, а затем скопировать данные из старого блока памяти в новый блок с помощью функции memcpy и освободить старый блок памяти вызовом free. При возникновении ошибки это позволит приложению сохранить доступ к данным, хранящимся в первоначальном блоке памяти, возможно, на время организации корректного завершения программы.
Блокировка файлов.
Блокировка файлов — очень важная составляющая многопользовательских многозадачных операционных систем. Программы часто нуждаются в совместно используемых данных, обычно хранящихся в файлах, и очень важно, что у этих программ есть способ управления файлом. Файл может быть при этом безопасно обновлен или программа может пресечь свои попытки чтения файла, находящегося в переходном состоянии во время записи в него данных другой программой.
У системы Linux есть несколько средств, которые можно применять для блокировки файлов. Простейший способ — блокировка файла на элементарном уровне, когда ничего не может произойти при установленной блокировке. Он предоставляет программе метод создания файлов, обеспечивающий уникальность файла и невозможность одновременного создания этого файла другой программой.
Второй способ более сложный, он позволяет программам блокировать части файла для получения исключительного права доступа к ним. Есть два метода реализации этого варианта блокировки. Мы рассмотрим подробно только один из них, поскольку второй очень похож и отличается от первого немного иным интерфейсом.
Создание файлов с блокировкой.
Многие приложения нуждаются в возможности создания ресурса в виде файла с блокировкой. Другие программы после этого могут проверить файл, чтобы узнать, есть ли у них право доступах ресурсу.
Как правило, эти заблокированные файлы находятся в специальном месте и имеют имена, связанные с управляемыми ими ресурсами. Например, когда используется модем, система Linux создает файл с блокировкой, часто применяя каталог в каталоге /var/spool.
Помните о том, что блокировки файлов действуют только как индикаторы; программы должны сотрудничать для их применения. Такие блокировки называют рекомендательными (advisory lock), в отличие от обязательных блокировок (mandatory lock), при которых система инициирует блокирование.
Для создания файла с блокировкой (упражнение 7.7) можно использовать системный вызов open, определенный в файле fcntl.h (уже встречавшемся в предыдущих главах) и содержащий набор флагов O_CREAT и O_EXCL. Этот способ позволяет проверить, не существует ли уже такой файл, и затем создать его за одну элементарную неделимую операцию.
Упражнение 7.7. Создание файла с блокировкой.
В программе lock1.c вы сможете увидеть файл с блокировкой в действии.
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
int main() {
int file_desc;
int save_errno;
file_desc = open("/tmp/LCK.test", O_RDWR | O_CREAT | O_EXCL, 0444);
if (file_desc == -1) {
save errno = errno;
printf("Open failed with error %d\n", save_errno);
} else {
printf("Open succeeded\n");
}
exit(EXIT_SUCCESS);
}
Выполнив программу первый раз, вы получите следующий вывод:
$ ./lock1
Open succeeded
Но при повторной попытке вы получите результат, приведенный далее:
$ ./lock1
Open failed with error 17
Как это работает
Для создания файла с именем /tmp/LCK.test программа выполняет вызов, использующий флаги O_CREAT и O_EXCL. Во время первого выполнения программы файл не существует, поэтому вызов open завершается успешно. Последующие запуски программы завершаются аварийно, потому что файл уже существует. Для успешного выполнения этой программы в дальнейшем вы должны вручную удалить файл с блокировкой.
В системах Linux, ошибка 17 соответствует константе EEXIST, указывающей на то, что файл уже существует. Номера ошибок определены в файле errno.h или, скорее, в файлах, включаемых этим файлом. В данном случае определение в действительности, находящееся в /usr/include/asm-generic/errno-base.h, гласит
#define EEXIST 17 /* File exists */
Это ошибка, соответствующая аварийному завершению вызова open(O_CREAT | O_EXCL).
Если программе на короткий период во время выполнения, часто называемый критической секцией, нужно право исключительного доступа к ресурсу, ей следует перед входом в критическую секцию, создать файл с блокировкой с помощью системного вызова open и применить системный вызов unlink для удаления этого файла впоследствии, когда она завершит выполнение критической секции.
Вы можете увидеть сотрудничество программ, применяющих этот механизм блокировки, написав программу-пример и запустив одновременно две ее копии (упражнение 7.8). В программе будет использован вызов функции getpid, с которой вы встречались в главе 4, она возвращает идентификатор процесса, уникальный номер для каждой выполняющейся в данный момент программы.
Упражнение 7.8. Совместная блокировка файлов.
1. Далее приведен исходный код тестовой программы lock2.с.
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
const char *lock_file = "/tmp/LCK.test2";
int main() {
int file_desc;
int tries = 10;
while (--tries) {
file_desc = open(lock_file, O_RDWR | O_CREAT | O_EXCL, 0444);
if (file_desc == -1) {
printf("%d - Lock already present\n", getpid());
sleep(3);
} else {
2. Далее следует критическая секция:
printf("%d — I have exclusive access\n", getpid());
sleep(1);
(void)close(file_desc);
(void)unlink(lockfile);
3. В этом месте она заканчивается:
sleep(2);
}
}
exit(EXIT_SUCCESS);
}
Для выполнения программы вам сначала нужно выполнить следующую команду, чтобы убедиться в том, что файла не существует:
$ rm -f /tmp/LCK.test2
Затем с помощью приведенной далее команды запустите две копии программы:
$ ./lock2 & ./lock2
Она запускает одну копию программы в фоновом режиме, а вторую — как основную программу. Далее приведен вывод:
1284 — I have exclusive access
1283 — Lock already present
1283 — I have exclusive access
1284 — Lock already present
1284 — I have exclusive access
1283 — Lock already present
1283 — I have exclusive access
1284 — Lock already present
1284 — I have exclusive access
1283 — Lock already present
1283 — I have exclusive access
1284 — Lock already present
1284 — I have exclusive access
1283 — Lock already present
1283 — I have exclusive access
1284 — Lock already present
1284 — I have exclusive access
1283 — Lock already present
1283 — I have exclusive access
1284 — Lock already present
В приведенном примере показано, как взаимодействуют две выполняющиеся копии одной и той же программы. Если вы попробуете выполнить данный пример, то почти наверняка увидите другие идентификаторы процессов в выводе, но поведение программ будет тем же самым.
Как это работает
Для демонстрации вы 10 раз выполняете в программе цикл с помощью оператора while. Затем программа пытается получить доступ к дефицитному ресурсу, создав уникальный файл с блокировкой /tmp/LCK.test2. Если эта попытка терпит неудачу из-за того, что файл уже существует, программа ждет короткий промежуток времени и затем снова пытается создать файл. Если ей это удается, она получает доступ к ресурсу и в части программы, помеченной как "критическая секция", выполняет любую обработку, требующую исключительных прав доступа.
Поскольку это всего лишь пример, вы ждете очень короткий промежуток времени. Когда программа завершает использование ресурса, она снимает блокировку, удаляя файл с блокировкой. Далее она может выполнить другую обработку (в данном случае это просто функция sleep) прежде, чем попытаться возобновить блокировку. Файлы с блокировкой действуют как двоичный семафор, давая программе ответ "да" или "нет" на вопрос: "Могу ли я использовать ресурс?". В главе 14 вы узнаете больше о семафорах.
Примечание.
Важно уяснить, что это совместное мероприятие, и вы должны корректно писать программы для его работы. Программа, потерпевшая неудачу в создании файла с блокировкой, не может просто удалить файл и попробовать снова, Возможно, в дальнейшем она сумеет создать файл с блокировкой, но у другой программы, уже создавшей такой файл, нет способа узнать о том, что она лишилась исключительного доступа к ресурсу.
Блокировка участков файла.
Создание файлов с блокировкой подходит для управления исключительным доступом к ресурсам, таким как последовательные порты или редко используемые файлы, но этот способ не годится для доступа к большим совместно используемым файлам. Предположим, что у вас есть большой файл, написанный одной программой и одновременно обновляемый многими программами. Такая ситуация может возникнуть, если программа записывает какие-то данные, получаемые непрерывно или в течение длительного периода, и обрабатывает их с помощью нескольких разных программ. Обрабатывающие программы не могут ждать, пока программа, записывающая данные, завершится — она работает постоянно, поэтому программам нужен какой-то способ кооперации для обеспечения одновременного доступа к одному и тому же файлу.
Урегулировать эту ситуацию можно, блокируя участки файла. При этом конкретная часть файла блокируется, но другие программы могут иметь доступ к другим участкам файла. Это называется блокировкой сегментов или участков файла. У системы Linux есть (как минимум) два способа сделать это: с помощью системного вызова fcntl или системного вызова lockf. Мы рассмотрим интерфейс fcntl, поскольку он наиболее часто применяется. Интерфейс lockf в основном аналогичен, и в ОС Linux он используется как альтернативный интерфейсу fcntl. Однако блокирующие механизмы fcntl и lockf не работают вместе: у них разные низкоуровневые реализации. Поэтому никогда не следует смешивать вызовы этих двух типов; выберите один или другой.
Вы встречали вызов fcntl в главе 3. У него следующее определение:
#include <fcntl.h>
int fcntl(int fildes, int command, ...);
Системный вызов fcntl оперирует открытыми дескрипторами файлов и, в зависимости от параметра command, может выполнять разные задачи. Для блокировки файлов интересны три приведенные далее возможные значения параметра command:
□ F_GETLK;
□ F_SETLK;
□ F_SETLKW.
Когда вы используете эти варианты, третий аргумент в вызове должен быть указателем на структуру struct flock, поэтому на самом деле прототип вызова выглядит следующим образом:
int fcntl(int fildes, int command, struct flock *flock_structure);
Структура flock (он англ. file lock) зависит от конкретной реализации, но, как минимум, она будет содержать следующие элементы:
□ short l_type;
□ short l_whence;
□ off_t l_start;
□ off_t l_len;
□ pid_t l_pid.
Элемент l_type принимает одно из нескольких значений (табл. 7.1), определенных в файле fcntl.h.
Таблица 7.1.
Значение | Описание |
---|---|
F_RDLCK | Разделяемая или совместная блокировка (блокировка на чтение). У разных процессов может быть разделяемая блокировка одних и тех же (или перекрывающихся) участков файла. Если у какого-либо процесса есть разделяемая блокировка, ни один процесс не сможет установить исключительную блокировку этого участка. Для получения совместной блокировки файл должен быть открыт с правом на чтение или на чтение/запись |
F_UNLCK | Разблокировать. Применяется для снятия блокировок |
F_WRLCK | Исключительная блокировка (или блокировка на запись). Только один процесс может установить исключительную блокировку на любой конкретный участок файла. После того как процесс установил такую блокировку, никакой другой процесс не сможет установить блокировку любого типа на этот участок файла. Для установки исключительной блокировки файл должен быть открыт с правом на запись или на чтение/запись |
Элементы l_whence, l_start и l_len определяют участок файла, непрерывную область в байтах. Элемент l_whence должен задаваться одним из следующих значений: SEEK_SET, SEEK_CUR, SEEK_END (из файла unistd.h). Они соответствуют началу, текущей позиции или концу файла соответственно. Элемент l_whence задает смещение для первого байта участка файла, определенного элементом l_start. Обычно оно задается константой SEEK_SET, поэтому l_start отсчитывается от начала файла. Параметр l_len содержит количество байтов в участке файла.
Параметр l_pid применяется для указания процесса, установившего блокировку; см. следующее далее описание значения F_GETLK параметра command.
Для каждого байта в файле может быть установлена блокировка только одного типа в каждый конкретный момент времени и может быть либо разделяемой блокировкой, либо исключительной или блокировка может отсутствовать. Для системного вызова fcntl существует совсем немного комбинаций значений команд и вариантов, поэтому рассмотрим их все по очереди.
Значение F_GETLK параметра command.
Первое значение параметра command — F_GETLK. Эта команда получает информацию о файле, который открыт fildes (первый параметр в вызове). Она не пытается блокировать файл. В процессе вызова передаются сведения о типе блокировки, которую хотелось бы установить, и вызов fcntl с командой F_GETLK возвращает любую информацию, которая могла бы помешать установке блокировки.
Значения, используемые в структуре flock, приведены в табл. 7.2.
Таблица 7.2
Значение | Описание |
---|---|
l_type | Или F_RDLCK для разделяемой (только чтение) блокировки, или F_WRLCK для исключительной (на запись) блокировки |
l_whence | Одно из значений: SEEK_SET, SEEK_CUR или SEEK_END LCK |
l_start | Начальный байт интересующего вас участка файла |
l_len | Количество байтов в интересующем вас участке файла |
l_pid | Идентификатор процесса, удерживающего блокировку |
Процесс может применять вызов с командой F_GETLK для определения текущего состояния блокировки участка файла. Он должен настроить структуру flock, указав тип требуемой блокировки и определив интересующую его область файла. Вызов fcntl возвращает в случае успешного завершения значение, отличное от -1. Если у файла уже есть блокировки, препятствующие установке требуемой блокировки, структура flock обновляется соответствующими данными. Если блокировке ничто не мешает, структура flock не изменяется. Если вызов с командой F_GETLK не может получить информацию, он возвращает -1 для обозначения аварийного завершения.
Если вызов с командой F_GETLK завершился успешно (т. е. вернул значение, отличное от -1), вызвавшее его приложение должно проверить, изменено ли содержимое структуры flock. Поскольку значение l_pid содержит идентификатор блокирующего процесса (если таковой найден), это поле очень удобно для того, чтобы проверить, изменялась ли структура flock.
Значение F_SETLK параметра command.
Эта команда пытается заблокировать или разблокировать участок файла, заданного fildes. В табл. 7.3 приведены значения полей структуры flock (отличающиеся от значений, применяемых командой F_GETLK).
Таблица 7.3
Значение | Описание |
---|---|
l_type | Одно из следующих: • F_RDLCK — для разделяемой или допускающей только чтение блокировки; • F_WRLCK — для исключительной или блокировки записи; • F_UNLCK — для разблокирования участка |
l_pid | Не используется |
Как и в случае F_GETLK, блокируемый участок определяется значениями элементов l_start, l_whence и l_len структуры flock. Если блокировка установлена, вызов fcntl вернет значение, отличное от -1, при аварийном завершении возвращается -1. Вызов завершается немедленно.
Значение F_SETLKW параметра command.
Команда F_SETLKW аналогична команде F_SETLK за исключением того, что при невозможности установки блокировки вызов будет ждать до тех пор, пока такая возможность не представится. После перехода в состояние ожидания вызов завершится только, когда блокировка будет установлена или появится сигнал. Сигналы мы обсудим в главе 11.
Все блокировки файла, установленные программой, автоматически очищаются, когда закрывается соответствующий дескриптор файла. То же самое происходит, когда программа завершается.
Применение вызовов read и write при наличии блокировки.
Когда вы применяете блокировку участков файла, очень важно использовать для доступа к данным низкоуровневые вызовы read и write вместо высокоуровневых функций freadи fwrite. Это необходимо, поскольку функции fread и fwrite выполняют внутри библиотеки буферизацию читаемых или записываемых данных, так что при выполнений вызова fread для считывания 100 байтов из файла может быть (и на самом деле почти наверняка будет), считано более 100 байтов, и дополнительные данные помещаются во внутрибиблиотечный буфер. Если программа применит функцию fread для считывания следующих 100 байтов, она на самом деле считает данные из буфера и не разрешит низкоуровневому вызову read извлечь больше данных из файла.
Для того чтобы понять, в чем тут проблема, рассмотрим две программы, которые хотят обновить один и тот же файл. Предположим, что файл содержит 200 байтов данных, все нули. Первая программа начинает работу и устанавливает блокировку на запись для первых 100 байтов файла. Затем она применяет функцию fread для считывания этих 100 байтов. Однако, как было показано в одной из предшествующих глав, fread будет каждый раз считывать больше, до BUFSIZ байтов, поэтому она на самом деле считает в память целиком весь файл, но программе вернет только первые 100 байтов.
Затем стартует вторая программа. Она устанавливает блокировку write на вторые 100 байтов файла. Это действие завершится успешно, поскольку первая программа заблокировала только первые 100 байтов. Вторая программа записывает двойки в байты с 100-го по 199-й, закрывает файл, снимает блокировку и завершается. В это время первая программа блокирует вторые 100 байтов файла и вызывает функцию fread для их считывания. Поскольку эти данные были уже занесены библиотекой в буфер, программа увидит 100 байтов нулей, а не 100 двоек, которые на самом деле хранятся в файле на жестком диске. Подобной проблемы не возникает, если вы применяете вызовы read и write.
Приведенное описание блокировки файла может показаться сложноватым, но ее труднее описать, чем применить. Поэтому выполните упражнение 7.9.
Упражнение 7.9. Блокировка файла с помощью вызова fcntl.
Давайте рассмотрим пример работы блокировки файла в программе lock3.с. Для опробования блокировки вам понадобятся две программы: одна для установки блокировки и другая для ее тестирования. Первая программа выполняет блокировку.
1. Начните с файлов include и объявлений переменных:
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
const char *test_file = "/tmp/test_lock";
int main() {
int file desc;
int byte_count;
char *byte_to_write = "A";
struct flock region_1;
struct flock region_2;
int res;
2. Откройте файловый дескриптор:
file_desc = open(test_file, O_RDWR | O_CREAT, 0666);
if (!file_desc) {
fprintf(stderr, "Unable to open %s for read/write\n", test_file);
exit(EXIT_FAILURE);
}
3. Поместите данные в файл:
for (byte_count = 0; byte_count < 100; byte_count++) {
(void)write(file_desc, byte_to_write, 1);
}
4. Задайте разделяемую блокировку для участка region 1 с 10-го байта по 30-й:
region_1.l_type = F_RDLCK;
region_1.l_whence = SEEK_SET;
region_1.l_start = 10;
region_1.l_len = 20;
5. Задайте исключительную блокировку для участка region_2 с 40-го байта по 50-й:
region_2.l_type = F_WRLCK;
region_2.l_whence = SEEK_SET;
region_2.l_start = 40;
region_2.l_len = 10;
6. Теперь заблокируйте файл:
printf("Process %d locking file\n", getpid());
res = fcntl(file_desc, F_SETLK, ®ion_1);
if (res == -1) fprintf(stderr, "Failed to lock region 1\n");
res = fcntl(file_desc, F_SETLK, ®ion_2);
if (res = fprintf(stderr, "Failed to lock region 2\n");
7. Подождите какое-то время:
sleep(60);
printf ("Process %d closing file\n", getpid());
close(file_desc);
exit(EXIT_SUCCESS);
}
Как это работает
Сначала программа создает файл, открывает его для чтения и записи и затем заполняет файл данными. Далее задаются два участка: первый с 10-го по 30-й байт для разделяемой блокировки и второй с 40-го по 50-й байт для исключительной блокировки. Затем программа выполняет вызов fcntl для установки блокировок на два участка файла и ждет в течение минуты, прежде чем закрыть файл и завершить работу.
На рис. 7.1 показан этот сценарий с блокировками в тот момент, когда программа переходит к ожиданию.

Рис. 7.1
Сама по себе эта программа не очень полезна. Вам нужна вторая программа lock4.c для тестирования блокировок (упражнение 7.10).
Упражнение 7.10. Тестирование блокировок файла.
В этом примере вы напишете программу, проверяющую блокировки разных типов, установленные для различных участков файла.
1. Как обычно, начнем с заголовочных файлов и объявлений:
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
const char *test_file = "/tmp/test_lock";
#define SIZE_TO_TRY 5
void show_lock_info(struct flock *to_show);
int main() {
int file_desc;
int res;
struct flock region_to_test;
int start_byte;
2. Откройте дескриптор файла:
file_desc = open(test_file, O_RDWR | O_CREAT, 0666);
if (!file_desc) {
fprintf(stderr, "Unable to open %s for read/write", test_file);
exit(EXIT_FAILURE);
}
for (start_byte = 0; start_byte < 99; start_byte += SIZE_TO_TRY) {
3. Задайте участок файла, который хотите проверить:
region_to_test.l_type = F_WRLCK;
region_to_test.l_whence = SEEK_SET;
region_to_test.lstart = start_byte;
region_to_test.l_len = SIZE_TO_TRY;
region_to_test.l_pid = -1;
printf("Testing F_WRLCK on region from %d to %d\n", start_byte, start_byte + SIZE_TO_TRY);
4. Теперь проверьте блокировку файла:
res = fcntl(file_desc, F_GETLK, ®ion_to_test);
if (res == -1) {
fprintf(stderr, "F_GETLK failed\n");
exit(EXIT_FAILURE);
}
if (region_to_test.l_pid != -1) {
printf("Lock would fail. F_GETLK returned:\n");
showlockinfo(®ion_to_test);
} else {
printf("F_WRLCK - Lock would succeed\n");
}
5. Далее повторите тест с разделяемой блокировкой (на чтение). Снова задайте участок файла, который хотите проверить:
region_to_test.l_type = F_RDLCK;
region_to_test.l_whence = SEEK_SET;
region_to_test.l_start = start_byte;
region_to_test.l_len = SIZE_TO_TRY;
region_to_test.l_pid = -1;
printf("Testing F_RDLCK on region from %d to %d\n", start_byte, start_byte + SIZE_TO_TRY);
6. Еще раз проверьте блокировку файла:
res = fcntl(file_desc, F_GETLK, ®ion_to_test);
if (res == -1) {
fprintf(stderr, "F_GETLK failed\n");
exit(EXIT_FAILURE);
}
if (region_to_test.l_pid != -1) {
printf("Lock would fail. F_GETLK returned:\n");
show_lock_info(®ion_to_test)