«Шелл» на С: пишем командную оболочку для Unix

Многие считают, что сделать программу, которой будут пользоваться миллионы, очень трудно. Однако за любым, даже самым сложным, продуктом всегда стоит простая идея. Одним из них является командная оболочка, или «шелл». В этой статье мы расскажем, как написать упрощенную командную оболочку Unix на C.

Совет Не стоит сдавать или использовать (даже в изменённом виде) приведённый ниже код в качестве домашнего проекта в школе или вузе. Многие преподаватели знают об оригинальной статье и уличат вас в обмане.

Жизненный цикл командной оболочки

Оболочка выполняет три основные операции за время своего существования:

1. Инициализация: на этом этапе она читает и исполняет свои файлы конфигурации. Они изменяют её поведение.
2. Интерпретация: далее оболочка считывает команды из stdin и исполняет их.
3. Завершение: после исполнения основных команд она исполняет команды выключения, освобождает память и завершает работу.

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

В примере выше можно увидеть функцию lsh_loop() , которая будет циклически интерпретировать команды. Реализацию рассмотрим чуть ниже.

Базовый цикл командной оболочки

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

1. Чтение: считывание команды со стандартных потоков.
2. Парсинг: распознавание программы и аргументов во входной строке.
3. Исполнение: запуск распознанной команды.

Эта идея реализована в функции 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 функция становится тривиальной:

Парсинг строки

Теперь нам нужно распарсить входную строку в список аргументов. Мы сделаем небольшое упрощение и запретим пользователю использовать кавычки и обратную косую черту в аргументах командной строки. Вместо этого для разделения аргументов мы просто будем использовать пробелы. Таким образом команда echo «вот сообщение» будет вызывать команду echo не с одним аргументом «вот сообщение» , а с двумя: «вот» и «сообщение» .

22 апреля в 19:00, Онлайн, Беcплатно

Теперь всё, что нам нужно сделать — разбить строку на части, используя пробелы в качестве разделителей. Это значит, что мы можем использовать классическую библиотечную функцию strtok .

Реализация этой функции подозрительно похожа на lsh_read_line() , и это неспроста! Здесь используется та же стратегия, только вместо нуль-терминированного массива символов мы используем нуль-терминированный массив указателей.

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

При необходимости мы перераспределим массив указателей. Повторяем процесс до тех пор, пока strtok не перестанет возвращать токены, и завершаем массив токенов нуль-терминатором.

Теперь у нас есть массив токенов, готовых к исполнению.

Как командные оболочки запускают процессы

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

В Unix есть только два способа запуска процессов. Первый (который не будем брать в счет) — это Init . Видите ли, когда загружается Unix-система, загружается её ядро. После загрузки и инициализации ядро запускает только один процесс, который называется Init . Этот процесс выполняется в течение всего времени работы компьютера, и управляет загрузкой остальных процессов, которые необходимы для его работы.

Поскольку все остальные процессы не Init , остаётся только один практический способ запуска процессов: системный вызов fork() . Когда эта функция вызывается, операционная система делает дубликат процесса и запускает их параллельно. Первоначальный процесс называется «родительским», а новый — «дочерним». Дочернему процессу fork() возвращает 0 , а родителю — идентификатор процесса (PID) его дочернего элемента. Таким образом, любой новый процесс можно создать только из копии уже существующего.

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

Благодаря этим двум системным вызовам и возможен запуск большинства программ в Unix. Сперва существующий процесс раздваивается на родительский и дочерний, а затем дочерний процесс использует exec() для замены себя новой программой. Родительский процесс может продолжать делать другие вещи, а также следить за своими дочерними элементами, используя системный вызов wait() .

Да уж, информации немало. Давайте посмотрим на код запуска программы:

Эта функция принимает список аргументов, которые мы создали ранее. Затем она разворачивает процесс и сохраняет возвращаемое значение. Как только fork() возвращает значение, мы получаем два параллельных процесса. Дочернему процессу соответствует первое условие if (где pid == 0 ).

В дочернем процессе мы хотим запустить команду, заданную пользователем. Поэтому мы используем один из вариантов системного вызова exec , execvp . Разные варианты exec делают разные вещи. Одни принимают переменное количество строковых аргументов, другие берут список строк, а третьи позволяют указать окружение, в котором выполняется процесс. Этот конкретный вариант принимает имя программы и массив (также называемый вектором, отсюда ‘v’ ) строковых аргументов (первым должно быть имя программы). ‘p’ означает, что вместо предоставления полного пути к файлу программы для запуска мы укажем только её имя, а также скажем операционной системе искать её самостоятельно.

