Как создать shell файл и сделать его выполняемым
Добавил пользователь Владимир З. Обновлено: 19.09.2024
В Linux, так же как и в операционных системах семейства Microsoft Windows можно создавать командный файл . которые содержат в себе набор команд интерпретатора shell. Такие файлы имеют свой синтаксис, который позволяет оперировать такими структурами как циклы и условия. Далее основы shell программирования linux на примере командной строки ubuntu 9.04 и интерпретатора bash.
Основы
Запишем в файл sample последовательность команд
$ cat sample
pwd
ls
echo The END
А теперь выполним эти команды
$ sh sample
/home/sgww
cpp file.txt mydaemon net_sh perl php sample
The END
Таков принцип .
Командный файл легко сделать исполняемым
$ chmod +x sample
$ /home/sgww/sample
/home/sgww
cpp file.txt mydaemon net_sh perl php sample
The END
Параметры
$1, $2 . $9 - позволяют задавать аргументы командной строки для выполняемого файла
$ cat sample
echo the first parameter: $1
echo the second parametr: $2
echo the third parameter: $3
ls $1 $2 $3
$ /home/sgww/sample -l -s -r
the first parameter: -l
the second parametr: -s
the third parameter: -rtotal 28
4 -rwxr-xr-x 1 sgww sgww 100 Mar 2 11:19 sample
4 drwxr-xr-x 2 sgww sgww 4096 Dec 15 16:52 php
4 drwxr-xr-x 2 sgww sgww 4096 Feb 1 15:39 perl
4 -rw-r--r-- 1 sgww sgww 79 Mar 1 16:16 net_sh
4 drwxr-xr-x 2 sgww sgww 4096 Feb 1 17:15 mydaemon
4 -rw-r--r-- 1 sgww sgww 56 Mar 1 17:18 file.txt
drwxr-xr-x 2 sgww sgww 4096 Feb 1 17:15 cpp
Переменные
Имя переменной может начинаться с буквы или символа подчереркивания
знак равенства(=) это оператор присваиивания
_var=1
_word =slovo
value="t ak aia dli nna iain epo niat naia str oka"
Тип данных переменных shell это всегда строка символов!
$ cat sample
_string="Hello from Perm"
echo $_string
$ /home/sgww/sample
Hello from Perm
результат выполения команды в переменную (команда обрамляется обратными апострофами)
$cat sample
_date=`date`
echo $_date
$/home/sgww/sample
Tue Mar 2 11:41:30 YEKT 201
ввод значения переменной в консоли
$ cat sample
echo Enter data:
read data1
read data2
echo Your data: $data1 and $data2
$ /home/sgww/sample
Enter data:
Linux
Windows
Your data: Linux and Windows
Системные переменные
$ cat sample
echo $PATH
echo $HOME
echo $MAIL
echo $SHELL
$ /home/sgww/sample
/usr/local/bin:/usr/bin:/bin:/usr/bin/X1 1:/usr/games
/home/sgww
/var/mail/sgww
/bin/bash
PATH - пути поиска исполняемых файло (так как каталога /home/sgww/ там нет, постояно приходилось писать полный путь /home/sgww/sample для выполнения команды)
HOME - домашний каталог
MAIL - файл электронной почты
SHELL - оболочка в которой работаем
Добавим к переменной PATH каталог HOME что бы не приходилось постоянно писать полный путь
$ cat sample
PATH=$PATH:$HOME
Эти строки следует добавить в ~/.profile или ~/.bash_profile
теперь нет необходимости писать полный путь до команды
Специальные символы
* - любая последовательность, любых символов
? - один любой символ
[. ] - любой из символов диапазона
$echo *
cpp file.txt mydaemon net_sh perl php sample
$ echo "*"
*
$ cat sample
text="This is a text"
echo '$text'
$ sample
$text
$ cat sample
text="This is a text"
echo \$text
$ sample
$text
$ cat sample
text=`pwd`
echo $text
$ sample
/home/sgww
Арифметические операции
Для выполнения арифметических операций в командном файле понадобиться команда expr
$ expr 7 + 96
103
$ expr 87 - 555
-468
$ expr 18 / 2
9
$ expr 19 / 2
9
$ expr 19 % 2
1
$ expr 6 \* 32
192
$ expr 6 '*' 32
192
$ expr 6 * 32
expr: syntax error
Если при умножении не поставить \ или '' то * будет восприниматься как любой символ
Стоит отметить, что \ - это не деление, а целая часть от деления, операция % дает остаток от деления
Переменные окружения, команда export и unset
Для взаимодейстивя с другими процессами могут пригодияться переменные окружения
Их полный списко можно посмотреть командой export
$ export
declare -x HISTCONTROL="ignoreboth"
declare -x HOME="/home/sgww"
declare -x LESSCLOSE="/usr/bin/lesspipe %s %s"
declare -x LESSOPEN="| /usr/bin/lesspipe %s"
declare -x LOGNAME="sgww"
.
Задать свою переменную
$ name=Pavel && export name
$ echo $name
Pavel
$ unset name
$ echo name
Условие IF
Для составления условных выражений оператора if очень полезна программа test.
$ cat sample
if test -r sample
then
echo True
else
echo False
fi
$ sample
True
В этом примере test -r sample - это условие
echo True выполняется если условие истино
echo False если ложно
Программа test предназначена для проверки типов файлов и сравнения значений
$ x=32 && export x
$ y=32 && export y
Остальные параметры можно посмотреть в man test
Цикл FOR
$ cat sample
for x in 1 two 3
do
echo $x
done
$ sample
1
two
3
В этом цикле код между do и done выполниться 3 раза, при этом первый раз
x=1, второй раз x=two и последний x=3
Другой интересный пример
$ cat sample
for x in *
do
echo $x
done
$ sample
cpp
demo
file.txt
mydaemon
net_sh
perl
php
sample
* в списке переменных цикла, заставляет for использовать в качестве значения $x элементы текущего каталога
Циклы WHILE и UNTIL
$ cat sample
while test -r file
do
sleep 10
echo file exists
done
echo file does not exist
$ touch file
$ sample
file exists
file exists
Ctr+Z
[1]+ Stopped sample
$ rm file
$ fg
sample
file exists
file does not exist
$ cat sample
until test -r file
do
sleep 5
echo file does not exist
done
echo file exists
$ sample
file does not exist
file does not exist
Ctr+Z
[1]+ Stopped sample
$ touch file
$ fg
sample
file does not exist
file exists
$
Главная >> Linux >> Linux. Ubuntu. Как создать sh-скрипт?
Создание sh-скриптов позволяет, в простейшем случае, легко объединять множество команд, которые должны быть выполнены пакетно в один исполнимый файл.
Итак, теория скучна — разберем простейший пример:
Разберем файл. В первой строке обязательная для файлов sh строка, указывающая, что перед нами именно shell-скрипт.
Далее идет последовательность команд — 1 строка — одна команда. В нашем примере мы сначала создаем папку scripts, далее переходим в нее и создаем там три файла. В последней строке мы выводим на экран список файлов с текущей директории — т.е. видим три наших новосозданных файла.
После создания файла ему надо дать права на исполнение — в консоли это делается так:
Shell: что это такое и зачем он нужен
Интерпретатор командной строки, или shell (shell -- оболочка) -- эта та программа, которая принимает команды от пользователя и исполняет их.
- Взаимодействие с пользователем (редактирование командной строки, история команд и т.д.).
- Обработка (расширение) шаблонов имен (" * ", " ? " и т.д.).
- Перенаправление ввода/вывода команд.
- Управление заданиями.
Кроме того, shell -- это специализированный язык программирования, в котором есть переменные, конструкции while, if, for и т.д., функции и много чего еще. Он позволяет писать как несложные сценарии для автоматизации повседневных задач, так и довольно сложные программы (например, запуск и останов большинства Unix'ов производятся сценариями на языке shell).
Хотя работа непосредственно в командной строке (а не в оболочке типа NortonCommander или какой-нибудь оконной) на первый взгляд не столь удобна, она обеспечивает более удобный доступ к таким функциям, как перенаправление ввода/вывода и управление заданиями -- оболочки типа Midnight Commander в этом случае будут только мешать.
Shell -- это не одна конкретная программа. Исторически существует несколько подвидов оболочек; "генеалогическое древо" представлено на Рис.1.
| Рис.1: семейство интерпретаторов командной строки |
Не вдаваясь в подробности истории (краткое описание можно найти в разделе 3.10 книги "Unix: универсальная среда программирования" Кернигана и Пайка), стоит лишь заметить, что csh и tcsh не в полной мере реализуют командный язык sh, а zsh, являясь самой последней разработкой, умеет все, что и любой другой подвид, и плюс много чего еще.
Кроме того, поскольку командный интерпретатор имеет десятки параметров для настройки, не следует удивляться, увидев, что некая знакомая оболочка на другом компьютере выглядит и ведет себя по другому.
Изложение в данном разделе основано на zsh (которая и используется на практических занятиях), но большая часть описанного верно и для других оболочек.
| Совет: чтобы узнать, какой используется shell, надо выполнить команду
Перенаправление ввода/вывода file", "less file" 2. "cp src1 src2 dst" -- ошибка, "cat src1 src2 >dst" -- ok 3. "cat src >>dst" 4. "ls -l | less" 5. "sort log" -- ? : stderr! "ls -l >log 2>errlog", 2>/dev/null, 2>&1 7. zsh: "ls >file1 >file2" ---- 1.5 "ls -l >file" -- "file" войдет в список от ls! --> Представим себе ситуацию: хочется посмотреть листинг директории /bin (в которой лежат многие программы). Выполняем команду " ls -l /bin " и. Результат в экран не помещается. А ведь бывают директории еще большего объема. Что делать? Большинство команд выводят информацию на терминал, а некоторые (например, текстовый редактор) вводят данные с терминала. В Unix есть почти универсальное правило: терминал может быть заменен для ввода, вывода или и того, и другого, на файл . Так, чтобы сохранить вывод нашей команды в файл, надо написать: При этом весь вывод команды ls будет вместо терминала отправлен в файл. Символ " > " означает, что выходной поток должен быть помещен в указанный далее файл, а не выведен на терминал. Если в файле что-то было, то старое содержимое будет стерто. Получив таким образом список файлов, его можно просмотреть командой less . Еще один пример: можно слить содержимое нескольких файлов в один файл, "перехватив" выходной поток команды cat и отправив его в файл: Сделать то же самое при помощи команды cp нельзя: Символ " >> " действует подобно " > ", но указывает на необходимость добавить выходной поток к концу файла, вместо того, чтобы стереть старое содержимое. Например: Первая команда cat скопирует содержимое file1 в all , а вторая -- допишет к нему содержимое file2 и file3 . Использование " >> " очень удобно, если есть некий "долгоживущий" файл (например, протокол каких-то действий или результатов), к которому иногда надо дописывать данные в конец. Просто указать " >> " с какой-нибудь командой обычно намного быстрее, чем загружать файл в текстовый редактор и что-то дописывать. |
Теперь вернемся к нашему первому примеру: как посмотреть листинг большой директории. Мы отправили вывод команды ls в файл, а потом запустили less для его просмотра. Сам же временный файл не имеет никакого смысла -- потом он больше не нужен.
Можно обойтись без временного файла, воспользовавшись конвейером:
Большинство команд, выдающих информацию из файла на экран ( cat, more, less ) устроены так, что они будут читать входной поток, если не указан никакой файл -- вот почему less показывает то, что ему "пришло" от ls .
| В отличие от Dos, где тоже поддерживаются операторы перенаправления ввода/вывода, в Unix команды в конвейере запускаются одновременно, и данные передаются через программный канал (это специальное средство, предоставляемое ядром Unix) сразу от одной программы к другой, а не через скрытый временный файл. |
Можно заставить команду читать вместо терминала не только выходной поток другой команды, но и обычный файл. Это делается при помощи оператора " ", который указывает, что вместо терминала надо брать входной поток из указанного далее файла. Пример (команда " sort " построчно сортирует входные данные):
Что будет, если мы попросим ls показать файлы, которых нет?
Файлы которые есть, ls покажет, а про остальные скажет, что их нет. А теперь перенаправим вывод ls в файл:
В чем же дело?! Казалось бы, на экране ничего не должно появиться.
| Такое перенаправление потока stderr невозможно в оболочках csh и tcsh -- в них для этого используется другой, более запутанный синтаксис. |
Этот способ работает и тогда, когда стандартный вывод отправляется по конвейеру другой программе.
Подробную информацию на эту тему можно найти в info-документации на zsh , набрав команду " info zsh redirection ".
Часто возникает задача: надо найти, в каком файле встречается некое слово или фраза. Для этого служит команда " grep ". Она ищет "образец" в указанных файлах (или в стандартном вводе, если файлы не указаны) и печатает все строки, на которых он встречается. Пример (найти строку " no "):
Каждая строка предваряется именем файла, в котором она найдена, и двоеточием; если указан только один файл (или стандартный ввод), то этого не делается -- просто печатается найденная строка.
С ключом " -i " grep ищет, не различая маленькие/заглавные буквы:
- " . " означает "любой символ".
- " * " -- любое количество повторений (0 и больше) предшествующего символа.
- "^" -- начало строки.
- "$" -- конец строки.
- Специальное значение имеют также символы ? , [ , ] , < , >, | , + , \ .
Поскольку большинство этих символов имеют специальное значение и для оболочки, то образец следует указывать в одинарных кавычках (прямых апострофах).
Пример (найти все символьные линки в директории /etc):
Здесь используется то, что для символьных линков ls первым символом строки (тип файла) выводит букву " l ".
Вообще говоря, в конвейере может участвовать сколько угодно команд. Так, команда
делает почти то же, что и в предыдущем примере, но отбирает только те директории, в имени которых есть "lib".
| Команда grep -- одна из самых полезных и частоиспользуемых в Unix. Она столь же важна для нахождения файлов с нужным содержимым, как ls -- для нахождения файлов с нужным именем. Поэтому стоит хорошо освоить grep -- умелое владение ей позволяет сэкономить массу времени и сил. Кроме того, регулярные выражения широко используются во многих других программах. |
Фоновое исполнение задач
Часто бывает нужно запустить "долгоиграющую" программу, которая все равно пишет данные только в файл (например, какие-либо вычисления), или графическое приложение, которое не пользуется окном терминала. Но ведь пока программа запущена, терминал "принадлежит" ей, и им больше ни для чего нельзя пользоваться!
Unix позволяет запускать задачи в "фоновом режиме": если в конце командной строки указать символ " & ", то после запуска команды терминал можно продолжать использовать для ввода других команд.
Пример (запустить графический калькулятор):
В квадратных скобках shell печатает номер задания, а за ним -- номер процесса (об этом подробнее в следующем разделе).
Таким образом можно запустить в фоновом режиме несколько задач -- например, калькулятор, текстовый редактор и "снежную зиму":
Посмотреть список запущенных задач можно командой " jobs ":
(Символы "+" и "-" означают "последняя запущенная задача" и "предпоследняя").
Если у программы не предусмотрено способа завершить исполнение, то ее можно "убить" командой " kill ":
Символ процента и следующий за ним номер являются ссылкой на конкретное задание.
Если задача случайно запущена без символа " & ", то ее можно или завершить комбинацией клавиш Ctrl+C и потом запустить правильно, или "заморозить", нажав Ctrl+Z , а потом перевести в фоновый режим командой " bg " (сокращение от BackGround):
Бывает и обратное: случайно интерактивная программа (например, текстовый редактор) запущена в фоновом режиме. Интерактивные программы при этом автоматически "замораживаются" (потому, что они пытаются читать с терминала, который ей "не принадлежит"). Перевести их в "основной режим" можно командой " fg " (сокращение от ForeGround):
| Если командам bg и fg не указывать задачу, то они работают с последней запущенной -- той, что помечена символом "+". |
Если попробовать набрать " exit " для выхода из системы (или из окна терминала) при исполняющихся в фоновом режиме задачах, то zsh не позволит выйти:
Повторная команда " exit " все же будет выполнена, но zsh постарается завершить фоновые задачи:
Чтобы zsh не считал своей обязанностью "убитие" фоновых задач при выходе, можно заставить его забыть про них:
| Другие оболочки (bash и tcsh) менее "заботливы", и завершают работу по первой же команде exit , оставляя фоновые задачи "беспризорными". |
Чтобы запустить фоновую задачу и заставить zsh сразу же забыть про нее, надо набрать всю команду (включая " & ") в круглых скобках:
Допустим, запустив задачу в фоновом режиме, пользователь выходит из системы, оставляя задачу работать дальше. Хорошо, если это была графическая программа -- у нее почти наверняка будет хотя бы команда "Выход". А если нет, если это какая-либо счетная задача?
В этом случае придется воспользоваться средствами более низкого (системного) уровня -- управлением процессами.
Здесь следует сразу понять разницу. Задача (job) -- это одна или несколько программ (например, конвейер), запущенных из оболочки, которыми можно управлять при помощи команд оболочки jobs , bg , fg и kill . Процесс (process) -- это любая программа, запущенная любым способом (из оболочки; другой программой -- например, из графического меню; самой операционной системой при запуске и т.д.).
Для просмотра списка процессов служит команда " ps ". У нее есть довольно много ключей, которые к тому же различаются в BSD и SystemV. Поэтому здесь приведем лишь несколько наиболее часто встречающихся вариантов ее использования. В основном изложение относится к BSD-версии команды ps (в том числе и Linux), эквиваленты для SysV-версии (Solaris, IRIX) приведены отдельно.
Команда ps без параметров выводит список почти всех процессов, принадлежащих запустившему ее пользователю.
Из всей информации, что выдает ps , для нас пока интересны поля PID и COMMAND.
PID (Process IDentifier) -- это число, уникальное для каждого процесса, которое используется, например, для того, чтобы приостановить или завершить его исполнение. COMMAND -- название программы и ее параметры.
"Почти" -- потому, что в список не включаются процессы "без терминала", т.е. те, которые запущены в фоновом режиме, а окно, из которого это было сделано, потом было закрыто. Чтобы эти процессы также отображались, надо указать ключ " -x "; в поле TTY у них стоит " ? ".
Ключ " -a " показывает процессы всех пользователей, а не только запустившего ps.
Ключ " -u " выдает более полную информацию о каждом процессе -- потребление процессорного времени, памяти, время запуска.
Ключ " -f " выдает список процессов "со связями", позволяя понять, какой из процессов является чьим "родителем" и чьим "потомком".
Следует заметить, что в получившийся список может попасть и сам grep -- в его командной строке тоже присутствует искомое слово, а поскольку ps и grep исполняются параллельно (а может и не попасть, в случае если команда ps отработает раньше, чем запустится grep ).
| Команда ps в последних версиях Linux при указании любых ключей выдает предупреждение типа На это надо просто не обращать внимания -- просто команда ps сейчас находится в процессе переделки со стандарта BSD на стандарт Unix98, и это предупреждение -- следствие попытки обеспечить совместимость. |
- " ps " без параметров выводит список процессов, запущенных в данной сессии (т.е. в том же окне, что и ps).
- " ps -u пользователь " выводит список всех процессов указанного пользователя.
- " ps -e " показывает все процессы (аналог " ps -a " в BSD)
- " ps -f " показывает более полную информацию (аналог " ps -u " в BSD)
Команде kill можно указывать не только номер задания, но и PID. Так, команда " kill 1206 " пошлет команду завершения процессу с номером 1206. Стоит напомнить, что при запуске задач оболочка кроме номера задания печатает также PID соответствующего процесса (или процессов, в случае конвейера):
Вообще говоря, " kill " не завершает процесс, а посылает ему сигнал . Процесс же, получив сигнал, может завершиться, а может и предпринять какое-либо другое действие, например, проигнорировать сигнал.
Есть несколько десятков сигналов, каждый из которых имеет свой смысл. Каждый сигнал имеет как имя, так и номер, но, поскольку номера разные в разных Unix'ах, то лучше использовать имена. Чтобы указать kill , какой сигнал послать, надо указать его имя (или номер), предваренное дефисом:
Вот список самых часто употребляемых сигналов:
| Сигнал | Назначение |
|---|---|
| TERM | TERMinate -- завершить работу. Используется командой kill по умолчанию |
| INT | INTerrupt. Посылается при нажатии пользователем Ctrl+C |
| STOP | "замерзнуть" |
| CONT | CONTinue -- "размерзнуть" |
| HUP | HangUP -- "повесить трубку". Посылается при выходе пользователя из системы программам, запущенным в этой же сессии |
| KILL | "умереть" |
Сигналы TERM, INT, HUP и KILL обычно приводят к завершению работы программы. Разница между ними в том, в каких случаях они посылаются и в том, что одни сигналы программа перехватывает, а другие -- нет.
Сигнал KILL программа перехватить не может, поэтому если она не реагирует больше ни на что, то остается использовать его. Номер KILL во всех Unix'ах -- 9, поэтому его часто указывают по номеру, а не по имени -- " kill -9 ". Сигнал KILL следует использовать только в крайних случаях, когда ничто другое не помогает. Дело в том, что перехватив, к примеру, сигнал TERM, программа может корректно завершить работу, при надобности сохранив данные в файлы и восстановив правильное состояние терминала, а KILL не дает ей такой возможности.
Вообще говоря, большая часть функций по управлению заданиями реализуется при помощи сигналов. Так, послав программе сигнал STOP, получим тот же эффект, что и при нажатии Ctrl+Z .
В большинстве современных Unix'ов есть возможность послать сигнал процессу, указав его не по номеру, а по имени программы. Для этого служит команда " killall " -- она посылает сигнал всем процессам с указанным именем. Пример:
Не стоит ей злоупотреблять -- эта команда мало того, что "убивает" все процессы с таким именем, она пытается "убить" даже процессы с таким именем у других пользователей (чего ей Unix, естественно, не позволяет сделать).
В большинстве современных клонов Unix есть программа, позволяющая оперативно отслеживать, какие процессы запущены в системе и какие из них потребляют больше всего процессорного времени. Эта программа называется " top ".
top показывает процессы по убыванию "потребления" процессора. ("top" -- верхушка, вверху показываются те процессы, которые потребляют больше). К сожалению, как видно из приведенного примера, сам top также потребляет немало -- на старых компьютерах типа 486 он иногда пожирал больше 10%.
Где брать информацию про shell
Поскольку команды jobs , bg и fg -- это внутренние команды оболочки, то их описание следует искать в описании оболочки. Информация про перенаправление ввода/вывода имеется там же.
Для оболочек bash и tcsh лучше всего смотреть man-страницы. Для zsh -- info-документацию:
Совет Не стоит сдавать или использовать (даже в изменённом виде) приведённый ниже код в качестве домашнего проекта в школе или вузе. Многие преподаватели знают об оригинальной статье и уличат вас в обмане.
Жизненный цикл командной оболочки
Оболочка выполняет три основные операции за время своего существования:
- Инициализация: на этом этапе она читает и исполняет свои файлы конфигурации. Они изменяют её поведение.
- Интерпретация: далее оболочка считывает команды из stdin и исполняет их.
- Завершение: после исполнения основных команд она исполняет команды выключения, освобождает память и завершает работу.
Именно эти три операции мы будем использовать как основу для нашей командной оболочки. Мы не будем добавлять дополнительные файлы конфигурации и команду выключения. Будем лишь вызывать функцию цикла и завершать работу. Стоит отметить, что, с точки зрения архитектуры, жизненный цикл сложнее, чем просто цикл.
В примере выше можно увидеть функцию lsh_loop() , которая будет циклически интерпретировать команды. Реализацию рассмотрим чуть ниже.
Базовый цикл командной оболочки
В первую очередь нам нужно подумать о том, как программа должна запускаться. И здесь важно понимать, что делает оболочка во время цикла. Простой способ обработки команд состоит из трех шагов:
- Чтение: считывание команды со стандартных потоков.
- Парсинг: распознавание программы и аргументов во входной строке.
- Исполнение: запуск распознанной команды.
Эта идея реализована в функции lsh_loop() :
Пройдемся по коду. Первые несколько строк — это просто объявления. Цикл с постусловием более удобен для проверки состояния переменной, поскольку выполняется перед проверкой ее значения. Внутри цикла выводится приглашение ввода, вызываются функции для чтения входной строки и разбиения строки на аргументы, а затем исполняются аргументы. Далее освобождается память, выделенная под строку и аргументы. Стоит обратить внимание, что в коде используется переменная состояния, возвращаемая в lsh_execute() и определяющая, когда нужно выйти из функции.
Чтение строки
Чтение строки из стандартного потока ввода — это вроде бы просто, но в C это может вызвать много хлопот. Беда в том, что никто не знает заранее, сколько текста пользователь введет в командную оболочку. Нельзя просто выделить блок и надеяться, что пользователи не выйдут за него. Вместо этого нужно перераспределять выделенный блок памяти, если пользователи выйдут за его пределы. Это стандартное решение в C, и именно оно будет использоваться для реализации lsh_read_line() .
В первой части много объявлений. Стоит отметить, что в коде используется старый стиль C, а именно объявление переменных до основной части кода. Основная часть функции находится внутри, на первый взгляд, бесконечного цикла while(1) . В цикле символ считывается и сохраняется как int , а не char (EOF — это целое число, а не символ, поэтому для проверки используйте int ). Если это символ перевода строки или EOF, мы завершаем текущую строку и возвращаем ее. В обратном случае символ добавляется в существующую строку.
Затем мы проверяем, выходит ли следующий символ за пределы буфера. Если это так, то перераспределяем буфер (при этом проверяем его на наличие ошибок распределения) и продолжаем исполнение.
Те, кто знаком с новыми версиями стандартной библиотеки C, могут заметить, что в stdio.h есть функция getline() , которая выполняет большую часть работы, реализованной в коде выше. Эта функция была расширением GNU для библиотеки C до 2008 года, а затем была добавлена в спецификацию, поэтому большинство современных Unix-систем уже идут с ней в комплекте. С getline функция становится тривиальной:
Парсинг строки
1 декабря 2021 – 27 февраля 2022, Онлайн, Беcплатно
Теперь всё, что нам нужно сделать — разбить строку на части, используя пробелы в качестве разделителей. Это значит, что мы можем использовать классическую библиотечную функцию strtok .
Реализация этой функции подозрительно похожа на lsh_read_line() , и это неспроста! Здесь используется та же стратегия, только вместо нуль-терминированного массива символов мы используем нуль-терминированный массив указателей.
Мы начинаем разбиение, вызывая strtok . Она возвращает указатель на первый кусок строки (токен). Вообще strtok() возвращает указатели на места в строке и помещает нуль-терминаторы в конце каждого токена. Эти указатели мы храним в отдельном массиве.
При необходимости мы перераспределим массив указателей. Повторяем процесс до тех пор, пока strtok не перестанет возвращать токены, и завершаем массив токенов нуль-терминатором.
Теперь у нас есть массив токенов, готовых к исполнению.
Как командные оболочки запускают процессы
Теперь мы добрались до самой сути того, что делает оболочка. Запуск процессов — это основная функция командных оболочек. Поэтому если вы создаёте оболочку, то должны точно знать, что происходит с процессами и как они запускаются. Именно поэтому сейчас мы поговорим о процессах в Unix.
В Unix есть только два способа запуска процессов. Первый (который не будем брать в счет) — это Init . Видите ли, когда загружается Unix-система, загружается её ядро. После загрузки и инициализации ядро запускает только один процесс, который называется Init . Этот процесс выполняется в течение всего времени работы компьютера, и управляет загрузкой остальных процессов, которые необходимы для его работы.
Это может показаться проблемой. Обычно, когда вы хотите запустить новый процесс, вам не нужна копия уже работающей программы — вы хотите запустить другую программу. Для этого нужно использовать системный вызов exec() . Он заменяет текущую запущенную программу совершенно новой. Это значит, что при вызове exec операционная система останавливает процесс, загружает новую программу и запускает ее на том же месте. Вызов exec() не возвращает процесс, если нет ошибки.
Благодаря этим двум системным вызовам и возможен запуск большинства программ в Unix. Сперва существующий процесс раздваивается на родительский и дочерний, а затем дочерний процесс использует exec() для замены себя новой программой. Родительский процесс может продолжать делать другие вещи, а также следить за своими дочерними элементами, используя системный вызов wait() .
Да уж, информации немало. Давайте посмотрим на код запуска программы:
Эта функция принимает список аргументов, которые мы создали ранее. Затем она разворачивает процесс и сохраняет возвращаемое значение. Как только fork() возвращает значение, мы получаем два параллельных процесса. Дочернему процессу соответствует первое условие if (где pid == 0 ).
В дочернем процессе мы хотим запустить команду, заданную пользователем. Поэтому мы используем один из вариантов системного вызова exec , execvp . Разные варианты exec делают разные вещи. Одни принимают переменное количество строковых аргументов, другие берут список строк, а третьи позволяют указать окружение, в котором выполняется процесс. Этот конкретный вариант принимает имя программы и массив (также называемый вектором, отсюда 'v' ) строковых аргументов (первым должно быть имя программы). 'p' означает, что вместо предоставления полного пути к файлу программы для запуска мы укажем только её имя, а также скажем операционной системе искать её самостоятельно.
Третье условие означает, что вызов fork() выполнен успешно. Там находится родительский процесс. Мы знаем, что потомок собирается исполнить процесс, поэтому родитель должен дождаться завершения команды. Мы используем waitpid() для ожидания изменения состояния процесса. К сожалению, у waitpid() есть много опций (например, exec() ). Процессы могут изменять свое состояние множеством способов, и не все состояния означают, что процесс завершился. Процесс может либо завершиться обычным путём (успешно либо с кодом ошибки), либо быть остановлен сигналом. Таким образом, мы используем макросы, предоставляемые waitpid() , чтобы убедиться, что процесс завершен. Затем функция возвращает 1 как сигнал вызывающей функции, что она снова может вывести приглашение ввода.
Встроенные функции оболочки
Возможно, вы заметили, что функция lsh_loop() вызывает lsh_execute() , но выше мы назвали нашу функцию lsh_launch() . Это было намеренно! Дело в том, что большинство команд, которые исполняет оболочка, являются программами — но не все. Некоторые из команд встроены прямо в оболочку.
Причина довольно проста. Если вы хотите сменить каталог, вам нужно использовать функцию chdir() . Дело в том, что текущий каталог является свойством процесса. Итак, допустим, вы написали программу cd , которая изменяет каталог. Она просто меняет свой текущий каталог и завершается, но текущий каталог родительского процесса не изменится. Вместо этого процесс оболочки должен исполнить chdir() , чтобы обновить свой текущий каталог. Затем, когда он запускает дочерние процессы, они также наследуют этот каталог.
Аналогично программа с именем exit не сможет выйти из командной оболочки, которая ее вызвала. Эта команда также должна быть встроена в оболочку. Кроме того, большинство оболочек настраиваются с помощью сценариев конфигурации, таких как ~/.bashrc . Эти сценарии используют команды, которые изменяют работу оболочки. Сами же команды могут изменить работу оболочки, если только они были реализованы внутри самой оболочки.
Соответственно, имеет смысл добавить некоторые команды в оболочку. В эту оболочку мы добавим cd , exit и help . А вот и реализация этих функций:
Код состоит из трёх частей. Первая часть содержит предваряющее объявление функций. Предваряющее объявление — это когда вы объявляете (но не определяете) что-то, чтобы можно было использовать это имя до его определения. lsh_help() — причина, по которой мы делаем это. Она использует массив встроенных функций, а сами массивы содержат lsh_help() . Самый простой способ разбить этот цикл зависимостей — это предваряющее объявление.
Следующая часть представляет собой массив имён встроенных команд, за которыми следует массив соответствующих функций. Это значит, что в будущем встроенные команды могут быть добавлены путем изменения этих массивов, а не большого оператора switch где-то в коде. Если вы смущены объявлением builtin_func , все в порядке. Это массив указателей на функции (которые принимают массив строк и возвращают int ). Любое объявление, включающее указатели на функции в C, может стать действительно сложным.
Объединение встроенных функций и процессов
Последний недостающий фрагмент головоломки заключается в реализации функции lsh_execute() , которая либо запускает либо встроенный, либо другой процесс.
Код проверяет, является ли команда встроенной. Если это так, то запускает её, а в противном случае вызывает lsh_launch() , чтобы запустить процесс.
Собираем все вместе
Вот и весь код, который входит в командную оболочку. Если вы внимательно читали статью, то должны были понять, как работает оболочка. Чтобы испробовать оболочку (на Linux), вам нужно скопировать эти сегменты кода в файл main.c и скомпилировать его. Обязательно включите только одну реализацию lsh_read_line() . Вам нужно будет включить следующие заголовочные файлы:
Чтобы скомпилировать файл, введите в терминале gcc -o main main.c , а затем ./main , чтобы запустить.
Кроме того, все исходники доступны на GitHub.
Подводя итоги
Очевидно, что эта оболочка не является многофункциональной. Некоторые из ее упущений:
- аргументы разделяются только пробелами, нет поддержки кавычек или обратного слеша;
- нет перенаправления и конвейеров;
- мало встроенных функций;
- нет подстановки имён файлов.
Чтобы разобраться в системных вызовах, рекомендуем обратиться к мануалу: man 3p . Если вы не знаете, какой интерфейс вам предлагают стандартная библиотека C и Unix, советуем посмотреть спецификацию POSIX, в частности раздел 13.
Читайте также: