Операционная система UNIX пользуется в нашей стране заслуженной известностью. Начиная с 1985 г. вышло порядка 10 книг, рассказывающих об этой системе или ее отечественных аналогах. Специалисты в области вычислительной техники и программисты в других отраслях давно уже применяют систему в своей профессиональной деятельности. Развиваются советские операционные системы ДЕМОС, ИНМОС, МОС и другие, представляющие собой различные вариации на тему UNIX.

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

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

Утвердившись на 32-разрядных компьютерах, UNIX, по-видимому, вступила в период зрелости. "Изюминки" системы стали классикой системного программирования. Ведущие компьютерные компании, имеющие устойчивую репутацию производителей собственных операционных систем, делают серьезную ставку на UNIX для своих 32-разрядных компьютеров. Ассоциации UNIX International и Open Software Foundation под эгидой соответствующих фирм (AT&T и IBM) усиливают борьбу за лидерство в сфере UNIX. Рабочие группы института IEEE под эгидой международной организации стандартов ISO разрабатывают стандарты на интерфейсы мобильной операционной среды, беря за основу интерфейсы UNIX.

Книга Б. В. Кернигана и Р. Пайка — это не просто еще одно издание по модной системе. Написанная превосходными специалистами, один из которых (Б. В. Керниган) стоял у истоков UNIX и языка Си, книга заметно выделяется в общем потоке литературы по UNIX, в том числе и переведенной у нас. При сравнительно небольшом объеме рассматриваются не только общие вопросы строения, функционирования и использования системы, программирования основных операций, но и инструментарий обработки текстов, а также средства создания программ. Соотношение глубины изложения и широты охвата материала выбрано близким к оптимальному, и у читателя по прочтении очередной главы не возникает ощущения, что он либо получил весьма поверхностные сведения, либо, наоборот, чрезмерно углубился в нечто не столь существенное.

Книгу могут изучать начинающие, не знакомые с системой программисты. Таким читателям адресована первая глава, в общих чертах описывающая круг основополагающих идей UNIX. Затем последовательно рассматриваются свойства системы на разных уровнях интерфейса пользователя (программы), начиная от командного языка и кончая примитивами нижнего уровня (и даже внутренними структурами данных системы). Изложение сопровождается большим количеством примеров, иллюстрирующих как вопросы частного характера, так и технологию решения типовых задач, в частности создание программы с помощью инструментальных средств построения программ. Подробно разбираются файловая система, командный интерпретатор shell, методология программирования на командном языке и применения фильтров, стандартные средства буферизованного ввода-вывода и ввод-вывод нижнего уровня, генераторы лексических и синтаксических анализаторов и построитель программ make, форматирование текстов. В результате читатель получает цельное представление о возможностях системы и методах их использования для решения практических задач программирования.

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

Операционная система UNIX начала свой жизненный путь на "заброшенной" машине DEC PDP-7 BELL Laboratories в 1969 г.[1] К. Томпсон при поддержке Р. Канадея, Д. МакИлроя, Д. Осанна и Д. Ритчи написал небольшую систему разделения времени общего назначения, оказавшуюся достаточно удобной, что привлекло энтузиастов-пользователей и послужило основанием для приобретения более мощной машины — PDP-11/20. Одним из первых пользователей системы считается Д. Ритчи, который помог в 1970 г. перенести ее на PDP-11. Д. Ритчи также разработал и написал компилятор с языка программирования Си. В 1973 г. Д. Ритчи и К. Томпсон переписали ядро системы UNIX на языке Си, отойдя от традиции создания таких программ на языке Ассемблера. В этом последнем варианте система в основном сохранилась и по сей день.

В 1974 г. UNIX была передана университетам "для образовательных целей", а несколько лет спустя нашла и коммерческое применение. В течение всего этого периода система UNIX продолжала совершенствоваться в BELL Laboratories, получив признание в лабораториях, при создании программного обеспечения, в центрах обработки информации, при поддержке операций телефонных компаний. В настоящее время диапазон ее использования весьма широк — от микрокомпьютеров до самых больших универсальных машин.

В чем причины успеха системы UNIX? Их несколько. Во-первых, поскольку UNIX написана на языке Си, она переносима и, как уже отмечалось, имеет широкий диапазон применения. Во-вторых, доступны исходные тексты программ системы, написанные на языке высокого уровня, что позволяет легко адаптировать ее в соответствии с конкретными требованиями. Наконец, самое главное — это хорошая операционная система, особенно для программистов. Программная среда UNIX необычайно богата и результативна.

Вместе с UNIX появилось много новых программ и методов программирования, но никакая отдельная программа или идея не дает гарантии в отношении качества системы. Эффективность системы достигается благодаря определенному подходу к программированию, своего рода философии использования вычислительной машины. Основной смысл ее состоит в том, что мощь системы обусловливается взаимодействием программ, а не мощью самих программ. Многие программы UNIX могут решать простейшие задачи, но при объединении с другими программами они превращаются в универсальные и полезные средства. Поэтому в своей книге мы уделяем большое внимание вопросам, связанным с взаимодействием программ и с их использованием в качестве инструментария для создания других программ. Чтобы успешно работать с UNIX, необходимо не только знать, как применять ту или иную программу, но и понимать ее роль в системе.

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

Если наша книга поможет программистам-индивидуалам сделать свой труд более производительным, то тем самым повысится производительность и больших коллективов. Хотя книга в основном рассчитана на программистов, для понимания первых четырех или даже пяти глав программистский опыт не требуется, так что они могут оказаться полезными всем без исключения. Всюду, где было возможно, в качестве примеров мы приводили настоящие программы. Многие из них уже вошли в наш повседневный программный обиход. Все примеры проверялись на машине прямо из текста, который представлен в форме, пригодной для ввода.

Книга построена следующим образом. В гл. 1 излагаются основные возможности UNIX (вход в систему, почта, система файлов), рассматриваются наиболее употребительные команды и даются начальные сведения об интерпретаторе команд. Опытные пользователи могут опустить эту главу.

В гл. 2 обсуждается файловая система UNIX. Файловая система является центральным звеном в обеспечении успешной работы, и ее нужно хорошо понимать. Здесь описываются файлы и каталоги, права доступа и режимы файлов, а также индексные дескрипторы. Приводятся краткое описание иерархии файловой системы и пояснения относительно файлов устройств.

Интерпретатору команд (shell), этому основополагающему средству не только для выполнения программ, но и для их написания, посвящена гл. 3. Вы узнаете, как использовать shell для своих целей (новые команды, аргументы команд, переменные shell, простые структуры управления и переключение ввода-вывода).

Глава 4 познакомит вас с фильтрами, т.е. программами, которые производят какие-то простые преобразования данных по мере их получения. В первой части главы рассматривается команда контекстного поиска grep и родственные ей команды. Затем обсуждаются более общие фильтры, такие, как sort. В заключение описываются две программы преобразования данных общего назначения sed и awk. Потоковый редактор sed редактирует поток данных по мере их получения, awk — язык программирования для простых операций поиска информации и задач генерации отчетов. Эти программы, иногда в сочетании с интерпретатором shell, позволяют в ряде ситуаций обойтись без традиционных языков программирования.

В гл. 5 обсуждается, как с помощью языка shell можно создавать программы, которые будут использоваться другими людьми. Тема включает более развитые структуры управления и переменные, перехват и обработку прерываний. Приводятся примеры с привлечением программ sed и awk, а также интерпретатора shell.

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

Далее (гл. 7) мы переходим к системным обращениям, являющимся фундаментом для всех остальных слоев программного обеспечения. Здесь обсуждаются вопросы ввода-вывода, создания файла, обработки ошибки, описываются каталоги, индексные дескрипторы, процессы и сигналы.

В гл. 8 рассматриваются развитые программные средства: программа yacc, создающая программы грамматического разбора; make, управляющая процессом трансляции больших программ; lex, создающая лексические анализаторы. Изложение строится на примере создания большой программы — программного калькулятора в стиле языка Си.

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

В конце книги приводятся приложения. В приложении 1 суммируются возможности стандартного редактора ed. Хотя многие читатели предпочтут для повседневного пользования иной редактор, ed представляется общедоступным, действенным и эффективным средством. Регулярные выражения редактора являются ключевым понятием других программ, таких, как grep и sed, и даже только по этой причине его стоит изучить. Приложение 2 содержит справочное руководство по языку калькулятора из гл. 8, а приложение 3 — распечатку окончательной версии программы калькулятора, где для удобства чтения собраны воедино все программные фрагменты.

Некоторые практические вопросы. Во-первых, система UNIX стала очень популярной, и несколько ее версий нашли широкое применение. Например, седьмая версия происходит от первоначальной системы UNIX вычислительного и научно-исследовательского центра фирмы BELL. System III и System V — версии, официально поддерживаемые фирмой. Университет в Беркли (штат Калифорния) распространяет системы UCB 4.xBSD, производные от шестой версии. Помимо названных существуют многочисленные версии, особенно на малых машинах, которые созданы на базе седьмой версии. Мы пытались справиться с этим многообразием, стараясь максимально придерживаться каких-то общих концепций, одинаковых для всех систем. Для большей точности мы выбрали представление, базирующееся на седьмой версии, поскольку она является основой почти всех широко используемых систем UNIX. Программы прогонялись на System V фирмы BELL и на 4.1BSD из Беркли, причем потребовались лишь тривиальные изменения в нескольких примерах. Независимо от вашей версии системы найденные вами различия будут минимальны.

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

Наконец, мы убеждены в том, что лучший способ изучения чего-либо — это эксперимент. Книгу следует читать за терминалом, находя подтверждение либо опровергая прочитанное, исследуя ограничения и варианты. Читайте, проверяйте и снова читайте. Система UNIX — хотя и не идеальный, но удивительный программный мир, и мы надеемся, что вы откроете его для себя.

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

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

В более широком смысле под UNIX часто понимают не только ядро, но и такие важные компоненты, как компиляторы, редакторы, программы копирования и печати файлов. Сюда даже относят языки управления заданиями (командные языки). UNIX может также включать созданные вами или другими пользователями программы, работающие в вашей системе и предназначенные для подготовки документации, статистического анализа, или, скажем, "графические" средства. Значение слова "UNIX" в каждом конкретном случае зависит от того, на каком уровне вы рассматриваете систему. В дальнейшем изложении смысл этого термина вам будет ясен из контекста.

Иногда система UNIX кажется более сложной, чем она есть на самом деле. Новичку нелегко понять, как наилучшим образом воспользоваться доступными средствами. Но, к счастью, начинать работать в системе не так уж и трудно, а познакомившись с несколькими программами, вы получите достаточное стартовое ускорение. Цель настоящей главы помочь вам по возможности скорее освоить систему. Это не справочное руководство, а лишь краткий обзор приводимого в книге материала, причем многие вопросы будут рассмотрены более детально в последующих главах. Мы обсудим здесь следующие темы:

• основные понятия: вход и выход из системы, простые команды, исправление ошибок при вводе с терминала, связь между терминалами;

• повседневная работа: файлы и файловая система, печать файлов, каталоги, часто используемые команды;

• интерпретатор команд shell: сокращенная форма имен файлов, переключение ввода-вывода, программные каналы, установка символов удаления и стирания, задание вашего собственного пути поиска команд.

Если вы ранее работали в системе UNIX и большая часть материала главы покажется вам знакомой, то можете перейти сразу к гл. II. Но, даже прочитав эту главу, вы будете вынуждены обращаться к справочному руководству по системе, поскольку данная книги не заменяет его, а лишь дает рекомендации по применению описанных в нем команд. Более того, вы можете обнаружить расхождение в тексте книги и описании вашей системы. В начале справочного руководства приводится предметный указатель (индекс), который поможет вам ориентироваться в программах. Научитесь им пользоваться.

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

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

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

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

RETURN — это пример управляющего символа, т.е. невидимого символа, определяющего некоторые аспекты действий, выполняемых при вводе и выводе на терминал. На обычном терминале символ RETURN вводится с помощью отдельной клавиши, хотя большинство управляющих символов не связано с "персональными" клавишами. Для их ввода требуется нажать клавишу CONTROL, иногда обозначаемую как CTRL, CTL или CNTL, одновременно нажав еще одну клавишу, обычно соответствующую букве. Например, конец строки можно получить, нажав клавишу RETURN, либо (эквивалентный способ) при нажатой клавише CONTROL ввести символ 'm' Поэтому RETURN можно называть "управляющее m". или ctl-m. Среди других управляющих символов необходимо выделить ctl-d, сообщающий программе, что ввод окончен: "ctl-g", вызывающий звонок на терминале: ctl-h, который часто называется "шаг назад" и может использоваться при коррекции ошибок ввода, и ctl-i (или tab), перемещающий курсор на следующую позицию табуляции почти так же, как и на стандартном телетайпе. Позиции табуляции в системе UNIX отстоят друг от друга на восемь пробелов. На большинстве терминалов предусмотрены специальные клавиши для символов "шаг назад" и tab.

Существуют еще две особые клавиши: DELETE (DEL), иногда обозначаемая как RUBOUT (могут использоваться разные сокращения), и BREAK или INTERRUPT. В большинстве систем UNIX ввод символа DELETE немедленно останавливает программу, даже если она еще не завершилась. В некоторых системах для этого употребляется символ ctl-c. В ряде систем в зависимости от способа подключения терминала синонимом DELETE или ctl-c может служить BREAK.

Начнем с диалога между вами и системой UNIX.

Установить связь: позвонить по телефону или включить питание, если необходимо. Ваша система должна ответить

login: you     Введите ваше имя, затем нажмите RETURN

Password:      Ваш пароль, если вы его вводите, не появится на экране

You have mail. Есть почта, ее можно прочесть после входа в систему

$              Система готова к приему ваших команд

$              Можно нажать RETURN несколько раз

$ date         Узнаем дату и время

Sun Sep 25 23:02:57 EDT 1983

$ who          Узнаем, кто работает на машине?

jlb  tty0 Sep 25 13:59

you  tty2 Sep 25 23:01

mary tty4 Sep 25 19:03

doug tty5 Sep 25 19:22

egb  tty7 Sep 25 17:17

bob  tty8 Sep 25 20:48

$ mail         Прочтем почту

From doug Sun Sep 25 20:53 EDT 1983

зайди ко мне когда-нибудь в понедельник

?              При нажатии RETURN выдается следующее сообщение

From mary Sun Sep 25 19:07 EDT 1983

Пообедаем завтра в полдень?

? d            Удалим это сообщение

$              Почты больше нет

$ mail mary    Пошлем почту mary

обед в 12

ctl-d          Конец сообщения

$              Позвоним по телефону или выключим терминал

Вот и все

Иногда к такому диалогу сводится вся ваша работа с системой, однако бывает, что при этом и "дело делается". Далее мы разберем приведенный пример сеанса, а также некоторые полезные программы.

Вы должны иметь входное имя и пароль, которые можно получить от администратора системы. Система UNIX может работать с самыми разными терминалами, но в основном она ориентирована на устройства со строчными буквами. Разница между строчными и прописными буквами существенна! Если на вашем терминале есть только прописные буквы (как на некоторых портативных терминалах), это настолько усложнит вам жизнь, что вскоре вы начнете искать другой терминал.

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

login:

Если она выдала чепуху, то, может быть, у вас установлена не та скорость передачи: проверьте положение соответствующего (а заодно и других) переключателя. Когда это не помогает, нужно медленно несколько раз нажать клавишу BREAK или INTERRUPT. Если приглашение login: и теперь не появляется, вам следует обратиться за помощью к специалисту.

Получив приглашение на вход, введите ваше входное имя строчными буквами, после чего нажмите клавишу RETURN. При необходимости система запросит у вас пароль, и пока вы вводите его, выдача на терминал будет отключена. В конце концов, войдя в систему, вы получите приглашение (как правило, один символ, означающий, что система готова принимать ваши команды). Приглашением, вероятнее всего, окажется символ $ (знак доллара) или % (процент), но можно заменить его любым другим; позднее мы покажем, как это сделать. Приглашение обычно выдается программой, называемой интерпретатором команд, или shell, с помощью которой вы общаетесь с системой. Перед приглашением на экране может появиться сообщение о том, что для вас есть почта, или вопрос о типе применяемого терминала. Ваш ответ поможет системе воспользоваться какими-либо особыми свойствами данного терминала.

Получив приглашение, вы можете ввести команды, т.е. требования к системе что-либо сделать. Мы часто будем употреблять слово программа как синоним команды. Когда на экране появится приглашение (пусть это будет символ '$'), введите date и нажмите клавишу RETURN. Система в ответ выдаст дату и время и выведет следующее приглашение, так что весь диалог на вашем терминале примет вид:

$ date

Mon Sep 26 12 : 20 : 57 EDT 1983 $

Не забывайте нажимать клавишу RETURN и не вводите символ '$'. Если вам покажется, что о вас забыли, нажмите RETURN, возможно, что-нибудь и произойдет. В дальнейшем мы не будем напоминать вам о том, что символ RETURN должен завершать каждую строку.

Затем попробуйте ввести команду who, которая сообщает, кто в данный момент работает в системе:

$ who

rim    tty0 Sep 26 11:37

pjw    tty4 Sep 26 11:30

gerard tty7 Sep 26 10:27

mark   tty9 Sep 26 07:59

you    ttya Sep 26 12:20

$

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

$ who am i

you ttya Sep 26 12:20

$

Если вы ошибетесь и укажете при вводе несуществующую команду, система ответит, что команда с этим именем не найдена:

$ whom         Опечатка в имени команды...

whom:not found поэтому система не знает, как запустить ее

$

Конечно, если вы неумышленно введете имя существующей команды, то она начнет выполняться и, возможно, даст неожиданный результат.

Иногда ваш терминал может повести себя странно, например, каждая буква будет выдаваться дважды, или при нажатии клавиши RETURN курсор не переместится в первую позицию следующей строки. Обычно это можно устранить, выключив и включив терминал или выйдя из системы и вновь войдя в нее. Можно также прочитать описание команды stty ("set terminal options" — установка режима терминала) в разделе 1 справочного руководства. Для разумной интерпретации символа tab, если на вашем терминале не предусмотрен режим автоматической табуляции, введите команду

$ stty -tabs

и система будет преобразовывать символ tab в определенное число пробелов. Если же на терминале допускается возможность установки позиций табуляции от машины, то команда tabs поставит их должным образом. (Вы можете дать и такую команду:

$ tabs terminal-type

см. описание команды tabs в справочном руководстве.)

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

$ ddate@ Уничтожается вся строка:

date ввод с новой строки

Mon Sep 26 12:23:39 EDT 1983

$

Символ '#' стирает последний введенный символ: каждый раз при вводе # стирается только один символ слева от курсора. Поэтому если вы не уверены в своем вводе, можно делать поправки по мере работы:

$ dd#atte##e Исправления в процессе ввода

Mon Sep 26 12:24:02 EDT 1983

$

Представление символов стирания (#) и уничтожения (@) зависит от системы. Во многих системах (включая используемую здесь для примеров) в качестве символа стирания употребляется "шаг назад", что хорошо смотрится на видеотерминалах. С помощью своей системы вы можете легко проверить, так ли это:

$ datee←                     Пробуем ←

datee← : not found           Не подходит

$ datee#                     Пробуем #

Mon Sep 26 12:26:08 EDT 1983 # подходит

$

(Мы изображаем "шаг назад" как ←, чтобы символ был "виден".) Обычно принимается, что символ ctl-u уничтожает всю строку.

Далее в качестве символа стирания мы будем использовать #, поскольку он "виден" на терминале. Если в вашей системе его нет, то сделайте соответствующие изменения. Ниже при описании настройки окружения мы покажем, как задать удобное для вас представление символов стирания и уничтожения.

А что нужно, чтобы ввести сами символы стирания и уничтожения как часть текста? Если перед символами # и @ поставить обратную дробную черту (\), то они утрачивают свое специальное назначение. Поэтому для ввода # или @ необходимо набрать на клавиатуре \# или \@. При вводе @ система может передвинуть курсор в начало следующей строки, даже если ему предшествовала обратная дробная черта. Не волнуйтесь, символ @ в текст попадет.

Обратную дробную черту иногда называют символом экранирования. Она указывает на то, что следующий за ней символ в некотором смысле специальный. Для удаления обратной дробной черты необходимо ввести два символа стирания: \##. Понятно почему?

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

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

При нажатии клавиши RETURN хранимые символы пересылаются в программу, читающую сейчас символы с терминала. Считывающая программа в свою очередь может интерпретировать символы особым образом: например, интерпретатор shell исключает любую специальную интерпретацию символа, если ему предшествует обратная дробная черта. Мы вернемся к этому вопросу в гл. 3. Пока же следует помнить о том, что ядро системы реагирует лишь на символы уничтожения и стирания и на обратную дробную черту, если она предшествует одному из них. Любые символы, которые остаются после такой обработки, могут интерпретироваться другими программами.

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

Выполнение большинства команд можно остановить, нажав клавишу DELETE (УДАЛИТЬ). Чаще всего так же действует и клавиша BREAK (ПРЕРВАТЬ), которая имеется почти на всех терминалах. При работе некоторых программ, таких, как текстовые редакторы, DELETE прекращает выполнение программы, но без выхода из нее. При выключении терминала или отключении от сети выполнение многих программ завершается.

Если вы хотите приостановить вывод на терминал, например, для того, чтобы важная информация не исчезла с экрана, введите ctl-s. Вывод прекратится практически немедленно: выполнение программы приостановится до тех пор, пока вы не возобновите его, для чего достаточно ввести ctl-q.

Для правильного выхода из системы нужно вместо очередной команды ввести ctl-d. Shell воспримет это как сообщение о конце ввода. (Что произойдет на самом деле, будет объяснено в следующей главе.) Обычно вы можете просто выключить терминал или отключить его от сети, но произойдет ли при этом фактический выход из системы, зависит от самой системы.

Система предоставляет почтовые услуги для обмена сообщениями с другими пользователями, так что, войдя однажды в систему, вы увидите на экране до появления приглашения сообщение:

You have mail

Для чтения почты введите:

$ mail

Сообщения будут выведены одно за другим, начиная с самых последних. После каждого сообщения программа mail ожидает вашего указания, что делать с сообщением. Возможны два основных ответа: ввод символа 'd', означающего удаление сообщения, и ввод RETURN, оставляющего его (т.е. оно вновь появится при следующем просмотре почты). Другими ответами могут быть 'p', что означает распечатку сообщения, 's filename' — сохранение сообщения в поименованном файле и 'q' — выход из программы mail. (Если вы не знаете, что такое файл, то представьте его себе как место, где можно хранить информацию под выбранным вами именем, а затем получать ее оттуда. Файлы рассматриваются в разд. 1.2, как, впрочем, и в большей части этой книги.)

mail — именно та программа, которая, вероятно, будет отличаться от описываемой здесь, поскольку существует много вариантов такой программы. Более детально вы можете познакомиться с ней по своему справочному руководству.

Послать почту кому-нибудь весьма просто. Допустим, она предназначена для пользователя с входным именем nico. Легче всего это сделать так:

$ mail nico

Теперь вводите любой текст письма

из любого числа строк...

После последней строки письма введите ctl-d

ctl-d

$

Ввод ctl-d означает, что письмо окончено. Если в процессе составления письма вы передумаете и решите его не отправлять, нажмите клавишу DELETE вместо ctl-d. Незаконченное письмо будет сохранено в файле dead.letter.

Для проверки пошлите письмо самому себе, а затем введите mail, чтобы прочитать его. (Это не так странно, как может показаться, и представляется удобным механизмом напоминания.) Существуют и иные способы посылки почты: можно послать заранее подготовленное письмо, направить почту нескольким адресатам одновременно и даже переслать почту пользователям, работающим на других машинах (подробнее об этом см. в описании команды mail в разд. 1 справочного руководства по UNIX.) В дальнейшем мы будем применять обозначение mail(1) для страницы, описывающей команду mail в разд. 1 справочного руководства.

Имеется также служебная программа calendar для печати календаря (см. calendar(1)); в гл. 4 мы покажем, как создать такую программу, если она отсутствует.

Сообщение для других пользователей. Если ваша система UNIX многопользовательская, то как-нибудь однажды на вашем терминале может появиться сообщение типа

Message from mary tty 7...

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

$ write mary

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

У вас может появиться желание во время выполнения программы задать ту или иную команду для shell. Обычно, какая бы программа ни выполнялась, она должна быть приостановлена либо остановлена но некоторые программы, такие, как редактор или сама команда write, имеют специальную команду 'T' для временного выхода в интерпретатор shell (см. табл. 2 приложения 1).

Команда write не накладывает никаких ограничений, поэтому необходим протокол общения, чтобы ваш ввод не перемешивался с тем, что вводит Mary. Существует соглашение, согласно которому ввод следует осуществлять порциями, оканчивающимися символами (о), что означает конец ввода ("over"), а для сигнализации о прекращении связи использовать (oo) ("over" и "out" — конец и выход).

Терминал mary                               Ваш терминал

$ write you             $ Message from mary tty7...

                        write mary

Message from ttya...

did you forget lunch?(o)

                        did you forget lunch?(o)

                        five@

                        ten minutes(o)

ten minutes(o)

ok(oo)

                        ok(oo)

                        ctl-d

EOF

ctl-d

$                       $ EOF

Выполнение команды write также можно прекратить, нажав клавишу DELETE. Заметьте, что ваши ошибки при вводе не появляются на терминале у Mary.

Если вы попытаетесь послать сообщение на терминал тому, кто пока еще не вошел в систему или не хочет, чтобы его беспокоили, вас известят об этом. В том случае, когда адресат находится в системе, но не отвечает за разумный промежуток времени (возможно, он занят или отошел от терминала), просто введите ctl-d или DELETE. Если вы не хотите, чтобы вас беспокоили, используйте команду mesg(1).

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

$ news

Существует также большая сеть систем UNIX, которые связаны но телефонному каналу: справьтесь у местного специалиста о командах netnews или USENET.

В справочном руководстве по UNIX вы найдете большую часть того, что нужно знать о системе. В разд. 1 включены и те команды, которые мы обсуждали в этой главе. В разд. 2 описываются системные обращения, которые будут темой гл. 7, а в разд. 6 приводится информация об играх. В остальных разделах описываются функции, применяемые пользователями, программирующими на языке Си, а также структура файлов и средства поддержания работоспособности системы. (Число разделов варьируется от системы к системе.) Не забывайте о предметном указателе в начале руководства: вам достаточно бегло просмотреть его, чтобы найти команды, необходимые для вашей работы. Кроме того, существует введение в систему, где дается обзор ее функциональных возможностей. Часто справочное руководство хранится в системе и его можно читать с терминала. Если вам требуется помощь и не к кому обратиться, можно вывести на терминал любую страницу руководства по системе, введя команду man command-name. Так, чтобы получить информацию о команде who, введите

$ man who

и, конечно,

$ man man

выдаст вам сведения о самой команде man.

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

$ learn

Если эта команда существует в вашей системе, то она подскажет вам, что делать дальше. Если же ее нет, попробуйте ввести еще teach.

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

Информация в системе UNIX хранится в файлах, которые весьма похожи на обычные учрежденческие "дела". Каждый файл имеет имя, содержание, место, где он хранится, и некоторую служебную информацию, в частности о владельце файла, размере последнего и т.д. Файл может содержать письмо, список имен и адресов, операторы текста программы, данные, которые будет использовать программа, или даже программы в форме, готовой к выполнению, а также другую нетекстовую информацию.

Файловая система UNIX устроена таким образом, что вы можете хранить ваши личные файлы, не смешивая их с файлами других пользователей, причем те в свою очередь не смогут повлиять на ваши файлы. Существует бесчисленное множество программ, оперирующих с файлами, но пока мы остановимся на наиболее часто используемых. В гл. 2 дается последовательное изложение файловой системы и вводится много команд, с которыми приходится иметь дело при работе с файлами.

Если вы хотите ввести статью, письмо или программу, как заставить машину хранить информацию? Большинство таких задач решается с помощью текстового редактора, т. е. программы для ввода и обработки информации в машине. Практически в любой системе UNIX есть экранный редактор — редактор, который использует возможности современных терминалов отображать результат редактирования но мере корректирования текста. Наиболее популярны редакторы vi и emacs. Однако мы не будем описывать здесь какой-либо конкретный экранный редактор частично из-за сложностей, связанных с типографским набором, частично из-за отсутствия стандартного редактора.

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

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

Попытайтесь создать с помощью ed файл под именем junk следующим образом:

$ ed   Вызов текстового редактора

а      команда редактора для добавления текста (add)

now type in

whatever text you want...

.      Ввод только '.' прекращает добавление

w junk Запись текста в файл с именем junk

39     ed сообщает число введенных символов

q      Выход из ed (quit)

$

Команда 'a' (append — добавить) сообщает редактору, что нужно принять текст. Сигналом окончания текста служит один символ '.', который должен быть введен в начале строки. Не забывайте об этом, поскольку пока он не введен, не распознаются никакие команды редактора, т. е. все, что вы вводите, будет трактоваться как продолжение вводимого текста.

Команда редактора 'w' (write — писать) сохранит введенную информацию: 'w junk' запишет ее в файл с именем junk. Именем файла может быть любое слово. Мы выбрали junk, чтобы показать, что этот файл не очень важен ("junk" — мусор).

Редактор сообщает системе число символов, записанных им в файл. До ввода команды 'w' ничего не отправляется на постоянное хранение, поэтому, если вы отключите свой компьютер от сети и пойдете домой, информация не попадет в файл. (Если вы это сделаете во время редактирования, информация, с которой вы работаете, будет сохранена в файле ed.hup, и в дальнейшем можно будет продолжить работу.) В случае аварии системы в процессе редактирования (т.е. неожиданного останова из-за неисправности аппаратуры или ошибок в программном обеспечении) ваш файл сохранит только то, что в него записала последняя команда write. Но после выполнения команды w информация хранится постоянно. Она может стать доступной, если вы введете

$ ed junk

Конечно, можно редактировать введенный текст, чтобы исправить опечатки, заменить слова, переставить части текста и т.д. Когда вы завершите редактирование, команда 'q' ("quit" — выход) осуществит выход из редактора.

Чтобы знать, с чем приходится иметь дело, создадим два файла с именами junk и temp:

$ ed

а

То be or not to be

.

w junk

19

q

$ ed

a

What is a question.

.

w temp

22

q

$

Число символов, сообщаемое редактором ed, включает и специальный символ в конце каждой строки, называемый перевод строки или конец строки, — так система представляет символ RETURN.

Команда ls перечисляет имена (но не содержание) файлов:

$ ls

junk

temp

$

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

Как и большинство команд, ls имеет возможные аргументы, которые позволяют изменить ее действие. Возможные аргументы следуют за именем команды в командной строке и обычно состоят из знака минус и одной буквы, несущей смысловую нагрузку. Например, команда ls -t требует перечисления файлов во временном порядке, т.е. в зависимости от времени последнего изменения файла, причем файлы, измененные последними, перечисляются вначале:

$ ls -t

temp

junk

$

Возможный аргумент -l означает "длинный" список (long — длинный), который содержит больший объем информации о каждом файле:

$ ls -l

total 2

-rw-r--r-- 1 you 17 Sep 26 16:25 junk

-rw-r--r-- 1 you 18 Sep 26 16:26 temp

$

Строка total 2 указывает число занятых блоков на диске: блок обычно содержит 512 или 1024 символа. Строка -rw-r--r-- показывает, кто имеет право читать из файла и писать в него: в данном случае владелец (you) может и читать, и писать, но другие могут только читать. За ней следует 1 — число связей файла; забудем о нем до гл. 2. Строка you содержит имя владельца файла, т.е. пользователя, создавшего его. Число символов в соответствующих файлах (17 и 18) совпадает с тем, что сообщил редактор ed. Дата и время соответствуют последнему изменению файла.

Возможные аргументы (в дальнейшем будем именовать их флагами) могут быть сгруппированы: ls -lt дает ту же информацию, но отсортированную в определенном порядке, начиная с файлов, измененных последними. Флаг -r показывает дату и время последнего обращения к файлу; ls -lut представляет список файлов по порядку их использования, начиная с наиболее позднего. Флаг -r меняет порядок в списке на обратный, так что ls -rt перечисляет файлы, начиная с самых старых. Можно также указать имена интересующих вас файлов, тогда команда ls выдаст информацию только о них:

$ ls -l junk

-rw-r--r-- 1 you 17 Sep 26 16:25

$

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

Обозначение флага с помощью знака "дефис" и одной буквы, например -l, является весьма распространенным. В общем случае, если команда имеет возможные аргументы, то они должны предшествовать аргументам-именам файлов, но появляться могут в любом порядке. Однако система UNIX "капризна" при разборе многочисленных флагов. Например, в стандартной седьмой версии системы команда ls не принимает строку

$ ls -l-t Не работает в седьмой версии

в качестве синонима для ls -lt, тогда как другие команды требуют, чтобы флаги были разделены.

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

Теперь, когда у нас есть файлы, как посмотреть их содержимое? Существует множество программ, решающих эту задачу (возможно, даже слишком много). Один из вариантов — использование редактора:

$ ed junk

19                 ed сообщает, что в файле 17 символов

1,$ p              Печать от первой до последней строки

То be or not to be В файле только одна строка

q                  Все сделано

Редактор начинает работу с сообщения числа символов в файле junk: команда '1,$ p' инициирует вывод всех строк файла. После того как вы научитесь пользоваться редактором, вы сможете выбирать части файла, предназначенные для печати. Но бывают ситуации, когда невозможно использовать редактор для печати. Например, размер файла, с которым может работать редактор, имеет определенный предел (несколько тысяч строк). Далее, он может вывести на печать только один файл в данный момент, а нужно печатать несколько, один за другим без перерыва. В таких ситуациях существует несколько способов просмотра файлов.

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

$ cat junk

To be or not to be

$ cat temp

That is a question.

$ cat junk temp

To be or not to be

That is a question.

$

Поименованный файл или файлы "катенируются" (отсюда и имя cat), т.е. выводятся на терминал последовательно один за другим без промежутков.

С короткими файлами никаких проблем нет, но в случае длинных файлов, если ваш терминал соединен с машиной высокоскоростной линией, вы должны быть достаточно проворны, чтобы с помощью ctl-s остановить вывод прежде, чем он исчезнет с экрана. Стандартной команды для выдачи файла на видеотерминал порциями размеров в экран не существует, хотя в каждой системе UNIX такая команда имеется. В вашей системе это может быть команда pg или more. Здесь она называется pr в гл. VI будет показана ее реализация.

Подобно команде cat, pr выдает содержимое всех файлов, перечисленных в списке, но в виде, подходящем для устройства печати: каждая страница длиной в 11 дюймов содержит 66 строк, включая заголовок, где указываются номер страницы, имя файла, дата и время его последнего изменения. В месте сгиба бумаги строки пропускаются. Итак, для того чтобы красиво напечатать файл junk, затем перейти на следующую страницу и так же красиво напечатать файл temp, задайте:

$ pr junk temp

Sep 26 16:25 1983 junk Page 1

Система отличит ваш файл с именем junk от "нужного" файла с тем же именем. Это обеспечивается за счет группировки файлов в каталоги подобно тому, как книги помещаются на полках в библиотеке, так что файлы могут иметь одинаковые имена в разных каталогах без конфликтов.

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

Каталог может содержать и другие каталоги как обычные файлы. Естественным способом представления такой организации каталогов служит дерево файлов и каталогов. В процессе обхода дерева — от корня вдоль нужных ветвей — можно найти любой файл системы. Можно поступить и наоборот: начать в произвольном месте и двигаться по направлению к корню.

Рассмотрим первый способ. Основным нашим средством будет команда pwd ("print working directory" — печать рабочего каталога), которая выведет имена файлов каталога, с которым вы работаете:

$ pwd

/usr/you

$

Команда выведет сообщение о том, что вы находитесь в каталоге you, а сам каталог — в каталоге usr, который в свою очередь находится в корневом каталоге, традиционно обозначаемом как '/'. Символ '/' разделяет компоненты имени: каждый компонент ограничен по длине 14 символами. Во многих системах каталог /usr содержит имена каталогов всех пользователей. (Даже если ваш личный каталог не /usr/you, команда pwd выдаст нечто аналогичное, так что вы сможете следить за последующими примерами.) Введя

$ ls /usr/you

вы получите тот же самый список файлов, который выдает только ls. Если в команде ls нет аргументов, то она выводит содержимое текущего каталога; если же ей присвоить имя каталога, то она выдает содержимое указанного каталога. Далее вводите

$ ls /usr

Это приведет к появлению длинного списка имен, среди которых есть и ваш начальный каталог you.

На следующем шаге попытайтесь распечатать сам корневой каталог. В результате получите ответ, подобный следующему:

$ ls /

bin

boot

dev

etc

lib

tmp

unix

usr

$

(Пусть вас не смущает то, что символ '/' имеет два назначения одновременно: имя корневого каталога и разделитель в именах файлов.) Большую часть приведенного списка составляют имена каталогов, но unix на самом деле является файлом, содержащим в готовом к выполнению виде ядро системы UNIX (более подробно об этом см. в гл. 2).

Теперь попробуйте ввести

$ cat /usr/you/junk

(если файл junk все еще хранится в вашем каталоге). Имя /usr/you/junk называется путевым, или абсолютным, именем файла. Путевое имя имеет интуитивный смысл: оно представляет путь по дереву каталогов от корня к отдельному файлу. В системе UNIX есть универсальное правило: всюду, где можно использовать обычное имя файла, можно использовать и абсолютное имя.

Файловая система имеет структуру, подобную генеалогическому дереву:

Рис. 1.1: Карта файловой системы UNIX

Когда система выдает приглашение $ и вы вводите команды для выполнения, вы имеете дело не с ядром самой системы, а с неким посредником, называемым интерпретатором команд, или shell. Это обычная программа, подобная date или who, хотя она может делать удивительные вещи. Тот факт, что программа shell находится между вами и ядром, дает реальные выгоды, и некоторые из них мы вам укажем. Применение программы-посредника обеспечивает три главных преимущества:

• сокращенные имена файлов: можно задать целое множество файлов в качестве аргументов команде, указав шаблон для имен: shell будет искать файлы, имена которых соответствуют заданному шаблону;

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

• создание собственной среды: можно определить свои собственные команды и правила сокращений.

Начнем с шаблонов имен файлов. Допустим, вы вводите обширный документ, наподобие книги. Логически он разбивается на множество частей, аналогично главам и разделам. И физически его следует разбить на части, поскольку затруднительно редактировать большие файлы. В этом случае для печати всего текста нужно указать ряд файлов. У вас могут быть отдельные файлы для каждой главы с именами ch1, ch2 и т.д. Если каждая глава разбита на разделы, вы можете создать файлы с именами

ch.1

ch.2

ch.3

...

ch2.1

ch2.2

...

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

$ pr ch1.1 ch1.2 ch1.3...

но вы быстро устанете вводить имена файлов и начнете делать ошибки. Именно здесь приходит на помощь сокращенное имя файла. Если задать

$ pr ch*

интерпретатор shell воспримет * как любую последовательность символов, поэтому ch* является шаблоном, под который подходят все имена файлов из текущего каталога, начинающиеся на ch. Интерпретатор shell создаст список в алфавитном порядке[3] и передаст его программе pr. Команда pr никогда "не узнает" * ; выбор по шаблону, который shell производит в текущем каталоге, порождает список строк, передаваемых pr.

Ключевой момент состоит в том, что способ сокращения имени файла — это не свойство программы pr, а возможность, реализуемая интерпретатором shell. Поэтому вы можете использовать ее для создания последовательности имен файлов в любой команде, например для подсчета числа слов первой главы:

$ wc ch1.*

 113   562  3200 ch1.0

 935  4081 22435 ch1.1

 974  4191 22756 ch1.2

 378  1561  8481 ch1.3

1293  5298 28841 ch1.4

  33   194  1190 ch1.5

  75   323  2030 ch1.6

3801 16210 88930 total

$

Существует программа с именем echo ("эхо"), которая особенно ценна для экспериментов со "смыслом" сокращенных имен. Как вы смогли догадаться, echo лишь повторяет свои аргументы.

$ echo hello world

hello world

$

Но аргументы могут формироваться путем выбора по шаблону. Так, команда

$ echo ch1.*

перечисляет имена всех файлов в гл. 1,

$ echo *

перечисляет имена всех файлов текущего каталога в алфавитном порядке,

$ pr *

выводит на печать содержимое всех ваших файлов (в алфавитном порядке), а

$ rm *

удаляет все файлы текущего каталога. (Лучше быть абсолютно уверенным, что вы действительно этого хотите!)

Символ * может встречаться не только в конце имени файла. Его можно использовать всюду и даже по нескольку раз. Поэтому

$ rm *.save

удалит все файлы, оканчивающиеся на .save.

Заметьте, что все имена файлов выбираются в алфавитном порядке, который отличается от числового. Если в вашей книге 10 глав, порядок может быть не тем, на который вы рассчитываете, поскольку ch10 идет перед ch2:

$ echo *

ch1.1 ch1.2 ... ch10.1 ch10.2 ... ch2.1 ch2.2 ...

Символ * — не единственный способ задания шаблона для интерпретатора shell, хотя и наиболее часто используемый. Шаблон [...] задает любые символы из перечисленных внутри скобок. Несколько подряд следующих букв или цифр можно задать в сокращенном виде:

$ pr ch[12346789]* Печать глав 1,2,3,4,6,7,8,9, но не 5

$ pr ch[1-46-9]*   То же самое

$ rm temp[a-z]     Удалить все tempa, …, tempz

Шаблон ? задает любой одиночный символ:

$ ls ?        Список файлов с именем из одного символа

$ ls -l ch?.1 Список ch1.1 ch2.1 ch3.1 и т.д., но не ch10.1

$ rm temp?    Удалить все файлы temp1, …, tempa и т.д.

Отметим, что шаблоны сопоставляются только с именами существующих файлов. В частности, нельзя создать новые имена файлов с помощью шаблонов. Например, если вы захотите расширить ch до chapter в каждом имени файла, то такой вариант вам не поможет:

$ mv ch.* chapter.* Не работает!

поскольку chapter.* не соответствует ни одному из существующих имен файлов.

Символы шаблонов, подобные *, могут использоваться в абсолютных именах наравне с обычными именами файлов; сопоставление происходит для каждого компонента абсолютного имени, содержащего специальный символ. Так, /usr/mary/* инициирует поиск файлов в /usr/mary/, a /usr/*/calendar порождает список абсолютных имен всех пользователей, работающих с каталогом calendar.

Если вам когда-нибудь придется отказаться от специального назначения символов *, ? и др., заключите весь аргумент в апострофы, например:

$ ls '?'

Можно также предварить специальный символ обратной дробной чертой:

$ ls \?

(Вспомните, что, поскольку ? не является символом стирания или уничтожения, обратная дробная черта перед ним будет обрабатываться не ядром, а интерпретатором shell.) Использование кавычек подробно рассматривается в гл. 3.

Большинство команд, которые мы рассматривали, производят вывод на терминал, некоторые из них, подобно редактору, осуществляют ввод с терминала. А теперь приведем почти универсальное правило: терминал может быть заменен для ввода, вывода или обеих операций на файл.

Например,

$ ls

выдает список файлов на ваш терминал. Но если задать

$ ls > filelist

то тот же список файлов помещается вместо этого в файл filelist. Символ > означает, что выходной поток должен быть помещен в указанный далее файл, а не выведен на терминал. Файл будет создан, если он ранее не существовал, или будет заменено содержимое старого. На своем терминале вы ничего не получите. В качестве другого примера можно слить несколько файлов, "перехватив" выходной поток команды cat и направив его в файл:

$ cat f1 f2 f3 > temp

Символ >> действует подобно >, но указывает на необходимость добавить выходной поток к концу файла. Значит, команда

$ cat f1 f2 f3 >> temp

сольет содержимое f1, f2, f3 и добавит результат в конец temp, вместо того чтобы затереть его старое содержимое. Так же как и для операции >, если файл temp не существует, то он будет создан первоначально пустым.

Аналогично символ < означает, что входной поток программы берется из последующего файла, а не с терминала. Так, можно заготовить письмо в файле let, а затем послать его нескольким адресатам:

$ mail mary joe torn bob < let

Во всех этих примерах наличие пробелов по обе стороны символа > или < не обязательно, но такое представление традиционно.

Имея возможность переключать выходной поток с помощью <, мы можем комбинировать команды, получая эффект, недостижимый другим способом. Например, можно выдать список пользователей в алфавитном порядке

$ who > temp

$ sort < temp

Поскольку команда who выдает по одной строке на каждого пользователя, работающего в системе, a wc -l производит подсчет строк (подавляя вывод числа слов и символов), можно подсчитать число пользователей с помощью команд:

$ who > temp

$ wc -l < temp

и число файлов в текущем каталоге:

$ ls > temp

$ wc -l < temp

хотя в это число войдет и сам файл temp. Можно выдать список имен файлов в три столбца, задав

$ ls > temp

$ pr -3 < temp

Наконец, можно убедиться в том, что некий пользователь вошел в систему, комбинируя команды who и grep:

$ who > temp

$ grep mary < temp

Во всех перечисленных выше примерах, как и в случае имен файлов, содержащих образы типа *, важно понимать, что символы < и > обрабатываются самим интерпретатором shell, а не отдельной программой. Благодаря этому переключение входного и выходного потоков возможно для любой программы, причем сама программа даже "не подозревает", что происходит что-то необычное.

Изложенное подводит нас к важному выводу. Команда

$ sort < temp

сортирует содержимое файла temp так же, как

$ sort temp

но в их действиях есть различие. Поскольку строка < temp обрабатывается интерпретатором shell, первая команда sort не воспринимает файл temp как свой аргумент; она просто сортирует собственный стандартный входной поток, который переключен интерпретатором на файл temp. В то же время в последнем случае имя temp передается команде sort в качестве аргумента, она читает его и сортирует файл. Команде sort можно передать список файлов:

$ sort temp1 temp2 temp3

но, если имена файлов отсутствуют, она всегда будет сортировать стандартный входной поток. Это существенная особенность большинства команд: если не указаны имена файлов, то обрабатывается стандартный входной поток. Следовательно, достаточно ввести имя команды, чтобы посмотреть, как она выполняется. Например,

$ sort

ghi

abc

def

ctl-c

abc

def

ghi

$

В дальнейшем мы покажем, как реализуется этот принцип.

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

Пересмотрим теперь некоторые из предыдущих примеров с точки зрения использования программных каналов вместо временных файлов. Вертикальная черта служит указанием интерпретатору shell для создания конвейера:

$ who | sort      Печать отсортированного списка пользователей

$ who | wc -l     Подсчет числа пользователей

$ ls | wc -l      Подсчет числа файлов

$ ls | pr -3      Вывод списка имен файлов в три столбца

$ who | grep mary Поиск определенного пользователя

Всякая программа, вводящая информацию с терминала, может вводить ее и по программному каналу; всякая программа, производящая вывод на терминал, может выдавать информацию в программный канал. Это тот случай, когда приносит плоды решение читать стандартный входной поток, если не заданы никакие файлы. Любая программа, выполняющая данное соглашение, может быть включена в конвейер. В рассмотренных выше примерах команды pr, grep, sort и wc используются именно таким способом.

Можно связать конвейером сколь угодно много программ. Например,

$ ls | pr -3 | lpr

создает список имен файлов в три столбца и выдает его на печатающее устройство, а

$ who | grep mary | wc -l

подсчитывает, сколько раз пользователь Мэри входила в систему.

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

команда флаги возможные имена файлов

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

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

Рис. 1.2: Схема потоков в UNIX

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

Имеет смысл также периодически заглядывать в руководство, чтобы освежить свои знания об известных вам командах и познакомиться с новыми. В руководстве описывается множество программ, которые мы не обсуждали, включая компиляторы языков программирования, подобные Фортран 77, программы-калькуляторы типа bc(1), cu(1) и uucp(1) — программы для межмашинного взаимодействия, графические пакеты, статистические программы и даже такая программа, как units(1).

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

Все, с чем работает система UNIX, она воспринимает в виде файла. Это не такое уж упрощение, как может показаться на первый взгляд. Когда разрабатывалась первая версия системы, даже прежде, чем ей дали имя, все усилия сосредоточились на создании структуры файловой системы, которая должна была быть простой и удобной в использовании. Файловая система — ключевое звено, обеспечившее успешное применение UNIX. Это наилучший пример философии "прекрасное в малом", показывающий, какой мощи можно достичь реализацией нескольких хорошо продуманных идей.

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

Файл представляет собой последовательность байтов. (Байт — небольшая порция информации, обычно размером в восемь бит. Для наших целей можно считать байт синонимом слова "символ".) Никаких ограничений по структуре системой на файл не накладывается, и никакого смысла не приписывается его содержимому: смысл байтов зависит исключительно от программ, обрабатывающих файл. Более того, как мы увидим позднее, это верно не только для файлов, хранящихся на дисках, но и для файлов, представляющих периферийные устройства. Записи на магнитных лентах, почта, символы, вводимые с клавиатуры, вывод на печатающее устройство, данные, передаваемые по конвейеру — каждый из этих файлов система и входящие в нее программы воспринимают просто как последовательность байтов.

Лучше всего познакомиться с файлами экспериментальным путем, так что начнем с создания небольшого файла:

$ ed а

now is the time,

for all good people

.

w junk

36

q

$ls -l

-rw-r--r-- 1 you 26 Sep 27 06:11 junk

$

Здесь junk — это файл из 36 байт, т.е. 36 символов, которые вы ввели (не считая, конечно, символов, введенных при коррекции ошибок). Команда cat показывает содержимое файла в следующем виде:

$ cat junk

now is the time

for all good people

$

Команда od ("octal dump" — восьмеричный дамп) выдает "изображение" всех байтов файла:

$ od -с junk

0000000 n o w   i s   t h e   t i m e \n

0000020 f o r   a l l   g o o d   p e o

0000040 p l e \n

0000044

$

Флаг -с означает, что следует интерпретировать байты как символы. Если добавить флаг -b, то можно, кроме того, показать байты как восьмеричные числа.[5]

$ od -cb junk

0000000  n   o   w       i   s       t   h   e       t   i   m   e  \n

        156 157 167 040 151 163 040 164 150 145 040 164 151 155 145 012

0000020  f   o   r       a   l   l       g   o   o   d       p   e   o

        146 157 162 040 141 154 154 040 147 157 157 144 040 160 145 157

0000040  d   l   e  \n

        160 154 145 012

0000044 $

Семизначные числа в колонке слева показывают место в файле, т.е. порядковый номер следующего изображаемого символа в восьмеричной форме. Между прочим, приоритет восьмеричных чисел — это пережиток времен PDP-11, когда восьмеричной нотации отдавалось предпочтение. Для других машин больше подходит шестнадцатеричная нотация; флаг -х предписывает команде od печатать информацию в шестнадцатеричной форме.

Обратите внимание на то, что после каждой строки идет символ с восьмеричным значением 012. Это символ перевода строки для ASCII; система помещает его во входной поток, когда вы нажимаете клавишу RETURN. По соглашению, заимствованному из языка Си, символ перевода строки изображается как \n, что лишь облегчает чтение. Такого соглашения придерживаются только программы типа od; в файле же хранится единственный байт 012.

Перевод строки — наиболее типичный пример специального символа. Другими специальными символами, связанными с некоторыми операциями управления терминалом, являются символы: шаг назад (восьмеричное значение 010 изображается как \b), табуляция (011, \t), возврат каретки (015, \r).

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

Если ввести последовательность

\←

(т.е. символ \ и вслед за ним "шаг назад"), то ядро в этом случае "считает", что вы действительно хотите ввести символ ←, поэтому \ исчезает, а в вашем файле появляется байт 010. Когда "шаг назад" отражается на терминале, происходит возврат курсора, так что он указывает на символ \.

При выводе файла, содержащего символ ←, он передается на терминал без обработки, что опять приводит к передвижке курсора на одну позицию назад. Если воспользоваться командой od, чтобы вывести файл, содержащий символ ←, он появится как байт со значением 010 или, если указан флаг -с, как \b.

Аналогичную ситуацию мы имеем и с символом табуляции: при вводе он отражается на терминале и посылается программе, осуществляющей ввод; при выводе символ табуляции просто передается на терминал и интерпретируется. Однако в отличие от предыдущего случая здесь можно указать ядру, что вы хотите получить интерпретацию табуляции при выводе; тогда вместо изображения каждого символа табуляции будет выдаваться нужное число пробелов, чтобы перейти к следующей позиции табуляции. Позиции табуляции установлены в столбцах 9, 17, 25 и т.д. Команда

$ stty = tabs

приводит к замене символов табуляции пробелами при выводе на терминал см. описание stty(1).

Обработка символа RETURN аналогична рассмотренной выше. Ядро отображает RETURN на терминале как "возврат каретки" и "конец строки", но во входной поток попадает только "перевод строки". При выводе этот символ вновь заменяется символами возврата каретки и конца строки.

Подход системы UNIX к представлению управляющей информации нетрадиционен, особенно использование символа перевода строки для завершения строки (в качестве конца посылки). Многие системы вместо этого трактуют каждую строку как "запись", содержащую не только введенные данные, но и счетчик числа символов в строке (специального символа конца строки нет). В других системах каждая строка завершается символами возврата каретки и перевода строки, поскольку такая последовательность необходима для вывода на большинство терминалов. (Слово "linefeed" завершение строки, синоним перевода строки, поэтому такую последовательность часто называют "CRLF", что невозможно произнести.)

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

Поскольку завершение строки обозначается символом перевода строки, можно ожидать, что и файл завершается другим специальным символом, скажем \е как сокращение "end of file" конец файла. Но, посмотрев на вывод программы od, вы не увидите никакого специального символа в конце файла он просто кончается. Вместо того чтобы использовать специальный символ, система отмечает конец файла сообщением о том, что данных в файле больше нет. Ядро запоминает длину файла, поэтому программа встречает конец файла после обработки всех составляющих файл байтов.

Программы выбирают данные из файла с помощью системного обращения с именем read (подпрограмма в ядре). При каждом обращении к read читается следующая часть файла, например очередная введенная строка. Подпрограмма read также сообщает число прочитанных байтов файла, поэтому конец файла обнаруживается, когда она сообщает: "прочитано 0 байт". Если какие-либо байты оставались в файле, то подпрограмма read выдала хотя бы часть их. На самом деле, отказ от ввода байта со специальным значением "конец файла" вполне оправдан, поскольку, как отмечалось ранее, смысл содержимого байта зависит от интерпретации файла. Но все файлы имеют конец, и поэтому их следует читать с помощью подпрограммы read, а возврат нуля это зависящий от интерпретации способ представления конца файла без использования специальных символов.

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

Можно посмотреть ввод по строкам на примере команды cat. Эта команда обычно накапливает или буферизует свой выходной поток, чтобы для повышения эффективности писать большими порциями, но флаг -u отключает буферизацию, так что она выдает строку сразу по получении:

$ cat    Выдача команды cat с буферизацией

123

456

789

ctl-d

123

456

789

$ cat -u Выдача команды cat без буферизации

123

123

456

456

789

789

ctl-d

$

Команда cat получает каждую строку, когда вы нажимаете клавишу RETURN; без буферизации она выдает данные, как только их получит.

Теперь попробуем сделать нечто другое: введите несколько символов, а затем вместо RETURN наберите на клавиатуре ctl-d:

$ cat -u 123ctl-d123

Команда cat выдает символы мгновенно. Символ ctl-d означает, что нужно немедленно послать символы, введенные с терминала, программе, которая производит ввод с терминала. В отличие от символа перевода строки ctl-d не передается программе. Теперь введите второй раз ctl-d без каких-либо символов:

$ cat -u

123ctl-d123ctl-d$

Интерпретатор отвечает на это выводом приглашения, поскольку команда cat, не получив символов, считает, что файл кончился, и прекращает работу. Символ ctl-d передает все, что вы ввели, программе, производящей ввод с терминала. Если вы ничего не ввели, программа не получит никаких символов, что соответствует концу файла. Именно поэтому ввод ctl-d приводит к выходу из системы интерпретатор не получает больше входной информации. Конечно, символ ctl-d в основном используется как сигнал о конце файла, но он имеет и более общее назначение.

Формат файла зависит от программ, которые используют его. Типы файла весьма разнообразны, возможно, потому, что существует большое разнообразие программ. Но, поскольку типы файла не определяются файловой системой, ядро не может указать вам тип файла оно не знает его. Команда file делает обоснованную "догадку" (мы вскоре объясним, как это происходит):

$ file /bin /bin/ed /usr/src/cmd/ed.c /usr/man/man1/ed.1

/bin: directory

/bin/ed: pure executable

/usr/src/cmd/ed.с: c program text

/usr/man/man1/ed.1: roff, nroff, or eqn input text

Здесь показаны четыре типичных файла. Все они связаны с редактором: каталог (/bin), в котором находится редактор, двоичный файл или сама программа, готовая к выполнению (/bin/ed), входной текст, т.е. операторы языка Си, составляющие программу (/usr/src/cmd/ed.с), и страница справочного руководства (/usr/man/man1/ed.1).

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

Иногда установить тип файла нетрудно. Выполняемая программа помечается вначале двоичным "магическим" числом. Команда od, запущенная без всяких флагов, выдает содержимое файла по словам в 16-разрядном или двухбайтовом представлении, и магическое число становится видимым:

$ od /bin/ed

0000000 000410 025000 000462 011444 0000000 000000 000000 000001

0000020 170011 016600 000002 005060 1777776 010600 162706 000004

0000040 016616 000004 005720 010066 0000002 005720 001376 020076

...

$

Восьмеричное число 410 отмечает готовую к выполнению программу, которую могут разделять несколько процессов. (Конкретные магические числа зависят от системы.) Набор разрядов, представляющий 410, не является символом из множества ASCII, поэтому он не может быть создан непреднамеренно такими программами, как редактор. Но, конечно, вы можете создать подобный файл, запустив свою собственную программу, а система в соответствии с соглашением сочтет его выполняемой программой.

В случае текстовых файлов указание может быть скрыто более глубоко в файле, поэтому команда file отыскивает строки, подобные #include, чтобы распознать текст программы на Си, или строки, начинающиеся с точки, чтобы распознать входные данные для программ nroff или troff.

У вас может возникнуть вопрос: почему система не следит за типами файлов более внимательно, ведь тогда, например, программе sort в качестве входного потока никогда не попадал бы файл /bin/ed. Одна из причин состоит в том, чтобы не потерять какие- нибудь полезные для программиста свойства. Хотя команда

$ sort /bin/ed

не имеет особого смысла, существуют команды, которые могут выполняться с любыми файлами, и нет причин ограничивать их возможности. Команды od, cp, wc, cmp, file и многие другие обрабатывают файлы независимо от их содержания. Но идея бестиповых файлов этим не ограничивается. Если, скажем, для программы nroff входные данные отличаются от текста программы на Си, редактор будет вынужден различать их, создавая файл, и, вероятно, считывая файл для редактирования. Тогда, без сомнения, авторам этой книги было бы трудно подготавливать примеры на языке Си для глав 6, 7 и 8.

Система UNIX пытается сгладить все различия. Любой текст состоит из строк, заканчивающихся символом перевода строки, и большинство программ воспринимает такой простой формат. В процессе работы над книгой мы много раз запускали команды для создания текстовых файлов, затем обрабатывали эти файлы с использованием команд, подобных уже рассмотренным, и применяли редактор, чтобы слить файлы во входной поток для форматирующей программы troff, с помощью которой подготовлен текст книги. Практически любая страница здесь получена подобным образом:

$ od -с junk > temp

$ ed ch2.1

1534

r temp

168

...

Команда od передает текст в стандартный выходной поток, который можно использовать там же, где и сам текст. Такая универсальность непривычна; в большинстве систем имеется несколько форматов файла, даже для текста, и требуется диалог с системой со стороны программы или пользователя, чтобы создать файл определенного типа. В системе UNIX есть только один вид файла, и для доступа к такому файлу достаточно лишь знать его имя.[6]

Отсутствие форматов файла дает выигрыш во всем программисты не должны заботиться о типе файла, а все стандартные программы будут работать с любым файлом. Однако необходимо отметить и недостатки. Программы, которые сортируют, редактируют, проводят поиск, действительно ожидают текст в качестве входного потока: команда grep не может правильно анализировать двоичные файлы, команда sort не может сортировать их, и никакой стандартный редактор не может работать с ними.

В большинстве программ, которые ожидают текст в качестве входного потока, существуют ограничения реализации. Мы проверили несколько программ на тексте размером 30 тыс. байт, не содержащем ни одного символа перевода строки, и только некоторые из них работали правильно, поскольку многие программы делают явно неоговариваемые допущения о максимальном размере строки текста (исключительные ситуации см. в разделе BUGS (ошибки) описания sort(1)).

Нетекстовые файлы, несомненно, имеют свою специфику. Например, для очень больших баз данных обычно нужна дополнительная адресная информация, обеспечивающая быстрый доступ; для повышения эффективности она должна быть представлена в двоичном виде. Но каждому формату файла, не являющемуся текстовым, должно соответствовать свое семейство программ, выполняющее те операции, которые для текстовых файлов производят стандартные средства. Машинная обработка текстовых файлов, возможно, несколько менее эффективна, но это уравновешивается стоимостью дополнительного программного обеспечения, поддерживающего более сложные форматы. Если вы выбираете формат файла, следует тщательно все продумать, прежде чем остановиться на нетекстовом представлении. (Желательно также предусмотреть вариант, при котором поведение вашей программы будет "осмысленным" в случае длинных входных строк.)

Все ваши файлы имеют вполне определенные имена, начиная с /usr/you, но если у вас есть только файл junk, то при задании команды ls не выдается /usr/you/junk; имя файла выводится без всякого префикса:

$ ls

junk

$

Это происходит потому, что любая выполняемая программа, т.е. каждый процесс, имеет текущий каталог и неявно предполагается, что все имена файлов начинаются с имени этого каталога, если они явно не начинаются с дробной черты. Таким образом, у интерпретатора shell, в который вы вошли, и команды ls есть текущий каталог. Команда pwd ("print working directory" печать текущего каталога) выдает имя текущего каталога:

$ pwd

/usr/you

$

Текущий каталог представляет собой атрибут процесса, а не пользователя или программы: пользователям соответствуют начальные каталоги, а процессам — текущие. Если процесс порождает процесс-потомка, последний наследует текущий каталог родителя. Но, если затем потомок сменит текущий каталог, родителя это не затронет: его текущий каталог останется тем же, независимо от действий потомка.

Понятие текущего каталога, конечно, обеспечивает удобство обозначения, поскольку освобождает от излишнего ввода, но настоящее его назначение — организационное. Связанные друг с другом файлы находятся в одном каталоге. Каталог /usr обычно является начальным каталогом файловой системы пользователей (usr — сокращение от user, подобно cmp, ls и т.д.). Ваш начальный каталог /usr/you — это ваш текущий каталог при первом вхождении в систему. Каталог /usr/src содержит исходные тексты системных программ, каталог /usr/src/cmd — исходные тексты команд UNIX, /usr/src/cmd/sh — исходные тексты интерпретатора shell и т.д. Всякий раз, когда вы приступаете к новому проекту или когда у вас появляется группа связанных файлов, скажем, набор рецептов, вы можете создать новый каталог с помощью команды mkdir и поместить в него файлы.

$ pwd

/usr/you

$ mkdir recipes

$ cd recipes

$ pwd

/usr/you/recipes

$ mkdir pie cookie

$ ed pie/apple

...

$ ed

...

$

Заметьте, как легко ссылаться на вложенные каталоги. Файл pie/apple имеет очевидный смысл: рецепт яблочного пирога из каталога /usr/you/recipes/pie. Вместо этого вы могли бы поместить рецепт, например, в каталог recipes/apple.pie, а не во вложенный каталог в каталоге recipes, но лучшее решение — собрать все рецепты пирогов вместе. Так, рецепт крема мог бы храниться в recipes/pie/crust, чтобы не дублировать его в рецепте для каждого пирога. Хотя файловая система предоставляет мощное средство организации данных, вы можете забыть, куда помещен файл, и даже какие файлы у вас есть. Естественным решением было бы иметь одну или несколько команд, позволяющих "порыться" в каталогах. Конечно, команда ls помогает искать файлы, но не дает возможности исследовать вложенные каталоги:

$ cd

$ ls

junk

recipes

$ file *

junk: ascii text

recipes: directory

$ ls recipes

cookie

pie

$ ls recipes/pie

apple

crust

$

Эту часть файловой системы можно изобразить графически:

Рис. 2.1: Часть файловой системы

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

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

Если нужна большая защищенность, то можно изменить данные в файле так, что даже суперпользователь не сможет прочесть (или, по крайней мере, понять) их, для чего служит команда crypt (см. crypt(1)). Конечно, даже эта команда не дает абсолютной защиты. Суперпользователь может изменить команду crypt, или кто-то попытается расшифровать алгоритм crypt. Правда, и то и другое является трудно выполнимым, так что практически команда crypt достаточно надежна.

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

При входе в систему вы вводите имя и подтверждаете, что это вы, задавая пароль. Имя представляет собой ваш входной идентификатор, или login-id. На самом деле, система распознает вас по числу, называемому идентификатором пользователя, или uid. В действительности различным login-id может соответствовать один uid, что делает их неразличимыми для системы, хотя такое бывает относительно редко, и, по всей видимости, является нежелательным по соображениям безопасности. Кроме uid, вам приписывается идентификатор группы, или group-id, который относит вас к определенной группе пользователей. Во многих системах обычных пользователей (в отличие от тех, кто имеет login-id типа root) объединяют в одну группу под именем other (другие), но в вашей системе может быть иначе. Файловая система, а значит, и вся система UNIX в целом определяет ваши возможности исходя из прав доступа, предоставляемых вашему uid и group-id.

Файл /etc/passwd — это файл паролей; он содержит всю информацию, связанную со входом каждого пользователя в систему. Подобно системе, вы можете определить свой uid и group-id, если найдете свое имя в /etc/passwd:

$ grep you /etc/passwd

you:gkmbCTrJ04C0M:604:1:Y.0.А.People:/usr/you:

$

Поля в файле паролей разделяются двоеточием и расположены следующим образом (как видим из passwd(5)):

login-id:зашифрованный_пароль:uid:group-id:разное:начальный_каталог:shell

Файл паролей представляет собой обычный текстовый файл, но назначение и разделитель полей определяются по соглашению между программами, работающими с информацией этого файла. Поле shell обычно пустое; значит, по умолчанию используется стандартный интерпретатор /bin/sh. Поле "разное" может содержать что угодно (как правило, ваше имя, адрес или телефон).

Заметьте, что ваш пароль присутствует здесь во втором поле, но в зашифрованном виде. Файл паролей могут прочесть все (вы только что это сделали), и если ваш пароль бы там, то любой, кто пожелает, может выдать себя за вас. Когда вы вводите свой пароль при входе в систему, он шифруется, и результат сравнивается с зашифрованным паролем из /etc/passwd. Если они совпадают, то вам разрешают войти. Этот механизм работоспособен, потому что алгоритм шифрации таков, что позволяет легко перейти от раскрытой формы к зашифрованной, тогда как обратный переход очень труден. Например, если ваш пароль ka-boom, он может быть зашифрован как gkmbCTrJ04COM, но, получив последний, вам будет нелегко вернуться к оригиналу.

Ядро решает, что вам можно позволить читать файл /etc/passwd исходя из прав доступа, связанных с файлом. Для каждого файла предусмотрены три вида прав доступа: чтение (т.е. исследование его содержимого), запись (т. е. изменение его содержимого) и выполнение (т. е. запуск его как программы). Далее, разным пользователям могут быть предоставлены различные права доступа. Как владелец файла вы имеете один набор прав на чтение, запись и выполнение. У "вашей" группы — другой набор прав доступа, у всех остальных — третий набор.

Команда ls с флагом -l сообщает среди прочего права доступа:

$ ls -l /etc/passwd

-rw-r--r-- 1 root 5115 Aug 30 10:40 /etc/passwd

$ ls -lq /etc/passwd

-rw--r--r-- 1 adm 5115 Aug 30 10:40 /etc/passwd

Информацию, содержащуюся в двух строках вывода команды ls, можно интерпретировать так: владельцем файла /etc/passwd является пользователь с login-id, равным root; его группа называется adm; размер файла 5115 байт; последний раз изменен был 30 августа в 10:40; файл имеет единственную связь, т.е. одно имя в файловой системе (вопрос о связях мы обсудим в следующем разделе). Некоторые варианты команды ls выдают имена владельца и группы сразу при однократном вызове.

Строка -rw-r--r-- показывает, как представляет права доступа к файлу команда ls. Первый дефис (-) означает, что это обычный файл. В случае каталога на его месте стояла бы буква d. Следующие три символа обозначают права владельца файла на чтение, запись и выполнение (исходя из uid). Строка rw- свидетельствует о том, что владелец (root) может читать, писать, но не выполнять файл. В случае выполняемого файла дефис был бы заменен символом x.

Три символа (r--) обозначают права доступа группы, в данном случае пользователей из группы adm — по-видимому, системных администраторов, которые могут читать файл, но не писать и не выполнять его. Следующие три символа (также r--) определяют права доступа для всех остальных пользователей системы. Таким образом, на данной машине только root может изменить информацию по входу в систему для пользователя, но прочесть файл и узнать эту информацию может любой. Разумным был бы вариант, при котором группа adm также имела бы право на запись в файл /etc/passwd.

Файл /etc/group хранит в зашифрованном виде имена групп и их group-id и определяет, какие пользователи входят в какие группы. В файле /etc/passwd определяется только ваша группа при входе в систему; команда newgrp изменяет ее права доступа на права другой группы.

Кто угодно может задать:

$ ed /etc/passwd

и редактировать файл паролей, но только root может записать измененный файл. Поэтому вполне правомочен вопрос: как изменить свой пароль, если это требует редактирования файла паролей. Программа, изменяющая пароли, называется passwd, вероятно, вы найдете ее в /bin:

$ ls -l /bin/passwd

-rwsr-xr-x 1 root 8454 Jan 4 1983 /bin/passwd

$

(Обратите внимание на то, что /etc/passwd — текстовый файл, содержащий информацию по входу в систему, тогда как /bin/passwd находится в другом каталоге, содержит программу, готовую к выполнению, и позволяет изменить данные, связанные с паролем). Права доступа к этому файлу показывают, что выполнить команду может кто угодно, но изменить команду passwd — только root. Буква s вместо x в поле прав на выполнение для владельца файла означает, что при выполнении команды ей предоставляются права, соответствующие праву владельца файла, в данном случае root. Поскольку файл /bin/passwd имеет такой признак установки uid и при выполнении получает права root, любой пользователь, выполняя команду passwd, может редактировать файл /etc/passwd.

Введение признака установки uid — простое элегантное решение целого ряда проблем безопасности.[7] Например, автор игровой программы может установить свой uid для программы, поэтому она сможет изменять файл с результатами игр, который защищен от доступа со стороны других пользователей. Но идея введения признака установки uid потенциально опасна. Программа /bin/passwd должна быть правильной, иначе она может уничтожить системную информацию под прикрытием суперпользователя root. При наличии прав доступа -rwsrwxrwx ее мог бы переписать любой пользователь, и, таким образом, заменить файл на неработоспособную программу. Это особенно опасно для программ, обладающих признаком установки uid, поскольку root имеет доступ к каждому файлу, системы. (В некоторых системах UNIX происходит отключение признака установки uid всякий раз, когда файл изменяется, что уменьшает вероятность нарушения защиты).

Признак установки uid — мощное средство, но оно используется в основном для нескольких системных программ, таких, как passwd. Рассмотрим более типичный файл:

$ ls -l /bin/who

-rwxrwxr-x 1 root 6348 Mar 29 1983 /bin/who

$

Этот файл доступен для выполнения всем, а писать в него могут только root и пользователь той же группы. Слова "доступен для выполнения" означают, что при вводе

$ who

интерпретатор shell просматривает ряд каталогов, в том числе /bin, отыскивая файл с именем who. Если такой файл найден и он имеет право доступа на выполнение, то shell обращается к ядру для его запуска. Ядро проверяет права доступа, и, если они действительны, запускает программу. Отметим, что программа — это просто файл с правом доступа на выполнение. В следующей главе вы познакомитесь с программами, являющимися обычными текстовыми файлами, но они могут выполняться как команды, поскольку имеют право доступа на выполнение.

Права доступа к каталогам действуют несколько иначе, но основной принцип остается тем же:

$ ls -ld .

drwxrwxr-x 3 you 80 Sep 27 06:11 .

$

Команда ls с флагом -d сообщает скорее о самом каталоге, чем о его содержимом, и первая буква d в выводе означает, что '.' в действительности является каталогом. Поле r показывает, что можно читать каталог, поэтому с помощью команды ls (или od для данного случая) можно выяснить, какие файлы хранятся в нем. Буква w свидетельствует о том, что можно создавать и исключать файлы из каталога, поскольку это требует изменения, а значит, записи в файл каталога.

На самом деле нельзя просто писать в каталог, даже суперпользователю root это запрещено:

$ who > .        Попытка затереть '.'

.: cannot create Нельзя

$

Существуют системные обращения, которые создают и удаляют файлы, и только с их помощью можно изменить содержимое каталога. Но принцип прав доступа применим и для них: поле w показывает, кто может использовать системные функции для изменения каталога.

Право на удаление файла не зависит от самого файла. Если у вас есть право записи в каталог, вы можете удалять файлы из него, причем даже те, которые защищены от записи. Команда rm все-таки запрашивает подтверждение, прежде чем удалить защищенный файл, чтобы убедиться, что вы действительно хотите это сделать, — редкий для команд системы UNIX случай двойной проверки намерений пользователя. (Флаг -f команды rm обеспечивает удаление файлов без запроса.)

Поле x в случае каталога означает не выполнение, а поиск. Право на выполнение определяет возможность поиска файла в каталоге. Поэтому возможно создать каталог с правом доступа "x" для других пользователей, предполагая, что пользователи будут иметь доступ к любому известному им файлу в каталоге, но не смогут выполнять команду ls или читать каталог, чтобы узнать, какие файлы в нем находятся. Аналогично каталог с правом доступа r-- можно читать (с помощью ls), но нельзя работать с его файлами. В некоторых системах используют это свойство, чтобы закрыть каталог /usr/games в рабочее время.

Команда chmod ("change mode" — изменить режим) меняет права доступа к файлам:

$ chmod права_доступа имена файлов...

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

$ chmod rw-rw-rw- junk Так нельзя!

чем вводить

$ chmod 666 junk

но так не получается. Восьмеричное значение режима складывается из значений прав доступа: 4 — для чтения, 2 — для записи и 1 — для выполнения. Три цифры, как и в выводе команды ls, показывают права доступа для владельца, группы и всех остальных. Символьные обозначения объяснить труднее; их точное описание приводится в справочном руководстве chmod(1). Для наших же целей достаточно указать, что "+" устанавливает право доступа, а "-" лишает его. Например,

$ chmod +x command

позволяет всем выполнять команду, а

$ chmod -w file

лишает всех права записи в файл, включая и владельца файла. Если не принимать во внимание существование суперпользователя, то только владелец файла может изменить права доступа к файлу, независимо от текущих прав доступа. В том случае, когда кто-то еще предоставил вам право записи в файл, система не позволит изменить код прав доступа к файлу:

$ ls -ld /usr/mary

drwxrwxrwx 5 mary 704 Sep 25 10:18 /usr/mary

$ chmod 444 /usr/mary

chmod: can't change /usr/mary

$

Но, если каталог не защищен от записи, пользователи могут удалять файлы, несмотря на отсутствие права доступа к файлу. Если вы хотите быть уверенным в том, что ни вы, ни ваши друзья никогда не удалят файлы из каталога, отмените право на запись для каталога:

$ cd

$ date > temp

$ chmod -w .         Закрыть каталог по записи

$ ls -ld .

dr-xr-xr-x 3 you 80 Sep 27 11:48 .

$ rm temp

rm: temp not removed Нельзя удалить файл

$ chmod 775 .        Восстановление прав доступа

$ ls -ld .

drwxrwxr-x 3 you 80 Sep 27 11:48 .

$ rm temp            Теперь можно

$

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

Файл имеет несколько атрибутов: имя, содержимое и служебную информацию (права доступа и даты модификации). Служебная информация размещается в индексном дескрипторе вместе с важной системной информацией, такой, как размер файла, место хранения его на диске и т.д.[8] В индексном дескрипторе хранятся три даты: время последнего изменения файла (записи в него), время последнего использования файла (чтение или выполнение), время последнего изменения самого индексного дескриптора, например изменения прав доступа.

$ date

Tue Sep 27 12:07:24 EDT 1983 $ date > junk

$ ls -l junk

-rw-rw-rw 1 you 29 Sep 27 12:07 junk

$ ls -lu junk

-rw-rw-rw 1 you 29 Sep 27 06:11 junk

$ ls -lc junk

-rw-rw-rw 1 you 29 Sep 27 12:07 junk

$

Как видно из результата действия команды ls -lu, изменение содержимого файла не влияет на дату последнего использования, а с изменением прав доступа связана только дата изменения индексного дескриптора, о чем выдается сообщение командой ls -lc:

$ chmod 444 junk

$ ls -lu junk

-r--r--r-- 1 you 29 Sep 27 06:11 junk

$ ls -lc junk

-r--r--r-- 1 you 29 Sep 27 12:11 junk

$ chmod 666 junk $

Можно использовать флаг -t команды ls, который применяется для сортировки файлов по времени (по умолчанию принимается время последней модификации), совместно с флагами -с или -r, чтобы узнать порядок, в котором изменились индексные дескрипторы или читались файлы:

$ ls recipes

apple

pie

$ ls -lut total 2

drwxrwxrwx 4 you 64 Sep 27 12:11 recipes

-rw-rw-rw- 1 you 29 Sep 27 06:11 junk

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

Очень важное понять значение индексного дескриптора, причем не для того, чтобы оценить действие флагов команды ls. По существу, индексные дескрипторы и есть файлы. Иерархия каталогов предоставляет только удобный способ именования файлов. Внутреннее системное имя файла или индекс файла — это номер индексного дескриптора, содержащего информацию о файле. Команда ls -i выдает индекс файла в десятичной форме:

$ date > x

$ ls -i

15768 junk

15274 recipes

15852 x

$

Именно индекс файла хранится в первых двух байтах каталога, предшествующих имени. Команда od -d выдает информацию не в восьмеричной форме по байтам, а в десятичной, объединив по два байта в одно целое, и поэтому мы увидим на экране индекс файла:

$od -с .

0000000   4  ; . \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0

0000020 273 (  .  . \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0

0000040 252  ; p  е  ц  п  т  ы \0 \0 \0 \0 \0 \0 \0 \0

0000060 230  = j  u  n  к \0 \0 \0 \0 \0 \0 \0 \0 \0 \0

0000100 354  = x \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0

0000120

od -d .

0000000 15156 00046 00000 00000 00000 00000 00000 00000

0000020 10427 11822 00000 00000 00000 00000 00000 00000

0000040 15274 25970 26979 25968 00115 00000 00000 00000

0000060 15768 30058 27502 00000 00000 00000 00000 00000

0000100 15852 00120 00000 00000 00000 00000 00000 00000

0000120

$

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

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

$ rm x $ od -d .

0000000 15156 00046 00000 00000 00000 00000 00000 00000

0000020 10427 11822 00000 00000 00000 00000 00000 00000

0000040 15274 25970 26979 25968 00115 00000 00000 00000

0000060 15768 30058 27502 00000 00000 00000 00000 00000

0000100 00000 00120 00000 00000 00000 00000 00000 00000

0000120

$

Следующий файл, создаваемый в этом каталоге, займет освободившуюся позицию, хотя у него, вероятно, будет другой индекс. Команда ln, имеющая приведенный ниже синтаксис, устанавливает связь с уже существующим файлом:

$ ln old-file new-file

Назначение связи состоит в том, чтобы дать два имени одному и тому же файлу, поэтому он часто оказывается в двух разных каталогах. Во многих системах есть связь с редактором /bin/ed под названием /bin/е, так что пользователи могут вызывать редактор как е. Две связи одного файла указывают на одну и ту же запись, а значит, имеют один и тот же индекс файла:

$ ln junk linktojunk

$ ls -li total 3

15768 -rw-rw-rw- 2 you 29 Sep 27 12:07 junk

15768 -rw-rw-rw- 2 you 29 Sep 27 12:07 linktojunk

15274 drwxrwxrwx 4 you 64 Sep 27 09:34 recipes

$

Целое число, выдаваемое между правом доступа и именем владельца файла, является числом связей файла. Поскольку каждая связь ссылается на индексный дескриптор, все связи одинаково, важны — нет разницы между первой связью и последующими. (Заметим, что общий объем занимаемого на диске пространства, сообщаемый командой ls, вычисляется неверно из-за двойного подсчета).

Если изменить файл, то изменение обнаружится при обращении к файлу под любым из его имен, так как все связи ссылаются на один файл:

$ echo x > junk

$ ls -l total 3

-rw-rw-rw- 2 you  2 Sep 27 12:37 junk

-rw-rw-rw- 2 you  2 Sep 27 12:37 linktojunk

drwxrwxrwx 4 you 64 Sep 27 09:34 recipes

$ rm linktojunk

$ ls -l total 2

-rw-rw-rw- 1 you  2 Sep 27 12:37 junk

drwxrwxrwx 4 you 64 Sep 27 09:34 recipes

$

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

Предостережение тем, кто слишком торопится: после удаления последней связи данные становятся недоступными. Удаленные файлы попадают скорее в топку, чем в мусорную корзину, и нет средства возродить их из пепла. (Слабая надежда на возрождение все-таки есть. В больших системах UNIX есть рутинная функция дублирования, которая периодически копирует изменяемые файлы в какое-нибудь надежное место типа магнитной ленты, откуда их можно извлечь. Для собственного успокоения вам следует знать, какой объем дублирования обеспечивает ваша система. Если нет ничего, будьте бдительны — любые неполадки с дисками могут обернуться катастрофой.)

Связи файла удобны, если два пользователя совместно работают с ним, но иногда нужна на самом деле отдельная копия — другой файл с той же информацией. Например, вы можете скопировать документ до внесения в него существенных изменений, так что можно будет восстановить оригинал, если вас не устроят эти изменения. Здесь не поможет установление связи, так как при изменении данных обе связи будут ссылаться на измененный файл. Копирует файлы команда cp:

$ cp junk copyofjunk

$ ls -li total 3

15850 -rw-rw-rw- 1 you  2 Sep 27 13:13 copyofjunk

15768 -rw-rw-rw- 1 you  2 Sep 27 12:37 junk

15274 drwxrwxrwx 4 you 64 Sep 27 09:34 recipes

$

Индексы файлов junk и copyofjunk различны, поскольку это различные файлы, хотя в данный момент они имеют одинаковое содержимое. Существует полезный прием: можно изменить права доступа к копии файла, чтобы ее труднее было случайно удалить.

$ chmod -w copyofjunk     Убрать право записи

$ ls -li total 3

15850 -r--r--r-- 1 you  2 Sep 27 13:13 copyofjunk

15768 -rw-rw-rw- 1 you  2 Sep 27 12:37 junk

15274 drwxrwxrwx 4 you 64 Sep 27 09:34 recipes

$ rm copyofjunk

rm: copyofjunk 444 mode n Нельзя! Он нужен

$ date > junk

$ ls -li total 3

15850 -r--r--r-- 1 you  2 Sep 27 13:13 copyofjunk

15768 -rw-rw-rw- 1 you 29 Sep 27 13:16 junk

15274 drwxrwxrwx 4 you 64 Sep 27 09:34 recipes

$ rm copyofjunk

rm: copyofjunk 444 mode y А может быть, и не так нужен

$ ls -li total 2

15768 -rw-rw-rw- 1 you 29 Sep 27 13:16 junk

15274 drwxrwxrwx 4 you 64 Sep 27 09:34 recipes

$

Изменение копии файла или ее удаление не оказывает действия на оригинал. Обратите внимание на то, что, поскольку у файла copyofjunk отменено право на запись, команда rm запрашивает подтверждение, прежде чем удалить файл.

Есть еще одна команда общего назначения, управляющая файлами, — mv, которая переносит или переименовывает файлы, просто преобразуя связи. Синтаксис ее такой же, как у команд cp и ln:

$ mv junk sameoldjunk $ ls -li total 2

15274 drwxrwxrwx 4 you 64 Sep 27 09:34 recipes

15768 -rw-rw-rw- 1 you 29 Sep 27 13:16 sameoldjunk

$

sameoldjunk — это тот же самый файл, что и наш старый файл junk, вплоть до индекса файла, который связан с записью каталога с номером 15768; изменилось только его имя.

Все описанные выше манипуляции с файлами происходили в одном каталоге, однако команды применяются и в других каталогах. Команда ln часто используется для того, чтобы установить связь с одним именем в разных каталогах; это бывает в тех случаях, когда несколько пользователей работают с одной программой или над одним документом. Команда mv может переслать файл или каталог из одного каталога в другой. На самом деле, это довольно стандартный прием, так что у команд mv и cp есть специальный синтаксис для такой ситуации:

$ mv (или cp) file1 file2 ... directory

Здесь показана пересылка (или копирование) одного или нескольких файлов в каталог, который является последним аргументом. Связи или копии файлов получаются под теми же именами. Например, если вы хотите "набить руку" в работе с редактором, то можете начать с

$ cp /usr/src/cmd/ed.с .

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

$ mkdir sh

$ cp /usr/src/cmd/sh/* sh

и команда cp скопирует все исходные тексты shell в ваш вложенный каталог sh (мы считаем, что в /usr/src/cmd/sh нет вложенных каталогов, так как команда cp не слишком "умна"). В некоторых случаях команду ln допустимо применять с несколькими именами файлов в качестве аргументов, но имя каталога по-прежнему является последним аргументом. В ряде систем команды mv, cp и ln сами служат связями, ссылающимися на один файл, который анализирует имя команды, чтобы узнать, какое задание выполнить.

В первой главе рассмотрение иерархии файловой системы, начиная с каталога /usr/you, носило несколько неформальный характер. Теперь мы хотим изучить ее последовательно, начиная от корня дерева.

Корневой каталог называется /:

$ ls /

bin

boot

dev

etc

lib

tmp

unix

usr

$

Программа /unix — это программа ядра UNIX: когда система начинает работу, /unix считывается с диска в память и начинает выполняться. Все происходит за два шага: вначале считывается файл /boot, а затем он считывает /unix. Более подробно о таком процессе раскрутки можно узнать в справочном руководстве по boot(8). Остальные файлы каталога /, по крайней мере в нашей версии, являются каталогами, каждый из которых представляет законченный раздел файловой системы. После дальнейшего краткого обзора иерархии читателю будет предоставлена возможность поэкспериментировать с упоминаемыми здесь каталогами. Чем лучше вы разберетесь в устройстве файловой системы, тем более эффективно сможете ею пользоваться. В табл. 2.1 указаны подходящие места для поиска, хотя некоторые имена каталогов зависят от системы.

Таблица 2.1: Интересные каталоги (см. также hier(7))

В нашем кратком обзоре мы пропустили каталог /dev по той причине, что файлы в нем дают хорошее общее представление о файлах вообще. Как можно догадаться по его названию, этот каталог содержит файлы устройств ("device" — устройство).

К привлекательным чертам системы UNIX относится форма ее работы с периферийными устройствами: дисками, магнитными лентами, принтерами, терминалами и т.п. Вместо того чтобы иметь специальные системные программы, например программу чтения с магнитной ленты, достаточно создать файл с именем /dev/mt0 (опять-таки местные соглашения могут различаться). В ядре обращения к этому файлу преобразуются в машинные команды обращения к магнитной ленте, как если бы программа читала /dev/mt0, выдавая содержимое магнитной ленты, подключенной к устройству. Например, команда

$ cp /dev/mt0 junk

копирует содержимое магнитной ленты в файл junk. Команда cp не имеет понятия о специфике файла /dev/mt0; для нее он является обычным файлом, т.е. просто последовательностью байтов.

Файлы устройств в чем-то подобны зверинцу, где каждая особь чем-нибудь отличается от остальных, но основные характеристики применимы ко всем. Ниже приведен сокращенный список нашего каталога /dev:

$ ls -l /dev

crw--w--w- 1 root  0,  0 Sep 27 23:09 console

crw-r--r-- 1 root  3,  1 Sep 27 14:37 fcmem

crw-r--r-- 1 root  3,  0 May  6  1981 mem

brw-rw-rw- 1 root  1, 64 Aug 24 17:41 mt0

crw-rw-rw- 1 root  3,  2 Sep 28 02:03 null

crw-rw-rw- 1 root  4, 64 Sep  9 15:42 rmt0

brw-r----- 1 root  2,  0 Sep  8 08:07 rp00

brw-r----- 1 root  2,  1 Sep 27 23:09 rp01

crw-r----- 1 root 13,  0 Apr 12  1983 rrp00

crw-r----- 1 root 13,  1 Jul 28 15:18 rrp01

crw-rw-rw- 1 root  2,  0 Jul  5 08:04 tty

crw--w--w- 1 root  1,  0 Sep 28 02:38 tty0

crw--w--w- 1 root  1,  1 Sep 27 23:09 tty1

crw--w--w- 1 root  1,  2 Sep 27 17:33 tty2

crw--w--w- 1 root  1,  3 Sep 27 18:48 tty3

$

Первое, что здесь бросается в глаза, это то, что вместо количества байтов указывается пара небольших целых чисел, а в первой позиции прав доступа используется 'b' или 'c'. В таком виде команда ls выдает информацию из индексного дескриптора для файла устройств, но не для обычного файла. Обычному файлу предназначен хранимый в индексном дескрипторе список блоков памяти диска, в которых находится содержимое файла. В случае же файла устройств индексный дескриптор содержит внутреннее имя устройства, включающее его тип (символьное с или блочное b) и пару чисел, называемых верхним и нижним числами устройства. К блочным устройствам относятся диски и магнитные ленты, а все остальное: терминалы, принтеры, линии сетевой связи и т.п. — к символьным. Верхнее число устройства обозначает его тип, а нижнее характеризует различные экземпляры устройств одного типа. Например, /dev/tty0 и /dev/tty1 — это два порта одного контроллера терминала, поэтому они имеют одно и то же верхнее число и различные нижние числа.

Файлы для дисков обычно именуются в соответствии с тем вариантом оборудования, которое представлено в системе. Файлы /dev/rp00 и /dev/rp01 названы так потому, что в системе используются дисковые накопители DEC RP06. Есть только один дисковый накопитель, логически поделенный на две файловые системы. Если бы существовал еще один накопитель, связанные с ним файлы имели бы имена /dev/rp10 и /dev/rp11. Первая цифра обозначает номер накопителя, а вторая показывает, какая его часть используется.

У вас может возникнуть вопрос: почему существует несколько дисковых файлов устройств, а не одно? Исторически так сложилось (и для удобства поддержания), что файловая система была разделена на подсистемы. Файлы в подсистеме доступны через каталог главной системы. Программа /etc/mount показывает соответствие между файлами устройств и каталогами:

$ /etc/mount

rp01 on /usr

$

В нашем случае каталог root находится на /dev/rp00 (хотя команда /etc/mount об этом не сообщает), а файловая система пользователей, т.е. файлы из каталога /usr и вложенных каталогов, находится на /dev/rp01.

Каталог /root должен быть доступен системе для выполнения команд. Каталоги /bin, /dev и /etc всегда находятся в корневом каталоге, поскольку при запуске системы доступны только файлы корневого каталога, а такие, как /bin/sh, необходимы для работы. Во время раскрутки системы все файловые системы проверяются на целостность (см. icheck(8) или fsck(8)) и подключаются к корню иерархии файлов. Эта операция подключения называется присоединением и является программистским эквивалентом операции установки пакета дисков на накопитель; обычно она выполняется только суперпользователем. После присоединения /dev/rp01 в качестве /usr файлы пользователей становятся доступными, как если бы они были частью корневого каталога.

Для обычного пользователя детали операции присоединения подсистемы файлов представляют мало интереса, но здесь есть несколько моментов, относящихся к нашей теме. Во-первых, поскольку подсистемы файлов могут быть присоединены и отсоединены, недопустимо устанавливать связь с файлом из другой подсистемы. Например, нельзя связать программы из общего каталога /bin с какими-то файлами из каталогов /bin пользователей, поскольку /usr находится в иной подсистеме файлов, чем /bin:

$ ln /bin/mail /usr/you/bin/m

ln: Cross-device link

$

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

Далее, каждая подсистема ограничена по размеру (числу доступных блоков для файлов) и числу индексных дескрипторов. Если подсистема заполнена, то невозможно расширять файлы в такой системе, пока не будет добавлено какое-то пространство. Команда df ("disc free space" — свободное пространство диска) выдает сообщение о доступном пространстве в присоединенной подсистеме файлов:

$ df

/dev/rp00 1989

/dev/rp01 21257

В каталоге /usr имеется 21257 свободных блоков. Достаточно ли этого пространства или наступил кризис, зависит от того, как система используется; в одних случаях требуется больше свободного пространства, в других — меньше. Кстати, из всех команд df, вероятно, обеспечивает наибольшее разнообразие в формате вывода. Результат действия вашей команды df может выглядеть совершенно иначе.

Рассмотрим теперь некоторые более общие понятия. При входе в систему вы устанавливаете связь вашего терминала с системой и, значит, получаете в каталоге /dev файл, через который передаются вводимые и принимаемые вами символы. Команда tty сообщает, какой терминал вы используете:

$ whoami

you tty0 Sep 28 01:02

$ tty

/dev/tty0

$ ls -l /dev/tty0

crw--w--w- 1 you 1, 12 Sep 28 02:40 /dev/tty0

$ date >/dev/tty0

Wed Sep 28 02:40:51 EDT 1983

$

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

$ mesg n Запретим сообщения

$ ls -l /dev/tty0

crw--w---- 1 you 1, 12 Sep 28 02:41 /dev/tty0

$ mesg y Разрешим

$ ls -l /dev/tty0

crw--w--w- 1 you 1, 12 Sep 28 02:42 /dev/tty0

$

Часто бывает удобно использовать имя для ссылки на применяемый терминал, но трудно определить, каково имя вашего терминала. Имя устройства /dev/tty является синонимом имени терминала, с которого вы вошли в систему, с каким бы терминалом вы ни работали на самом деле:

$ date >/dev/tty

Wed Sep 28 02:42:23 EDT 1983

$

Имя /dev/tty особенно полезно, если программе необходимо начать диалог с пользователем, в то время когда ее стандартный входной и выходной потоки связаны с файлами, а не с терминалом. Команда crypt является одной из команд, использующих имя /dev/tty. "Открытый" текст поступает из стандартного входного потока, а зашифрованная информация направляется в стандартный выходной поток, поэтому команда crypt читает ключ для шифрования с /dev/tty:

$ crypt <cleartext >cryptedtext

Enter key: Введите ключ шифрования

$

В данном примере имя /dev/tty используется неявно, но все-таки используется. Если бы команда crypt читала ключ из стандартного входного потока, она бы прочла первую строку из файла cleartext. Вместо этого она открывает файл /dev/tty, отключает автоматическое эхо вводимых символов, чтобы ваш ключ не появился на экране, и читает ключ. В гл. 5 и 6 приводится несколько других примеров использования /dev/tty.

Иногда вы хотите запустить программу, но вам не важен результат ее выполнения. Например, вы могли уже ознакомиться с сегодняшними новостями и не желаете читать их еще раз. Переключение вывода команды news в файл /dev/null приведет к игнорированию выходного потока:

$ news >/dev/null

$

Информация, направляемая в /dev/null, просто пропадает, а программы, читающие из этого файла, сразу получают символ конца файла, поскольку программа чтения всегда возвращает 0 прочитанных байтов.

Обычно файл /dev/null используют, чтобы отказаться от стандартного выходного потока и сделать видимыми диагностические сообщения. Например, команда time (time(1)) сообщает об использованном программой процессорном времени. Результат выдается в стандартный поток диагностики, так что можно хронометрировать команды, производящие преобразование входного потока в выходной, переключая стандартный выходной поток в файл /dev/null:

$ ls -l /usr/diet/words

-r--r--r-- 1 bin 196513 Jan 20 1979 /usr/dict/words

$ time grep e /usr/dict/words/ >/dev/null

real 13.0

user  9.0

sys   2.7

$ time egrep e /usr/dict/words >/dev/null

real  8.0

user  3.9

sys   2.8

$

Команда time выдает прошедшее календарное время, время процессора, затраченное программой, и время процессора, затраченное ядром системы для выполнения запросов программы. Команда egrep — это мощный вариант команды grep, который мы обсудим в гл. 4; она выполняется почти в два раза быстрее команды grep при просмотре больших файлов. Если бы выдача команд egrep или grep не была переключена в /dev/null или текущий файл, пришлось бы ждать, пока сотни тысяч символов "пробегут" на экране, прежде чем появятся нужные нам временные характеристики.

Интерпретатор shell — это наиболее важная программа для пользователей UNIX, быть может, за исключением вашего любимого текстового редактора. Она исполняет ваши запросы на запуск программ и занимает гораздо больше вашего времени, чем любая другая программа системы. Значительная часть настоящей главы и гл. 5 будут посвящены описанию возможностей интерпретатора. Основная мысль, к которой мы хотим подвести вас, состоит в том, что если вы научитесь работать с интерпретатором, то сможете достичь многого и без особого труда, не прибегая к традиционным языкам программирования типа Си.

Как уже отмечалось, описание интерпретатора разделено на две части. В этой главе от простейших возможностей, показанных в гл. 1, мы перейдем к рассмотрению некоторых необычных, но широко используемых конструкций, таких, как метасимволы, кавычки, новые команды с переданными им аргументами, переменные shell и отдельные структуры управления. Все это понадобится вам для эффективной работы с интерпретатором. Материал гл. 5 более сложный. Изучив его, вы сможете писать настоящие программы на языке shell и даже предоставлять их другим пользователям. Такое деление темы, конечно, во многом произвольно, поэтому мы рекомендуем вам прочитать обе главы.

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

Самая простая команда состоит из одного слова, обычно имени файла, предназначенного для выполнения (позднее вы познакомитесь с другими типами команд):

$ who Выполняем файл /bin/who

you tty2 Sep 28 07:51

jpl tty4 Sep 28 08:32

$

Команда, как правило, завершается символом перевода строки, но может завершаться и точкой с запятой:

$ date;

Wed Sep 28 09:07:15 EDT 1983

$ date; who

Wed Sep 28 09:07:23 EDT 1983

you tty2 Sep 28 07:51

jpl tty4 Sep 28 08:32

$

Однако выполнение команды не начнется, пока вы не нажмете клавишу RETURN. Обратите внимание на то, что интерпретатор выдает только одно приглашение после нескольких команд, но если не учитывать этого, то ввод

$ date; who

идентичен вводу двух команд в разных строках. В частности, команда who не будет выполняться до завершения date. Попробуйте послать результат выполнения этих команд по программному каналу:

$ date; who | wc

Wed Sep 28 09: 08:48 EDT 1983

2 10 60

$

Возможно, вы получите не то, что ожидали, поскольку только результат команды who передается команде wc. При связывании who и wc через программный канал образуется единая команда, называемая конвейером, которая выполняется после date. В процессе разбора командной строки shell считает приоритет операции '|' выше, чем операции ';'. Для группирования команд следует использовать скобки:

$ (date; who)

Wed Sep 28 09:11:09 EDT 1983

you tty2 Sep 28 07:51

jpl tty4 Sep 28 08:32

$ (date; who) | wc

3 16 89

$

Результат выполнения команд date и who конкатенируется в один поток, который можно передать по программному каналу.

Информацию, поступающую по программному каналу, можно с помощью команды tee собрать и поместить в файл (но не в другой программный канал). Команда tee является частью интерпретатора shell, но тем не менее удобна и при манипулировании программными каналами. Ее можно использовать для сохранения промежуточного результата в файле:

$ (date; who) | tee save | wc

3 16 89 Результат команды wc

$ cat save

Wed Sep 28 09:13:22 EDT 1983

you tty2 Sep 28 07:51

jpl tty4 Sep 28 08:32

$ wc <save

3 16 48

$

Команда tee переписывает свой входной поток в поименованный файл (или файлы), а из него — точно так же без изменений в выходной поток, поэтому wc получает те же самые данные, как если бы команда tee не присутствовала в конвейере.

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

$ long-running-command &

5273 Номер процесса длительной команды

$    Приглашение появляется сразу

Имея возможность группировать команды, получаем некоторые интересные способы применения фоновых процессов. Команда sleep ожидает указанное число секунд, прежде чем закончить свое выполнение:

$ sleep 5

$ Проходит 5 секунд до появления приглашения

$ (sleep 5; date) & date

5278

Wed Sep 28 09:18:20 EDT 1983   Результат второй команды date

$ Wed Sep 28 09:18:25 EDT 1983 Появляется приглашение, затем

через 5 секунд дата

Фоновый процесс начинается, но сразу "засыпает"; тем временем вторая команда date выдает текущее время, а интерпретатор — приглашение для ввода новой команды. Пятью секундами позже прекращается выполнение команды sleep, и первая команда date выдает новое время. Трудно представить на бумаге истечение времени, поэтому вам следует попытаться самостоятельно реализовать этот пример. (Разница между двумя значениями времени может и не равняться в точности 5 с, в зависимости от загруженности машины и по ряду других причин.) Это удобный способ отложить запуск команды на будущее; рассмотрите также в качестве удобного механизма такой пример:

$ (sleep 300; echo Чай готов) & Чай будет готов через 5 минут

5291

$

(Если в строке, следующей за командой echo, есть символ ctl-g, то при появлении ее на экране зазвонит звонок.) В этих примерах нужны скобки, так как приоритет '&' выше, чем у ';'.

Символ & может завершать команды, а поскольку конвейеры являются командами, в скобках для запуска конвейеров как фоновых процессов нет необходимости, поэтому

$ pr файл | lpr &

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

$ (pr файл | lpr ) & To же, что и в предыдущем примере

Большинство команд допускает наличие аргументов в командной строке, таких, как файл в предыдущем примере (аргумент команды pr). Аргументами служат слова, разделенные пробелами и символами табуляции, которые обычно именуют файлы, предназначенные для обработки командой. Однако они рассматриваются просто как строки, и программа может интерпретировать их любым подходящим для нее способом. Например, команда pr допускает имена файлов, которые нужно напечатать, команда echo посылает эхо своих аргументов без всякой интерпретации, а первый аргумент команды grep специфицирует строку-шаблон для поиска. И конечно, многие команды имеют необязательные параметры (флаги), задаваемые аргументами, начинающимися со знака “-”.

Различные специальные символы, интерпретируемые shell, такие, как <, >, |, ; и &, не являются аргументами команд, запускаемых интерпретатором. Они управляют самим процессом запуска. Например,

$ echo Hello > junk

требует, чтобы интерпретатор запустил команду echo с одним аргументом Hello и поместил выходной поток в файл junk. Строка > junk не является аргументом команды echo; она интерпретируется shell, и echo никогда ее "не увидит". На самом деле, данная строка может и не быть последней в командной строке:

$ > junk echo Hello

Это идентичный запуск, хотя и менее очевидный.

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

$ echo *

есть не что иное, как некое подобие команды ls. В гл. 1 мы не отметили, что во избежание проблем с именами '.' и '..', которые присутствуют в любом каталоге, символы подстановки в именах файлов нельзя применять к именам файлов, начинающимся с точки. Правило таково: символы подстановки в именах файлов действуют на имена файлов, начинающихся с точки, только в том случае, если точка явно задана в шаблоне. Как обычно, "рассудительная" команда echo прояснит ситуацию:

$ ls

.profile

junk

temp

$ echo *

junk temp

$ echo .*

. .. .profile

$

Символы со специальным значением, подобные *, называются метасимволами. Существует множество метасимволов (в табл. 3.1 приводится их полный список, но некоторые символы мы обсудим только в гл. 5).

Таблица 3.1: Метасимволы shell

Теперь, как мы обещали вам в гл. 1, рассмотрим создание новых команд из старых. Имея последовательность команд, которую придется многократно повторять, преобразуем ее для удобства в "новую" команду со своим именем и будем использовать ее как обычную команду. Чтобы быть точными, предположим, что нам предстоит часто подсчитывать число пользователей с помощью конвейера

$ who | wc -l

(см. гл. 1), и для этой цели нужна новая программа nu.

Первым шагом должно быть создание обычного файла, содержащего 'who | wc -l'. Можно воспользоваться вашим любимым редактором или проявить изобретательность:

$ echo 'who | wc -l' >nu

(Что появится в файле nu, если не употреблять кавычки?)

Как отмечалось в гл. 1, интерпретатор является точно такой же программой, как редактор, who или wc; он называется sh. А коль скоро это программа, ее можно вызвать и переключить ее входной поток. Так что запускаем интерпретатор с входным потоком, поступающим из файла nu, а не с терминала:

$ who

you tty2 Sep 28 07:51 rhh tty4 Sep 28 10:02

moh tty5 Sep 28 09:38 ava tty6 Sep 28 10:17

$ cat nu who | wc -l

$ sh < nu

4

$

Результат получился таким же, каким бы он был при задании команды who | wc -l с терминала. Опять-таки, как и большинство программ, интерпретатор берет входной поток из файла, если он указан в качестве аргумента; вы с тем же успехом могли задать:

$ sh nu

Однако досадно вводить "sh" каждый раз; во всяком случае эта запись длиннее и создает различия между программами, написанными, например, на Си, и программами, написанными с помощью shell.[9] Поэтому если файл предназначен для выполнения и если он содержит текст, то интерпретатор считает, что он состоит из команд. Такие файлы называются командными. Все, что вам нужно сделать, это объявить файл nu выполняемым, задав

$ chmod + x nu

а затем вы можете вызывать его посредством

$ nu

С этого момента те, кто используют файл nu, не смогут определить способ его создания.

Способ, с помощью которого интерпретатор на самом деле выполняет nu, сводится к созданию нового процесса интерпретатора, как если бы вы задали

$ sh nu

Этот процесс-потомок называется порожденным интерпретатором, т.е. процессом интерпретатора, возбужденным вашим текущим интерпретатором. Но команда sh nu — это не то же самое, что sh < nu, поскольку в первом случае стандартный входной поток все еще связан с терминалом. Пока команда nu выполняется только в том случае, если она находится в вашем текущем каталоге (при условии, конечно, что текущий каталог включен в PATH, а именно это мы и предполагаем с настоящего момента). Чтобы сделать команду nu частью вашего репертуара независимо от того каталога, с которым вы работаете, занесите ее в свой собственный каталог bin и добавьте /usr/you/bin к списку каталогов поиска:

$ pwd /usr/you

$ mkdir bin                 Создать bin, если его еще не было

$ echo $PATH                Проверить Path, чтобы убедиться

:/usr/you/bin:/bin:/usr/bin Должно быть нечто похожее

$ mv nu bin                 Установить команду nu в bin

$ ls nu

nu not found                Она действительно исчезла

из текущего каталога

$ nu

4                           Но интерпретатор ее находит

$

Конечно, ваша переменная PATH должна быть правильно определена в файле .profile, чтобы вам не приходилось переопределять ее при каждом входе в систему.

Существуют и другие простые команды, которые вы можете адаптировать к среде по своему вкусу и создавать таким же способом. Нам показалось удобным иметь следующие команды:

• cs для посылки подходящей последовательности специфических символов с целью очистки экрана вашего терминала (24 символа перевода строки — практически универсальное решение);

• what для запуска who и ps -а, чтобы сообщить, кто работает в системе и что он делает;

• where для вывода идентифицированного названия используемой системы UNIX. Это удобно, если вы постоянно работаете с несколькими версиями. (Установка PS1 служит для подобной цели.)

Хотя команда nu, как она задумывалась, удовлетворяет своему назначению, многие программы на языке shell могут обрабатывать аргументы, так что при их запуске можно задавать имена файлов и флаги.

Допустим, вы хотите создать программу с именем cx для установки права доступа к файлу на выполнение, так что

$ cx nu

есть сокращенная запись для

$ chmod +x nu

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

chmod +x filename

Единственное, что требуется выяснить — как сообщить команде cx имя файла, так как при каждом запуске cx оно будет иным.

Если интерпретатор выполняет командный файл, то каждое вхождение $1 заменяется первым аргументом, каждое вхождение $2 — вторым и т.д. до $9. Поэтому если файл cx содержит строку

chmod +x $1

то при выполнении команды

$ cx nu

порожденный интерпретатор заменит "$1" на первый аргумент "nu". Рассмотрим всю последовательность операций:

$ echo 'chmod +x $1' >cx      Вначале создадим cx

$ sh cx сх                    Сделать сам файл cx выполняемым

$ echo echo Hi, there! >hello Приготовим тест

$ hello                       Попробуем

hello: cannot execute

$ cx hello                    Сделаем файл выполняемым

$ hello                       Попробуем снова

Hi, there!                    Работает

$ mv cx /usr/you/bin          Установим команду cx

$ rm hello                    Уберем ненужное

$

Заметьте, что мы задали

$ sh cx сх

в точности так, как сделал бы автоматически интерпретатор, если бы cx была выполняемой и можно было бы задать

$ cx сх

А как быть, если нужно работать с несколькими аргументами, например, заставить программу cx воздействовать сразу на несколько файлов? Прямолинейное решение состоит в том, чтобы включить девять аргументов в командный файл:

chmod +x $1 $2 $3 $4 $5 $6 $7 $8 $9

(Это годится только для девяти аргументов, так как конструкция $10 распознается как "первый аргумент, за которым следует 0"!) Если пользователь такого командного файла задаст меньше девяти аргументов, то недостающие окажутся пустыми строками. Это приведет к тому, что только настоящие аргументы будут переданы chmod порожденным интерпретатором. Такое решение, конечно, приемлемо, но не вполне корректно и не подходит для случая с числом аргументов более девяти.

С учетом упомянутой выше трудности интерпретатор предоставляет сокращенную запись $*, означающую "все аргументы". В этом случае правильно определить cx:

chmod +x $*

что является эффективным при любом числе аргументов.

Используя $* в своем репертуаре, вы можете создать некоторые полезные командные файлы, такие, как lc или m:

$ cd /usr/you/bin

$ cat lc

#lc: подсчет числа строк в файлах

wc -l $*

$ cat m

#m: точный способ послать почту

mail $*

$

Обе команды можно осмысленно использовать и без аргументов. Если нет аргументов, $* будет пустым, и wc и mail вообще не получат никаких аргументов. С аргументами или без них команда вызывается правильно:

$ lc /usr/you/bin/*

 1 /usr/you/bin/cx

 2 /usr/you/bin/lc

 2 /usr/you/bin/m

 1 /usr/you/bin/nu

 2 /usr/you/bin/what

 1 /usr/you/bin/where

 9 total

$ ls /usr/you/bin | lc

 6

$

Эти и другие команды, описываемые в настоящей главе, являются командами пользователя, т.е. вы создаете их для себя и помещаете в свой каталог /bin, поэтому вряд ли они должны стать общедоступными. В гл. 5 мы исследуем вопрос создания общедоступных программ на языке shell.

Аргументами командного файла не обязательно должны быть имена файлов. Рассмотрим в качестве примера поиск в каталоге, где хранится личный телефонный справочник. Если у вас есть файл с именем /usr/you/lib/phone-book, содержащий строки следующего вида:

dial-a-joke      212-976-3838

dial-a-prayer    212-246-4200

dial santa       212-976-3636

dow jones report 212-976-4141

то для поиска в нем можно воспользоваться командой grep. (Ваш собственный каталог lib — хорошее хранилище таких частных баз данных.) Поскольку команда grep не определяет формат информации, можно искать имена, адреса, индексы или еще какие-нибудь нужные вам сведения. Составим справочную программу для каталога, которой дадим имя 411 по номеру одной из телефонных справочных служб:

$ echo 'grep $* /usr/you/lib/phone-book' > 411

$ cx 411

$ 411 joke

dial-a-joke      212-976-3838

$ 411 dial

dial-a-joke      212-976-3838

dial-a-prayer    212-246-4200

dial santa       212-976-3636

$ 411 'dow jones'

grep: can't open jones Что-то не так

$

Последний пример вскрывает потенциальную проблему: хотя dow jones представляет для команды 411 единый аргумент, он содержит пробел и уже не заключен в апострофы, поэтому порожденный интерпретатор, выполняющий команду 411, преобразует его в два аргумента для grep, как если бы вы задали

$ grep dow jones /usr/you/lib/phone-book

что, очевидно, неверно.

Один из возможных путей обойти эту проблему основан на том, как интерпретатор трактует кавычки. Хотя все, что заключено в '...', не затрагивается, интерпретатор "заглядывает" внутрь "..." в поиске комбинаций с $, \, `...`. Поэтому если изменить команду 411 следующим образом:

$ grep "$*" /usr/you/lib/phone-book

то $* заменяется на аргументы, но команде grep передается как один аргумент, даже при наличии пробелов:

$ 411 dow jones

dow jones report 212-976-4141

$

Кстати, можно сделать с помощью флага -y команду grep (а значит, и 411) независимой от использования строчных или прописных букв:

$ grep -y pattern ...

При наличии флага -y строчные буквы из шаблона могут сопоставляться с прописными буквами из входного потока. (Такой флаг есть в седьмой версии, но отсутствует в других системах.)

Более подробно аргументы команд мы рассмотрим в гл. 5, но одно важное замечание необходимо сделать здесь. Аргумент $0 — это имя выполняемой программы; в случае cx $0 есть "cx". Новое применение $0 находит в реализации программ 2, 3, 4, …, которые печатают свой выходной поток в несколько столбцов:

$ who | 2

drh tty0 Sep 28 21:23 cvw tty5 Sep 28 21:09

dmr tty6 Sep 28 21:10 scj tty7 Sep 28 22:11

you tty9 Sep 28 23:00 jib ttyb Sep 28 19:58

$

Реализация команд 2, 3, … идентична. По существу, они являются связями с одним файлом:

$ ln 2 3; ln 2 4; ln 2 5; ln 2 6

$ ls -l [1-9]

167222 -rwxrwxrwx 5 you 51 Sep 28 23:21 2

167222 -rwxrwxrwx 5 you 51 Sep 28 23:21 3

167222 -rwxrwxrwx 5 you 51 Sep 28 23:21 4

167222 -rwxrwxrwx 5 you 51 Sep 28 23:21 5

167222 -rwxrwxrwx 5 you 51 Sep 28 23:21 6

$ ls /usr/you/bin | 5

2    3     4    411   5

6    cx    lc   m     nu

what where

$ cat 5

# 2, 3, ...: печать в n столбцов

pr -$0 -t -11 $*

$

Флаг -t убирает заголовки в начале страницы, а флаг -ln устанавливает размер страницы равным n строк. Имя программы становится числом столбцов, т.е. аргументов для команды pr, так что выходной поток печатается строками по несколько столбцов, число которых определено аргументом $0.

Теперь перейдем от аргументов команд для командного файла к порождению аргументов. Конечно, расширение имен файлов с помощью метасимволов, подобных *, является наиболее типичным способом порождения аргументов (иным, чем их явное задание), но столь же хорошим способом представляется и выполнение программы. Результат выполнения любой программы можно использовать в командной строке, заключив ее вызов в символы слабого ударения `...`:

$ echo At the tone the time will be `date`.

At the tone the time will be Thu Sep 29 00:02:15 EDT 1983.

$

Небольшое изменение показывает, что `...` интерпретируется и внутри кавычек "...":

$ echo "At the tone

> the time will be `date`."

At the tone

the time will be Thu Sep 29 00:03:07 EDT 1983.

$

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

$ mail `cat mailinglist` <letter

Запуск команды cat порождает список имен пользователей, и эти имена становятся аргументами команды mail. (При обработке результата выполнения команды, помещенной между знаками слабого ударения и используемой в качестве аргумента, интерпретатор считает символы перевода строки разделителями слов, а не символами завершения командной строки; подробнее данный вопрос обсуждается в гл. 5.) Работать со знаками слабого ударения нетрудно, и поэтому, действительно, нет нужды вводить отдельный флаг команды mail, задающий список адресатов.

Несколько иной подход требуется для преобразования файла mailinglist из простого списка имен в программу, выдающую список имен:

$ cat mailinglist

echo don whr ejs mb Новая версия

$ cx mailinglist

$ mailinglist

don whr ejs mb

$

Теперь посылка писем адресатам из списка реализуется командой:

$ mail `mailinglist` <letter

Добавив еще одну программу, получим возможность даже изменять список пользователей в диалоге. Такая программа называется pick:

$ pick аргументы...

и выдает свои аргументы по одному, ожидая каждый раз ответа. Результатом действия команды pick являются те аргументы, на которые был дан ответ y (yes — да); при всяком другом ответе аргумент отбрасывается. Например,

$ pr `pick *.с` | lpr

Здесь вначале выдаются имена файлов, оканчивающиеся на .с. Выбранные имена печатаются с помощью команд pr и lpr. (Команда pick не входит в состав команд седьмой версии, но она столь проста и полезна, что мы включили ее варианты в гл. 5 и 6).

Допустим, вы используете второй вариант команды mailinglist. Тогда посылка писем адресатам don и mb выглядит так:

$ mail `pick \`mailinglist\`` <letter

don? y

whr?

ejs?

mb? y

$

Обратите внимание на вложенные знаки слабого ударения; обратная дробная черта запрещает обработку вложенной конструкции `...` при разборе внешних знаков слабого ударения.

Подобно большинству языков программирования, shell имеет переменные, которые на программистском жаргоне называются параметрами. Такие строки, как $1, являются позиционными параметрами-переменными, хранящими аргументы командного файла. Цифра показывает положение параметра в командной строке. Ранее мы имели дело с другими переменными языка shell: PATH — список каталогов, в которых происходит поиск команд, НОМЕ — ваш начальный каталог и т.д. В отличие от переменных в обычном языке переменные, задающие позиционные параметры, не могут быть изменены; хотя PATH представляет собой переменную со значением $PATH, нет переменной 1 со значением $1, т.е. $1 — это не что иное, как компактное обозначение первого аргумента.

Если забыть о позиционных параметрах, переменные языка shell можно создавать, выбирать и изменять. Например,

$ PATH=:/bin:/usr/bin

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

$ PATH=$PATH:/usr/games

$ echo $PATH

:/usr/you/bin:/bin:/usr/bin:/usr/games

$ PATH=:/usr/you/bin:/bin:/usr/bin Восстановим значение

$

He все переменные имеют специальное значение для интерпретатора. Можно создавать новые переменные, присваивая им значения. По традиции переменные, имеющие специальное значение, обозначаются прописными буквами, а обычные переменные — строчными. Типичным примером использования переменных является хранение в них длинных строк, таких, как имена файлов:

$ pwd

/usr/you/bin

$ dir=`pwd`        Запомним, где находимся

$ cd /usr/mary/bin Перейдем в другое место

$ ln $dir/cx .     Используем переменную в имени файла

$ ...              Поработаем некоторое время

$ cd $dir          Вернемся

$ pwd

/usr/you/bin

$

Встроенная в интерпретатор команда set показывает значения всех определенных вами переменных. Для просмотра одной или двух переменных более подходит команда echo:

$ set

HOME=/usr/you

IFS=

Понятие стандартного потока диагностики было введено для того, чтобы сообщения об ошибках всегда появлялись на терминале:

$ diff file1 file2 >diff.out

diff: file2: No such file or directory

$

Без сомнения, сообщения об ошибке должны появляться подобным образом — было бы крайне неприятно, если бы они исчезли в файле diff.out, оставляя вас в уверенности, что ошибочная команда diff выполнена правильно.

В начале выполнения каждой программы определены по умолчанию три файла, обозначаемые небольшими целыми числами и называемые дескрипторами файла (мы рассмотрим их в гл. 7). Со стандартными входным (0) и выходным (1) потоками вы уже знакомы: они часто переключаются на файл или программный канал. Последний поток с номером 2 представляет собой стандартный поток диагностики и обычно предназначается для вывода на терминал.

Иногда программы осуществляют вывод в стандартный поток диагностики, даже если они работают правильно. Типичным примером является программа time, которая выполняет команду и выдает в стандартный поток диагностики сообщение о том, сколько времени заняло выполнение:

$ time wc ch3.1

931 4288 22691 ch3.1

Язык shell — действительно язык программирования: в нем есть переменные, циклы, ветвления и т.п. Здесь мы обсудим основные циклы, а структуры управления рассмотрим более подробно в гл. 5.

Типичным считается цикл по последовательности имен файлов, и оператор for языка shell является единственной структурой управления, которую обычно задают с терминала, а не помещают в файл для последующего выполнения. Синтаксис оператора for таков:

for перем in список_слов

do

 команды

done

Например, для получения эха имен файлов по одному на строке достаточно задать:

$ for i in *

> do

>  echo $i

> done

Вместо i можно применять любую переменную языка shell, но это обозначение традиционно. Заметьте, что значение переменной получается с помощью $i, однако в заголовке цикла переменную указывают как i. Мы задействовали * для выбора всех файлов текущего каталога, но можно использовать и любой другой список аргументов. Обычно нужно сделать что-нибудь более интересное, чем печать имен файлов. Нам часто приходилось сравнивать набор файлов с их предыдущими версиями, например старую версию гл. 2 (хранимую в каталоге old) с текущей:

$ ls ch2. * | 5

ch2.1 ch2.2 ch2.3 ch2.4 ch2.5

ch2.6 ch2.7

$ for i in ch2.*

> do

>  echo $i

>  diff -b old/$i $i

> echo Добавим пустую строку для красоты

> done | pr -h "diff `pwd`/old `pwd` | lpr &

3712   Номер процесса

$

Выходной поток направлен по конвейеру через команды pr и lpr просто для того, чтобы показать, что это возможно: стандартный выходной поток программ, находящихся внутри цикла for, попадает в стандартный выходной поток самой команды for. С помощью флага -h в команде pr мы поместили в выходной поток заголовок с "архитектурными излишествами", используя два вложенных обращения к pwd. Вся последовательность команд запущена асинхронно (&), так что не нужно ждать ее окончания; & применяется ко всякому циклу и конвейеру.

Мы предпочитаем указанный формат для цикла for, но вы можете сократить его. Единственное ограничение заключается в том, что do и done распознаются как ключевые слова, только если они появляются сразу после перевода строки или точки с запятой. В зависимости от размера цикла for иногда лучше помещать все на одной строке:

for i in список; do команды; done

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

# Плохая идея:

for i in $*

do

 chmod +x $i

done

Предпочтительнее сделать так:

chmod +x $*

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

for i in *

в которой цикл выполняется по всем именам файлов текущего каталога, и

for i in $*

в которой цикл выполняется по всем аргументам командного файла.)

Список аргументов для цикла for часто получают путем выбора имен файлов по шаблону, но можно получать и любым другим способом, в частности:

for i in `cat ...`

или просто вводом аргументов. Например, ранее в этой главе мы создали ряд программ для печати в несколько столбцов под именами 2, 3 и т.д. Они являются связями с одним файлом, которые можно установить следующим образом (при условии, что программа 2 написана):

$ for i in 3 4 5 6; do ln 2 $i; done

$

Цикл for имеет и более интересное назначение. Выберем с помощью команды pick те файлы, которые будут сравниваться с файлами из каталога старых версий:

$ for i in `pick ch2.*`

> do

>  echo $i:

>  diff old/$i $i

> done | pr | lpr

ch2.1? y

ch2.2

ch2.3

ch2.4? y

ch2.5? y

ch2.6?

ch2.7?

$

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

Чтобы лучше понять, как создаются командные файлы, обратимся к такому примеру. Предположим, вы получили почту от приятеля с другой машины: "где-то!боб" (Существует несколько вариантов обозначений для адресата на другой машине. Наиболее общим является следующее: машина!пользователь[10]. См. справочное руководство по mail(1)), и он хотел бы скопировать командные файлы из вашего каталога bin. Самый простой способ их пересылки заключается в ответной почте, так что вы могли бы начать вводить:

$ cd /usr/you/bin

$ for i in `pick *`

> do

>  echo ============== Это файл $i ==============

>  cat $i

> done | mail где-то!боб

$

Однако посмотрим на это с точки зрения адресата "где-то!боб": он должен получить почту, в которой все файлы четко разделены, но ему придется воспользоваться редактором для разбивки сообщений на отдельные файлы. Для того чтобы адресату ничего не надо было делать, почтовое сообщение, построенное подходящим образом, должно автоматически распаковать себя, а значит, оно должно быть командным файлом, содержащим и сами файлы, и операции по их распаковке. Вторая идея заключается в том, что конструкция языка shell "документ здесь" является удобным способом задания информации для команды при ее запуске. Тогда остальная часть задачи сводится к тому, чтобы правильно расставить кавычки. Ниже приведена работающая программа bundle, которая группирует файлы в выходной поток самодокументированного командного файла:

$ cat bundle

# bundle: группирует файлы в распределенный пакет

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

Интерпретатор дает вам такие средства, как циклы, переключение ввода-вывода с помощью < и >, порождение имен файлов с помощью *, причем применение этих средств единообразно во всех программах. Некоторые средства, например командные файлы и программные каналы, на самом деле обеспечиваются ядром, но язык shell предоставляет естественную запись для их создания. Они не только удобны, но и увеличивают мощность системы в целом.

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

В гл. 5 мы вернемся к теме программирования на языке shell, а пока запомните: вне зависимости от того, как вы работаете с интерпретатором, вы программируете на его языке (чем в основном и объясняются его достоинства).

Существует большое число программ UNIX, которые читают входной поток, выполняют простые операции над ним и записывают результат в выходной поток. Примерами могут служить программы grep и tail, выбирающие часть входного потока, sort, сортирующая его, wc, производящая подсчет в нем, и т.д. Такие программы называются фильтрами.

В настоящей главе обсуждаются наиболее часто используемые фильтры. Первой мы рассмотрим программу grep, сосредоточившись на более сложных шаблонах, чем описанные в гл. 1, а затем две другие родственные программы — egrep и fgrep. Далее вы познакомитесь с еще несколькими полезными фильтрами, включая tr, который предназначен для транслитерации символов, dd, предназначенный для работы с данными, полученными из других систем, и uniq — для обнаружения повторяющихся строк. Приводится дополнительная информация и о программе sort.

Конец главы посвящен двум преобразователям данных общего назначения, или программируемым фильтрам. Они называются так потому, что конкретное преобразование записывается как программа на некотором простом языке программирования. Различные программы могут породить совершенно разные преобразования. Речь идет здесь о программах sed ("stream editor" — потоковый редактор) и awk, имя которой составлено из начальных букв имен ее авторов. Обе программы получаются путем обобщения команды grep:

$ программа шаблон-действие имена_файлов...

которая сканирует последовательность файлов, ведя поиск строк, совпадающих с шаблоном, — если строка найдена, выполняется необходимое действие. Для команды grep, как и для редактора ed, шаблоном является регулярное выражение, а действие по умолчанию сводится к печати каждой строки, соответствующей шаблону.

В программах sed и awk обобщаются и шаблоны, и действия. Команда sed, производная от ed, выполняет "программу", состоящую из команд редактирования. Она пропускает данные из файлов через эту программу, выполняя для каждой строки команды из программы. Команда awk не так удобна, как sed, для манипуляций с текстом, но в ней предусмотрены арифметические операции, переменные, встроенные функции и язык программирования, схожий с Си. В данной главе не приводится полное описание обеих программ; оно есть в т. 2B справочного руководства по UNIX.

В гл. 1 мы кратко упомянули о команде grep, а затем использовали ее в примерах. Конструкция

$ grep шаблон имена_файлов

проводит поиск в поименованных файлах или в стандартном входном потоке и выводит на печать каждую строку, в которую входит шаблон. Команда grep неоценима для поиска переменных в программах и слов в документах, а также для выбора части выходного потока программы:

$ grep -n variable *.[гл]           Поиск variable в тексте на Си

$ grep From $MAIL                   Печать заголовков сообщений из почтовой

посылки

$ grep From $MAIL | grep -v mary    Заголовки, которые получены не от

адресата mary

$ grep -y mary $HOME/lib/phone-book Поиск номера mary

$ who | grep mary                   Выяснить, работает ли mary в системе

$ ls | grep -v temp                 Имена файлов, не содержащих temp

Флаг -n инициирует вывод номеров строк, флаг -v меняет на противоположное значение условия, а флаг -y допускает сопоставление строчных букв из шаблона с прописными буквами из файла (но прописные буквы все-таки могут сопоставляться только с прописными).

Во всех рассматривавшихся до сих пор примерах проводился поиск обычных строк из букв и чисел. Но команда grep может искать и более сложные шаблоны: она интерпретирует выражения согласно простому языку для описания строк. С технической точки зрения шаблон представляет в некоторой степени ограниченную форму спецификаций строк, называемую регулярным выражением. Команда интерпретирует такие же регулярные выражения, как и редактор ed. На самом деле, эта команда была создана (за один вечер) прямым редактированием ed.

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

Таблица 4.1: Регулярные выражения grep и egrep (в порядке убывания приоритета)

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

Рассмотрим сначала программу sort, как наиболее часто используемую. В гл. I было указано ее назначение: сортировка входного потока по строкам в порядке, задаваемом множеством ASCII. Хотя это очевидный порядок для сортировки по умолчанию, существует множество других полезных способов сортировки данных, и программа sort пытается удовлетворить всех, предоставляя множество различных флагов. Например, флаг -f устраняет различие между прописными и строчными буквами, флаг -d (словарный порядок) игнорирует при сравнении все символы, кроме букв, цифр и пробелов.

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

$ ls | sort -f     Сортировка имен файлов в алфавитном порядке

$ ls -s | sort -n  Сортировка в порядке возрастания размеров файлов

$ ls -s | sort -nr Сортировка в порядке убывания размеров файлов

Программа sort обычно сортирует целые строки, но ее можно заставить работать только с определенными полями. Обозначение +m показывает, что при сравнении пропускается m полей, а +0 обозначает начало строки, например:

$ ls -l | sort +3nr Сортировка по счетчику байтов в порядке убывания

размеров

$ who | sort +4nr   Сортировка по времени входа в систему, в порядке

возрастания размеров файлов

Еще одним полезным флагом программы является -о, задающий имя файла для выходного потока (это может быть один из входных файлов), и флаг -u, который удаляет все, за исключением одной из строк, совпадающих в сортируемых полях. Можно использовать несколько флагов, как показано в примере на странице sort(1) справочного руководства:

$ sort +0f +0 -u filenames

здесь флаг +0f сортирует строку, совмещая строчные и прописные буквы, но идентичные строки могут не быть соседними. Поэтому вводится второй флаг +0, который сортирует одинаковые строки после первой сортировки в обычном порядке ASCII. Наконец, флаг -u выбрасывает все, кроме одной из соседних повторяющихся строк. Таким образом, получив список слов по одному в строке, команда выдает неповторяющиеся слова. Указатель для этой книги был подготовлен с помощью сходной команды sort, обладающей еще большими возможностями (см. руководство по sort(1)).

Создание команды uniq явилось стимулом для введения флага -u в команде sort: флаг отбрасывает все строки, кроме одной, из группы соседних повторяющихся строк. Выведение отдельной программы для этой операции позволяет выполнять ее независимо от сортировки. Например, uniq удалит повторяющиеся пустые строки, независимо от того, сортируется входной поток или нет. Флаги предусматривают специальные способы обработки повторяющихся строк: uniq -d печатает только повторяющиеся строки, uniq -u — только уникальные, т.е. неповторяющиеся строки; uniq -c подсчитывает число вхождений каждой строки, в чем вскоре вы убедитесь на примере.

Программа comm служит для сравнения файлов. Получив два отсортированных входных файла f1 и f2, она выдает выходной поток в три столбца: строки, встречающиеся только в f1, строки, встречающиеся только в f2, и строки, встречающиеся в обоих файлах. С помощью флага можно убрать любой из этих столбцов:

$ comm -12 f1 f2

выдает только строки, содержащиеся в обоих файлах, а

$ comm -23 f1 f2

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

Команда tr проводит транслитерацию символов своего входного потока. Наиболее часто они используются для преобразования строчных букв в прописные и обратно:

$ tr a-z A-Z Перевести строчные буквы в прописные

$ tr A-Z a-z Перевести прописные буквы в строчные

Несколько отличается от всех рассмотренных выше команд dd. Эта команда предназначена прежде всего для обработки данных на магнитной ленте, полученных из других систем — само ее название служит напоминанием о языке управлений заданиями OS/360. Команда dd выполняет преобразование прописных букв в строчные, и наоборот (в нотации, отличной от нотации команды tr). Она осуществляет перевод из множества символов ASCII в EBCDIC, и наоборот; может читать и писать данные в формате записей фиксированного размера с дополнением пробелами, что характерно для отличных от UNIX систем. На практике команду dd часто используют для работы с исходными неотформатированными данными, откуда бы они ни были получены; она реализует набор средств для работы с двоичными данными.

Посмотрим, чего можно достичь с помощью взаимодействия фильтров на примере конвейера, который печатает 10 наиболее часто встречающихся во входном потоке слов:

cat $* |

tr -sc A-Za-z '\012' | Сжимаем все небуквы в перевод строки

sort |

uniq -с |

sort -n |

tail |

5

Команда cat собирает файлы, поскольку tr может читать только стандартный входной поток. Команда tr действует, как указано в справочном руководстве: она сжимает соседние, отличные от букв, символы в символы перевода строк, преобразуя таким образом входной поток в строки из одного слова. Затем слова сортируются и с помощью uniq -с каждая группа идентичных слов сжимается в одну строку, начинающуюся со счетчика, который используется как сортируемое поле в команде sort -n. (Эта последовательность двух команд сортировки, между которыми находится команда uniq, применяется так часто, что уже стала идиомой.) В результате получаются неповторяющиеся слова, отсортированные в порядке возрастания частоты появления в документе. Команда tail отбирает 10 наиболее часто встречающихся слов (т.е. конец отсортированного файла) и команда 5 печатает их в пять столбцов.

Заметьте, кстати, что введение символа | в конце строки — это законный способ ее продолжения.

Вернемся теперь к редактору sed. Поскольку он происходит непосредственно от ed, вы легко изучите его и закрепите свои знания о редакторе ed. Основа редактора sed проста:

$ sed 'список команда ed' имена_файлов...

Читаются строки по одной из входных файлов; команды из списка применяются к каждой строке по одной в указанном порядке и результат редактирования записывается в стандартный выходной поток. Например, можно заменить в любом из указанных файлов UNIX на UNIX (TM) с помощью команды:

$ sed 's/\UNIX/\UNIX\ (TM)/g' имена_файлов...> выходной поток

Нужно правильно понимать действие команды. Она не изменяет содержимое своих входных файлов, а лишь пишет в стандартный выходной поток; исходные же файлы не изменяются. Вы уже достаточно разобрались в интерпретаторе, чтобы понять, что

$ sed '...' файл > файл

не лучшее решение: для замены содержимого файлов нужно задействовать временный файл или другую программу. В дальнейшем мы рассмотрим программу, реализующую задачу записи в существующий файл; обратитесь к команде overwrite в (гл. 5).

Редактор sed выдает все строки автоматически, поэтому команда p не нужна после ввода команды замены, приведенной выше; более того, если она задается, то каждая изменяемая строка печатается дважды. Однако кавычки необходимы почти всегда, поскольку многие метасимволы программы sed имеют специальные значения и для интерпретатора. Рассмотрим, например, команду du -а, порождающую список имен файлов. Обычно она выдает размер и имя файла:

$ du -a ch4*

18 ch4.1

13 ch4.2

14 ch4.3

17 ch4.4

 2 ch4.9

$

Можно использовать sed, чтобы отбросить размеры файлов, но в команде редактирования нужны кавычки для защиты символов * и табуляции от обработки интерпретатором:

$ du -a ch4.* | sed 's/.*→//'

ch4.1

ch4.2

ch4.3

ch4.4

ch4.9

$

В команде замены удаляются все символы (.*) до крайнего правого символа табуляции включительно (он показан в шаблоне как →). Аналогичным способом можно выделить из вывода команды who имена пользователей и время входа в систему:

$ who

lr  tty1 Sep 29 07:14

ron tty3 Sep 29 10:31

you tty4 Sep 29 08:36

td  tty5 Sep 29 08:47

$ who | sed 's/ .* / /'

lr  07:14

ron 10:31

you 08:36

td  08:47

$

Команда s заменяет пробел и все, что следует за ним (максимально возможно, включая дополнительные пробелы) до следующего пробела на единственный пробел. Кавычки нужны.

Почти такую же команду sed можно использовать, чтобы создать программу getname, возвращающую имя пользователя:

$ cat getname

who am i | sed 's/ .*//'

$ getname

you $

Другая команда sed применяется настолько часто, что мы поместили ее в командный файл с именем ind. Эта команда вставляет пробелы до шага табуляции; она удобна для лучшего расположения текста при печати.

Реализовать команду ind просто: достаточно установить символ табуляции в начале каждой строки:

$ sed 's/^/→/' $* Первая версия ind

В этой версии символ табуляции вставляется даже в пустую строку, что не требуется. В лучшей версии используется возможность sed выбирать строки для модификации. Если команде предшествует шаблон, то изменяться будут только строки, соответствующие шаблону:

sed '/./s/^/→/' $* Вторая версия

Шаблон /./ задает любую строку, в которой есть по крайней мере один символ, кроме символа перевода строки, поэтому команда s не выполняется для пустых строк. Вспомним, что sed выдает все строки, независимо от того, менялись они или нет, так что пустые строки по-прежнему выдаются.

Есть еще один способ определения команды ind. Можно выполнять команды только для тех строк, которые не соответствуют выбираемому шаблону, предварив команду знаком восклицания '!'. В команде

sed '/^$/!s/^/→/' $* Третья версия

шаблон /^$/ задает пустые строки (перевод строки сразу следует за ее началом), поэтому /^$/! предписывает не выполнять команду для пустых строк.

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

sed 3q

Хотя 3q не является законной командой ed, для sed она имеет смысл: копировать строки и завершить выполнение после третьей.

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

sed 'S/^/→/

3q'

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

Представляется естественным с помощью рассмотренных выше приемов составить программу head, которая будет печатать несколько строк из каждого своего файла-аргумента. Но sed 3q (или 10q) настолько просто задать, что в этом никогда не возникало потребности. Однако мы ввели команду ind, так как соответствующая последовательность для sed длиннее. (В процессе работы над книгой мы заменили существовавшую программу на языке Си в 30 строк на одну строку команды ind версии 2, приведенной выше.) Четкого критерия в отношении того, когда имеет смысл создавать отдельную программу из сложной командной строки, нет, поэтому мы предлагаем вам свое решение: поместите программу в свой каталог /bin и посмотрите, будете ли вы ее действительно применять.

Можно помещать команды редактора sed в файл и выполнять их, получая оттуда с помощью обращения:

$ sed -f командный_файл

Вы можете обращаться к строкам, используя не только их номера. Так, команда

$ sed '/шаблон/q'

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

$ sed '/шаблон/d'

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

Хотя автоматический вывод обычно удобен, иногда он мешает. Его можно отключить с помощью флага -n; в этом случае в выходном потоке появятся только строки, задаваемые явной командой вывода p. Например,

$ sed -n '/шаблон/p'

эквивалентен команде grep. Условие сопоставления можно инвертировать, если завершить его символом !, поэтому

$ sed -n '/шаблон/!p'

эквивалентно команде grep -v. (Так же, как sed '/шаблон/d'.)

Для чего нужны две команды sed и grep? В конце концов, grep — всего лишь частный случай команды sed. Это в какой-то степени объясняется историческими причинами: команда grep появилась намного раньше, чем команда sed. Но она не только уцелела, но и активно применялась. В силу специфики назначения обеих команд grep значительно проще использовать, чем команду sed, так как ее использование в типичных ситуациях настолько лаконично, насколько возможно (к тому же у нее есть возможности, отсутствующие у команды sed; см., например, описание флага -b). Но все-таки программы могут "умирать". Когда-то была программа с именем gres, выполняющая простую подстановку, но она исчезла почти мгновенно, когда появилась команда sed.

Используя запись, такую же, как в редакторе ed, можно вставлять символы перевода строк с помощью команды sed:

$ sed '/$/\

> /'

Здесь добавляется символ перевода строки к каждой строке, и таким образом пустые строки вставляются во входной поток, а команда

$ sed 's/[→][→]*/\

>/g'

заменяет каждую последовательность пробелов или символов табуляции на символ перевода строки, т. е. разбивает входной поток на строки из одного слова. (Регулярное выражение '[→]' задает пробел или символ табуляции, '[→]*' задает нуль или более таких символов, а весь шаблон — один или более пробелов и/или символов табуляции.)

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

$ sed -n '20,30p'       Печать только строк с 20-й по 30-ю

$ sed '1,10d'           Удаление строк с 1-й до 10-й (=tail +11)

$ sed '1,/^$/cd'        Удаление всех строк до первой пустой включительно

$ sed -n '/^$/,/^end/p' Печать всех групп строк, начиная от пустой строки до

строки, начинающейся с end

$ sed '$d'              Удаление последней строки

Строки нумеруются с начала входного потока; обнуление не происходит с началом нового файла.

У команды sed есть существенное ограничение, которое, однако, отсутствует в редакторе ed: в ней поддерживается относительная нумерация строк. В частности, операции + и - не действуют в выражениях, задающих номера строк, поэтому невозможно двигаться назад во входном потоке:

$ sed '$-1d' Недопустима обратная адресация

Unrecognized command: $-1d

$

Если строка считана, предыдущая исчезла навсегда: нет способа специфицировать предыдущую строку, а именно это требуется в команде. В принципе такой способ есть в команде sed, но он слишком изощренный. (См. команду hold в справочном руководстве по UNIX.) Невозможна и относительная прямая адресация:

$ sed '/что-то/+1d' Недопустима прямая адресация

Редактор sed имеет возможность записывать в несколько выходных файлов. Например, команда

$ sed -n '/шабл/w файл1

> /шабл/!w файл2' имена_файлов...

$

записывает строки, соответствующие "шабл", в файл1, а не соответствующие — в файл2, или, если вернуться к нашему первому примеру:

$ sed 's/\UNIX(TM)/gw u.out' имена_файлов...> выход

то здесь, как и ранее, весь выходной поток записывается в файл "выход", но к тому же измененные строки записываются в файл u.out.

Иногда нужна помощь со стороны интерпретатора, чтобы в команду редактора включить аргументы командного файла. Одним из примеров служит программа newer, которая выдает все более новые, чем заданный, файлы каталога:

$ cat newer

# newer f: список файлов, созданных после f

ls -t | sed '/'$1'$/q'

$

Кавычки защищают различные специальные символы, предназначенные для редактора, оставляя $1 открытым для интерпретатора, чтобы он заменил его на имя файла. Существует альтернативный способ записи аргумента:

"/^$1\$/q"

так как $1 заменяется на аргумент, тогда как \$ становится просто $.

Аналогично можно составить программу older, которая выдает в качестве параметра все файлы, более старые, чем заданный:

$ cat older

# older f: список файлов, созданных ранее f

ls -tr | sed '/'$1'$/q'

$

Единственное различие состоит в применении флага -r в команде ls для изменения порядка выдачи файлов.

Хотя редактор sed способен на гораздо большее, чем мы вам продемонстрировали, включая проверку условий, циклы и ветвления, запоминание предыдущих строк, и, конечно, в нем допустимы многие команды редактора ed, описанные в приложении 1. Тем не менее в основном sed используется так, как было показано; одна или две простые команды редактирования, а не длинные и сложные последовательности. В табл. 4.2 собраны некоторые команды sed, хотя и не приведены операции над несколькими строками.

Таблица 4.2: Сводка команд sed

Некоторые ограничения sed преодолены в программе awk. Принцип работы этой программы сходен с принципом работы программы sed, но синтаксически она ближе к языку программирования Си, чем к текстовому редактору. Способ задания команды такой же, как и для sed:

$ awk 'программа' имена_файлов...

но программа другая:

шаблон {действие}

шаблон {действие}

...

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

Шаблоны могут быть регулярными выражениями в sed или более сложными условиями, напоминающими язык Си. Приведем простой пример (такого же результата можно добиться с помощью команды egrep):

$ awk '/регулярное_выражение/ {print}' имена_файлов...

Печатается каждая строка, соответствующая регулярному выражению.

Шаблоны или действия могут отсутствовать. Если отсутствует действие, то по умолчанию печатаются строки, соответствующие шаблону, поэтому команда

$ awk '/регулярное_выражение/' имена_файлов...

эквивалентна предыдущей. Наоборот, если отсутствует шаблон, то действие выполняется для каждой входной строки. Следовательно, команда

$ awk '{print}' имена_файлов...

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

Теперь перейдем к более интересным примерам, но прежде сделаем одно замечание. Как и в случае sed, программу команды awk можно получать из файла:

$ awk -f кмд файл имена_файлов...

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

$ who

you tty2 sep 29 11:53

jim tty4 sep 29 11:27

$

Поля обозначаются как $1, $2, …, $NF, где NF — переменная, значение которой установлено равным числу полей. В нашем случае NF=5 для обеих строк. (Учтите разницу между NF, числом полей и $NF — последним полем строки. В отличие от интерпретатора в программе awk только номера полей начинаются с $; переменные не имеют такого префикса.) Например, следующая команда выдаст поле "размер файла" из результата выполнения команды du -а

$ du -a | awk '{print $2}'

а для печати имен пользователей, работающих в системе, и времени входа нужно задать:

$ who awk '{print $1, $5}'

you 11:53

jim 11:27 $

Для печати имени и времени входа в систему, упорядоченных по времени, зададим:

$ who awk '{print $5, $1}' | sort

11:27 jim

11:53 you

$

Это альтернативные решения примеров, приведенных выше в данной главе, в которых использовалась команда sed. Хотя с программой awk проще работать в подобных случаях, она обычно выполняется медленнее как в начальной фазе, так и при большом входном потоке.

Обычно предполагается, что поля разделяются произвольным числом пробелов и символов табуляций, но можно определить в качестве разделителя любой одиночный символ. Один из способов состоит в задании в командной строке флага -F (здесь прописная буква). Например, поля в файле паролей /etc/passwd разделяются двоеточиями:

$ sed 3q /etc/passwd

root:3D.fHR5KoB.3s:0:1:S.User:/:

ken:y.68wdl.ijayz:6:1:K.Thompson:/usr/ken:

dmr:z4u3dJWbg7wCk:7:1:D.M.Ritchie:/usr/dmr:

$

Для печати имен пользователей, образующих первое поле, можно задать:

$ sed 3q /etc/passwd | awk -F : '{print $1}'

root

ken

dmr

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

В программе awk, помимо числа входных полей, доступна и другая интересная информация. Встроенная переменная NR хранит номер текущей входной "записи", т.е. строки. Поэтому для вставки номера строки перед строкой входного потока достаточно задать:

$ awk '{print NR, $0}'

Поле $0 обозначает всю входную строку без изменений. В операторе print фрагменты, отделяемые запятой, печатаются через символы разделения полей выходного потока, которые по умолчанию служат пробелами.

Формат печати оператора print обычно является приемлемым. При несоответствующем формате используйте оператор printf, обеспечивающий полный контроль над выходным потоком. Например, для печати номеров строк в поле размером в четыре цифры можно задать такую команду:

$ awk '{printf "%4d %s\n", NR, $0}'

Выражение %4 задает десятичное целое число (NR) в поле размером в четыре цифры, %S — строка символов ($0), \n — символ перевода строки, который нужен потому, что оператор printf не выдает автоматически пробелы или символы перевода строк. Оператор printf сходен с аналогичной Си функцией (см. справочное руководство по printf(3)).

Мы могли бы определить программу ind (рассматривавшуюся в начале главы) следующим образом:

$ awk '{printf "\t%s\n", $0}' $*

Здесь выдается символ табуляции (\t) и входная строка.

Предположим, что вы хотите найти в файле /etc/passwd пользователей, не имеющих пароля. Зашифрованный пароль находится во втором поле, поэтому программа состоит из одного шаблона:

$ awk -F: '$2 == ""' /etc/passwd

Шаблон проверяет, является ли второе поле пустой строкой (операция == — это проверка на равенство).

Такой шаблон можно задать различными способами:

$2==""          Второе поле пусто

$2~/^$/         Второе поле соответствует пустой строке

$2!~/./         Второе поле не содержит ни одного символа

length($2) == 0 Длина второго поля равна нулю

Символ ~ обозначает соответствие регулярному выражению, а символ ! — отсутствие соответствия. Само регулярное выражение заключено в символы дробной черты.

Встроенная функция length программы awk вычисляет длину строки символов. Шаблону может предшествовать символ ! для отрицания его, например,

!($2=="")

Операция ! подобна такой же операции в языке Си, но в редакторе sed эта операция следует за шаблоном.

Наиболее типичное использование шаблонов в программе awk сводится к задачам простой проверки данных. Большинство из них немногим сложнее, чем поиск строк, не удовлетворяющих какому-то критерию; если нет выходного потока, то считается, что данные удовлетворяют соответствующему критерию (по принципу "отсутствие новостей — хорошая новость"). Например, в следующем шаблоне проверяется с помощью операции %, вычисляющей остаток от деления, четно или не четно число полей в каждой входной строке:

$ NF % 2 != 0 # напечатать, если нечетное число полей

Другой шаблон выдает исключительно длинные строки, используя встроенную функцию length:

length ($0) >72 # напечатать, если слишком длинная строка

В программе awk используется то же соглашение о комментарии, что и в интерпретаторе: символ # отмечает начало комментария.

Можно сделать выходной поток более информативным, снабдив его предупреждающим сообщением и частью слишком длинной строки, используя для этого встроенную функцию substr:

length($0) > 72 {print "Строка", NR, "длинная" : substr($0, 1, 60)}

Функция substr(s, m, n) выделяет подстроку из строки s, начинающуюся с символа с номером m и длиной в n символов. (Символы в строке нумеруются с 1.) Если n отсутствует, то берется подстрока от m до конца строки. Эту функцию можно использовать для выделения полей с фиксированным положением, например выделить время в часах и минутах из результата выполнения команды date:

$ date

Thu Sep 29 12:17:01 EDT 1983

$ date | awk '{print substr($4, 1, 5) }'

12:17

$

Программа awk имеет два специальных шаблона BEGIN и END. Действия, соответствующие BEGIN, выполняются прежде, чем читается первая входная строка; можно использовать этот шаблон для инициации переменных, печати заголовков или для установки символа разделителя полей, присваивая его переменной FS.

$ awk 'BEGIN { FS = ":" }

> $2 == "" ' /etc/paswd

$ Результата нет: все работают с паролями

Действия, указанные в шаблоне END, выполняются после обработки последней входной строки:

$ awk 'END {print NR}'...

Здесь печатается число строк входного потока.

До сих пор в примерах выполнялись только простые операции с текстом. Достоинством программы awk является ее возможность попутно проводить вычисления над входными данными: что-нибудь подсчитать, вычислить суммы и средние значения и т.п. Типичный пример таких вычислений — подсчет суммы столбца чисел. Так, следующая команда складывает все числа первого столбца

{s=s+$1}

END {print s}

Поскольку число значений доступно с помощью переменной NR, изменив последнюю строку на

END {print s, s/NR}

мы получим и сумму, и среднее значение.

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

В программе awk есть такие же сокращенные формы арифметических операторов, как и в языке Си, поэтому естественная запись примера имела бы вид:

{s+=$1}

END {print}

Запись s+=$1 равноценна записи s=s+$1, но более компактна. Можно обобщить пример по подсчету входных строк:

    { nc+=length($0) +1 # число символов, +1 для \n

     nw += NF           # число слов

    }

END {print NR, nw, nc }

Здесь подсчитывается число строк, слов и символов входного потока, т.е. выполняются те же действия, что и по команде wc (хотя она и не разбивает общую сумму по файлам).

В качестве другого примера выполнения арифметических операций рассмотрим программу, подсчитывающую число страниц по 66 строк в каждой. Страницы получаются при прогоне несколько файлов через команду pr. Это можно оформить в виде команды prpages:

$ cat prpages

# prpages: подсчет числа страниц, выдаваемых pr

wc $* |

awk '!/total$/ { n += int(($1+55)/56) }

     END       { print n }'

$

Команда pr помещает на каждую страницу 56 строк текста (это число определяется эмпирически). Для каждой строки вывода команды wc, которая не содержит слово total в конце строки, число страниц округляется, а затем выделяется целая часть с помощью встроенной функции int.

$ wc ch4.*

 753  3090 18129 ch4.1

 612  2421 13242 ch4.2

 637  2462 13455 ch4.3

 802  2986 16904 ch4.4

  50   213  1117 ch4.9

2854 11172 62847 total

$ prpages ch4.*

53

$

Для проверки этого результата запустим команды pr и awk одновременно:

$ pr ch4.* | awk 'END {print NR/66}'

53

$

Переменные программы awk могут также хранить строки символов. Рассматривать ли переменную как число или как строку символов — зависит от контекста. Грубо говоря, в арифметических выражениях типа s+=$1 используется числовое значение в контексте операций со строками типа x=="abc" — строковое значение в неясных случаях, например x>y, — строковое значение, если только операнды не являются явно числовыми. (Правила четко сформулированы в справочном руководстве по применению команды awk.) Строковые переменные инициируются пустой строкой. В последующих разделах строки будут активно использоваться.

В программе awk есть несколько своих встроенных переменных обоих типов, таких, как NR и FS. Их полный список приведен в табл. 4.3, а в табл. 4.4 перечислены операции, выполняемые командой.

Таблица 4.3: Встроенные переменные awk

Несмотря на то что в качестве примеров использования языка awk приводились независимые программы, в большинстве случаев его применяют для написания простых программ в одну или две строки, являющихся фильтрами в больших конвейерах. Это справедливо для большинства фильтров: редко поставленная задача может быть решена с помощью одного фильтра, чаще она разбивается на подзадачи, где фигурируют несколько фильтров, объединенных в конвейер. Такую реализацию программных компонентов называют основным принципом организации программного мира UNIX. Фильтры буквально "пронизывают" всю систему, и очень важно понимать причины этого.

Программы UNIX выдают выходной поток в таком формате, что его можно использовать в качестве входного потока для других программ. Файлы, пропускаемые через фильтр, состоят из строк текста, свободных от декоративных заголовков, завершителей или пустых строк. Каждая строка представляет интерес — это имя файла, слово, описатель выполняемого процесса, поэтому программы типа wc или grep могут рассчитывать определенные характеристики объектов или искать их по именам. Если о каждом объекте имеется большая информация, файл все равно состоит из строк, разбиваемых на поля пробелами или символами табуляции, как в выводе команды ls -l. Располагая данными, разбитыми на такие поля, программы типа awk могут легко выбрать, обработать или переупорядочить информацию.

Фильтры построены по общей схеме. Каждый из них пишет в стандартный выходной поток результат обработки файлов-аргументов или стандартного выходного потока, если аргументов нет. Аргументы задают входной поток и никогда не задают выходной[11] , поэтому выходной поток команда всегда может передать в конвейер. Необязательные аргументы (или аргументы, не являющиеся файлами, такие, как шаблон в команде grep) задаются перед именем файлов. Наконец, сообщения об ошибках пишутся в стандартный поток диагностики, поэтому они не могут исчезнуть в конвейере.

Эти соглашения не оказывают большого влияния на программы пользователя, но единообразное применение их ко всем программам обеспечивает простоту взаимодействия, что подтверждается многочисленными примерами на протяжении всей книги и наиболее наглядно продемонстрировано программой подсчета слов в конце разд. 4.2. Если каким-либо программам потребуется входной или выходной файл с конкретным именем, определенное обращение для спецификации параметров или создание заголовков и завершений, то схема конвейера работать не будет. И конечно, если бы система UNIX не предоставляла программные каналы, кому-то пришлось создать подобное стандартное средство. Однако программные каналы есть, и конвейеры работают. Их даже можно запрограммировать, но для этого вы должны знать возможности системы.

Большинство пользователей считают, что shell представляет собой диалоговый интерпретатор команд. На самом же деле это язык программирования, в котором каждый оператор инициирует запуск команды. Язык shell может показаться вам несколько странным, поскольку в нем находят отражение и диалоговый, и программный аспекты выполнения команд. Он формировался по плану, хотя и имеет свою историю. Разнообразие применений языка привело к некоторой незавершенности в деталях, но для его эффективного использования вам и не нужно разбираться во всех нюансах. В данной главе мы рассмотрим основы программирования с помощью shell на примерах разработки ряда полезных программ. При изучении материала желательно иметь под рукой страницу sh(1) справочного руководства по UNIX.

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

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

Типичная задача программирования на языке shell сводится к изменению взаимодействия между пользователем и программой, чтобы сделать это взаимодействие более удобным. В качестве примера рассмотрим команду cal(1):

$ cal

usage: cal [month] year Пока хорошо

$ cal october

Bad argument            Уже не так хорошо

$ cal 10 1983

  October 1983

  S  M  Tu W  Th F  S

                    1

  2  3  4  5  6  7  8

  9 10 11 12 13 14 15

 16 17 18 19 20 21 22

 23 24 25 26 27 28 29

 30 31

$

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

Указанные выше неудобства связаны с тем, что взаимодействие пользователя с программой было реализовано без привлечения команды cal. Вы можете изменить характер этого взаимодействия, не меняя самой программы. Если поместить команду в ваш собственный каталог bin, то возможен более удобный способ перевода аргументов в те, которые нужны настоящей команде cal. Вы можете даже вызывать свою версию команды, и тогда вам меньше придется запоминать.

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

Язык shell имеет оператор case, который успешно применяется в таких ситуациях:

case слово in

шаблон) команды ;;

шаблон) команды ;;

