Для работы с примерами книги можно ввести программный код вручную или воспользоваться сопроводительными файлами с исходным текстом примеров. Весь программный код, применяемый в книге, можно найти на 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 версии 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)

   В последние годы ОС Linux стала заметным явлением. И дня не проходит без того или иного упоминания Linux в электронных средствах массовой информации. Мы потеряли счет приложениям, которые стали доступны в ОС Linux и внедрившим ее организациям, включая некоторые министерства и городские администрации. Основные поставщики компьютерного оборудования, такие как корпорации IBM и Dell, поддерживают ОС Linux, а крупнейшие разработчики программного обеспечения, например компания Oracle, обеспечивают выполнение своих программ в ОС Linux. Linux стала по-настоящему конкурентоспособной операционной системой, особенно на серверном рынке.
   Своим успехом она обязана системам и приложениям — предшественникам: ОС UNIX и программному обеспечению GNU. В этом разделе рассматривается, как появилась ОС Linux и каковы ее корни. 

   Операционная система 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 — это свободно распространяемая реализация 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, выполняющуюся на этом процессоре!

   ОС 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, т.к. они содержат много программ помимо ядра. Большинство утилит приходит от проекта 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 означает применение языка программирования С. Известно, что ОС 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-приложения представлены файлами двух типов: исполняемыми (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 libfоо.a bill.о fred.о
   а - bill.о а - fred.о
   7. Библиотека создана, и в нее добавлены два объектных файла. Для того чтобы успешно применять библиотеку в некоторых системах, в особенности в производных от Berkeley UNIX, требуется создать для библиотеки индекс содержимого архива или список вложенных в библиотеку функций и переменных (table of contents). Сделайте это с помощью команды ranlib. В ОС Linux при использовании программных средств разработки GNU этот шаг не является необходимым (но и не приносит вреда).
   $ ranlib libfoo.a
   Теперь ваша библиотека готова к использованию. Вы можете добавить следующий список файлов, которые должен обработать компилятор для создания вашей программы:
   $ gcc -о program program.о libfоо.а
   $ ./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.

   Возможно, вы уже знакомы с некоторыми видами перенаправления, например, таким как:
   $ 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_$$

Примечание

   Если вы хотите проверить с помощью команды env <команда>, как работает программа в разных окружениях, познакомьтесь с интерактивным справочным руководством к команде env. Далее в этой главе вы увидите, как задавать переменные окружения в подоболочках (subshells), применяя команду export.

Переменные-параметры

   Если ваш сценарий вызывается с параметрами, создается несколько дополнительных переменных. Если параметры не передаются, переменная окружения $# все равно существует, но равна 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 -lе Выражение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 (истина), если файл — исполняемый файл

Примечание

   Вас могли заинтересовать непонятные биты set-group-id и set-user-id (также называемые set-gid и set-uid). Бит set-uid предоставляет программе права владельца, а не просто ее пользователя, бит set-gid предоставляет программе права группы. Эти биты устанавливаются командой chmod с помощью опций s и g. На файлы, содержащие сценарии, флаги set-gid и set-uid не влияют, они оказывают влияние только на исполняемые двоичные файлы.

   Мы немного сами себя обогнали, но далее следует пример тестирования состояния файла /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). Обе они часто применяются вместе, но мы рассмотрим синтаксическую запись каждой из них отдельно.

И-cписок

   Эта конструкция позволяет выполнять последовательность команд, причем каждая последующая выполняется только при успешном завершении предыдущей. Синтаксическая запись такова:
   оператор1 && оператор2 && оператор3  && ...
   Выполнение операторов начинается с самого левого, если он возвращает значение 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 || оператор3 || ...
   Операторы выполняются слева направо. Если очередной оператор возвращает значение 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, за исключением того, что перед обработкой файловкомандой выводится подсказка для получения подтверждения пользователя на обработку каждого файла. Это действие следует завершать символьной парой \;
-print	Вывод на экран имени файла
-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

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

   Предположим, что у вас есть разнообразная коллекция компакт-дисков. Для того чтобы облегчить себе жизнь, вы собираетесь разработать и реализовать программу управления компакт-дисками. Электронный каталог представляется идеальным проектом для реализации, когда вы учитесь программированию в ОС 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, как и 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.

   У каждой выполняющейся программы, называемой процессом, есть ряд связанных с ней дескрипторов файлов. Существуют короткие целые (small integer) числа, которые можно использовать для обращения к открытым файлам и устройствам. Количество дескрипторов зависит от конфигурации системы. Когда программа запускается, у нее обычно уже открыты три подобных дескриптора. К ним относятся следующие:
   □ 0 — стандартный ввод;
   □ 1 — стандартный вывод;
   □ 2 — стандартный поток ошибок.
   Вы можете связать с файлами и устройствами другие дескрипторы файлов, используя системный вызов open, который уже обсуждался вкратце. Дескрипторы файлов, открытые автоматически, уже позволяют вам создавать простые программы с помощью вызова 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 считывает до 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.
   #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 — это аналог низкоуровневого системного вызова 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 применяется для чтения данных из файлового потока. Данные считываются из потока 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 аналогичен интерфейсу функции fread. Она принимает записи данных из заданного буфера данных и записывает их в поток вывода. Функция возвращает количество успешно записанных записей.
   Далее приведена синтаксическая запись функции:
   #include <stdio.h>
   size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE *stream);

Примечание

   Имейте в виду, что функции fread и fwrite не рекомендуется применять со структурированными данными. Частично проблема заключается в том, что файлы, записанные функцией fwrite, могут быть непереносимыми между машинами с разной архитектурой.

   Библиотечная функция fclose закрывает заданный поток stream, заставляя записать все незаписанные данные. Важно применять функцию fclose, поскольку библиотека stdio будет использовать буфер для данных. Если программе нужна уверенность в том, что все данные записаны, следует вызвать fclose. Имейте в виду, что функция fclose вызывается автоматически для всех файловых потоков, которые все еще открыты к моменту нормального завершения программы, но при этом у вас, конечно же, не будет возможности проверить ошибки, о которых сообщает fclose.
   Далее приведена синтаксическая запись функции:
   #include <stdio.h>
   int fclose(FILE* stream);

   Библиотечная функция fflush вызывает немедленную запись всех данных файлового потока, ждущих выполнения операции записи. Вы можете применять ее, например, чтобы убедиться, что интерактивное приглашение отправлено на терминал до того, как делается попытка считать ответ. Эта функция также полезна, если вы хотите, прежде чем продолжить выполнение, убедиться в том, что важные данные помещены на диск. Ее можно применять в некоторых случаях при отладке программы, чтобы быть уверенным в том, что программа действительно записывает данные, а не зависла. При вызове функции fclose выполняется неявная операция fflush, поэтому перед fclose не нужно вызывать функцию fflush. 
   Далее приведена синтаксическая запись функции:
   #include <stdio.h>
   int fflush(FILE *stream);

   Функция 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 возвращает из файлового потока следующий байт как символ. Когда она достигает конца файла или возникает ошибка, функция возвращает EOF. Для того чтобы различить эти два случая, следует применять функции ferror или feof.
   Далее приведена синтаксическая запись функций:
   #include <stdio.h>
   int fgetc(FILE *stream);
   int getc(FILE *stream);
   int getchar();
   Функция getc эквивалентна fgetc за исключением того, что может быть реализована как макрос. В этом случае аргумент stream может определяться несколько раз, поэтому он лишен побочных эффектов (например, не затронет переменные). К тому же вы не можете гарантировать возможности применения адреса getc как указателя функции.
   Функция getchar эквивалентна вызову функции getc(stdin) и читает следующий символ из стандартного ввода.

   Функция 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 читает строку из файла ввода 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 форматирует и выводит переменное число аргументов разных типов. Способ их представления в потоке вывода управляется параметром 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 действует аналогично функциям группы 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.
   Далее приведена синтаксическая запись вызова:
   #include <sys/stat.h>
   int chmod(const char *path, mode_t mode);
   Права доступа к файлу, заданному параметром path, изменяются в соответствии со значением параметра mode. Режим файла mode задается как в системном вызове open с помощью поразрядной операции OR, формирующей требуемые права доступа. Если программе не даны соответствующие полномочия, только владелец файла и суперпользователь могут изменять права доступа к файлу.

   Суперпользователь может изменить владельца файла с помощью системного вызова 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 вы можете удалить файл.
   Системный вызов 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.
   #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 использует этот системный вызов для выполнения аналогичной работы.

   Программа может перемещаться по каталогам во многом так же, как пользователь перемещается по файловой системе. Как вы применяете в командной оболочке команду 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 открывает каталог и формирует поток каталога. Если она завершается успешно, то возвращает указатель на структуру DIR, которая будет использоваться для чтения элементов каталога.
   #include <sys/types.h>
   #include <dirent.h>
   DIR *opendir(const char *name);
   В случае неудачи функция opendir возвращает пустой указатель. Имейте в виду, что для доступа к самому каталогу поток каталога использует низкоуровневый дескриптор файла, поэтому opendir может дать сбой, если открыто слишком много файлов.

   Функция 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 возвращает значение, регистрирующее текущую позицию в потоке каталога. Вы можете использовать ее в последующих вызовах функции seekdir для переустановки просмотра каталога, начиная с текущей позиции.
   #include <sys/types.h>
   #include <dirent.h>
   long int telldir(DIR *dirp);

   Функция seekdir устанавливает указатель на элемент каталога в потоке каталога, заданном в параметре dirp. Значение параметра loc, применяемого для установки позиции, следует получить из предшествующего вызова функции telldir.
   #include <sys/types.h>
   #include <dirent.h>
   void seekdir (DIR *dirp, long int loc);

   Функция 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 преобразует номер ошибки в строку, описывающую тип возникшей ошибки. Она может быть полезна для регистрации условий, вызывающих ошибку.
   Далее приведена ее синтаксическая запись:
   #include <string.h>
   char *strerror(int errnum);

   Функция perror также превращает текущую ошибку в виде, представленном в переменной errno, в строку и выводит ее в стандартный поток ошибок. Ей предшествует сообщение, заданное в строке s (если указатель не равен NULL), за которым следуют двоеточие и пробел.
   Далее приведена синтаксическая запись функции:
   #include <stdio.h>
   void perror(const char *s);
   Например, вызов
   perror("program");
   может дать следующий результат в стандартном потоке ошибок:
   program: Too many open files

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

   Системный вызов 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, в которой мы обсуждаем блокировку файлов.

   Система 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 или 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.

   Для того чтобы вам легче было следовать правилам, приведенным в этих руководствах, ОС 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.

   Многие приложения 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 $НOМЕ
   /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 вы напишeте программу для вывода значения любой выбранной вами переменной окружения. У вас также будет возможность задать значение, если вы укажете второй аргумент программы.

