Идентификатор группы

Как было рассказано в лекции 1, пользователь может быть членом нескольких групп, равно как и несколько пользователей могут быть членами одной и той же группы. Исторически сложилось так, что одна из групп – группа по умолчанию – является для пользователя основной: когда (не вполне точно) говорят о "GID пользователя", имеют в виду именно идентификатор группы по умолчанию. В лекции 12 будет рассказано о том, что GID пользователя вписан в учетную запись и хранится в /etc/passwd, а информация о соответствии имен

групп их идентификаторам, равно как и о том, в какие еще

группы входит пользователь – в файле /etc/group. Из этого следует, что пользователь не может не быть членом как минимум одной группы, как снаряд не может не попасть в эпицентр взрыва.1)

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

идентификатором пользователя.

Идентификатор пользователя

Говоря о правах доступа пользователя к файлам, стоит заметить, что в действительности манипулирует файлами не сам пользователь, а запущенный им процесс (например, утилита rm или cat). Поскольку и файл, и процесс создаются и управляются системой, ей нетрудно организовать какую угодно политику доступа одних к другим, основываясь на любых свойствах процессов как субъектов и файлов как объектов системы.

В Linux, однако, используются не какие угодно свойства, а результат идентификации пользователя – его UID. Каждый процесс системы обязательно принадлежит какому-нибудь пользователю, и идентификатор пользователя (UID) – обязательное свойство любого процесса Linux. Когда программа login запускает стартовый командный интерпретатор, она приписывает ему UID, полученный в результате диалога. Обычный запуск программы (exec()) или порождение нового процесса (fork()) не изменяют UID процесса, поэтому все

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

Поскольку UID однозначно определяется входным именем, оно нередко используется вместо

идентификатора – для наглядности. Например, вместо выражения "идентификатор пользователя, соответствующий входному имени methody", говорят "UID methody" (в приведенном ниже примере этот идентификатор равен 503):

[methody@localhost methody]$ id uid=503(methody) gid=503(methody) группы=503(methody) [methody@localhost methody]$ id shogun uid=400(shogun) gid=400(shogun) г руппы=400(shogun),4(adm),10(wheel),19(proc)

Пример 6.1. Как узнать идентификаторы пользователя и членство в группах (html, txt)

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

Иерархия прав доступа

Теперь – более подробно о том, чему соответствуют девять символов в строке атрибутов, выдаваемой ls. Эти девять символов имеют вид "rwxrwxrwx", где некоторые "r", "w" и "x" могут заменяться на "-". Очевидно, буквы отражают принятые в Linux три вида доступа – чтение, запись и использование – однако в ярлыке они присутствуют в трех экземплярах!

Дело в том, что любой пользователь (процесс) Linux по отношению к любому файлу может выступать в трех ролях: как хозяин (user), как член группы, которой принадлежит файл (group), и как посторонний (other), никаких отношений собственности на этот файл не имеющий. Строка атрибутов – это три тройки "rwx", описывающие права доступа к файлу хозяина этого файла (первая тройка, "u"), группы, которой принадлежит файл (вторая тройка, "g") и посторонних (третья тройка, "o"). Если в какой-либо тройке не хватает буквы, а вместо нее стоит "-", значит, пользователю в соответствующей роли будет в соответствующем виде доступа отказано.

При выяснении отношений между файлом и пользователем, запустившим процесс, роль определяется так:

Если UID файла совпадает с UID процесса, пользователь – хозяин файла Если GID файла совпадает с GID любой

группы, в которую входит пользователь, он – член группы, которой принадлежит файл. Если ни UID, ни GID файла не пересекаются с UID процесса и списком групп, в которые входит запустивший его пользователь, этот пользователь – посторонний.

Именно в роли хозяина пользователь (процесс) может изменять

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

Далее следует протокол действий Гуревича, который, пользуясь возможностями суперпользователя, создал в каталоге /tmp несколько файлов с различными правами доступа к ним. Для того чтобы напомнить человеку, что работа ведется с правами суперпользователя (это требует гораздо большей ответственности), bash заменил привычный "доллар" в конце приглашения командной строки на "решетку". Входное имя он тоже заменил, но практика показывает, что решетка эффективнее:

[root@localhost root]# echo "All can read" > /tmp/read.all [root@localhost root]# echo "Group wheel can read" > /tmp/read.wheel [root@localhost root]# echo "Group methody can read" > /tmp/read.methody [root@localhost root]# echo "Methody himself can read" > /tmp/read.Methody [root@localhost root]# chgrp wheel /tmp/read.wheel; chmod o-r /tmp/read.wheel [root@localhost root]# chgrp methody /tmp/read.methody; chmod o-r /tmp/read.methody [root@localhost root]# chown methody /tmp/read.Methody; chmod og-r /tmp/read.Methody

Пример 6.4. Создание файлов с различными правами доступа (html, txt)

Права доступа изменяются с помощью трех команд: chown (change owner, сменить владельца), chgrp (change group, сменить группу) и chmod с расширенным форматом параметра: перед частью, определяющей доступ (перед знаком "+" или "-"), могут быть перечислены роли "u", "g", "o" и "a" (all, что соответствует "ugo"), доступ для которых изменяется. Кроме того, при задании доступа можно вместо "+" и "-" использовать "=", тогда для заданных ролей указанные способы доступа разрешаются, а неуказанные – запрещаются. Вместо пары команд chown хозяин файл; chgrp группа файл можно применять одну: chown хозяин:группа файл, которая изменяет одновременно и UID, и GID файла (каталога, ссылки и т. п.).

Мефодий хочет посмотреть, кто имеет доступ к файлам, созданным Гуревичем, а вдобавок – к файлу /etc/shadow. Для этого он использует команду ls -l с шаблоном, описывающим сразу все файлы, которые находятся в /tmp и имя которых начинается на "read.".

[methody@localhost methody]$ ls -l /tmp/read.* /etc/shadow -r-------- 1 root root 0 Сен 10 02:08 /etc/shadow -rw-r--r-- 1 root root 13 Сен 22 17:49 /tmp/read.all -rw-r----- 1 root methody 23 Сен 22 17:49 /tmp/read.methody -rw------- 1 methody root 25 Сен 22 17:50 /tmp/read.Methody -rw-r----- 1 root wheel 21 Сен 22 17:49 /tmp/read.wheel [methody@localhost methody]$ cat /tmp/read.* /etc/shadow All can read Group methody can read Methody himself can read cat: /tmp/read.wheel: Permission denied cat: /etc/shadow: Permission denied

Пример 6.5. Чтение файлов с различными правами доступа (html, txt)

Что же получается? Из файла /etc/shadow можно только читать, причем только пользователю root. Изменять файлы /tmp/read.all, /tmp/read.wheel и /tmp/read.methody может только root, он же может и читать из них. Также читать из файла /tmp/read.wheel могут члены группы wheel, а из файла /tmp/read.methody – члены группы methody (это имя группы, а не имя пользователя!). Читать и писать в файл /tmp/read.Methody может только пользователь methody. Наконец, читать из файла /tmp/read.all могут к тому же и члены группы root, и вообще любые пользователи.

Попытка вывести содержимое этих файлов на экран (а значит, прочитать их) приводит к ожидаемому результату: процессу cat (UID methody ) разрешено чтение из трех файлов. Из /tmp/read.all – так как по отношению к нему Мефодий играет роль постороннего, а ему открыт доступ на чтение ("r" в начале третьей тройки). Из /tmp/read.methody – так как пользователь methody входит в группу methody (см. пример 6.1), членам которой разрешено читать из этого файла ("r" в начале второй тройки). И, конечно, из файла /tmp/read.Methody, которому methody – хозяин, имеющий доступ на чтение ("r" в первой тройке).

Если бы Мефодию захотелось записать что-нибудь в эти файлы, он бы получил доступ только к одному – /tmp/read.Methody, потому что по отношению к остальным файлам Мефодий играет роль, которой закрыт доступ на запись (/tmp/read.methody – член группы, остальные три – посторонние).

Таким образом, определение прав доступа процесса к объекту файловой системы (например, файла) происходит так. Используя UID процесса, список групп, в которые входит пользователь, запустивший этот процесс, UID файла и GID файла, система определяет роль

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

Использование групп

В Linux определено несколько системных групп, задача которых – обеспечивать доступ членов этих групп к разнообразным ресурсам системы. Часто такие группы носят говорящие названия: "disk", "audio", "cdwriter" и т. п. Тогда обычным пользователям доступ к некоторому файлу, каталогу или файлу-дырке Linux закрыт, но открыт членам группы, которой этот объект принадлежит.

Например, в Linux почти всегда используется виртуальная файловая система /proc – каталог, в котором в виде подкаталогов и файлов представлена информация из таблицы процессов. Имя подкаталога /proc совпадает с PID соответствующего процесса, а содержимое этого подкаталога отражает свойства процесса. Хозяином такого подкаталога будет хозяин процесса (с правами на чтение и использование), поэтому любой пользователь сможет посмотреть информацию о своих

процессах. Именно каталогом /proc пользуется утилита ps:

[methody@arnor methody]$ ls -l /proc . . . dr-xr-x--- 3 methody proc 0 Сен 22 18:17 4529 dr-xr-x--- 3 shogun proc 0 Сен 22 18:17 4558 dr-xr-x--- 3 methody proc 0 Сен 22 18:17 4589 . . . [methody@localhost methody]$ ps -af UID PID PPID C STIME TTY TIME CMD methody 4529 4523 0 13:41 tty1 00:00:00 -bash methody 4590 4529 0 13:42 tty1 00:00:00 ps -af

Пример 6.6. Ограничение доступа к полной таблице процессов (html, txt)

Оказывается, запущено немало процессов, в том числе один – пользователем shogun (PID 4558 ). Однако, несмотря на ключ "-a" (all), ps выдала Мефодию только сведения о его процессах: 4529 – это входной shell, а 4590 – видимо, сам ls.

Другое дело – Гуревич. Он, как видно из примера 6.1, входит в группу proc, членам которой разрешено читать и использовать каждый подкаталог /proc:

shogun@localhost ~ $ ps -af UID PID PPID C STIME TTY TIME CMD methody 4529 4523 0 13:41 tty1 00:00:00 -bash shogun 4558 1828 0 13:41 tty3 00:00:00 -zsh shogun 4598 4558 0 13:41 tty3 00:00:00 ps -af

Пример 6.7. Доступ к полной таблице процессов: группа proc (html, txt)

Гуревич, опытный пользователь Linux, предпочитает bash "The Z Shell", zsh. Отсюда и различие приглашения в командной строке. Во всех shell, кроме самых старых, символ "~" означает домашний каталог. Этим сокращением удобно пользоваться, если текущий каталог – не домашний, а оттуда (или туда) нужно скопировать файл. Получается команда наподобие "cp ~/нужный_файл ." или "cp нужный_файл ~" соответственно.

Команда ps -a выводит информацию обо всех

процессах, запущенных "живыми" (а не системными) пользователями 1). Для просмотра всех процессов Гуревич пользуется командой ps -efH.

Ярлыки объектов файловой системы

При создании объектов файловой системы – файлов, каталогов и т. п. – каждому в обязательном порядке приписывается ярлык. Ярлык включает в себя UID – идентификатор пользователя-хозяина файла, GID – идентификатор группы, которой принадлежит файл, тип объекта и набор так называемых атрибутов, а также некоторую дополнительную информацию. Атрибуты определяют, кто и что имеет право делать с файлом, они описаны ниже:

[methody@arnor methody]$ ls -l итого 24 drwx------ 2 methody methody 4096 Сен 12 13:58 Documents drwxr-xr-x 2 methody methody 4096 Окт 31 15:21 examples -rw-r--r-- 1 methody methody 26 Сен 22 15:21 loop -rwxr-xr-x 1 methody methody 23 Сен 27 13:27 script drwx------ 2 methody methody 4096 Окт 1 15:07 tmp -rwxr-xr-x 1 methody methody 32 Сен 22 13:26 to.sort

Пример 6.2. Права доступа к файлам и каталогам, показанные командой ls -l (html, txt)

Ключ "-l" утилиты ls определяет "длинный" (long) формат выдачи (справа налево): имя файла, время последнего изменения файла, размер в байтах, группа, хозяин, количество жестких ссылок и строчка атрибутов. Первый символ в строчке атрибутов определяет тип файла. Тип "-" отвечает "обычному" файлу, а тип "d" – каталогу (directory). Имя пользователя и имя группы, которым принадлежит содержимое домашнего каталога Мефодия, – естественно, methody.

Быстрый разумом Мефодий немедленно заинтересовался вот чем: несмотря на то, что создание жестких ссылок на каталог невозможно, значение поля "количество жестких ссылок" для всех каталогов примера равно двум, а не одному. На самом деле этого и следовало ожидать, потому что любой каталог файловой системы Linux всегда имеет не менее двух имен: собственное (например, tmp) и имя "." в самом этом каталоге (tmp/.). Если же в каталоге создать подкаталог, количество жестких ссылок на этот каталог увеличится на 1 за счет имени ".." в подкаталоге (например, tmp/subdir1/..):