...

esac

В операторе case слово сравнивается поочередно со всеми шаблонами от начала до конца и выполняются команды, связанные с первым (и только первым) шаблоном, соответствующим слову. Шаблоны составляются по правилам соответствия шаблонов, которые в некоторой степени обобщают правила задания имен файлов. Каждое действие завершается двумя символами ;; (для последнего варианта можно обойтись без ;;, но обычно мы ставим их для удобства редактирования).

В нашей версии команды определяется число заданных аргументов, обрабатываются названия месяцев, затем происходит обращение к настоящей команде cal. В переменной интерпретатора $# хранится число аргументов, с которыми была вызвана программа; другие специальные переменные интерпретатора перечислены в табл. 5.1.

Таблица 5.1: Встроенные переменные интерпретатора

При обзаведении собственными версиями команд, аналогичных cal, возникает ряд трудностей. В частности, когда вы работаете как пользователь Мэри и вошли в систему под именем mary, то, вводя команду cal, получаете стандартную версию команды вместо новой, если, конечно, не установили в своем каталоге bin связь с новой командой cal. Это может привести к путанице: вспомните, что сообщения об ошибках в исходной, команде cal не очень вразумительны. Мы привели всего лишь один пример возникающих трудностей. Поскольку интерпретатор осуществляет поиск команд среди каталогов, задаваемых переменной PATH, всегда есть вероятность столкнуться не с той версией команды, которую вы ожидали. Например, если вы задали команду, скажем echo, имя выполняемого на самом деле файла будет ./echo, /bin/echo, /usr/bin/echo или какое-то другое в зависимости от компонентов вашей переменной PATH и от того, где находятся файлы. Может случиться, что в вашей последовательности поиска ранее, чем вы ожидали, окажется выполняемый файл с правильным именем, но не с теми результатами. Наиболее типичным примером в такой ситуации является команда test, которую мы обсудим позднее. Ее название настолько распространено для временной версии программы, что вызовы "не тех" команд test происходят раздражающе часто[12]. Здесь весьма полезным средством явилась бы команда, которая помогла бы выяснить, какая версия программы должна выполняться.