Упражнение 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, которая объявляется, как
   #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 — массиву нуль-терминированных строк.

   В главе 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, в которой мы более подробно рассматриваем синтаксические правила, связанные с ним.) В данном случае вам нужно отправить сообщение непосредственно на терминал пользователя.

   Иногда программе нужно более мощные средства управления терминалами, чем простые файловые операции. ОС Linux предоставляет ряд интерфейсов, позволяющих управлять поведением драйвера терминала и обеспечивающих больше возможностей управления вводом и выводом терминала.

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

   Перед тем как подробно рассматривать общий терминальный интерфейс, очень важно проанализировать аппаратную модель, предназначенную для управления.
   Концептуальная схема (физическая модель на некоторых старых узлах UNIX подобна данной) включает машину с ОС UNIX, подключенную через последовательный порт с модемом и далее по телефонной линии с другим модемом к удаленному терминалу (рис. 5.2). На деле это просто вариант установки, применявшийся некоторыми малыми провайдерами интернет-услуг "на заре туманной юности" Интернета. Эта модель отдаленно напоминает организацию "клиент — сервер", при использовании которой программа выполняется на большом компьютере, а пользователи работают на терминалах ввода/вывода.
   Рис. 5.2
 
   Если вы работаете на ПК под управлением ОС Linux, эта модель может показаться чересчур сложной. Однако, поскольку у обоих авторов есть модемы, мы можем при желании использовать программу эмуляции терминала, например, minicom для запуска удаленного сеанса работы в системе на любой другой машине, подобной этой, с помощью пары модемов и телефонной линии связи. Конечно, сегодня быстрый широкополосный доступ вытеснил из потребления эту рабочую модель, но она до сих пор не лишена некоторых достоинств.
   Преимущество применения этой аппаратной модели заключается в том, что в большинстве реальных ситуаций возникает потребность в некотором сокращенном варианте этого наиболее сложного случая. Удовлетворить эти потребности будет гораздо легче, если приведенная модель сохранит подобные функциональные возможности.

   Тип 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> для чтения программой входных данных. Вам следует заставить программу ждать всю строку ввода или набрасываться на ввод, как только он набран на клавиатуре.