[methody@arnor methody]$ ls -ld tmp drwx------ 3 methody methody 4096 Окт 1 15:07 tmp [methody@arnor methody]$ mkdir tmp/subdir2 [methody@arnor methody]$ ls -ld tmp drwx------ 4 methody methody 4096 Окт 1 15:07 tmp [methody@arnor methody]$ rmdir tmp/subdir* [methody@arnor methody]$ ls -ld tmp drwx------ 2 methody methody 4096 Окт 1 15:07 tmp

Пример 6.3. Несколько жестких ссылок на каталог все-таки бывает! (html, txt)

Здесь Мефодий использовал ключ "-d" (directory) для того, чтобы ls выводил информацию не о содержимом каталога tmp, а о самом этом каталоге.

Подмена идентификатора

Утилиты su и sudo имеют некоторую странность, объяснить которую Мефодий пока не в состоянии. Эта же странность распространяется и на давно известную программу passwd, которая позволяет редактировать собственную учетную запись. Запускаемый процесс наследует

UID от родительского, поэтому если этот UID – не нулевой, он не в состоянии поменять его. Тогда как же su запускает для обычного пользователя суперпользовательский shell? Как passwd получает доступ к хранилищу всех учетных записей? Должен существовать механизм, позволяющий пользователю запускать процессы с идентификаторами другого пользователя, причем механизм строго контролируемый, иначе с его помощью можно натворить немало бед.

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

[foreigner@somewhere foreigner]$ ls -l /usr/bin/passwd /bin/su -rws--x--x 1 root root 19400 Фев 9 2004 /bin/su -rws--x--x 1 root root 5704 Янв 18 2004 /usr/bin/passwd [foreigner@somewhere foreigner]$ ls -l /etc/shadow -r-------- 1 root root 5665 Сен 10 02:08 /etc/shadow

Пример 6.11. Обычная программа passwd, использующая SetUID (html, txt)

Как и в случае с t-атрибутом, ls выводит букву "s" вместо буквы "x" в тройке "для хозяина". Точно так же, если соответствующего x-атрибута нет (что бывает редко), ls выведет "S" вместо "s". Во многих дистрибутивах Linux и /bin/su, и /usr/bin/passwd имеют установленный SetUID и принадлежат пользователю root, что и позволяет su запускать процессы с правами этого пользователя (а значит, и любого другого), а passwd – модифицировать файл /etc/shadow, содержащий в таких системах сведения обо всех учетных записях. Как правило, файлы с атрибутом SetUID доступны обычным пользователям только на выполнение, чтобы не провоцировать пользователей рассматривать содержимое этих файлов и исследовать их недокументированные возможности. Ведь если обнаружится способ заставить, допустим, программу passwd выполнить любую другую программу, то все проблемы с защитой системы от взлома будут разом решены – нет защиты, нет и проблемы.

Однако Мефодий работает с такой системой, где /usr/bin/passwd вообще не имеет атрибута SetUID. Зато эта программа принадлежит группе shadow и имеет другой атрибут, SetGID, так что при ее запуске процесс получает идентификатор группы shadow. Утилита ls выводит SetGID в виде "s" вместо "x" во второй тройке атрибутов ("для группы"). Замечания касательно "s", "S" и "x" действительны для SetGID так же, как и для SetUID:

[root@localhost root]# ls -l /usr/bin/passwd -rwx--s--x 1 root shadow 5704 Jan 18 2004 /usr/bin/passwd [root@localhost root]# ls -al /etc/tcb/methody total 3 drwx--s--- 2 methody auth 1024 Sep 22 12:58 . drwx--x--- 55 root shadow 1024 Sep 22 18:41 .. -rw-r----- 1 methody auth 81 Sep 22 12:58 shadow -rw------- 1 methody auth 0 Sep 12 13:58 shadow- -rw------- 1 methody auth 0 Sep 12 13:58 shadow.lock

Пример 6.12. Не подверженная взлому программа passwd, использующая SetGID (html, txt)

Каталог /etc/tcb в этой системе содержит подкаталоги, соответствующие входным именам всех ее пользователей. В каждом подкаталоге хранится, в числе прочего, собственный файл shadow соответствующего пользователя. Доступ к каталогу /etc/tcb на использование (а, следовательно, и ко всем его подкаталогам) имеют, кроме root, только члены группы shadow. Доступ на запись к каталогу /etc/tcb/methody и к файлу /etc/tcb/methody/shadow имеет только пользователь methody. Значит, чтобы изменить что-либо в этом файле, процесс обязан иметь UID methody и GID shadow (или нулевой UID, конечно). Именно такой процесс запускается из /usr/bin/passwd: он наследует UID у командного интерпретатора и получает GID shadow из-за атрибута SetGID. Выходит, что даже найдя в программе passwd ошибки и заставив ее делать что угодно, злоумышленник всего только и сможет, что... отредактировать собственную

учетную запись!

Оказывается, атрибут SetGID можно присваивать каталогам. В последнем примере каталог /etc/tcb/methody имел SetGID, поэтому все создаваемые в нем файлы получают GID, равный GID самого каталога – auth. Используется это разнообразными процессами идентификации, которые, не будучи суперпользовательскими, но входя в группу auth и shadow, могут прочесть информацию из файлов /etc/tcb/входное_имя/shadow.

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

Права доступа в файловой системе

Работая с Linux, Мефодий заметил, что некоторые файлы и каталоги недоступны ему ни для чтения, ни для записи, ни для использования. Зачем такие нужны? Оказывается, другие пользователи могут обращаться к этим файлам, а у Мефодия просто недостаточно прав.

Как узнать идентификаторы пользователя

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

Закрыть окно

Пример 6.2. Права доступа к файлам и каталогам, показанные командой ls -l

Закрыть окно

Пример 6.3. Несколько жестких ссылок на каталог все-таки бывает!

Закрыть окно

Пример 6.4. Создание файлов с различными правами доступа

Закрыть окно

[methody@localhost methody]$ ls -l /tmp/read.* /etc/shadow -r-------- 1 root root 0 Сен 10 02:08 /etc/shadow -rw-r--r-- 1 root root 13 Сен 22 17:49 /tmp/read.all -rw-r----- 1 root methody 23 Сен 22 17:49 /tmp/read.methody -rw------- 1 methody root 25 Сен 22 17:50 /tmp/read.Methody -rw-r----- 1 root wheel 21 Сен 22 17:49 /tmp/read.wheel [methody@localhost methody]$ cat /tmp/read.* /etc/shadow All can read Group methody can read Methody himself can read cat: /tmp/read.wheel: Permission denied cat: /etc/shadow: Permission denied

Пример 6.5. Чтение файлов с различными правами доступа

Закрыть окно

Пример 6.6. Ограничение доступа к полной таблице процессов

Закрыть окно

shogun@localhost ~ $ ps -af UID PID PPID C STIME TTY TIME CMD methody 4529 4523 0 13:41 tty1 00:00:00 -bash shogun 4558 1828 0 13:41 tty3 00:00:00 -zsh shogun 4598 4558 0 13:41 tty3 00:00:00 ps -af

Пример 6.7. Доступ к полной таблице процессов: группа proc

Закрыть окно

[methody@localhost methody]$ ls 4TO- TO Mep3koe Documents examples loop script tmp to.sort [methody@localhost methody]$ ls -l 4* -rw------- 1 root root 0 Сен 22 22:20 4TO-TO Mep3koe [methody@localhost methody]$ rm -i 4* rm: удалить защищенный от записи пустой обычный файл `4TO-TO Mep3koe'? y

Пример 6.8. Удаление чужого файла с неудобным именем

Закрыть окно

[methody@localhost methody]$ ls -dl /tmp drwxrwxrwt 4 root root 1024 Сен 22 22:30 /tmp [methody@localhost methody]$ ls -l /tmp итого 4 -rw-r--r-- 1 root root 13 Сен 22 17:49 read.all -rw-r----- 1 root methody 23 Сен 22 17:49 read.methody -rw------- 1 methody root 25 Сен 22 22:30 read.Methody -rw-r----- 1 root wheel 21 Сен 22 17:49 read.wheel [methody@localhost methody]$ rm -f /tmp/read.* rm: невозможно удалить '/tmp/read.all': Operation not permitted rm: невозможно удалить '/tmp/read.methody': Operation not permitted rm: невозможно удалить '/tmp/read.wheel': Operation not permitted [methody@localhost methody]$ ls /tmp read.all read.methody read.wheel

Пример 6.9. Работа с файлами в разделяемом каталоге

Закрыть окно

[methody@localhost methody]$ ls -l loop -rw-r--r-- 1 root root 26 Сен 22 22:10 loop [methody@localhost methody]$ chown methody loop chown: изменение владельца `loop': Operation not permitted [methody@localhost methody]$ cp loop loopt [methody@localhost methody]$ ls -l loop* -rw-r--r-- 1 root root 26 Сен 22 22:10 loop -rw-r--r-- 1 methody methody 26 Сен 22 22:15 loopt [methody@localhost methody]$ mv -f loopt loop [methody@localhost methody]$ ls -l loop* -rw-r--r-- 1 methody methody 26 Сен 22 22:15 loop

Пример 6.10. Что можно делать с чужим файлом в своем каталоге

Закрыть окно

Пример 6.11. Обычная программа passwd, использующая SetUID

Закрыть окно

Пример 6.12. Не подверженная взлому программа passwd, использующая SetGID

Закрыть окно

Разделяемые каталоги

Проанализировав систему прав доступа к каталогам в Linux, Мефодий пришел к выводу, что в ней имеется существенный недочет. Тот, кто имеет право изменять каталог, может удалить любой файл оттуда, даже такой, к которому не имеет доступа. Формально все правильно: удаление файла из каталога – всего лишь изменение содержимого каталога. Если у файла было больше одного имени (существовало несколько

жестких ссылок на этот файл), никакого удаления данных не произойдет, а если ссылка была последней – файл в самом деле удалится. Вот это-то, по мнению Мефодия, и плохо.

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

[methody@localhost methody]$ ls 4TO-TO Mep3koe Documents examples loop script tmp to.sort [methody@localhost methody]$ ls -l 4* -rw------- 1 root root 0 Сен 22 22:20 4TO-TO Mep3koe [methody@localhost methody]$ rm -i 4* rm: удалить защищенный от записи пустой обычный файл `4TO-TO Mep3koe'? y

Пример 6.8. Удаление чужого файла с неудобным именем (html, txt)

Подозревая, что от хулиганов всего можно ожидать, Мефодий не решился набрать имя удаляемого файла с клавиатуры, а воспользовался шаблоном и ключом "-i" (interactive) команды rm, чтобы та ожидала подтверждения перед тем, как удалять очередной файл. Несмотря на отсутствие доступа к самому файлу, удалить его оказалось возможно:

Пример 6.9. Работа с файлами в разделяемом каталоге (html, txt)

Убедившись, что любой доступ в каталог /tmp открыт всем, Мефодий решил удалить оттуда все файлы. Затея гораздо более хулиганская, чем заведение файла: а вдруг они кому-нибудь нужны? Удивительно, но удален оказался только файл, принадлежащий самому Мефодию...

Дело в том, что Мефодий проглядел особенность атрибутов каталога /tmp: вместо "x" в тройке "для посторонних" ls выдал "t". Это еще один атрибут каталога, наличие которого как раз и запрещает пользователю удалять оттуда файлы, которым он не хозяин. Таким образом, права записи в каталог с ярлыком "drwxrwxrwt группа хозяин" и для членов группы, и для посторонних ограничены их собственными файлами, и только хозяин имеет право изменять список файлов в каталоге, как ему вздумается. Такие каталоги называются разделяемыми, потому что предназначены они, как правило, для

совместной работы всех пользователей в системе, обмена информацией и т. п.

При установке атрибута "t" доступ на использование для посторонних ("t" в строчке атрибутов стоит на месте последнего "x") не отменяется. Просто они так редко используются друг без друга, что ls выводит их в одном и том же месте. Если кому-нибудь придет в голову организовать разделяемый каталог без доступа посторонним на использование, ls выведет на месте девятого атрибута не "t", а "T":

[methody@localhost methody]$ ls -l loop -rw-r--r-- 1 root root 26 Сен 22 22:10 loop [methody@localhost methody]$ chown methody loop chown: изменение владельца `loop': Operation not permitted [methody@localhost methody]$ cp loop loopt [methody@localhost methody]$ ls -l loop* -rw-r--r-- 1 root root 26 Сен 22 22:10 loop -rw-r--r-- 1 methody methody 26 Сен 22 22:15 loopt [methody@localhost methody]$ mv -f loopt loop [methody@localhost methody]$ ls -l loop* -rw-r--r-- 1 methody methody 26 Сен 22 22:15 loop

Пример 6.10. Что можно делать с чужим файлом в своем каталоге (html, txt)