Один из вариантов решения — цикл поиска по каталогам, указанным в PATH, выполняемого файла с данным именем. В гл. 3 мы использовали цикл for по именам файлов и аргументам. Здесь же нужен такой цикл:

for i in компонента в PATH

do

 если заданное имя в каталоге i

  печать полного путевого имени

done

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

$ echo $PATH

:/usr/you/bin:/bin:/usr/bin 4 компонента

$ echo $PATH | sed 's/:/ /a'

/usr/you/bin /bin /usr/bin  Только три выдано!

$ echo `echo $PATH | sed 's/:/ /g'`

/usr/you/bin /bin /usr/bin  По-прежнему только три

$

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

$ echo $PATH | sed 's/^:/./

>                   s/::/:.:/g

>                   s/:$/:./

>                   s/:/ /g'

. /usr/you/bin /bin /usr/bin

$

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

После задания каталогов в компонентах PATH упомянутая выше команда test(1) может вывести сообщение о том, существует ли файл в каждом каталоге. В принципе команда test — одна из самых "неуклюжих" программ UNIX. Например, команда "test -r файл" проверяет, существует ли файл и можно ли его читать; "test -w файл" проверяет, существует ли файл и можно ли в него писать, но в седьмой версии нет команды test -х (хотя в System V и других версиях есть), а именно она нам и нужна. Мы примем, что обращение "test -f файл" будет проверять, существует ли файл и не является ли он каталогом, т.е. представляет ли он собой обычный файл. Но вам следует обратиться к соответствующей странице справочного руководства, поскольку имеет хождение несколько версий.