Если команда exec возвращает -1 (или любое другое значение), значит, произошла ошибка. Таким образом, мы используем perror для вывода сообщения об ошибке вместе с именем программы, чтобы было понятно, где произошла ошибка. Затем мы завершаем процесс, но так, чтобы программная оболочка продолжала работать.

Второе условие ( pid ) проверяет, произошла ли в процессе выполнения fork() ошибка. Если ошибка есть, мы выводим сообщение об этом на экран, но программа продолжает работать.

Третье условие означает, что вызов 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_cd() сначала проверяет наличие своего второго аргумента и выводит сообщение об ошибке, если его нет. Затем она вызывает chdir() , проверяет наличие ошибок и завершает работу. Функция справки выводит информативное сообщение и имена всех встроенных функций. А функция выхода возвращает 0 , как сигнал для окончания цикла команд.

Объединение встроенных функций и процессов

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

Код проверяет, является ли команда встроенной. Если это так, то запускает её, а в противном случае вызывает lsh_launch() , чтобы запустить процесс.

Собираем все вместе

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

Чтобы скомпилировать файл, введите в терминале gcc -o main main.c , а затем ./main , чтобы запустить.

Кроме того, все исходники доступны на GitHub.

Подводя итоги

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

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

Чтобы разобраться в системных вызовах, рекомендуем обратиться к мануалу: man 3p . Если вы не знаете, какой интерфейс вам предлагают стандартная библиотека C и Unix, советуем посмотреть спецификацию POSIX, в частности раздел 13.

Что такое shell? Типы shell в Linux и Unix

Обновл. 18 Мар 2021 |

В этой статье мы разберемся, что такое shell и зачем это нужно, а также рассмотрим наиболее часто используемые командные оболочки в Linux и Unix.

Что такое shell?

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

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

Если пользователь не наделен особыми правами, то в качестве приглашения к вводу команд в терминале будет отображаться символ $ . Если же был выполнен вход под учетной записью привилегированного (root) пользователя, то в терминале вы увидите символ # :

Окно терминала обычного пользователя (виден символ $)

Окно терминала привилегированного (root) пользователя (виден символ #)

Примечание: Знак тильды (

) указывает на то, что мы находимся в домашнем каталоге текущего пользователя.

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

Ниже представлен пример выполнения простой команды date , возвращающей текущую дату и время:

Внутренние и внешние команды оболочки

Вводимые пользователем команды делятся на два типа:

Внутренние — это команды, изначально встроенные в оболочку.

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

Чтобы определить тип команды, достаточно в окне терминала ввести type :

Как вы можете видеть, команды dirs , pwd , cd и true — являются внутренними командами оболочки bash. А вот команды uname , id и whereis — являются внешними, т.к. они ссылаются на соответствующие файлы в каталоге /usr/bin.

Ознакомиться с полным списком внутренних команд оболочки можно при помощи команды help :

Как узнать какая оболочка у меня установлена?

Если вы только начинаете свое знакомство с Linux и не меняли оболочку, то наиболее вероятно, что в вашей системе используется bash. Самый простой способ узнать, какая оболочка используется в данный момент — это обратиться к переменной окружения SHELL :

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

Не трудно заметить, что в настоящее время используется оболочка bash. Для просмотра всех доступных оболочек в вашей системе, необходимо обратиться к содержимому файла /etc/shells:

Типы командных оболочек

В *nix-системах существует два основных типа оболочек: оболочки на основе Bourne shell и оболочки на основе C shell.

Типичными представителями оболочек типа Bourne shell являются:

sh (Bourne shell)

bash (Bourne Again shell)

К оболочкам типа C Shell относятся:

tcsh (TENEX/TOPS C shell)

Ниже представлены некоторые из самых распространенных шеллов, используемых в *nix-системах:

Примечание: Термин «*nix-системы» обозначает Unix-подобные операционные системы.

sh (Bourne shell)

sh (сокр. от «Bourne shell») — это самая старая (среди рассматриваемых) оболочка, написанная Стивеном Борном из AT&T Bell Labs для ОС UNIX v7. Оболочка доступна практически в любом *nix-дистрибутиве. Многие другие шеллы уходят своими корнями именно к sh. Благодаря своей скорости работы и компактности, данная оболочка является предпочтительным средством для написания shell-скриптов. К её недостаткам можно отнести отсутствие функций для использования оболочки в интерактивном режиме, а также отсутствие встроенной обработки арифметических и логических выражений.

Примечание: Стоит отметить, что из-за общего морального устаревания оболочки, в современных системах ссылка на шелл sh (/bin/sh), обычно, является псевдонимом для запуска текущей, более новой оболочки.

Характерные черты sh:

Полные пути к интерпретатору: /bin/sh и /sbin/sh.

Приглашение для обычного пользователя: $ .

Приглашение для суперпользователя (root): # .

bash (Bourne-Again shell)

bash (сокр. от «Bourne–Again shell») — это усовершенствованный и дополненный вариант шелла sh, является одной из самых популярных современных командных оболочек *nix-систем.

Объединяет в себе полезные фишки оболочек ksh и csh.

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

Характерные черты bash:

Полный путь к интерпретатору: /bin/bash.

Приглашение для обычного пользователя: имя_пользователя@имя_хоста:

— это домашний каталог текущего пользователя, например, mrsmith@mypc:

Приглашение для суперпользователя (root): root@имя_хоста:

ksh (Korn shell)

ksh (сокр. от «Korn shell») — это командная оболочка, разработанная Дэвидом Корном из AT&T Bell Labs в 1980-x годах.

Является расширением sh.

Имеет обратную совместимость с sh.

Имеет интерактивный функционал, сравнимый с csh.

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

Работает быстрее, чем csh.

Может запускать скрипты, написанные для sh.

Характерные черты ksh:

Полный путь к интерпретатору: /bin/ksh.

Приглашение для обычного пользователя: $ .

Приглашение для суперпользователя (root): # .

csh (C shell)

csh (сокр. от «C shell») — это командная оболочка, созданная Биллом Джоем (автором редактора vi) с целью усовершенствования стандартного шелла Unix (sh).

Имеет встроенные функции для интерактивного использования, например, псевдонимы (aliases) и историю команд.

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

Характерные черты csh:

Полный путь к интерпретатору: /bin/csh.

Приглашение для обычного пользователя: % .

Приглашение для суперпользователя (root): # .

tcsh (TENEX C Shell)

tcsh (сокр. от «TENEX C shell») — это командная оболочка, созданная Кэном Гриром, которая позиционируется как улучшенная версия шелла csh.

Имеет полную совместимость csh.

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

Удобна для интерактивной работы.

Поддерживает редактор командной строки в стиле vi или emacs.

Является стандартным шеллом во FreeBSD.

Характерные черты tcsh:

Полный путь к интерпретатору: /bin/tcsh.

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

Приглашение для суперпользователя (root): # .

zsh (Z Shell)

zsh (сокр. от «Z shell») — это командная оболочка, созданная Паулем Фалстадом во время его учебы в Принстонском университете, позиционируется как свободная современная sh-совместимая командная оболочка.

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

Встроенная поддержка программируемого автодополнения команд, имен файлов и пр.

Поддержка проверки орфографии и опечаток.

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

Характерные черты zsh:

Полный путь к интерпретатору: /bin/zsh.

Приглашение для обычного пользователя: имя_хоста% .

Приглашение для суперпользователя (root): root@имя_хоста:

Резюмируем

Краткая сводная таблица для 6 вышерассмотренных командных оболочек:

Командная оболочка	Путь	Приглашение (обычный пользователь)	Приглашение (root)
sh (Bourne Shell)	/bin/sh и /sbin/sh	$	#
bash (Bourne-Again Shell)	/bin/bash	имя_пользователя@имя_хоста:

$ имя_пользователя@имя_хоста:

# ksh (Korn Shell) /bin/ksh $ # csh (C Shell) /bin/csh % # tcsh (TENEX C Shell) /bin/tcsh имя_хоста:

> # zsh (Z Shell) /bin/zsh % #

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

mksh — оболочка, основной упор в которой сделан на написание скриптов;

dash — более легковесная в сравнении с bash оболочка, но из-за этого обладающая ограниченной функциональностью;

fish — «новая» оболочка, написанная в 2005 году, отличительной чертой которой является упор на комфорт использования и упрощение командного языка;

Поделиться в социальных сетях: