Рис. 4.3. Канал после вызова fork
Рис. 4.4. Канал между двумя процессами
При вводе команды наподобие
who|sort|lp
в интерпретаторе команд Unix интерпретатор выполняет вышеописанные действия для создания трех процессов с двумя каналами между ними. Интерпретатор также подключает открытый для чтения конец каждого канала к стандартному потоку ввода, а открытый на запись — к стандартному потоку вывода. Созданный таким образом канал изображен на рис. 4.5.
Рис. 4.5. Каналы между тремя процессами при конвейерной обработке
Все рассмотренные выше каналы были однонаправленными (односторонними), то есть позволяли передавать данные только в одну сторону. При необходимости передачи данных в обе стороны нужно создавать пару каналов и использовать каждый из них для передачи данных в одну сторону. Этапы создания двунаправленного канала IPC следующие:
1. Создаются каналы 1 (fd1[0] и fd1[1]) и 2 (fd2[0] и fd2[1]).
2. Вызов fork.
3. Родительский процесс закрывает доступный для чтения конец канала 1 (fd1[0]).
4. Родительский процесс закрывает доступный для записи конец канала 2 (fd2[1]).
5. Дочерний процесс закрывает доступный для записи конец канала 1 (fd1[1]).
6. Дочерний процесс закрывает доступный для чтения конец канала 2 (fd2[0]).
Текст программы, выполняющей эти действия, приведен в листинге 4.1. При этом создается структура каналов, изображенная на рис. 4.6.
Рис. 4.6. Двусторонняя передача данных по двум каналам
Пример
Давайте напишем программу, описанную в разделе 4.2, с использованием каналов. Функция main создает два канала и вызывает fork для создания копии процесса. Родительский процесс становится клиентом, а дочерний — сервером. Первый канал используется для передачи полного имени от клиента серверу, а второй — для передачи содержимого файла (или сообщения об ошибке) от сервера клиенту. Таким образом мы получаем структуру, изображенную на рис. 4.7.
Рис. 4.7. Реализация рис. 4.1 с использованием двух каналов
Обратите внимание на то, что мы изображаем на рис. 4.7 два канала, соединяющих сервер с клиентом, но оба канала проходят через ядро, поэтому каждый передаваемый байт пересекает интерфейс ядра дважды: при записи в канал и при считывании из него.
В листинге 4.1[1] приведена функция main для данного примера.
Листинг 4.1. Функция main для приложения клиент-сервер, использующего два канала
//pipe/mainpipe.c
1 #include "unpipc.h"
2 void client(int, int), server(int, int);
3 int
4 main(int argc, char **argv)
5 {
6 int pipe1[2], pipe2[2]:
7 pid_t childpid;
8 Pipe(pipe1); /* создание двух каналов */
9 Pipe(pipe2);
10 if ((childpid = Fork()) == 0) { /* child */
11 Close(pipe1[1]);
12 Close(pipe2[0]);
13 server(pipe1[0], pipe2[1]);
14 exit(0);
15 }
16 /* родитель */
17 Close(pipel[0]);
18 Close(pipe2[1]);
19 client(pipe2[0], pipel[1]);
20 Waitpid(childpid, NULL, 0); /* ожидание завершения дочернего процесса */
21 exit(0);
22 }
Создание каналов, вызов fork
8-19 Создаются два канала и выполняются шесть шагов, уже упоминавшиеся в отношении рис. 4.6. Родительский процесс вызывает функцию client (листинг 4.2), а дочерний — функцию server (листинг 4.3).
Использование waitpid дочерним процессом
20 Процесс-сервер (дочерний процесс) завершает свою работу первым, вызывая функцию exit после завершения записи данных в канал. После этого он становится процессом-зомби. Процессом-зомби называется дочерний процесс, завершивший свою работу, родитель которого еще функционирует, но не получил сигнал о завершении работы дочернего процесса. При завершении работы дочернего процесса ядро посылает его родителю сигнал SIGCHLD, но родитель его не принимает и этот сигнал по умолчанию игнорируется. После этого функция client родительского процесса возвращает управление функции main, закончив Считывание данных из канала. Затем родительский процесс вызывает waitpid для получения информации о статусе дочернего процесса (зомби). Если родительский процесс не вызовет waitpid, а просто завершит работу, клиент будет унаследован процессом init, которому будет послан еще один сигнал SIGCHLD.
Функция client приведена в листинге 4.2.
Листинг 4.2. Функция client для приложения типа клиент-сервер с двумя каналами
//pipe/client.с
1 #include "unpipc.h"
2 void
3 client(int readfd, int writefd)
4 {
5 size_t len;
6 ssize_t n;
7 char buff[MAXLINE];
8 /* получение полного имени файла */
9 Fgets(buff, MAXLINE, stdin);
10 len = strlen(buff); /* fgets() гарантирует завершающий нулевой байт */
11 if (buff[Len-l] == ' n' )
12 len--; /* удаление перевода строки из fgets() */
13 /* запись полного имени в канал IPC */
14 Write(writefd, buff, len);
15 /* считывание из канала, вывод в stdout */
16 while ((n = Read(readfd, buff, MAXLINE)) > 0)
17 Write(STDOUT_FILENO, buff, n);
18 }
Считывание полного имени из стандартного потока ввода
8-14 Полное имя файла считывается из стандартного потока ввода и записывается в канал после удаления завершающего символа перевода строки, возвращаемого функцией fgets.
Копирование из канала в стандартный поток вывода
15-17 Затем клиент считывает все, что сервер направляет в канал, и записывает эти данные в стандартный поток вывода. Ожидается, что это будет содержимое файла, но в случае его отсутствия будет принято и записано в стандартный поток вывода сообщение об ошибке.
В листинге 4.3 приведена функция server.
Листинг 4.3. Функция server для приложения клиент-сервер с двумя каналами
//pipe/server.c
1 #include "unpipc.h"
2 void
3 server(int readfd, int writefd)
4 {
5 int fd;
6 ssize_t n;
7 char buff[MAXLINE+1];
8 /* получение полного имени из канала IPC */
9 if ((n = Read(readfd, buff, MAXLINE)) == 0)
10 err_quit("end-of-file while reading pathname"):
11 buff[n] = ' '; /* полное имя завершается 0 */
12 if ((fd = open(buff, O_RDONLY)) < 0) {
13 /* 4error: must tell client */
14 snprintf(buff + n, sizeof(buff) – n, ": can't open. %sn".
15 strerror(errno)):
16 n = strlen(buff);
17 Write(writefd, buff, n);
18 } else {
19 /* файл успешно открыт и копируется в канал */
20 while ( (n = Read(fd, buff, MAXLINE)) > 0)
21 Write(writefd, buff, n);
22 Close(fd);
23 }
24 }
Считывание полного имени файла из канала
8-11 Записанное в канал клиентом имя файла считывается сервером и дополняется завершающим символом с кодом 0 (null-terminated). Обратите внимание, что функция read возвращает данные, как только они помещаются в поток, не ожидая накопления некоторого их количества (MAXLINE в данном примере).
Открытие файла, обработка возможной ошибки
12-17 Файл открывается для чтения и при возникновении ошибки сообщение о ней возвращается клиенту с помощью канала. Для получения строки с соответствующим значению переменной errno сообщением об ошибке вызывается функция strerror (в книге [24, с. 690-691] вы найдете более подробный рассказ об этой функции).
Копирование из файла в канал
18-23 При успешном завершении работы функции open содержимое файла копируется в канал.
Ниже приведен результат работы программы в случае наличия файла с указанным полным именем и в случае возникновения ошибок:
solaris % mainpipe /etc/inet/ntp.conf файл, состоящий из двух строк
multicastclient 224.0.1.1
driftfile /etc/inet/ntp.drift
solaris % mainpipe /etc/shadow фaйл, на чтение которого нет разрешения
/etc/shadow: can't open. Permission denied
solaris % mainpipe /no/such/file несуществующий файл
/no/such/file: can't open. No such file or directory
4.4. Двусторонние каналы
В предыдущем разделе мы отметили, что во многих системах реализованы двусторонние каналы. В Unix SVR4 это обеспечивается самой функцией pipe, а во многих других ядрах — функцией socketpair. Но что в действительности представляет собой двусторонний канал? Представим себе сначала однонаправленный канал, изображенный на рис. 4.8.
Рис. 4.8. Односторонний канал
Двусторонний канал мог бы быть реализован так, как это изображено на рис. 4.9. В этом случае неявно предполагается существование единственного буфера, в который помещается все, что записывается в канал (с любого конца, то есть дескриптора), и при чтении из канала данные просто считываются из буфера.