Каждая команда вырабатывает код завершения — значение, передаваемое интерпретатору и показывающее, что произошло. Это небольшое целое число, которое устанавливается по соглашению. Так, нуль может означать "истину" (команда успешно завершена), а ненулевое значение трактуется как "ложь" (выполнение команды было неудачным). Обратите внимание на то, что выбранные здесь значения противоположны значениям истины и лжи в языке Си.

Поскольку ложь может представлять множество различных значений, причина неудачи обозначается кодом завершения по лжи. Например, команда grep возвращает 0, если произошло сопоставление, 1 — если сопоставления не было, и 2 — в случае ошибки в шаблоне или именах файлов. Каждая программа возвращает код завершения, хотя обычно нас не интересует его значение. Команда test неординарна: ее единственное назначение состоит в передаче кода завершения. Она ничего не выводит и не изменяет файлы.

Интерпретатор хранит код завершения последней программы в переменной $?:

$ cmp /usr/you/.profile /usr/you/.profile

$ Выдачи нет, файлы совпадают

$ echo $?

0 0 означает успех, файлы идентичны

$ cmp /usr/you/.profile /usr/mary/.profile

/usr/you/.profile /usr/mary/.profile differ: char 6, line 3

$ echo $?

1 He нуль означает, что файлы различны