Оказывается, мелкие пакости продолжаются. Кто-то сменил файлу loop хозяина, так что теперь Мефодий может только читать его, но не изменять. Удалить этот файл – проще простого, но хочется "вернуть все как было": чтобы получился файл с тем же именем и тем же содержанием, принадлежащий Мефодию, а не root. Это несложно: чужой файл можно переименовать (это действие над каталогом, а не над файлом), скопировать переименованный файл в файл с именем старого (доступ на чтение открыт) и, наконец, удалить чужой файл с глаз долой. Ключ "-f" (force, "силком") позволяет утилите mv делать свое дело, не спрашивая подтверждений. В частности, увидев, что файл с именем, в которое необходимо переименовывать, существует, даже чужой, даже недоступный на запись, mv преспокойно удалит его и выполнит операцию переименования.

Суперпользователь

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

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

Суперпользователь в Linux – это выделенный пользователь системы, на которого не распространяются ограничения прав доступа. UID суперпользовательских процессов равен 0: так система отличает их от процессов других пользователей. Именно суперпользователь имеет возможность произвольно изменять владельца и группу файла. Ему открыт доступ на чтение и запись к любому файлу системы и доступ на чтение, запись и использование к любому каталогу. Наконец, суперпользовательский процесс может на время сменить свой собственный

UID с нулевого на любой другой. Именно так и поступает программа login, когда, проведя процедуру идентификации пользователя, запускает стартовый командный интерпретатор.

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

Существует два различных способа получить права суперпользователя. Первый – это зарегистрироваться в системе под этим именем, ввести пароль и получить стартовую оболочку, имеющую нулевой UID. Это – самый неправильный способ, пользоваться которым стоит, только если нельзя применить другие. Что в этом случае выдаст команда last? Что тогда-то с такой-то консоли в систему вошел неизвестно кто с правами суперпользователя и что-то там такое делал. С точки зрения системного администратора, это очень подозрительное событие, особенно если сам он в это время к указанной консоли не подходил... Сами администраторы такого способа избегают.

Второй способ —воспользоваться специальной утилитой su (shell of user), которая позволяет выполнить одну или несколько команд от лица другого пользователя. По умолчанию эта утилита выполняет команду sh от лица пользователя root, то есть запускает командный интерпретатор с нулевым UID. Отличие от предыдущего способа – в том, что всегда известно, кто именно запускал su, а значит, ясно, с кого спрашивать за последствия. В некоторых случаях удобнее использовать не su, а утилиту sudo, которая позволяет выполнять только заранее заданные команды.

Восьмеричное представление атрибутов

Все двенадцать атрибутов можно представить в виде битов двоичного числа, равных 1, если атрибут установлен, и 0, если нет. Порядок битов в числе следующий: sU|sG|t|rU|wU|xU|rG|wG||xG|rO|wO|xO, где sU – это SetUID, sG – это SetGID, t – это t-атрибут, после чего следуют три тройки атрибутов доступа. Этим форматом можно пользоваться в команде chmod вместо конструкции "роли=виды_доступа", причем число надо записывать в восьмеричной системе счисления. Так, атрибуты каталога /tmp будут равны 1777, атрибуты /bin/su – 4711, атрибуты /bin/ls – 755 и т. д.

Тем же побитовым представлением атрибутов регулируются и права доступа по умолчанию при создании файлов и каталогов. Делается это с помощью команды umask. Единственный параметр umask – восьмеричное число, задающее атрибуты, которые не надо устанавливать новому файлу или каталогу. Так, umask 0 приведет к тому, что файлы будут создаваться с атрибутами "rw-rw-rw-", а каталоги – "rwxrwxrwx". Команда umask 022 убирает из атрибутов по умолчанию права доступа на запись для всех, кроме хозяина (получается "rw-r--r--" и "rwxr-xr-x" соответственно), а с umask 077 новые файлы и каталоги становятся полностью недоступны ("rw-------" и "rwx------") всем, кроме их хозяев. 3)

Фильтры

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

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

В любом дистрибутиве Linux присутствует набор стандартных утилит, предназначенных для работы с файловой системой и обработки текстовых данных. Многими из них Мефодий уже успел воспользоваться: это who, cat, ls, pwd, cp, chmod, id, sort и др. Мефодий уже успел заметить, что каждая из этих утилит предназначена для исполнения какой-то одной операции над файлами или текстом: вывод списка файлов в каталоге, копирование, сортировка строк, хотя каждая утилита может выполнять свою функцию по-разному, в зависимости от переданных ей ключей и параметров. При этом все они работают со стандартными потоками ввода/вывода, поэтому хорошо приспособлены для построения конвейеров: последовательно выполняя простые операции над потоком данных, можно решать довольно нетривиальные задачи.

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

Конвейер

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

В bash для перенаправления стандартного вывода на стандартный ввод другой программе служит символ "|". Самый простой и наиболее распространенный случай, когда требуется использовать конвейер, возникает, если вывод программы не умещается на экране монитора и очень быстро "пролетает" перед глазами, так что человек не успевает его прочитать. В этом случае можно направить вывод в программу просмотра (less), которая позволит не торопясь пролистать весь текст, вернуться к началу и т. п.:

[methody@localhost methody]$ cat cat.info | less

Пример 7.9. Простейший конвейер (html, txt)

Можно последовательно обработать данные несколькими разными программами, перенаправляя вывод на ввод следующей программе и организуя сколь угодно длинный конвейер для обработки данных. В результате получаются очень длинные командные строки вида "cmd1 | cmd2 | ... | cmdN", которые могут показаться громоздкими и неудобными, но оказываются очень полезными и эффективными при обработке большого количества информации, как мы увидим далее в этой лекции.

Организация конвейера устроена в shell по той же схеме, что и перенаправление в файл, но с использованием особого объекта системы - канала. Если файл можно представить в виде коробки с данными, снабженной клапаном для чтения или клапаном для записи, то канал - это оба клапана, приклеенные друг к другу вообще без коробки. Для определенности между клапанами можно представить трубу, немедленно доставляющую данные от входа к выходу (английский термин - "pipe" - основан как раз на этом представлении, а в роли трубы выступает, конечно же, сам Linux). Каналом пользуются сразу два процесса: один пишет туда, другой читает. Связывая две команды конвейером, shell открывает канал (заводится два дескриптора - входной и выходной), подменяет по уже описанному алгоритму стандартный вывод первого процесса на входной дескриптор канала, а стандартный ввод второго процесса - на выходной дескриптор канала. После чего остается запустить по команде в этих процессах, и стандартный вывод первой попадет на стандартный ввод второй.

Канал (pipe) - неделимая пара дескрипторов (входной и выходной), связанных друг с другом таким образом, что данные, записанные во входной дескриптор, будут немедленно доступны на чтение с выходного дескриптора.

Отбрасывание ненужного

Иногда пользователя интересует только часть из тех данных, которые собирается выводить программа. Мефодий уже пользовался утилитой head, которая нужна, чтобы вывести только первые несколько строк файла. Не менее полезна утилита tail (англ. "хвост"), выводящая только последние строки файла. Если же пользователя интересует только определенная часть каждой строки файла - поможет утилита cut.

Допустим, Мефодию потребовалось получить список всех файлов и подкаталогов в "/etc", которые принадлежат группе "adm". И при этом ему почему-то нужно, чтобы найденные файлы в списке были представлены не полным путем, а только именем файла (скорее всего, это требуется для последующей автоматической обработки полученного списка):

Пример 7.11. Извлечение отдельного поля (html, txt)

Если команда получается такой длинной, что ее неудобно набирать в одну строку, можно разбить ее на несколько строк, не передавая системе: для этого в том месте, где нужно продолжить набор со следующей строки, достаточно поставить символ "\" и нажать Enter. При этом в начале строки bash выведет символ ">", означающий, что команда еще не передана системе и набор продолжается1). Для системы безразлично, в сколько строк набрана команда, возможность набора в несколько строк нужна только для удобства пользователя.

Мефодий получил нужный результат, задав параметры find - каталог, где нужно искать и параметр поиска - наибольшую допустимую глубину вложенности и группу, которой должны принадлежать найденные файлы. Ненужные диагностические сообщения о запрещенном доступе он отправил в /dev/null, а потом указал утилите cut, что в полученных со стандартного ввода строках нужно считать разделителем символ "/" и вывести только третье поле. Таким образом, от строк вида "/etc/filename" осталось только "filename"2).

Перенаправление в никуда

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

Пример 7.8. Перенаправление в /dev/null (html, txt)

Точно таким же образом можно избавиться и от стандартного вывода, отправив его в /dev/null.

Перенаправление ввода и вывода

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

Каждый процесс Linux получает при старте три "файла", открытых для него системой. Первый из них (дескриптор 0) открыт на чтение, это стандартный ввод процесса. Именно со стандартным вводом работают все операции чтения, если в них не указан дескриптор файла. Второй (дескриптор 1) - открыт на запись, это стандартный вывод процесса. С ним работают все операции записи, если дескриптор файла не указан в них явно. Наконец, третий поток данных (дескриптор 2) предназначается для вывода диагностических сообщений, он называется стандартный вывод ошибок. Поскольку эти три дескриптора уже открыты к моменту запуска процесса, первый файл, открытый самим процессом, будет, скорее всего, иметь дескриптор 3.

Дескриптор- это описатель потока данных, открытого процессом. Дескрипторы нумеруются, начиная с 0. При открытии нового потока данных его дескриптор получает наименьший из неиспользуемых в этот момент номеров. Три заранее открытых дескриптора - стандартный ввод (0), стандартный вывод (1) и стандартный вывод ошибок (2) - выдаются при запуске.

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

Подсчет

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

[methody@localhost methody]$ find . | wc -l 42 [methody@localhost methody]$

Пример 7.10. Подсчет файлов при помощи find и wc (html, txt)

Мефодий получил желаемое число - "42". Для этого ему потребовалась команда find - рекомендованный Гуревичем инструмент поиска нужных файлов в системе. Мефодий вызвал find с одним параметром - каталогом, с которого надо начинать поиск. find выводит список найденных файлов по одному на строку, а поскольку критерии поиска в данном случае не уточнялись, то find просто вывела список всех файлов во всех подкаталогах текущего каталога (домашнего каталога Мефодия). Этот список Мефодий передал утилите wc, попросив ее посчитать количество полученных строк "-l". В ответ wc выдала искомое число.

Задав find критерии поиска, можно посчитать и что-нибудь менее тривиальное, например, файлы, которые создавались или были изменены в определенный промежуток времени, файлы с определенным режимом доступа, с определенным именем и т. п. Узнать обо всех возможностях поиска при помощи find и подсчета при помощи wc можно из руководств по этим программам.

Поиск

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

Пример 7.12. Поиск строки в выводе программы (html, txt)

Первый аргумент команды grep - та строка, которую нужно искать в стандартном вводе, в данном случае это "bash", а поскольку ps выводит сведения по строке на каждый процесс, Мефодий получил только процессы, в имени которых есть "bash". Однако Мефодий неожиданно нашел больше, чем искал: в списке выполняющихся процессов присутствовали две строки, в которых встретилось слово "bash", т. е. два процесса: один - искомый - командный интерпретатор bash, а другой - процесс поиска строки "grep bash", запущенный Мефодием после ps. Это произошло потому, что после разбора командной строки bash запустил оба дочерних процесса, чтобы организовать конвейер, и на момент выполнения команды ps процесс grep bash уже был запущен и тоже попал в вывод ps. Чтобы в этом примере получить правильный результат, Мефодию следовало бы добавить в конвейер еще одно звено: | grep -v grep, эта команда исключит из конечного вывода все строки, в которых встречается "grep".

Поиск по регулярному выражению

Очень часто точно не известно, какую именно комбинацию символов нужно будет найти. Точнее, известно только то, как примерно должно выглядеть искомое слово, что в него должно входить и в каком порядке. Так обычно бывает, если некоторые фрагменты текста имеют строго определенный формат. Например, в руководствах, выводимых программой info, принят такой формат ссылок: "*Note название_узла::". В этом случае нужно искать не конкретное сочетание символов, а "Строку "*Note", за которой следует название узла (одно или несколько слов и пробелов), оканчивающееся символами "::"". Компьютер вполне способен выполнить такой запрос, если его сформулировать на строгом и понятном ему языке, например, на языке регулярных выражений. Регулярное выражение - это способ одной формулой задать все последовательности символов, подходящие пользователю:

Пример 7.13. Поиск ссылок в файле info (html, txt)

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

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

Вторая звездочка обозначает, что стоящий перед ней элемент может быть повторен любое количество раз от нуля до бесконечности. В нашем случае звездочка относится к выражению в квадратных скобках - "[^:]", что означает "любой символ, кроме ":"". Целиком регулярное выражение можно прочесть так: "Строка "*Note", за которой следует ноль или больше любых символов, кроме ":", за которыми следует строка "::"". Особенность работы "*" состоит в том, что она пытается выбрать совпадение максимальной длины. Именно поэтому элемент, к которому относилась "*", был задан как "не ":"". Выражение "ноль или более любых символов" (оно записывается как ".*") в случае, когда, например, в одной строке встречается две ссылки, вбирает подстроку от конца первого "*Note" до начала последнего "::" (символы ":", поместившиеся внутри этой подстроки, распознаются как "любые").

На языке регулярных выражений можно также обозначить "любой символ" ("."), "одно или более совпадений" ("+"), начало и конец строки ("^" и "$" соответственно) и т. д. Благодаря регулярным выражениям можно автоматизировать очень многие задачи, которые в противном случае потребовали бы огромной и кропотливой работы человека. Более подробные сведения о возможностях языка регулярных выражений можно получить из руководства regex(7). Однако руководство - это не учебник, поэтому чтобы научиться экономить время и усилия при помощи регулярных выражений, полезно прочесть соответствующие главы книг [4], [10].

Регулярные выражения в Linux используются не только для поиска программой grep. Очень многие программы, так или иначе работающие с текстом, в первую очередь текстовые редакторы, поддерживают регулярные выражения. К таким программам относятся два "главных" текстовых редактора Linux - Vim и Emacs, о которых речь пойдет в следующей лекции (9). Однако нужно учитывать, что в разных программах используются разные диалекты языка регулярных выражений, где одни и те же понятия имеют разные обозначения, поэтому всегда нужно обращаться к руководству по конкретной программе.

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

less 00000000 7f 45 4c

[methody@localhost methody]$ hexdump -C /bin/cat | less 00000000 7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 |.ELF............| 00000010 02 00 03 00 01 00 00 00 90 8b 04 08 34 00 00 00 |............4...| 00000020 e0 3a 00 00 00 00 00 00 34 00 20 00 07 00 28 00 |Ю:......4. ...(.| . . . 00000100 00 00 00 00 00 00 00 00 00 00 00 00 06 00 00 00 |................| 00000110 04 00 00 00 2f 6c 69 62 2f 6c 64 2d 6c 69 6e 75 |..../lib/ld-linu| 00000120 78 2e 73 6f 2e 32 00 00 04 00 00 00 10 00 00 00 |x.so.2..........| 00000130 01 00 00 00 47 4e 55 00 00 00 00 00 02 00 00 00 |....GNU.........| . . . [methody@localhost methody]$ strings /bin/cat | less /lib/ld-linux.so.2 _Jv_RegisterClasses __gmon_start__ libc.so.6 stdout . . . [methody@localhost methody]$ strings -n3 /bin/cat | less /lib/ld-linux.so.2 GNU _Jv_RegisterClasses __gmon_start__ libc.so.6 stdout . . .

Пример 7.1. Использование hexdump и strings

Закрыть окно

[methody@localhost methody]$ cat > textfile Это файл для примеров. ^D [methody@localhost methody]$ ls -l textfile -rw-r--r-- 1 methody methody 23 Ноя 15 16:06 textfile

Пример 7.2. Перенаправление стандартного вывода в файл

Закрыть окно

[methody@localhost methody]$ cat >> textfile Пример 1. ^D [methody@localhost methody]$ cat textfile Это файл для примеров. Пример 1. [methody@localhost methody]$

Пример 7.3. Недеструктивное перенаправление стандартного вывода

Закрыть окно

[methody@localhost methody]$ sort < textfile Пример 1. Это файл для примеров. [methody@localhost methody]$

Пример 7.4. Перенаправление стандартного ввода из файла

Закрыть окно

[methody@localhost methody]$ info cat > cat.info info: Запись ноды (coreutils.info.bz2)cat invocation... info: Завершено. [methody@localhost methody]$ head -1 cat.info File: coreutils.info, Node: cat invocation, Next: tac invocation, Up: Output of entire files [methody@localhost methody]$

Пример 7.5. Стандартный вывод ошибок

Закрыть окно

[methody@localhost methody]$ info cat > cat.info 2> cat.stderr [methody@localhost methody]$ cat cat. stderr info: Запись ноды (coreutils.info.bz2)cat invocation... info: Завершено. [methody@localhost methody]$

Пример 7.6. Перенаправление стандартного вывода ошибок

Закрыть окно

[methody@localhost methody]$ info cat > cat.info 2>&1 [methody@localhost methody]$ head -3 cat.info info: Запись ноды (coreutils.info.bz2)cat invocation... info: Завершено. File: coreutils.info, Node: cat invocation, Next: tac invocation, Up: Output of entire files [methody@localhost methody]$

Пример 7.7. Объединение стандартного вывода и стандартного вывода ошибок

Закрыть окно

[methody@localhost methody]$ info cat > cat.info 2> /dev/null [methody@localhost methody]$

Пример 7.8. Перенаправление в /dev/null

Закрыть окно

[methody@localhost methody]$ cat cat.info | less

Пример 7. 9. Простейший конвейер

Закрыть окно

[methody@localhost methody]$ find . | wc -l 42 [methody@localhost methody]$

Пример 7.10. Подсчет файлов при помощи find и wc

Закрыть окно

[methody@localhost methody]$ find /etc -maxdepth 1 - group adm 2> /dev/null \ > | cut -d / -f 3 syslog.conf anacrontab [methody@localhost methody]$

Пример 7.11. Извлечение отдельного поля

Закрыть окно

[methody@susanin methody]$ ps aux | grep bash methody 3459 0.0 3.0 2524 1636 tty2 S 14:30 0:00 -bash methody 3734 0.0 1.1 1644 612 tty2 S 14:50 0:00 grep bash

Пример 7.12. Поиск строки в выводе программы

Закрыть окно

[methody@susanin methody]$ info grep > grep.info 2> /dev/null [methody@susanin methody]$ grep -on "\*Note[^:]*::" grep.info 324:*Note Grep Programs:: 684:*Note Invoking:: [methody@susanin methody]$

Пример 7.13. Поиск ссылок в файле info

Закрыть окно

[methody@localhost methody]$ cat cat.info | tr abcdefghijklmnopqrstuvwxyz абцдефгхийклмнопкрстуввсиз \ > | tr ABCDEFGHIJKLMNOPRSTUVWXYZ АБЦДЕФГХИЙКЛМНОПКРСТУВВСИЗ | head -4 Филе: цореутилс.инфо, Ноде: цат инвоцатион, Нест: тац инвоцатион, Тп: Оутпут оф ентире филес 'цат': Цонцатенате анд врите филес =================================== [methody@localhost methody]$

Пример 7.14. Замена символов (транслитерация)

Закрыть окно

[methody@localhost methody]$ ls -l | sed s/^-[-rwx]*/Файл:/ | sed s/^d[-rwx]*/Каталог:/ итого 124 Файл: 1 methody methody 2693 Ноя 15 16:09 cat.info Файл: 1 methody methody 69 Ноя 15 16:08 cat.stderr Каталог: 2 methody methody 4096 Ноя 15 12:56 Documents Каталог: 3 methody methody 4096 Ноя 15 13:08 examples Файл: 1 methody methody 83459 Ноя 15 16:11 grep.info Файл: 1 methody methody 26 Ноя 15 13:08 loop Файл: 1 methody methody 23 Ноя 15 13:08 script Файл: 1 methody methody 33 Ноя 15 16:07 textfile Каталог: 2 methody methody 4096 Ноя 15 12:56 tmp Файл: 1 methody methody 32 Ноя 15 13:08 to.sort [methody@localhost methody]$

Пример 7.15. Замена по регулярному выражению

Закрыть окно

Пример 7.16. Получение упорядоченного по частотности списка словоупотреблений

Закрыть окно

[methody@localhost methody]$ find /bin -type f -perm +a=x \ > | xargs grep -l -e '^#!/' 2> /dev/null /bin/egrep /bin/fgrep /bin/unicode_start /bin/bootanim [methody@localhost methody]$

Пример 7.17. Поиск всех исполняемых файлов, которые точно являются сценариями

Закрыть окно

Примеры задач

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

Стандартный ввод

Аналогичным образом для передачи данных на вход программе может быть использован стандартный ввод (сокращенно - stdin). При работе с командной строкой стандартный ввод - это символы, вводимые пользователем с клавиатуры. Стандартный ввод можно перенаправить при помощи командной оболочки, подав на него данные из некоторого файла. Символ "<" служит для перенаправления содержимого файла на стандартный ввод программе. Например, если вызвать утилиту sort без параметра, она будет читать строки со стандартного ввода. Команда "sort < имя_файла" подаст на ввод sort данные из файла:

[methody@localhost methody]$ sort < textfile Пример 1. Это файл для примеров. [methody@localhost methody]$

Пример 7.4. Перенаправление стандартного ввода из файла (html, txt)

Результат действия этой команды аналогичен команде sort textfile - разница лишь в том, что когда используется "<", sort получает данные со стандартного ввода ничего не зная о файле "textfile", откуда они поступают. Механизм работы shell в данном случае тот же, что и при перенаправлении вывода: shell читает данные из файла "textfile", запускает утилиту sort и передает ей на стандартный ввод содержимое файла.

Необходимо помнить, что операция ">" деструктивна: она всегда создает файл нулевой длины. Поэтому для, допустим, сортировки данных в файле надо применять последовательно sort < файл > новый_файл и mv новый_файл файл. Команда вида команда < файл > тот_же_файл просто урежет его до нулевой длины!

Стандартный ввод (standard input, stdin) - поток данных, открываемый системой для каждого процесса в момент его запуска и предназначенный для ввода данных.

Стандартный вывод

Мефодий уже сталкивался с тем, что некоторые программы умеют выводить не только на терминал, но и в файл. Например, info при указании параметрического ключа "-o" с именем файла выведет текст руководства в файл, вместо того, чтобы отображать его на мониторе. Даже если разработчиками программы не предусмотрен такой ключ, Мефодию известен и другой способ сохранить вывод программы в файле вместо того, чтобы выводить его на монитор: поставить знак ">" и указать после него имя файла. Таким образом Мефодий уже создавал короткие текстовые файлы (сценарии) при помощи утилиты cat (см. лекцию 5):

[methody@localhost methody]$ cat > textfile Это файл для примеров. ^D [methody@localhost methody]$ ls -l textfile -rw-r--r-- 1 methody methody 23 Ноя 15 16:06 textfile

Пример 7.2. Перенаправление стандартного вывода в файл (html, txt)

От использования символа ">" возможности самой утилиты cat, конечно, не расширились. Более того, cat в этом примере не получила от командной оболочки никаких параметров: ни знака ">", ни последующего имени файла. В этом случае cat работала как обычно, не зная (и даже не интересуясь!), куда попадут выведенные данные: на экран монитора, в файл или куда-нибудь еще. Вместо того, чтобы самой обеспечивать доставку вывода до конечного адресата (будь то человек или файл), cat отправляет все данные на стандартный вывод (сокращенно - stdout).

Подмена стандартного вывода - задача командной оболочки (shell). В данном примере shell создает пустой файл, имя которого указано после знака ">", и дескриптор этого файла передается программе cat под номером 1 (стандартный вывод). Делается это очень просто. В лекции 5 было рассказано о том, как запускаются команды из оболочки. В частности, после выполнения fork() появляется два одинаковых процесса, один из которых - дочерний - должен запустить вместо себя команду (выполнить exec()). Так вот, перед этим он закрывает стандартный вывод (дескриптор 1 освобождается) и открывает файл (с ним связывается первый свободный дескриптор, т. е. 1), а запускаемой команде ничего знать и не надо: ее стандартный вывод уже подменен. Эта операция называется перенаправлением стандартного вывода. В том случае, если файл уже существует, shell запишет его заново, полностью уничтожив все, что в нем содержалось до этого. Поэтому Мефодию, чтобы продолжить записывать данные в textfile, потребуется другая операция - ">>":

[methody@localhost methody]$ cat >> textfile Пример 1. ^D [methody@localhost methody]$ cat textfile Это файл для примеров. Пример 1. [methody@localhost methody]$

Пример 7.3. Недеструктивное перенаправление стандартного вывода (html, txt)

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

Cтандартный вывод (standard output, stdout) - это поток данных, открываемый системой для каждого процесса в момент его запуска и предназначенный для данных, выводимых процессом.

Стандартный вывод ошибок

В качестве первого примера и упражнения на перенаправление Мефодий решил записать руководство по cat в свой файл cat.info:

Пример 7.5. Стандартный вывод ошибок (html, txt)

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

Стандартный вывод ошибок (standard error, stderr) - поток данных, открываемый системой для каждого процесса в момент его запуска и предназначенный для диагностических сообщений, выводимых процессом.

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

Пример 7.6. Перенаправление стандартного вывода ошибок (html, txt)

В этот раз на терминал уже ничего не попало, стандартный вывод отправился в файл cat.info, стандартный вывод ошибок - в cat.stderr. Вместо ">" и "2>" Мефодий мог бы написать "1>" и "2>". Цифры в данном случае обозначают номера дескрипторов открываемых файлов. Если некая утилита ожидает получить открытый дескриптор с номером, допустим, 4, то, для того чтобы ее запустить, обязательно потребуется использовать сочетание "4>".

Иногда, однако, требуется объединить стандартный вывод и стандартный вывод ошибок в одном файле, а не разделять их. В командной оболочке bash для этого имеется специальная последовательность "2>&1". Это означает "направить стандартный вывод ошибок туда же, куда и стандартный вывод":

Пример 7.7. Объединение стандартного вывода и стандартного вывода ошибок (html, txt)

В этом примере важен порядок перенаправлений: в командной строке Мефодий сначала указал, куда перенаправить стандартный вывод ("> cat.info") и только потом велел направить туда же стандартный вывод ошибок. Сделай он наоборот ("2>&1 > cat.info"), результат получился бы неожиданный: в файл попал бы только стандартный вывод, а диагностические сообщения появились бы на терминале. Однако логика здесь железная: на момент выполнения операции "2>&1" стандартный вывод был связан с терминалом, значит, после ее выполнения стандартный вывод ошибок тоже будет связан с терминалом. А последующее перенаправление стандартного вывода в файл, конечно, никак не отразится на стандартном выводе ошибок. Номер в конструкции "&номер" - это номер открытого дескриптора. Если бы упомянутая выше утилита, записывающая в четвертый дескриптор, была написана на shell, в ней бы использовались перенаправления вида ">&4". Чтобы не набирать громоздкую конструкцию "> файл 2>&1" в bash используются сокращения: "&> файл" или, что то же самое, ">& файл".

Структурные единицы текста

Работу в системе Linux почти всегда можно представить как работу с текстами. Поиск файлов и других объектов системы - это получение от системы текста особой структуры - списка имен. Операции над файлами - создание, переименование, перемещение, а также сортировка, перекодировка и прочее - замену одних символов и строк другими либо в каталогах, либо в самих файлах. Настройка системы в Linux сводится непосредственно к работе с текстами - редактированию конфигурационных файлов и написанию сценариев (подробнее об этом см. лекции 8 и 12).

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

Строки

Строка - основная единица передачи текста в Linux. Терминал передает данные от пользователя системе строками (командная строка), множество утилит вводят и выводят данные построчно, при работе многих утилит одной строке соответствует один объект системы (имя файла, путь и т. п.), sort сортирует строки. Строки разделяются символом конца строки "\n" (newline).

Поля

В одной строке может упоминаться и больше одного объекта. Если понимать объект как последовательность символов из определенного набора (например, букв), то строку можно рассматривать как состоящую из слов и разделителей1). В этом случае текст от начала строки до первого разделителя - это первое поле, от первого разделителя до второго - второе поле и т. д. В качестве разделителя можно рассматривать любой символ, который не может использоваться в объекте. Например, если в пути "/home/methody" разделителем является символ "/", то первое поле пусто, второе содержит слово "home", третье - "methody". Некоторые утилиты позволяют выбирать из строк отдельные поля (по номеру) и работать со строками как с таблицей.

Символы

Минимальная единица текста - символ. Символ - это одна буква или другой письменный знак. Стандартные утилиты Linux позволяют заменять одни символы другими (производить транслитерацию), искать и заменять в строках символы и комбинации символов.

Символ конца строки в кодировке ASCII совпадает с управляющей последовательностью "^J" - "перевод строки", однако в других кодировках он может быть иным. Кроме того, на большинстве терминалов - но не на всех! - вслед за переводом строки необходимо выводить еще символ возврата каретки ("^M"). Это вызвало путаницу: некоторые системы требуют, чтобы в конце текстового файла стояли оба этих символа в определенном порядке. Чтобы избежать путаницы, в UNIX (и, как следствие, в Linux) было принято единственно верное решение: содержимое файла соответствует кодировке, а при выводе на терминал концы строки преобразуются в управляющие последовательности согласно настройке терминала.

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

Упорядочивание

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

Пример 7.16. Получение упорядоченного по частотности списка словоупотреблений (html, txt)

Мефодий (вернее, компьютер по плану Мефодия) подсчитал, сколько раз какие слова были употреблены в файле "grep.info" и вывел несколько самых частоупотребляемых с указанием количества употреблений в файле. Для этого потребовалось сначала заменить все большие буквы маленькими, чтобы не было разных способов написания одного слова, затем заменить все пробелы и знаки препинания концом строки (символ "\n"), чтобы в каждой строке было ровно по одному слову (Мефодий всюду взял параметры tr в кавычки, чтобы bash не понял их неправильно). Потом список был отсортирован, все повторяющиеся слова заменены одним словом с указанием количества повторений ("uniq -c"), затем строки снова отсортированы по убыванию чисел в начале строки ("sort -nr") и выведены первые 8 строк ("head -8").

Ввод и вывод

Любая программа - это автомат, предназначенный для обработки данных: получая на входе одну информацию, они в результате работы выдают другую. Хотя входящая и/или выходящая информация может быть и нулевой, т. е. попросту отсутствовать. Те данные, которые передаются программе для обработки - это ее ввод, то, что она выдает в результате работы - вывод. Организация ввода и вывода для каждой программы - это задача операционной системы.

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

"Текстовость" данных - всего лишь договоренность об их формате. Никто не мешает выводить на экран нетекстовый файл, однако пользы в этом будет мало. Во-первых, раз уж файл содержит не текст, то не предполагается, что человек сможет что-либо понять из его содержимого. Во-вторых, если в нетекстовых данных, выводимых на терминал, случайно встретится управляющая последовательность, терминал ее выполнит. Например, если в скомпилированной программе записано число 1528515121, оно представлено в виде четырех байтов: 27, 91, 49 и 74. Соответствующий им текст состоит из четырех символов ASCII: "esc", "[", "1" и "J", и при выводе файла на виртуальную консоль Linux в этом месте выполнится очистка экрана, так как "^[[1J" - именно такая управляющая последовательность для виртуальной консоли. Не все управляющие последовательности столь безобидны, поэтому использовать нетекстовые данные в качестве текстов не рекомендуется.

Что же делать, если содержимое нетекстового файла все-таки желательно просмотреть (то есть превратить в текст)? Можно воспользоваться программой hexdump, которая выдает содержимое файла в виде шестнадцатеричных ASCII-кодов, или strings, показывающей только те части файла, которые могут быть представлены в виде текста:

Пример 7.1. Использование hexdump и strings (html, txt)

В примере Мефодий, зная заранее, что текста будет выдано много, воспользовался конвейером "| less", описанным в разделе "Конвейер". С ключом "-C" утилита hexdump выводит в правой стороне экрана текстовое представление данных, заменяя непечатные символы точками (чтобы среди выводимого текста не встретилось управляющей последовательности). Мефодий заметил, что strings "не нашла" в файле /bin/cat явно текстовых подстрок "ELF" и "GNU": первая из них - вообще не текст (перед ней стоит непечатный символ с кодом 7f, а после - символ с кодом 1), а вторая - слишком короткая, хоть и ограничена символами с кодом 0, как это и полагается строке в скомпилированной программе. Наименьшая длина строки передается strings ключом "-n".

Замены

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

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

Пример 7.14. Замена символов (транслитерация) (html, txt)

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

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

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

Пример 7.15. Замена по регулярному выражению (html, txt)

У sed очень широкие возможности, но довольно непривычный синтаксис, например, замена выполняется командой "s/что_заменять/на_что_заменять/". Чтобы в нем разобраться, нужно обязательно прочесть руководство sed(1) и знать регулярные выражения.

Запуск команд

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

[methody@localhost methody]$ find /bin -type f -perm +a=x \ > | xargs grep -l -e '^#!/' 2> /dev/null /bin/egrep /bin/fgrep /bin/unicode_start /bin/bootanim [methody@localhost methody]$

Пример 7.17. Поиск всех исполняемых файлов, которые точно являются сценариями (html, txt)

Здесь Мефодий решил определить, какие из исполняемых файлов в каталоге "/bin" являются сценариями. Для этого он нашел все обычные исполняемые файлы (указывать "-type f" - "обычные файлы" потребовалось, чтобы в результат не попали каталоги, которые обычно являются исполняемыми), а затем для каждого найденного файла вызвал grep, чтобы поискать в нем сочетание символов "#!/" в начале строки. Ключ "-l" велел grep выводить не обнаруженную строку, а имя файла, в котором найдено совпадение. Так Мефодий получил список исполняемых файлов, в которых есть строка с указанием интерпретатора -несомненных сценариев1).

Достраивание

Сокращения позволяют быстро набирать команды, однако никак не затрагивают имен файлов, которые чаще всего и оказываются параметрами этих команд. Бывает, что набранной строки - пути к файлу и нескольких первых букв его имени - достаточно для однозначного указания на этот файл, потому что по введенному пути других файлов, чье имя начинается на эти буквы, просто нет. Чтобы не дописывать оставшиеся буквы (а имена файлов в Linux могут быть весьма длинными), Гуревич посоветовал Мефодию нажать клавишу Tab. И - о чудо! - bash сам достроил начало имени файла до целого (снова воспользуемся методом "кадров"):

[methody@localhost methody]$ ls -al /bin/base Tab | [methody@localhost methody]$ ls -al /bin/basename -rwxr-xr-x 1 root root 12520 Июн 3 18:29 /bin/basename [methody@localhost methody]$ base Tab | [methody@localhost methody]$ basename Tab | [methody@localhost methody]$ basename ex Tab | [methody@localhost methody]$ basename examples/ Tab | [methody@localhost methody]$ basename examples/-filename-with- -filename-with-

Пример 8.6. Использование достраивания (html, txt)

Дальше - больше. Оказывается, и имя команды можно вводить не целиком: оболочка достроит набираемое слово именно до команды, раз уж это слово стоит в начале командной строки. Таким образом, команду basename examples/-filename-with- Мефодий набрал за восемь нажатий на клавиатуру ("base" и четыре Tab)! Ему не пришлось вводить начало имени файла в каталоге examples, потому что файл там был всего один.

Выполняя достраивание (completion), bash может вывести не всю строку, а только ту ее часть, относительно которой у него нет сомнений. Если дальнейшее достраивание может пойти несколькими путями, то однократное нажатие Tab приведет к тому, что bash растерянно пискнет2), а повторное - к выводу под командной строкой списка всех возможных вариантов. В этом

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

Поиск ключевого слова "completion" по документации bash выдал так много информации, что Мефодий обратился к Гуревичу за помощью. Однако тот ответил, что не использует bash, и поэтому не в состоянии объяснять тонкости его настройки. Если в bash предусмотрено несколько типов достраивания (по именам файлов, по именам команд и т. п.), то в zsh их сколько угодно: существует способ запрограммировать любой алгоритм достраивания и задать шаблон командной строки, в которой именно этот способ будет применяться.

Генерация имен файлов

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

Интеграция процессов

Каждый процесс Linux при завершении передает родительскому код возврата (exit status), который равен нулю, если процесс считает, что его работа была успешной, или номеру ошибки - в противном случае. Командный интерпретатор хранит код возврата последней команды в специальной переменной "?". Что более важно, код возврата используется в условных операторах: если он равен нулю, условие считается выполненным, а если нет - невыполненным:

Пример 8.14. Оператор if использует код возврата программы grep (html, txt)

Условный оператор if запускает команду-условие, grep -q, которая ничего не выводит на экран, зато возвращает 0, если шаблон найден, и 1, если нет. В зависимости от кода возврата этой команды, if выполняет или не выполняет тело: список команд, заключенный между then и fi. Точка с запятой разделяет операторы в sh; либо она, либо перевод строки необходимы перед then и fi, иначе все, что идет после grep, интерпретатор посчитает параметрами этой утилиты.

Множеством функций обладает команда test: она умеет сравнивать числа и строки, проверять ярлык объекта файловой системы и наличие самого этого объекта. У "test" есть второе имя: "[" (как правило, /usr/bin/[ - символьная или даже жесткая ссылка на /usr/bin/test), позволяющее оформлять оператор if более привычным образом:

Пример 8.15. Оператор test (html, txt)

Команда test -f проверяет, не является ли ее аргумент файлом; поскольку examples - это каталог, результат будет неудачным. Команда [ -d - то же самое, что и test -d (не каталог ли первый параметр), только последним параметром этой команды - исключительно для красоты - должен быть символ "]". Результат - успешный, и выполняется команда ls -ld. Команда test параметр1 -lt параметр3 проверяет, является ли параметр1 числом, меньшим, чем (less then) параметр3. В более сложных случаях оператор if удобнее записывать "лесенкой", выделяя переводами строки окончание условия и команды внутри тела (их может быть много).

Второй тип подстановки, которую shell делает внутри двойных кавычек - это подстановки вывода команды. Подстановка вывода имеет вид "`команда`" (другой вариант - "$(команда)"). Как и подстановка значения переменной, она происходит перед тем, как начнется разбор командной строки: выполнив команду и получив от нее какой-то текст, shell примется разбирать его, как если бы этот текст пользователь набрал вручную. Это очень удобное средство, если то, что выводит команда, необходимо передать самому интерпретатору:

[methody@localhost methody]$ A=8; B=6 [methody@localhost methody]$ expr $A + $B 14 [methody@localhost methody]$ echo "$A + $B = `expr $A + $B`" 8 + 6 = 14 [methody@localhost methody]$ A=3.1415; B=2.718 [methody@localhost methody]$ echo "$A + $B = `expr $A + $B`" expr: нечисловой аргумент 3.1415 + 2.718 = [methody@localhost methody]$ echo "$A + $B" | bc 5.8595 [methody@localhost methody]$ C=`echo "$A + $B" | bc` [methody@localhost methody]$ echo "$A + $B = $C" 3.1415 + 2.718 = 5.8595

Пример 8.16. Подстановка вывода команды (html, txt)

Сначала для арифметических вычислений Мефодий хотел воспользоваться командой expr, которая работает с параметрами командной строки. С целыми числами expr работает неплохо, и ее результат можно подставить прямо в аргумент команды echo. С действительными числами умеет работать утилита-фильтр bc; арифметическое выражение пришлось сформировать с помощью echo и передать по конвейеру, а результат поместить в переменную C. Во многих современных командных оболочках есть встроенная целочисленная арифметика вида "$(( выражение ))".

Использование шаблонов

Шаблоны используются в нескольких конструкциях shell. Главное место их применения - командная строка. Если оболочка "видит" в командной строке шаблон, она немедленно заменяет его списком файлов, имена которых ему соответствуют. Команда, которая затем вызывается, получает в качестве параметров список файлов уже без всяких шаблонов, как если бы этот список пользователь ввел вручную. Эта способность командного интерпретатора называется генерацией имен файлов:

[methody@localhost methody]$ ls .bash* .bash_history .bash_logout .bash_profile .bashrc [methody@localhost methody]$ /bin/e* /bin/ed /bin/egrep /bin/ex [methody@localhost methody]$ ls *a* -filename-with- [methody@localhost methody]$ ls -dF *[ao]* Documents/ examples/ loop to.sort*

Пример 8.7. Использование шаблона в командной строке (html, txt)

Мефодий, как это случается с новичками, немедленно натолкнулся на несколько "подводных камней", неизбежных в ситуации, когда конечный результат неизвестен. Только первая команда сработала не вопреки его ожиданиям: шаблон ".bash*" был превращен командной оболочкой в список файлов, начинающихся на .bash, этот список получила в качестве параметров командной строки ls, после чего честно его вывела. С "/bin/e*" Мефодию повезло - этот шаблон превратился в список файлов из каталога /bin, начинающихся на "e", и первым файлом в списке оказалась безобидная утилита /bin/echo. Поскольку в командной строке ничего, кроме шаблона, не было, именно строка /bin/echo была воспринята оболочкой в качестве команды1), которой (в качестве параметров) были переданы остальные элементы списка - /bin/ed, /bin/egrep и /bin/ex.

Что же касается ls *a*, то, по расчетам Мефодия, эта команда должна была выдать список файлов в текущем каталоге, имя которых содержит "a". Вместо этого на экран вывелось имя файла из подкаталога examples... Впрочем, никакой черной магии тут нет. Во-первых, имена файлов вида ".bash*" хотя и содержат "a", но начинаются с точки, и, стало быть, считаются скрытыми. Скрытые файлы попадают в результат генерации имен только если точка в начале указана явно (как в первой команде примера). Поэтому по шаблону "*a*" в домашнем каталоге Мефодия bash нашел только подкаталог с именем examples - его-то он и передал в качестве параметра утилите ls. Что было выведено на экран в результате образовавшейся команды ls examples? Конечно, содержимое каталога. Шаблон в последней команде из примера, "*[ao]*" был превращен в список файлов, чьи имена содержат "a" или "o" - Documents examples loop to.sort, а ключ "-d" потребовал от ls показывать информацию о каталогах, а не об их содержимом. В соответствии с ключом "-F", ls расставила "/" после каталогов и "*" после исполняемых файлов.

Еще одно отличие генерации имен от стандартной обработки шаблона - в том, что символ "/", разделяющий элементы пути, никогда не ставится в соответствие "*" или диапазону. Происходит это не потому, что искажен алгоритм, а потому, что при генерации имен шаблон применяется именно к элементу пути, внутри которого уже нет "/". Например, получить список файлов, которые находятся в каталогах /usr/bin и /usr/sbin и содержат подстроку "ppp" в имени, можно с помощью шаблона "/usr/*bin/*ppp*". Однако одного шаблона, который бы включал в этот список еще и каталоги /bin и /sbin - то есть подкаталоги другого уровня вложенности - по стандартным правилам сделать нельзя2).

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

[methody@localhost methody]$ echo *o* Documents loop to.sort [methody@localhost methody]$ echo \*o\* *o* [methody@localhost methody]$ echo "*o*" *o* [methody@localhost methody]$ echo *y* *y* [methody@localhost methody]$ ls *y* ls: *y*: No such file or directory

Пример 8.8. Экранирование специальных символов и обработка "пустых" шаблонов (html, txt)

Мефодий заметил, что шаблон, которому не соответствует ни одно имя файла, bash раскрывать не стал, как если бы все "*" в нем были экранированы. В самом деле, какое из двух зол меньше: изменять интерпретацию спецсимволов в зависимости от содержимого каталога, или сохранять логику интерпретации с риском превратить команду с параметрами в команду без параметров? Если бы, допустим, шаблон, которому не нашлось соответствия, попросту удалялся, то команда ls *y* превратилась бы в ls и неожиданно выдала бы содержимое всего каталога. Авторы bash (как и Стивен Борн, автор самой первой командной оболочки - sh) выбрали более непоследовательный, но и более безопасный первый способ3).

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

История команд

Двумя другими клавишами со стрелками - вверх и вниз - Мефодий тоже активно пользовался, не подозревая, что задействует этим весьма мощный механизм bash - работу с историей команд. Все команды, набранные пользователем, bash запоминает и позволяет обращаться к ним впоследствии. По стрелке вверх (можно использовать и "^P", previous), список поданных команд "прокручивается" от последней к первой, а по стрелке вниз ("^N", next) - обратно. Соответствующая команда отображается в командной строке как только что набранная, ее можно отредактировать и подать оболочке (подгонять курсор к концу строки при этом необязательно).

Если необходимо добыть из истории какую-то давнюю команду, проще не гонять список истории стрелками, а выполнить поиск с помощью команды "^R" (reverse search). При этом выводится подсказка специального вида ("reverse-i-search"), подстрока поиска (окруженная символами ` и ') и последняя из команд в истории, в которой эта подстрока присутствует:

Пример 8.3. Поиск по истории команд (html, txt)

Пример представляет символы, вводимые Мефодием (в левой части до "|"), и содержимое последней строки терминала. Это "кадры" работы с одной и той же строкой, показывающие, как она меняется при наборе. Набрав "info", Мефодий продолжил поиск этой подстроки, повторяя "^R" до тех пор, пока не наткнулся на нужную ему команду, содержащую подстроку "info". Осталось только передать ее bash с помощью Enter.

Чтобы история команд могла сохраняться между сеансами работы пользователя, bash записывает ее в файл .bash_history, находящийся в домашнем каталоге пользователя. Делается это в момент завершения оболочки: накопленная за время работы история дописывается в конец этого файла. При следующем запуске bash считывает .bash_history целиком. История хранится не вечно, количество запоминаемых команд в .bash_history ограничено (обычно сохраняется 500 команд, но это можно и перенастроить).

Язык программирования sh

Некогда Мефодий выучил несколько языков программирования, и уже собрался было написать кое-какие нужные программы на Си или Python, однако Гуревич его остановил. Большая часть того, что нужно начинающему пользователю Linux, делается с помощью одной правильной команды, или вызовом нескольких команд в конвейере. От пользователя только требуется оформить решение задачи в виде сценария на shell. На самом же деле уже самый первый из командных интерпретаторов, sh, был настоящим высокоуровневым языком программирования - если, конечно, считать все утилиты системы его операторами. При таком подходе от sh требуется совсем немного: возможность вызывать утилиты, возможность свободно манипулировать результатом их работы и несколько алгоритмических конструкций (условия и циклы).

К сожалению, программирование на shell, а также других, более мощных интерпретируемых языках в Linux, остается за рамками нашего курса. Так что, пока Мефодий читает документацию по bash и упражняется в написании сценариев, нам остается только поверхностно рассмотреть свойства shell как языка программирования и интегратора команд. Заметим попутно, что писать сценарии для bash - непрактично, так как исполняться они смогут лишь при помощи bash. Если же ограничить себя рамками sh, совместимость с которым объявлена и в bash, и в zsh, и в ash (наиболее близком по возможностям к sh), и в других командных интерпретаторах, выполняться эти сценарии смогут любым из sh-подобных интерпретаторов, и не только в Linux.

Настройка командного интерпретатора

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

Окружение

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

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

[methody@localhost methody]$ date Птн Ноя 5 16:20:16 MSK 2004 [methody@localhost methody]$ LC_TIME=C date Fri Nov 5 16:20:23 MSK 2004

Пример 8.9. Утилита date пользуется переменной окружения LC_TIME (html, txt)

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

Переменные окружения, используемые системой и командным интерпретатором

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

Весьма примечательна переменная окружения PATH. В ней содержится список каталогов, элементы которого разделяются двоеточиями. Если команда в командной строке - не собственная команда shell (вроде cd) и не представлена в виде пути к запускаемому файлу (как /bin/ls или ./script), то shell будет искать эту команду среди имен запускаемых файлов во всех каталогах PATH, и только в них. Точно так же будут поступать и другие утилиты, использующие библиотечную функцию execlp() или execvp() (запуск программы).

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

Пример 8.12. Использование PATH (html, txt)

Пути, указанные в PATH, могут и не существовать на самом деле. Обнаружив в $PATH элемент /home/methody/bin (подкаталог bin домашнего каталога), Мефодий решил, что гораздо правильнее будет складывать исполняемые файлы не куда попало, а именно в этот каталог: во-первых, это упорядочит структуру домашнего каталога, а во-вторых, позволит запускать эти файлы по имени. Но для начала пришлось такой каталог создать. Порядок, при котором собственные программы лежат в специальном каталоге, куда безопаснее беспорядка, при котором поиск запускаемого файла по имени начинается с текущего каталога. Если в текущем каталоге окажется программа ls и этот каталог - не /bin, а, допустим, /home/shogun/dontrunme, тогда следует ожидать подвоха...

Переменных окружения, влияющих на работу разных утилит, довольно много. Например, переменные семейства LC_(полный их список выдается командой locale), определяющие язык, на котором выводятся диагностические сообщения, стандарты на формат даты, денежных единиц, чисел, способы преобразования строк и т. п. Очень важна переменная TERM, определяющая тип терминала: как известно из лекции 2, разные терминалы имеют различные управляющие последовательности, поэтому программы, желающие эти последовательности использовать, обязательно сверяются с переменной TERM2). Если какая-то утилита требует редактирования файла, этот файл передается программе, путь к которой хранится в переменной EDITOR (обычно это /usr/bin/vi, о котором речь пойдет в лекции 9). Наконец, некоторые переменные вроде UID, USER или PWD просто содержат полезную информацию, которую можно было бы добыть и другими способами.

Некоторые переменные окружения предназначены специально для bash: они задают его свойства и особенности поведения. Таковы переменные семейства PS (Prompt String). В этих переменных хранится строка-подсказка, которую командный интерпретатор выводит в разных состояниях. В частности, содержимое PS1 - это подсказка, которую shell показывает, когда вводит командную строку, а PS2 - когда пользователь нажимает Enter, а интерпретатор по какой-то причине считает, что ввод командной строки не завершен (например, не закрыты кавычки). С $PS2 (символом ">") Мефодий уже сталкивался в лекциях 2 и 7:

[methody@localhost methody]$ cd examples/ [methody@localhost examples]$ echo $PS1 [\u@\h \W]\$ [methody@localhost examples]$ PS1="--> " --> --> PS1="\t \w " 22:11:47 ~ 22:11:48 ~ 22:11:48 ~ PS1="\u@\h:\w \$ " methody@localhost:~/examples $ methody@localhost:~/examples $ methody@localhost:~/examples $ cd methody@localhost:~ $ methody@localhost:~ $

Пример 8.13. Использование переменной окружения PS1 (html, txt)

Мефодий экспериментировал с PS1, параллельно читая документацию по bash ("(bash.info)Printing a Prompt"). Оказывается, в этом командном интерпретаторе содержимое PS1 не просто подставляется при выводе - оно еще и преобразуется, позволяя выводить всякую полезную информацию: имя пользователя (соответствует подстроке "\u", user), имя компьютера ("\h", host), время ("\t", time), путь к текущему каталогу ("\w", work directory) и т. п. В примере Мефодий заменил "\W" (показывающую последний элемент пути, то есть собственное имя текущего каталога) на "\w", полный путь, потому что "\w" обладает свойством выделять в полном пути домашний каталог и заменять его на "~". Такое преобразование значений переменных семейства PS1 выполняется, только когда их использует bash в качестве подсказки, а при обычной подстановке этого не происходит.

a localhost 38400 baud; rows

[methody@localhost methody]$ stty - a localhost 38400 baud; rows 30; columns 80; line = 0; intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = ; eol2 = ; start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R; werase = ^W; lnext = ^V; flush = ^O; min = 1; time = 0; -parenb -parodd cs8 hupcl -cstopb cread -clocal -crtscts -ignbrk -brkint -ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl ixon -ixoff -iuclc -ixany -imaxbel -iutf8 opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0 isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt echoctl echoke

Пример 8.1. Настройки терминальной линии

Закрыть окно

Пример 8.2. Экранирование управляющих символов

Закрыть окно

Пример 8.3. Поиск по истории команд

Закрыть окно

[methody@localhost methody]$ alias alias cd..='cd ..' alias cp='cp -i' alias l='ls -lapt' alias ll='ls -laptc' alias ls='ls --color=auto' alias md='mkdir' alias mv='mv -i' alias rd='rmdir' alias rm='rm -i'

Пример 8.4. Просмотр заранее определенных сокращений

Закрыть окно

[methody@localhost methody]$ unalias cp rm mv [methody@localhost methody]$ alias pd=pushd [methody@localhost methody]$ alias pp=popd [methody@localhost methody]$ pd /bin /bin ~ [methody@localhost bin]$ pd /usr/share/doc /usr/share/doc /bin ~ [methody@localhost doc]$ cd /var/tmp [methody@localhost tmp]$ dirs /var/tmp /bin ~ [methody@localhost tmp]$ pp /bin ~ [methody@localhost bin]$ pp ~ [methody@localhost methody]$ pp -bash: popd: directory stack empty

Пример 8.5. Использование сокращений и pushd/popd

Закрыть окно

Пример 8.6. Использование достраивания

Закрыть окно

Пример 8.7. Использование шаблона в командной строке

Закрыть окно

Пример 8.8. Экранирование специальных символов и обработка "пустых" шаблонов

Закрыть окно

[methody@localhost methody]$ date Птн Ноя 5 16:20:16 MSK 2004 [methody@localhost methody]$ LC_TIME=C date Fri Nov 5 16:20:23 MSK 2004

Пример 8.9. Утилита date пользуется переменной окружения LC_TIME

Закрыть окно

[methody@localhost methody]$ A=dit [methody@localhost methody]$ C=dah [methody@localhost methody]$ echo $A $B $ C dit dah [methody@localhost methody]$ B=" " [methody@localhost methody]$ echo $A $B $C dit dah [methody@localhost methody]$ echo "$A $B $C" dit dah [methody@localhost methody]$ echo '$A $B $C' $A $B $C

Пример 8.10. Подстановка значений переменных

Закрыть окно

[methody@localhost methody]$ echo "$Qwe -- $LANG" -- ru_RU.KOI8-R [methody@localhost methody]$ Qwe="Rty" LANG=C [methody@localhost methody]$ echo "$Qwe -- $LANG" Rty -- C [methody@localhost methody]$ sh sh-2.05b$ echo "$Qwe -- $LANG" -- C sh-2.05b$ exit [methody@localhost methody]$ echo "$Qwe -- $LANG" Rty -- C [methody@localhost methody]$ export Qwe [methody@localhost methody]$ sh sh-2.05b$ echo "$Qwe -- $LANG" Rty -- C sh-2.05b$ exit

Пример 8.11. Экспорт переменных shell в окружение

Закрыть окно

[methody@localhost methody]$ echo $PATH /home/methody/bin:/bin:/usr/bin:/usr/local/bin:/usr/X11R6/bin:/usr/games [methody@localhost methody]$ mkdir /home/methody/bin [methody@localhost methody]$ mv to. sort loop script bin/ [methody@localhost methody]$ script Hello, Methody!

Пример 8.12. Использование PATH

Закрыть окно

Пример 8.13. Использование переменной окружения PS1

Закрыть окно

[methody@localhost methody]$ grep Methody bin/script echo 'Hello, Methody!' [methody@localhost methody]$ grep -q Methody bin/script ; echo $? 0 [methody@localhost methody]$ grep -q Shogun bin/script ; echo $? 1 [methody@localhost methody]$ if grep -q Shogun bin/script ; then echo "Yes"; fi [methody@localhost methody]$ if grep -q Methody bin/script ; then echo "Yes"; fi Yes

Пример 8.14. Оператор if использует код возврата программы grep

Закрыть окно

[methody@localhost methody]$ if test -f examples ; then ls -ld examples ; fi [methody@localhost methody]$ if [ -d examples ] ; then ls -ld examples ; fi drwxr-xr-x 2 methody methody 4096 Окт 31 15:26 examples [methody@localhost methody]$ A=8; B=6; if [ $A -lt $B ] ; then echo "$A<$B" ; fi [methody@localhost methody]$ A=5; B=6; if [ $A -lt $B ] ; then echo "$A<$B" ; fi 5<6

Пример 8.15. Оператор test

Закрыть окно

Пример 8.16. Подстановка вывода команды

Закрыть окно

[methody@localhost methody]$ cat > bin/two #!/bin/sh echo "Running $0: $*" $1 $3 $2 $3 [methody@localhost methody]$ chmod +x bin/two [methody@localhost methody]$ bin/two file "ls -ld" examples Running bin/two: file ls -ld examples examples: directory drwxr-xr-x 2 methody methody 4096 Окт 31 15:26 examples [methody@localhost methody]$ two "ls -s" wc "bin/two bin/loop" junk Running /home/methody/bin/two: ls -s wc bin/two bin/loop junk 4 bin/loop 4 bin/two 4 9 44 bin/two 1 5 26 bin/loop 5 14 70 итого

Пример 8.17. Использование позиционных параметров в сценарии

Закрыть окно

[methody@localhost methody]$ for Var in Wuff-Wuff Miaou-Miaou; do echo $Var; done Wuff-Wuff Miaou-Miaou [methody@localhost methody]$ for F in `date`; do echo -n "<$F>"; done; echo <Сбт><Ноя><6><12:08:38><2004> [methody@localhost methody]$ cat > /tmp/setvar QWERTY="$1" [methody@localhost methody]$ sh /tmp/setvar 1 2 3; echo $QWERTY [methody@localhost methody]$ . /tmp/setvar 1 2 3; echo $QWERTY 1

Пример 8.18. Использование for и операции "."

Закрыть окно

"\e[5~": backward-word "\e[6~": forward-word

Пример 8. 19. Настройка .inputrc

Закрыть окно

PS1="\u@\h:\w \$ " EDITOR="/usr/bin/vim" export PS1 EDITOR # Get the aliases and functions if [ -f ~/.bashrc ]; then . ~/.bashrc fi

Пример 8.20. Пример файла .bash_profile

Закрыть окно

# User specific aliases and functions if [ -r ~/.alias ]; then . ~/.alias fi # Source global definitions if [ -r /etc/bashrc ]; then . /etc/bashrc fi

Пример 8.21. Пример файла .bashrc

Закрыть окно

alias > ~/.alias

Пример 8.22. Пример файла .bash_logout

Закрыть окно

alias l='ls -FAC' alias ls='ls --color=auto' alias pd='pushd' alias pp='popd' alias v='ls -ali' alias vi='/usr/bin/vim'

Пример 8.23. Пример файла .alias

Закрыть окно

Пример настроек

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

PS1="\u@\h:\w \$ " EDITOR="/usr/bin/vim" export PS1 EDITOR # Get the aliases and functions if [ -f ~/.bashrc ]; then . ~/.bashrc fi

Пример 8.20. Пример файла .bash_profile (html, txt)

В этом файле вызывается ~/.bashrc (если он существует).

# User specific aliases and functions if [ -r ~/.alias ]; then . ~/.alias fi # Source global definitions if [ -r /etc/bashrc ]; then . /etc/bashrc fi

Пример 8.21. Пример файла .bashrc (html, txt)

Мефодий решил, что сокращения удобнее будет хранить в отдельном файле - ~/.alias. Кроме того, вызывается сценарий bashrc, который Мефодий обнаружил в каталоге /etc. Этот файл не входит в число автоматически выполняемых bash, поэтому его выполнение надо задавать явно:

alias > ~/.alias

Пример 8.22. Пример файла .bash_logout (html, txt)

Заметив, что команда alias выдает список сокращений в том же формате, в котором они и задаются, Мефодий придумал, как обойтись без редактирования файла ~/.alias. Отныне все сокращения, определенные к моменту завершения сеанса работы, будут записываться обратно в .alias. Туда попадут и те сокращения, что были считаны во время выполнения .bashrc, и те, что впоследствии были определены вручную:

alias l='ls -FAC' alias ls='ls --color=auto' alias pd='pushd' alias pp='popd' alias v='ls -ali' alias vi='/usr/bin/vim'

Пример 8.23. Пример файла .alias (html, txt)

Последняя запись в файле .alias относится к инструменту, с помощью которого Мефодий создавал все эти файлы: текстовому редактору vim. О текстовых редакторах речь пойдет в следующей лекции.

4)
Можно вспомнить про нулевой параметр командной строки, обсуждавшийся в лекции 5.

5)
Генерация имен файлов в "zsh" предусматривает специальный шаблон "**", которому соответствуют подстройки с любым количеством "/". Пользоваться им следует крайне осторожно, понимая, что при генерации имен по такому шаблону выполняется операция, аналогичная не ls, а ls -R или find. Так, использование "/**" в начале шаблона вызовет просмотр всей файловой системы!

6)
Авторы zsh пошли по другому пути: в этой версии shell использование шаблона, которому не соответствует ни одно имя файла, приводит к ошибке, и соответствующая команда не выполняется.

7)
Эта ситуация называется "race condition" ("состояние гонки"), и часто встречается в плохо спроектированных системах, где есть хотя бы два параллельных процесса

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

Привязка к клавишам

Оказалось, что настройка управляющих клавиш в bash не выглядит как сценарий, и даже имеет отношение не только к bash, а ко всем программам, использующим библиотеку терминального ввода readline. Конфигурационный файл readline называется .inputrc и состоит, в основном, из команд вида "управляющая_последовательность": функция, где управляющая_последовательность - это символы, при получении которых readline выполнит функцию работы с вводимой строкой. Список всех функций readline можно узнать у bash по команде bind -l, а список всех привязок этих функций к клавиатурным последовательностям - по команде bind -p. Мефодий вписал в .inputrc такие две строки:

"\e[5~": backward-word "\e[6~": forward-word

Пример 8.19. Настройка .inputrc (html, txt)

Упомянутые в примере функции позволяют перемещать курсор в командной строке по словам, а esc-последовательности возвращаются, соответственно, клавишами Page Up и Page Down виртуальной консоли Linux (сочетание "\e" означает в .Inputrc клавишу esc, то есть "^[", символ с ASCII-кодом 27).

К одной и той же функции readline можно привязать сколько угодно управляющих последовательностей: например, клавиша home делает то же, что и "^A", Стрелка вверх - то же, что и "^P", а Del - то же, что и "^D" (только не в пустой строке!). Таким образом отчасти решается проблема несовместимости управляющих последовательностей терминалов: если в каком-нибудь терминале другого типа Page Up или Page Down будут возвращать другие последовательности, Мефодий просто добавит в .inputrc еще одну пару команд. Правда, Гуревич советовал ему вовсе отказаться от редактирования .inputrc, а воспользоваться утилитой tput, которая обращается к переменной TERM и базе данных по терминалам terminfo и готова выдать верную для любого данного терминала информацию по kpp (key previous page) и knp (key next page). Выдачу tput можно "скормить" той же bind, и получить команду, которая работает на любом терминале: bind "\"`tput kpp`\": backward-word" (кавычки, экранированные обратной косой чертой, \", передадутся bind в неизменном виде)

Работа с переменными в shell

В последнем примере Мефодий воспользовался подсмотренным у Гуревича приемом: присвоил некоторое значение переменной окружения в командной строке перед именем команды. Командный интерпретатор, увидев "=" внутри первого слова командной строки, приходит к выводу, что это - операция присваивания, а не имя команды, и запоминает, как надо изменить окружение команды, которая последует далее. Переменная окружения LC_TIME предписывает использовать определенный язык при выводе даты и времени, а значение "C" соответствует стандартному системному языку (чаще всего - английскому).

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

[methody@localhost methody]$ A=dit [methody@localhost methody]$ C=dah [methody@localhost methody]$ echo $A $B $C dit dah [methody@localhost methody]$ B=" " [methody@localhost methody]$ echo $A $B $C dit dah [methody@localhost methody]$ echo "$A $B $C" dit dah [methody@localhost methody]$ echo '$A $B $C' $A $B $C

Пример 8.10. Подстановка значений переменных (html, txt)

Как видно из примера, значение неопределенной переменной (B) в shell считается пустым и при подстановке не выводится никаких предупреждений. Сама подстановка происходит, как и генерация имен, перед разбором командной строки, набранной пользователем. Поэтому вторая команда echo в примере получила, как и первая, два параметра ("dit" и "dah"), несмотря на то, что переменная B была к тому времени определена и содержала разделитель-пробел. А вот третья и четвертая команды echo получили по одному параметру. Здесь сказалось различие между одинарными и двойными кавычками в shell: внутри двойных кавычек действует подстановка значений переменных.

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

Пример 8.11. Экспорт переменных shell в окружение (html, txt)

Здесь Мефодий завел новую переменную Qwe и изменил значение переменной окружения LANG, доставшейся стартовому bash от программы login. В результате запущенный дочерний процесс sh получил измененное значение LANG и никакой переменной Qwe в окружении. После export Qwe эта переменная была добавлена в окружение и, соответственно, передалась sh.

Редактирование командной строки

Даже не изучая специально возможностей командной оболочки, Мефодий активно использовал некоторые из них, не доступные при вводе текста большинству утилит (в частности, ни cat, ни hexdump). Речь идет о клавишах Стрелка влево и Стрелка вправо, с помощью которых можно перемещать курсор по командной строке, и клавише Del, удаляющей символ под курсором, а не позади него. В лекции 2 он уже убедился, что эти команды работают в bash, но не работают для cat. Более того, в простом командном интерпретаторе - sh - они тоже не работают.

Следовательно, возможности редактора командной строки специфичны для разных командных оболочек. Однако самые необходимые команды редактирования поддерживаются во всех разновидностях shell сходным образом. По словам Гуревича "во всех видах Linux обязательно есть bash, а если ты достаточно опытен, чтобы устанавливать и настраивать пакеты, можешь установить zsh, у него возможностей больше, чем может понадобиться одному человеку". Поэтому Мефодий занялся изучением документации по bash, что оказалось делом непростым, ибо в bash.info он насчитал более восьми с половиной тысяч строк. Даже про редактирование командной строки написано столько, что за один раз прочесть трудно.

Попытка "наскоком" узнать все про работу в командной строке принесла некоторую пользу. Во-первых, перемещаться в командной строке можно не только по одному символу вперед и назад, но и по словам: команды escF/escB или Alt+F/Alt+B соответственно (от forward и backward), работают также клавиши home и end, или, что то же самое, "^A" и "^E". А во-вторых, помимо работы с одной командной строкой, существует еще немало других удобств, о которых и пойдет речь в этой лекции.

Редактирование ввода

Некоторое время поработав в Linux и понабирав команды в командной строке, Мефодий пришел к выводу, что в "общении" с оболочкой не помешают кое-какие удобства. Одно из таких удобств - возможность редактировать вводимую строку с помощью клавиши Backspace (удаление последнего символа), "^W" (удаление слова) и "^U" (удаление всей строки) - предоставляет сам терминал Linux. Эти команды работают для любого построчного ввода: например, если запустить программу cat без параметров, чтобы та немедленно отображала вводимые с терминала строки. Если по каким-то причинам в строчку на экране попало что-то лишнее, можно нажать "^R" (redraw) - система выведет в новой строке содержимое входного буфера.

Мефодий не забыл, что cat без параметров следует завершать командой "^D" (конец ввода). Эту команду, как и предыдущие, интерпретирует при вводе с терминала система. И она же превращает некоторые другие управляющие символы (например, "^C" или "^Z") в сигналы. В действительности все управляющие символы, интерпретируемые системой, можно перенастроить с помощью команды stty. Полный список того, что можно настраивать, выдает команда stty -a:

Пример 8.1. Настройки терминальной линии (html, txt)

При виде столь обширных возможностей Мефодий немедленно взялся читать руководство (man stty), однако нашел в нем не так уж много для себя полезного. Из управляющих символов (строки со второй по четвертую) интересны "^S" и "^Q", с помощью которых можно, соответственно, приостановить и возобновить выдачу на терминал (если текста вывелось уже много, а прочесть его не успеваешь). Можно заметить, что настройка erase (удаление одного символа) соответствует управляющему символу, который возвращается клавишей Backspace именно виртуальной консоли Linux - "^?". На многих терминалах клавиша Backspace возвращает другой символ - "^H". Если необходимо переопределить настройку erase, можно воспользоваться командой "stty erase ^H", причем "^H" (для удобства) разрешено вводить и как два символа: "^" и "H".

Наконец, чтобы лишить передаваемый символ его управляющих функций (если, например, требуется передать программе на ввод символ с кодом 3, т. е. "^C"), непосредственно перед вводом этого символа нужно подать команду "^V" (lnext):

Пример 8.2. Экранирование управляющих символов (html, txt)

Здесь Мефодий прервал, как и собирался, работу первого из cat. При этом до hexdump, фильтра, переводящего входной поток в шестнадцатеричное представление, дело даже не дошло, потому что cat не успел обработать ни одной строки. Во втором случае "^C" после "^V" потеряло управляющий смысл и отобразилось при вводе. С ключом "-C" hexdump выводит также и текстовое представление входного потока, заменяя непечатные символы точками. Так, на точки были заменены и "^C" (ASCII-код 03), и возвращаемый Enter символ конца строки (ASCII-код 0a, в десятичном виде - 10). Ни "^V", ни "^D" на вход hexdump, конечно, не попали: их, как управляющие, обработала система.

Прочие настройки stty относятся к обработке текста при выводе на терминал и вводе с него. Они интересны только в том смысле, что при их изменении работать с командной оболочкой становится неудобно. Например, настройка echo определяет, будет ли система отображать на экране все, что вводит пользователь. При включенном echo нажатие любой алфавитно-цифровой клавиши (ввод символа) приводит к тому, что система (устройство типа tty) выведет этот символ на терминал. Настройка отключается, когда с клавиатуры вводится пароль. При этом трудно отделаться от ощущения, что ввода с клавиатуры не происходит. Еще хуже обстоит дело с настройками, состоящими из кусков вида "i", "o", "cr" и "nl". Эти настройки управляют преобразованием при вводе и выводе исторически сложившегося обозначения конца строки двумя символами в один, принятый в Linux. Может случиться так, что клавиша Enter терминала возвращает как раз неправильный символ конца строки, а преобразование отключено. Тогда вместо Enter следует использовать "^J" - символ, на самом деле соответствующий концу строки.

Во всех случаях, когда терминал находится в непонятном состоянии - не реагирует на Enter, не показывает ввода, не удаляет символов, выводит текст "ступеньками" и т. п., рекомендуется "лечить" настройки терминала с помощью stty sane - специальной формы stty, сбрасывающей настройки терминала в некоторое пригодное к работе состояние. Если непонятное состояние терминала возникло однократно, например, после аварийного завершения экранной программы (редактора vim или оболочки mc), то можно воспользоваться командой reset. Она заново настраивает терминал в полном соответствии с системной конфигурацией (указанной в файле /etc/inittab, см. лекцию 10) и terminfo1).

Сценарии

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

Пример 8.17. Использование позиционных параметров в сценарии (html, txt)

Как видно из примера, форма "$номер_параметра" позволяет обратиться и к нулевому параметру - команде, а вся строка параметров хранится в переменной "*". Кроме того, свойство подстановки выполняться до разбора командной строки позволило Мефодию передать в качестве одного параметра "ls -ld" или "bin/two bin/loop", а интерпретатору - разбить эти параметры на имя команды и ключи и два имени файла соответственно.

В sh есть и оператор while, формат которого аналогичен if, и более удобный именно в сценариях оператор обхода списка for (список делится на слова так же, как и командная строка - с помощью разделителей):

Пример 8.18. Использование for и операции "." (html, txt)

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

Во втором for Мефодий воспользовался подстановкой вывода команды date, каждое слово которой вывел с помощью echo -n в одну строку, а в конце команды пришлось вывести один перевод строки вручную.

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

Шаблоны

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

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

Шаблону, состоящему только из обычных символов, соответствует единственная строка, состоящая из тех же символов в том же порядке. Например, шаблону "abc" соответствует строка abc, но не aBc или ABC, потому что большие и маленькие буквы различаются. Шаблону, состоящему из единственного спецсимвола "*", соответствует любая строка любой длины (в том числе и пустая). Шаблону, состоящему из единственного спецсимвола "?", соответствует любая строка длиной в один символ, например, a, + или @, но не ab или 8888. Шаблону, состоящему из любых символов, заключенных в квадратные скобки "[" и "]" соответствует строка длиной в один символ, причем этот символ должен встречаться среди заключенных в скобки. Например, шаблону "[bar]" соответствуют только строки a, b и r, но не c, B, bar или ab. Символы внутри скобок можно не перечислять полностью, а задавать диапазон, в начале которого стоит символ с наименьшим ASCII-кодом, затем следует "-", а затем - символ с наибольшим ASCII-кодом. Например, шаблону "[0-9a-fA-F]" соответствует одна шестнадцатеричная цифра (скажем, 5, e или C). Если после "[" в шаблоне следует "!", то ему соответствует строка из одного символа, не перечисленного между скобками. Шаблону, состоящему из нескольких частей, соответствует строка, которую можно разбить на столько же подстрок (возможно, пустых), причем первая подстрока будет отвечать первой части шаблона, вторая - второй и т. д. Например, шаблону "a*b?c" будут соответствовать строки ab@c ("*" соответствует пустая подстрока), a+b=c и aaabbc, но не будут соответствовать abc ("?" соответствует подстрока c, а для "c" соответствия не находится), @ab@c (нет соответствия для "a") или aaabbbc (из трех b первое соответствует "b", второе - "?", а вот третье приходится на "c").

Шаблон (pattern) - строка специального формата, используемая в процедурах текстового поиска. Говорят, что строка соответствует шаблону, если можно по определенным правилам каждому символу строки поставить в соответствие символ шаблона. В Linux наиболее популярны шаблоны в формате командного интерпретатора и регулярные выражения.

Сокращения

Поиск по истории - удобное средство: длинную командную строку можно не набирать целиком, а отыскать и использовать. Однако давнюю команду придется добывать с помощью нескольких "^R" - а можно и совсем не доискаться, если она уже выбыла оттуда. Для того чтобы оперативно заменять короткие команды длинными, стоит воспользоваться сокращениями (aliases). В конфигурационных файлах командного интерпретатора пользователя обычно уже определено несколько сокращений, список которых можно посмотреть с помощью команды alias без параметров:

Пример 8.4. Просмотр заранее определенных сокращений (html, txt)

С сокращениями Мефодий уже сталкивался в примерах, приведенных в лекции 6, где команда ls отказалась работать в согласии с теорией. Выяснилось, что по команде ls вместо утилиты /bin/ls bash запускает собственную команду-сокращение, превращающееся в команду ls --color=auto. Повторно появившуюся в команде подстроку "ls" интерпретатор уже не обрабатывает, во избежание вечного цикла. Например, команда ls -al превращается в результате в ls --color=auto -al. Точно так же любая команда, начинающаяся с rm, превращается в rm -i (interactive), что Мефодия крайне раздражает, потому что ни одно удаление не обходится без вопросов в стиле "rm: удалить обычный файл `файл'?":

Пример 8.5. Использование сокращений и pushd/popd (html, txt)

От надоедливого "-i" Мефодий избавился с помощью команды unalias, а заодно ввел сокращения для полюбившихся ему команд bash - pushd и popd. Эти команды1), подобно cd, меняют текущий каталог. Разница состоит в том, что pushd все каталоги, которые пользователь делает текущими, запоминает в особом списке (стеке). Команда popd удаляет последний элемент этого стека и делает текущим каталогом предпоследний. Обе команды вдобавок выводят содержимое стека каталогов (то же самое делает и команда dirs). Команда cd в bash также работает со стеком каталогов: она заменяет его последний элемент новым.

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

Стартовые сценарии

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

Что касается bash, то структура его стартовых файлов сложнее. Прежде всего, ~/.profile выполняется, только если в домашнем каталоге нет файла .bash_profile или .bash_login, иначе стартовый сценарий берется оттуда. В эти файлы можно помещать команды, несовместимые с другими версиями shell, например, управление сокращениями или привязку функций к клавишам. Кроме того, каждый интерактивный (взаимодействующий с пользователем), но не стартовый bash выполняет системный и персональный конфигурационные сценарии /etc/bashrc и ~/.bashrc. Чтобы стартовый bash также выполнял ~/.bashrc, соответствующую команду необходимо вписать в ~/.bash_profile. Далее, каждый неинтерактивный (запущенный для выполнения сценария) bash сверяется с переменной окружения BASH_ENV и, если в этой переменной записано имя существующего файла, выполняет команды оттуда. Наконец, при завершении стартового bash выполняются команды из файла ~/.bash_logout.