Практическое занятие №1



Скачать 144.41 Kb.

Дата15.02.2017
Размер144.41 Kb.
Просмотров129
Скачиваний0

Практическое занятие №1 1. Графический и текстовый вход в систему
В зависимости от настроек системы UNIX/LINUX доступны текстовый и графический режимы доступа в систему, дальше будем говорить о тек- стовом и графическом входе в систему. Названия режимов определяются режимом работы монитора. При входе в систему пользователь видит на экране монитора приглашение ввести имя и некоторую информацию о системе (название операционной системы, имя рабочей станции и т.д.)).
Для того, чтобы получить доступ в систему пользователь должен ввести имя и пароль. Если указанное имя зарегистрировано в системе и введен правильный пароль, то пользователь получает доступ в систему.
При текстовом входе, пользователь работает с командным интерпретато- ром (иногда такие программы называют командным процессором), кото- рый обрабатывает команды пользователя. Сразу после входа в систему,
рабочим каталогом пользователя является его домашний каталог.
При графическом входе, пользователю сразу предоставляется рабочий стол. В зависимости от оконного менеджера, у пользователя имеется больше или меньше возможностей настройки внешнего вида и функцио- нальности рабочего стола. Например, оконный менеджер KDE позволяет настроить рабочий стол так, чтобы он был более функциональным чем в операционной системе Windows.
2. Некоторые простейшие команды: ls, cd, pwd, cp, mkdir, rm, cat,
less, man
Чтобы посмотреть содержимое каталога существует команда ls:
$ ls
Как и у большинства команд UNIX/LINUX, у этой команды имеются ар- гументы, которые изменяют ее поведение. В указанном режиме коман- да ls непоказывает скрытые файлы и каталоги, чтобы увидеть скрытые файлы и каталоги нужно добавить аргумент -a:
$ ls -a
Команда ls так же может показать дополнительную информацию по файлам и каталогам: владельца, группу владельца, права доступа, раз- мер, дату последнего изменения, для этого используется директива -l:
$ ls -l
Если нужно посмотреть информацию по отдельному файлу, то имя это- го файла указывается после всех директив команды ls:
$ ls -l myfile.txt
Если нужно посмотреть информацию по отдельному каталогу, то надо
1
указать ключ -d, иначе ls покажет информацию по содержимому ката- лога:
$ ls -ld /home
Для перехода из одного каталога в другой используется команда cd (со- кращение от change directory), аргументом этой команды является имя каталога в который надо перейти:
$ cd /home
Чтобы перейти на уровень вверх по файловому дереву, используется сле- дующая форма команды cd:
$ cd ..
Существует специальная форма команды cd для возвращения в домаш- ний каталог пользователя – это просто имя команды cd без аргументов:
$ cd
Команда pwd (сокращение от print work directory) используется для по- каза имени текущего каталога:
$ pwd
Команда cp используется для копирования файлов:
$ cp file1 file2
Команда mkdir используется для создания каталогов:
$ mkdir mydir
Команда rm используется для удаления файлов и каталогов:
$ rm file но в показанной форме она способна удалить только файл, для удаления каталога надо добавить ключи -rf:
$ rm -rf dir/
Просмотреть содержимое файла можно командой cat:
$ cat file но эта команда выводит все содержимое файла на экран, т.е. если файл большой, то пользователь увидит только конец файла. Для постранич- ного просмотра предназначена команда less:
$ less file выход из этой команды – q. Все указанные команды имеют еще аргумен- ты, с которыми можно познакомиться при помощи справочной системы
UNIX/LINUX. Для получения информации по какой-либо команде ис- пользуется команда man, которая читает архив информации по коман- дам и выводит в отформатированном виде эту информацию на экран.
Например, получение справки по команде pwd:
$ man pwd
2

3. Текстовый редактор joe
Редактор запускается при помощи команды joe. После имени коман- ды можно указать имя файла, который редактор должен открыть, если файла с указанным именем не существует, то редактор создаст его. joe может работать в режиме редактирования и командном режиме. Сразу после заргрузки joe оказывается в режиме редактирования, в котором можно набирать и удалять текст. Чтобы переключиться в командный режим надо нажать клавишу Control и не отпуская клавишу K, редак- тор перейдет в командный режим, о чем свидетельствует значок ˆK в левом верхнем углу экрана. Перечислим некоторые команды этого режи- ма, чтобы сделать эту команду надо нажать соответствующую клавишу:
• H – вызов справки, повторное выполнение этой команды закроет окно справки
• S – сохранение файла, если файл новый, то будет задан вопрос об имени файла
• D – сохранение в файл с другим именем
• X – сохранить файл и выйти, если файл не был изменен, то сохра- нения не будет
Практическое занятие №2 1. Пользователи, группы и права доступа
Файлы в UNIX имеют двух владельцев: пользователя и группу
1
. Владелец- пользователь может не являться членом группы, владеющей файлом.
Для определения владельцев файла достаточно посмотреть подробный вывод команды ls -l. Третья и четвертая колонки содержат имена владельца- пользователя и владельца-группы, соответственно:
1 2 3 4
5 6
7 8
-rw-r–r–
1 andy group
235520 Dec 22 19:13 pride.tar
-rw-rw-r– 1 andy student 3450
Nov 12 19:13 exams.quest
Владельцем-пользователем вновь созданного файла является пользова- тель, который создал файл. Порядок назначения владельца-группы за- висит от конкретной версии UNIX.
Для изменения владельца файла используется команда chown. В ка-
1
Группой называется определенный список пользователей системы. Пользователь системы может быть членом нескольких групп, одна из которых является первичной (primary), остальные – дополнительными
(supplementary).
3
честве параметров команда принимает имя владельца-пользователя и список файлов, для которых требуется изменить данный атрибут. На- пример, следующая команда установит пользователя sergey владельцем файлов client.c и server.c:
$ chown sergey client.c server.c
Изменение владельца-группы производится командой chgrp. В качестве параметров она принимает имя владельца-группы и список файлов, для которых требуется изменить данный атрибут. Однако, не во всех систе- мах обычный пользователь может менять владельцев, следующая таб- лица это показывает.
Операция
Команда система BSD 4.x система SVR4 2
Изменение chown суперпользователь владелец файла владельца-пользователя
Изменение chgrp суперпользователь владелец файла владельца-группы только для группы,
к которой сам принадлежит
Скопируйте какой-нибудь ваш файл в каталог /tmp и попробуйте сме- нить владельца-пользователя и владельца-группу этого файла на владельца- пользователя и владельца-группу кого-либо из ваших одногруппников.
В UNIX существуют три базовых класса доступа к файлу, в каждом из которых установлены соответствующие права доступа:
User access (u)
Для владельца-пользователя файла
Group access (g) Для членов группы, являющейся владельцем файла
Other access (o)
Для остальных пользователей (кроме суперпользователя)
UNIX поддерживает три типа прав доступа для каждого класса: на чте- ние (read, обозначается символом r), на запись (write, обозначается сим- волом w), на выполнение (execute, обозначается символом x).
С помощью команды ls -l можно получить список прав доступа к фай- лу:
-rw-r–r–
1 andy group 36482 Dec 22 19:13 report.txt.1
drwxr-xr– 2 andy group 64
Aug 15 11:03 temp
-rwxr-xr–
1 andy group 4889
Dec 22 15:13 a.out
-rw-r–r–
1 andy group 7622
Feb 11 09:13 cont.c
2
System V Release 4 4

Права доступа листинга отображаются в первой колонке (за исключени- ем первого символа, обозначающего тип файла). Наличие права досту- па обозначается соответствующим символом, а отсутствие – символом
’-’. Рассмотрим, например, права доступа к файлу a.out: самый первый символ ’-’ обозначает, что это обычный файл, далее идут три симво- ла обозначающие права доступа для владельца-пользователя файла –
rwx – чтение, запись, выполнение, потом три символа для прав доступа владельца-группы – r-x – чтение и выполнение, и, наконец, три символа для остальных пользователей – r– – только чтение.
Права доступа могут быть изменены только владельцем файла или су- перпользователем – администратором системы. Для этого использует- ся команда chmod. В качестве аргументов команда принимает указание классов доступа (’u’ – владелец-пользователь, ’g’ – владелец-группа, ’o’ –
остальные пользователи, ’a’ – все классы пользователей), права доступа
(’r’ – чтение, ’w’ – запись, ’x’ – выполнение) и операцию, которую необ- ходимо произвести (’+’ – добавить, ’-’ – удалить). Например, команда
$ chmod g-wx ownfile лишит членов группы-владельца файла ownfile права на запись и выпол- нение этого файла. В одной команде можно задавать различные права доступа для нескольких классов доступа, разделив их запятыми. Еще несколько примеров:
$ chmod a+w test
$ chmod g+x-w text
$ chmod u+w,og+r-w text1 text2
Потренируйтесь в изменении прав доступа у своих файлов.
Значение прав доступа различно для разных типов файлов. Для обыч- ных файлов операции, которые можно производить, следуют из самих названий прав доступа: просмотр содержимого требует право на чте- ние, редактирование файла требует право на запись, выполнение какой- либо программы – право на выполнение. Для каталогов права доступа несколько отличаются: право чтения позволяет получить имена (и толь- ко имена) файлов, находящихся в данном каталоге; право на выполнение требуется для получения дополнительной информации о файлах (коман- дой ls -l) и возможности перехода в данный каталог; право на запись требуется для создания и удаления(!) файлов в каталоге. При удалении файла из каталога права доступа для самого файла не учитываются!
5

Практическое занятие №3 1. Файлы и файловая система
Файлы в ОС UNIX играют ключевую роль: в них хранятся все данные пользователей, файлы определяют привилегии пользователей, посколь- ку права пользователя в большинстве случаев контролируются с помо- щью прав доступа к файлам. Файлы обеспечивают доступ к периферий- ным устройствам компьютера (диски, CD-ROM, принтеры, терминалы,
сетевые адаптеры и даже память). Для приложений UNIX доступ к дис- ковому файлу "неотличим" от доступа, скажем, к принтеру. Наконец,
все программы, которые выполняются в системе, включая прикладные задачи пользователей, системные процессы, ядро(!) UNIX, являются ис- полняемыми файлами.
В UNIX файлы организованы в виде древовидной структуры (дерева)

файловой системы .Каждый файл имеет имя, определяющее его рас- положение в дереве файловой системы. Корнем этого дерева является корневой каталог, имеющий имя "/". Имена всех остальных файлов со- держат путь – список каталогов (ветвей дерева файловой системы), ко- торые необходимо пройти, чтобы достичь файла. В UNIX все доступное пользователям файловое пространство объединено в единое дерево ката- логов, корнем которого является каталог "/". Полное имя любого файла начинается с "/" и не содержит идентификатора устройства (например,
диска или CD-ROM как в Windows), на котором он фактически хранит- ся.
Однако это не означает, что в системе присутствует только одна фай- ловая система. В большинстве случаев единое дерево, такое, каким его видит пользователь, составлено из нескольких отдельных файловых си- стем, которые могут иметь различную внутреннюю структуру, а фай- лы, принадлежащие этим системам, могут быть расположены на разных устройствах и даже компьютерах.
Имя файла является атрибутом файловой системы, а не набора некото- рых данных на диске, который не имеет имени как такового. Каждый файл имеет связанные с ним метаданные, содержащие все характери- стики файла (в частности, указатели на дисковые блоки хранения дан- ных файла). Имя файла в файловой системе является указателем на его метаданные, в то время как метаданные не содержат указателя на имя файла.
Структура файловой системы UNIX. Использование общеприня- тых имен основных файлов и структуры каталогов существенно облег-
6
чает работу в операционной системе, ее администрарование и переноси- мость. Эта структура используется в работе системы, например при ее инициализации и конфигурировании. Нарушение этой структуры может привести к неработоспособности системы или отдельных ее компонентов.
Ниже представлена структура файловой системы с наиболее распростра- ненными элементами (более глубокие уровни не показаны):
• /
– bin
– dev
– etc
– home
– lib
– lost+found
– mnt
– tmp
– usr
– var
Приведем краткое описание этих каталогов.
• Корневой каталог является основой любой файловой системы UNIX.
Все остальные файлы и каталоги распологаются в рамках структу- ры, порожденной корневым каталогом, независимо от их физическо- го местонахождения.
• /bin здесь находятся наиболее часто употребляемые команды и ути- литы системы, как правило, общего пользования.
• /dev содержит специальные файлы устройств, являющиеся интер- фейсом доступа к периферийным устройствам. Этот каталог мо- жет содержать несколько подкаталогов, группирующих специаль- ные файлы устройств одного типа.
• /etc в этом каталоге находятся системные конфигурационные фай- лы, а в некоторых системых и многие утилиты администраирования.
Среди наиболее важных файлов – скрипты инициализации системы.
• /home общеупотребительный каталог для размещения домашних каталогов пользователей. Например, имя домашнего каталога поль- зователя andrei будет /home/andrei.
• /lib содержит библиотечные файлы языка C и других языков про- граммирования. Стандартные названия библиотечных файлов име-
7
ют вид libx.a (или libx.so), где x – один или более символов, определя- ющих содержимое библиотеки. Например, стандартная библиотека
C называется libc.a. Часть библиотечных файлов также находится в каталоге /usr/lib.
• /lost+found это каталог "потерянных" файлов. Ошибки целост- ности файловой системы, возникающие при неправильном останове
UNIX или аппаратных сбоях, могут привести к появлению так на- зываемых "безымянных" файлов – структура и содержимое файла являются правильными, но для него отсутствует имя в каком-либо из каталогов. Программы проверки и восстановления файловой си- стемы помещают такие файлы в данный под системными числовыми именами.
• /mnt стандартный каталог для временного связывания (монтиро- вания, подключения) физических файловых систем к корневой для получения единого дерева логической файловой системы.
• /tmp каталог хранения временных файлов, необходимых для ра- боты различных подсистем UNIX. Обычно этот каталог открыт на запись для всех пользователей системы.
• /usr в этом каталоге находятся подкаталоги различных обслужива- ющих подсистем – системы печати, электронной почты и т.д. (/usr/spool),
исполняемые файлы утилит UNIX (/usr/bin), дополнительные про- граммы, используемые на данном компьютере (/usr/local), файлы заголовков (/usr/include), электронные справочники (/usr/man) и т.д.
• /var используется для хранения временных данных, например, фай- лов регистрации системных или служебных событий или почтовых ящиков пользователей.
2. Некоторые команды: grep, head, tail, sort, wc, ps
Команда grep используется для поиска фрагментов текста в файлах. Мо- гут использоваться в качастве фильтров в конвейерах. Например, для поиска слова first в файле list эта команда используется следующим об- разом:
$ grep first list
Общий формат вызова этой команды:
$ grep [opt] рег_выражение file1...
здесь opt – ключи для изменения работы команды (квадратные скобки при вызове команды набирать не нужно, здесь они приведены как ука- зание, что аргументы не обязательны при вызове), рег_выражение – ре-
8
гулярное выражение, используемое в качестве подстроки поиска, file1...
– список файлов через пробел в которых искать текст.
Если вы хотите посмотреть заголовок какого-либо файла, который со- держит много строк (больше 40), вместо команды less можно воспользо- ваться командой head:
$ head file
Этой команде можно дать аргумент -n:
$ head -n file n – число, которое говорит сколько первых строк выводить на экран.
Команда tail аналогична head, но выводит последние строки файла:
$ tail file ей также можно дать аргумент -n, указывающий количество последних строк для отображения.
Для сортировки строк файла используется утилита sort:
$ sort file эта команда отсортирует строки файла file и в отсортированном виде выведет на экран. У этой команды также имеется множество ключей, с которыми можно познакомиться через справку:
$ man sort wc позволяет вывести число строк, слов и символов текста файла:
$ wc file
Утилита ps выводит информацию о существующих процессах:
$ ps
При использовании различных ключей она позволяет получить инфор- мацию о статусе процесса, его состоянии, идентификаторе (имени) поль- зователя-владельца, идентификатор процесса и т.д.
Все эти (и многие другие) команды можно использовать в конвейерах,
в которых вывод одной команды направляется на вход другой команды.
Рассмотрим примеры:
$ head file | grep pattern | wc
$ tail file1 | sort > file2
В первой строчке заголовок файла file будет подан (head file) на вход ко- манды grep, она во входном потоке будет искать строку, содержащую слово pattern (grep pattern), все строки, которая обнаружит команда grep, будут поданы на вход команды wc, а она, в свою очередь, посчита- ет их число и выведет на экран. Во-второй командной строке последние строчки файла file1 будут переданы (tail file1) на ввод команде sort, ко- торая их отсортирует и выведет в файл file2.
9

Практическое занятие №4
Основы программирования на языке shell.
По сути, сценарии shell представляют собой просто последовательность ко- манд, решающих какую-то задачу, порой достаточно сложную. И значитель- ная часть того, что может быть написано в скрипте может быть выполнено посредством введения тех же команд с командной строки. Однако, сценарии предоставляют хранить какую-либо последовательность команд в виде ис- полняемого файла и запускать её всякий раз по мере необходимости. Кроме того, в скриптах проще найти ошибку, хотя бы потому, что они предостав- ляют возможность структурировать текст программы. Можно привести ещё
множество преимуществ использования скриптов вместо простой работы в командной строке, но ... приступим.
Любая программа на языке shell начинается со строчки
#!/bin/bash здесь символы #! говорят, что данный файл является скриптом и исполнять этот скрипт должна команда указанная сразу после этих символов, в данном случае это /bin/bash. Вообще говоря, скрипты могут сздаваться не толь- ко для shell, но и на любом другом интерпретируемом языке существующем в UNIX, например: awk, perl и другие. Соответственно первая строка будет другая, например:
#!/usr/bin/perl
Символ # отдельно от символа ! является коментарием в языке программи- рования shell. Рассмотрим программу, которая выводит на экран приветствие "Hello, world!":
#!/bin/bash echo "Hello, world!"
В этой программе, кроме уже известной строчки, имеется одна строка, кото- рая выводит приветствие на экран:
echo "Hello, world!"
В этой строке команде echo в качестве аргумента подаётся строка "Hello,
world!". Эту же команду можно выполнить просто введя её с клавиатуры.
Когда файл сценария готов, его можно попытаться выполнить (пусть prog имя скрипта):
./prog на эту команду вы получите сообщение: "Отказано в доступе". Дело в том,
что при создании текстового файла, а файл скрипта именно такой, не уста- навливается право на выполнение этого файла. Убедиться в этом можно ко- мандой
10
ls -l prog
-rw-r--r-- 1 alex alex ... prog
Можно поступить двояко: либо запустить скрипт командой bash prog либо, установив право на выполнение chmod +x prog
В первом случае придётся всегда имя скрипта предварять именем shell’а, во- втором скрипт запускается командой:
./prog
Для работы сценарию можно передавать параметры через аргументы ко- мандной строки. Например:
./prog2 123
Здесь скрипту prog2 мы передали аргумент "123". Каждый сценарий, не за- висимо от того используете вы аргументы командной строки или нет имеет доступ к переменным $0, $1, ..., $9, которые представляют собой аргументы командной строки. $0 – содержит имя сценария, $1 – первый аргумент, $2
– второй и т.д. до девятого. Хотя переменных всего девять, но аргументов может быть сколько угодно. Доступ к аргументам следующим за девятым может быть осуществлён $10, $11 и т.д. Также можно использовать команду shift, которая "сдвигает" параметры на один влево: $1 <– $2, $2 <– $3, и т.д. Прежний аргумент $1 теряется, но аргумент $0 (имя файла сценария)
остаётся без изменений. Как работать в сценарии с аргументами командной строки. Пусть наш скрипт prog2 выводит переданный ему аргумент на экран.
Это можно сделать следующим образом:
#!/bin/bash echo $1
Если задаются два аргумента:
./prog3 123 456
то вывести их можно так
#!/bin/bash echo $1
echo $2
или так
#!/bin/bash echo $1
shift echo $1 11

Во время работы сценарий может получать данные не только через аргумен- ты командной строки, но и напрямую от пользователя:
#!/bin/bash read a echo $a
Здесь после запуска сценарий будет ожидать ввода данных пользователем с клавиатуры. При нажатии на клавишу перевода строки, скрипт прекращает приём данных, а то, что уже было введено, записывается в переменную a. За- тем содержимое этой переменной будет выведено на экран командой echo $a.
Общий формат команды read такой read переменные
Когда выполняется эта команда, shell считывает строку со стандартного пото- ка ввода и присваивает первое прочитанное слово первой переменной в списке переменные, второе прочитанное слово – второй переменной и т.д. Если слов в строке больше чем переменных в списке, то лишние слова присваиваются последней переменной. Слова в строке разделяются либо пробелами, либо табуляцией.
Обратите внимание на использование переменной: когда мы ей присваи- ваем значение (read a) её имя используется без знака $, а когда мы хотим получить её значение, то обязательно использование знака $ перед именем
(echo $a).
Для форматированного вывода существует команда printf, которая сильно походит на тёзку из языка C. Общий формат команды:
printf "format" arg1 arg1 ...
здесь format – строка, описывающая как отображать следующие за ней ар- гументы, её желательно заключать в кавычки. Например:
printf "This is a number: %d\n" 10
выведет
This is a number: 10
Знак процента вместе со следующим за ним символом указывает на тип вы- водимого аргумента, а символ \n заставляет переводить строку, чего printf по умолчанию не делает в отличие от echo.
символ тип d
целый u
беззнаковый целый o
восьмеричный целый x
шестнадцатеричный целый, символы a-f
X
шестнадцатеричный целый, символы A-F
c один символ
12
s
строка символов
%
знак процента
Условный оператор
Общий формат if условие1
then список1
[elif условие2
then список2]
[else список3]
fi
Здесь условие1 и условие2 два выражения, результатом которых может быть ноль или единица. Это могут быть как логические выражения (о них ни- же), так и просто последовательность команд. список1, список2 и список3
– последовательности команд, которые выполняются в зависимости от усло- вия. Алгоритм работы условного оператора аналогичен алгоритму в языках высокого уровня (С, Паскаль и т.д.): если условие истинно, то выполняет- ся список1, иначе происходит переход и проверка условие2 (если таковое имеется), в случае истинности этого выражения выполняется список2, иначе переход к список3, если такового не обнаруживается, то выполнение скрипта продолжается с команды следующей за fi. Здесь между квадратными скобками располагаются необязательные элементы! Пример:
if grep root /etc/passwd then echo "User root found!"
else echo "User root doesn’t found!"
fi
Вычисление логических выражений может выполняться двумя различными опеаторами:
test выражение или
[ выражение ]
Здесь квадратные скобки – это оператор вычисляющий логическое выражение! Оба эти оператора возвращают ноль если выражение истин- но(!) и единицу если выражение ложно(!). Пример на применение оператора test:
13
if test $a -eq 10
then echo "a equal 10"
else echo "a doesn’t equal 10"
fi здесь переменная a сравнивается с числом 10, и если a равно 10, то выводится сообщение "a equal 10"и другое сообщение в противном случае. В операторе test используется логическая операция равенства -eq, которая отделяется от операндов обязательными пробелами. Пример на применение оператора
[ ]:
if test $a -gt 10
then echo "a is great than 10"
else echo "a doesn’t great than 10"
fi здесь проверяется, что переменная a больше 10 с помощью логической опе- рации -gt, которая также отделяется от операндов обязательными про- белами. В остальном этот пример аналогичен предыдущему. В следующей таблице приведены некоторые логические операции.
Операция
Описание
-f file
Файл существует и является обычным s1 = s2
Равенство строк s1 и s2
s1 != s2
Не равенство строк s1 и s2
-z str
Нулевая строка i1 -eq i2
Равенство целых чисел i1 и i2
i1 -ne i2
Не равенство целых чисел i1 и i2
i1 -lt i2
i1 строго меньше i2
i1 -le i2
i1 не строго меньше i2
i1 -gt i2
i1 строго больше i2
i1 -ge i2
i1 не строго больше i2
!выражение
Отрицание результата выражения выражение1 -a выражение2 Логическое И
выражение1 -o выражение2 Логическое ИЛИ
Циклы while условие do список done
Тело цикла список будет выполняться пока условие истинно. Пример:
14

#!/bin/bash a=$1
while $a -lt 10
do read a done
В данном примере в цикле будет запрашиваться число (предположительно)
до тех пор пока оно не станет больше или равно 10.
for переменная in список_значений do список done
В этом цикле тело будет выполняться пока не будут перебраны все значения в список_значений. Пример:
for dir in /bin /etc /dev /home /lib /tmp /usr do ls $dir done
Этот цикл последовательно выведет на экран содержимое каталогов, указан- ных справа от слова in.
Практическое занятие №5
Основы работы в сети.
SSH (Secure SHell) – программа для регистрации на удалённом компьютере и для выполнения команд на удалённом хосте. Реализует протоколы SSH
версий 1 и 2, которые шифруют всю передаваемую информацию. Один из вариантов вызова этой команды:
ssh [user@]hostname [command]
hostname – символьное (DNS) имя удалённого компьютера или его IP-адрес.
Квадратные скобки ограничивают необязательные параметры: user – заре- гистрированное на удалённом компьютере имя пользователя, command – ко- манда, которую нужно выполнить на удалённом компьютере. Например ssh 192.168.210.32
ssh alex@192.168.210.32
ssh alex@192.168.210.32 ls
Первая команда подключится к удалённому компьютеру и запросит имя, а затем (в зависимости от настроек SSH на удалённом сервере) пароль. Вторая
15

– подключится сразу с именем alex и запросит пароль. Третья команда за- просит пароль для пользователя alex и после его успешного ввода выполнит команду ls в домашнем каталоге пользователя.
Программа SSH позволяет выполнять команды на удалённом компьютере,
но не позволяет копировать файлы между компьютерами по сети. Для этого предназначена программа SCP (Secure CoPy). Использует она те же прото- колы SSH 1 и SSH 2 для шифрования данных. Синтаксис вызова команды:
scp [[user@]host1:]file1 [...] [[user@]host2:]file2
Первая часть команды [[user@]host1:]file1 [...] означает скопировать файл file1 и все остальные [..] с компьютера host1 (имя пользователя на этом хосте user) на компьютер указанный во второй части команды. Вторая часть команды [[user@]host2:]file2 указывает имя компьютера, на кото- рый копируется файл file1, и имя файла file2 на этом хосте. Например scp file1 alex@192.168.210.32:file2
scp alex@192.168.210.22:file1 alex@192.168.210.25:file2
Первая команда копирует файл file1 из данного каталога на данной ма- шине в домашний каталог пользователя alex на удалённом компьютере с
IP-адресом 192.168.210.32 и присваивает ему имя file2. Вторая команда копирует файл file1 из домашнего каталога пользователя alex на компью- тере 192.168.210.22 в файл file2 домашнего каталога пользователя alex на хосте 192.168.210.25.
Практическое занятие №6
Основы создание программ на С в системах Linux/UNIX.
Стандартные конструкции языка C не зависят от операционной системы поэтому основы языка С не рассматриваем. Начнём с программы печатаю- щей на терминале приветствие "Hello, World!". В редакторе JOE наберите следующий текст и сохраните его под любым именем, но с расширением cpp:
#include
int main(void)
{
cout << "Hello, World!\n";
return 0;
}
Допустим вы назвали файл first.cpp Для компиляции и создания исполня- емого файла в строке командного интерпретатора введите строку:
16
gcc first.cpp gcc – это имя компилятора. Любой UNIX/Linux в стандартном дистрибутиве включает один или два компилятора с языка C и столько же компиляторов с языка Fortran. Другие компиляторы могут отсутствовать в дистрибутиве.
При компиляции могут быть ошибки двух типов: синтаксические и ошибки линковщика. В первом случае на терминале будут строки сообщений компи- лятора, начинающиеся с имени вашего файла:
first.cpp:...
и заканчивающийся описанием ошибки. Проверьте исходный текст вашего файла и сравните его с приведённым выше. Во-втором случае сообщения будут исходить от компоновщика (линкёра), который связывает ваш файл с другими библиотечными файлами, необходимыми для работы вашей про- граммы. Сообщения будут следующего типа
/tmp/ccsnKp4j.o: In function
‘__static_initialization_and_destruction_0(int, int)’:
first.cpp:(.text+0x23): undefined reference to
‘std::ios_base::Init::Init()’
/tmp/ccsnKp4j.o: In function ‘__tcf_0’:
first.cpp:(.text+0x6c): undefined reference to
‘std::ios_base::Init::
Init()’
/tmp/ccsnKp4j.o: In function ‘main’:
first.cpp:(.text+0x8e): undefined reference to ‘std::cout’
/tmp/ccsnKp4j.o:(.eh_frame+0x11): undefined reference to
‘__gxx_personality_v0’
collect2: ld returned 1 exit status
В этом случае в строку компиляции добавьте аргументы:
gcc first.cpp -l stdc++
Теперь, после успешной компиляци, в вашем текущем каталоге появится файл a.out Это исполняемый файл вашей программы. Запустить его можно командой
./a.out
Странное имя объясняется тем, что компилятор всем исполняемым файлам,
для которых не задано имя, задаёт имя a.out Чтобы задать своё имя файла добавьте следующие аргументы gcc first.cpp -o execute -l stdc++
17

Здесь execute имя исполняемого файла, которое вы можете задать иное. Об- ратите внимание, что аргументы -l stdc++ идут последними! Вообще -l ука- зывает линковщику какие библиотеки подключать. Этот ключ или несколь- ко ключей (если подключается несколько библиотек) всегда должны идти последними. После выполнения указанной команды в текущем каталоге по- явится файл execute (или с другим именем если вы указали другое имя).
Запускается он аналогично
./execute
Рассмотрим теперь как компилировать программы состоящие из нескольких файлов. В одном файле у нас будет определена функция, например f(x) =

1 − x
2
В заголовочном файле будет описываться прототип этой функции и в третьем файле эта функция будет вызываться в функции main. Файл содержащий определение функции назовём func.cpp Его текст
#include
double f(double x)
{
return sqrt(1-pow(x,2));
}
Заголовочный файл my.h, содержащий прототип функции double f(double);
Последний файл second.cpp, содержащий функцию main
#include
#include"my.h"
int main(void)
{
cout << f(.5) << endl;
return 0;
}
Сначала просто откомпилируем исходные файлы, а затем соберём объектные файлы вместе с библиотеками в исполняемый файл. Команда компиляции gcc -c second.cpp func.cpp
Еслм синтаксических ошибок нет, то будут созданы файлы second.o и func.cpp
Теперь для сборки (линковки) оъектных файлов и файлов библиотек в ис- полняемый файл вводим команду
18
gcc second.o func.o -o execute -l stdc++ -lm
Здесь мы поключаем ещё одну библиотеку – математическую (-lm). Испол- няемый файл – execute.
Практическое занятие №7
Основы использования программы управления компиляцией make.
Обзор make. Утилита make автоматически определяет, какие части боль- шой программы должны быть перекомпилированы и команды для их пере- компиляции.
В примерах демонстрируются C-программы, но вы можете использовать make с любым языком программирования, компилятор которого может за- пускаться из командной строки. На самом деле, применение утилиты make не ограничивается программами. Вы можете использовать его для описания любой задачи, где некоторые файлы должны автоматически порождаться из других всегда, при изменении последних.
Прежде чем использовать make, вы должны создать файл, называемый make-файлом с именем Makefile или makefile, который описывает отношения между файлами вашей программы и содержит команды для обновления каж- дого файла. Обычно в программе исполняемый файл обновляется на основе объектных файлов, которые, в свою очередь, создаются путем компиляции исходных файлов.
Как только создан подходящий Makefile, для выполнения всех необходи- мых перекомпиляций при изменении исходных файлов достаточно просто на- брать в командной строке:
make
Программа make использует информацию из Makefile и время последнего изменения каждого файла для того, чтобы решить, какие файлы нужно об- новить. Для каждого обновляемого файла он вызывает соответствующие ко- манды, указанные в Makefile.
Обсудим простой make-файл, который описывает, как компилировать и компоновать программу описанную в практическом занятии №6. Эта про- грамма состоит из двух исходных C-файлов и одного заголовочного файла.
Этот make-файл может также указывать программе make, как выполнить различные команды, если явно указан запрос на их исполнение (например,
удалить определенные файлы в качестве команды clean).
Когда make перекомпилирует программу, каждый измененный исходный
C-файл должен быть перекомпилирован. Если был изменен заголовочный
19
файл, на всякий случай нужно перекомпилировать каждый исходный C- файл, который его включает. Каждая компиляция порождает объектный файл, соответствующий исходному файлу. Наконец, если какой-либо исход- ный файл был перекомпилирован, все объектные файлы, как новые, так и оставшиеся от предыдущих компиляций, должны быть скомпонованы вместе для создания нового исполняемого файла программы.
Правила. Простой make-файл состоит из "правил" следующего вида:
ЦЕЛЬ ...
: ЗАВИСИМОСТЬ ...
КОМАНДА
ЦЕЛЬ обычно представляет собой имя файла, генерируемого программой make;
примерами целей являются исполняемые или объектные файлы. Цель может также быть именем выполняемого действия, как, например, ’clean’.
ЗАВИСИМОСТЬ – это файл, используемый как вход для порождения цели. Ча- сто цель зависит от нескольких файлов.
КОМАНДА – это действие, которое выполняет make. Правило может иметь бо- лее, чем одну команду – каждую на своей собственной строке. Важное замеча- ние: вы должны начинать каждую строку, содержащую команды, с символа табуляции. Это является незаметным средством борьбы с неострожностью.
Обычно команда появляется в правиле с зависимостями и служит для созда- ния целевого файла, если какая-либо из зависимостей изменилась. Однако,
правило, определяющее команды для цели, не обязательно должно иметь за- висимости. Например, правило, содержащее команду удаления, связанную с целью ’clean’, не имеет зависимостей.
Правила описывают, как и когда заново порождать определенные файлы,
которые являются целями правил. Правило может также описывать, как и когда выполнять действие.
Помимо правил, make-файл, может содержать другой текст, однако простой make-файл содержит только правила. Правила могут выглядеть более слож- ными, чем показаный шаблон, но все они более или менее соответствуют ему по структуре.
Итак, Makefile, который описывает, как исполняемый файл, называемый execute, зависит от двух объектных файлов, которые, в свою очередь, зави- сят от двух исходных C-файлов и одного заголовочного файла.
execute: second.o func.o gcc -o execute second.o func.o second.o : second.cpp my.h
20
gcc -c second.cpp func.o : func.cpp my.h gcc -c func.cpp clean :
rm execute second.o func.o
Чтобы использовать этот make-файл для создания исполняемого файла с именем ’execute’, наберите в командной строке:
make
Чтобы использовать этот Makefile для удаления исполняемого файла и всех объектных файлов из текущего каталога, наберите в командной строке:
make clean
В приведенном примере make-файла к целям относятся, в частности, испол- няемый файл ’execute’ и объектные файлы ’second.o’ и ’func.o’. К зависимо- стям относятся такие файлы, как ’second.cpp’ и ’my.h’. Фактически, каждый объектный файл является как целью, так и зависимостью. Примерами ко- манд являются ’gcc -c second.cpp’ и ’gcc -c func.cpp’.
Когда цель является файлом, этот файл должен быть перекомпилирован или перекомпонован, если изменилась любая из его зависимостей. Кроме того,
любые зависимости, которые сами автоматически генерируются, должны об- новляться первыми. В этом примере, ’execute’ зависит от каждого из двух объектных файлов; объектный файл ’second.o’ зависит от исходного файла
’second.cpp’ и заголовочного файла ’my.h’.
За каждой строкой, содержащей цель и зависимости, следует команда. Эти команды указывают, как обновлять целевой файл. В начале каждой командой строки должен располагаться символ табуляции, чтобы отличать командные строки от других строк make-файла. (Держите в уме, что make ничего не знает о том, как работают команды. Обеспечить команды, которые коррект- но обновят целевой файл – целиком ваша забота. Все, что делает make – это выполнение команд из опреденного вами правила, когда целевой файл дол- жен быть обновлен.)
Цель ’clean’ является не файлом, а просто именем действия. Так как обычно вы не хотите выполнять действия из этого правила, ’clean’ не является зави- симостью какого-либо другого правила. Следовательно, make никогда ничего с ним не сделает, если вы этого специально не укажете. Обратите внимание,
что это не только не является зависимостью, оно также не имеет никаких зависимостей, таким образом, единственным предназначением правила яв- ляется выполнение определенных в правиле команд.
21

Как make обрабатывает make-файл По умолчанию, make начинает с первого правила. Это называется главной целью по умолчанию. В простом примере из предыдущего раздела главной целью по умолчанию является об- новление исполняемой программы ’execute’; следовательно, мы располагаем это правило первым.
Таким образом, когда вы даете команду:
make make читает Makefile в текущем каталоге и начинает с обработки первого правила. В приведенном примере им является правило для перекомпоновки
’execute’; но, прежде чем make сможет полностью обработать это правило,
он должен обработать правила для файлов, от которых зависит ’execute’ (в данном случае ими являются объектные файлы). Каждый из этих файлов обрабатывается в соответствии со своими собственным правилом. Эти пра- вила указывают обновить каждый объектный файл путем компиляции его исходного файла. Перекомпиляция должна быть проведена, если исходный файл или любой из заголовочных файлов, упомянутых среди зависимостей,
обновлен позднее, чем объектный файл, или если объектный файл не суще- ствует.
Другие правила обрабатываются по той причине, что их цели появляются в качестве зависимостей главной цели. Если от какого-либо правила не за- висит главная цель (или что-нибудь, отчего она зависит), то это правило не обрабатывается, если вы не укажете программе make сделать это (с помощью такой команды, как make clean).
Перед перекомпиляцией объектного файла make рассматривает время обнов- ления его зависимостей: исходного файла и заголовочных файлов. Данный make-файл не определяет ничего, что должно делаться для их порождения
– файлы, имена которых оканчиваются на ’.c’ и ’.h’ не являются целями каких-либо правил – таким образом, make ничего не делает для этих файлов.
Однако make мог бы обновить автоматически генерируемые C-программы,
например, получаемые с помощью программ Bison или Yacc, если бы для них, в этом случае, были определены свои правила.
После перекомпиляции всех объектных файлов, для которых это необходи- мо, make решает, перекомпоновывать ли ’execute’. Это должно быть сделано,
если файл ’execute’ не существует, или какой-либо из объектных файлов об- новлен позднее его. Если объектный файл был только что перекомпилирован,
то сейчас он новее, чем ’execute’, так что ’execute’ перекомпоновывается.
Таким образом, если мы изменим файл ’func.cpp’ и запустим make, make от- компилирует этот файл для обновления ’func.o’, и затем скомпонует ’execute’.
Если мы изменим файл ’my.h’ и запустим make, make перекомпилирует объ- ектный файл ’second.o’, а затем скомпонует ’execute’.
22


Поделитесь с Вашими друзьями:


База данных защищена авторским правом ©nethash.ru 2017
обратиться к администрации

войти | регистрация
    Главная страница


загрузить материал