$

У некоторых команд, таких, как cmp и grep, есть флаг -s, который заставляет их завершить выполнение с определенным кодом, но подавляет вывод. Оператор if языка shell запускает команды в зависимости от кода завершения некоторой команды, а именно:

if команда

then

 команды, если условие верно

else

 команды, если условие ложно

fi

Местоположение символов перевода строк очень важно: fi, then и else распознаются только после символа перевода строки или точки с запятой.

Оператор if всегда запускает команду (условие), тогда как в операторе case сопоставление с шаблоном производится самим интерпретатором. В некоторых версиях UNIX, включая System V, test является встроенной командой интерпретатора, поэтому if и test будут выполняться так же быстро, как и case. Если test — не встроенная команда, то операторы case более эффективны, чем операторы if, и следует использовать именно их для поиска шаблонов;

$ case "$1" in

hello) command

esac

выполняется быстрее, чем

if test "$1"==hello Медленнее, если test не встроенная

then

 command

fi

Это одна из причин, по которой в языке shell иногда для проверки условий применяются операторы case, хотя в большинстве языков программирования использовались бы операторы if. С другой стороны, с помощью оператора case непросто определить, имеется ли право доступа к файлу на чтение; здесь предпочтение следует отдать команде test и оператору if.

Итак, теперь мы готовы воспользоваться первой версией команды which, которая выведет сообщение о том, какой файл соответствует команде:

$ cat which

# which cmd: which cmd in PATH is executed, version 1

В гл. 3 цикл for использовался для нескольких итеративных программ. Обычно цикл for охватывает множество имен файлов, как в 'for i in * .с', или все аргументы командного файла, как в 'for i in $*'. Но циклы в языке shell могут быть более общими, чем в этих идиомах, например цикл for в команде which.

Имеются три вида циклов: for, while и until. Чаще всего используется цикл for. В нем выполняется последовательность команд (тело цикла) для каждого элемента из множества слов. В большинстве случаев множество образуют просто имена файлов. В циклах while и until контроль над выполнением тела цикла осуществляется с помощью кода завершения команды. Тело цикла выполняется до тех пор, пока команда условия не вернет ненулевой код для while или нуль для until. Циклы while и until идентичны, за исключением кода завершения команды.

Ниже приведены основные формы каждого цикла:

for i in список слов

do

 тело цикла, $i последовательно получает значения элементов

done