Основы программирования в Linux - Нейл Мэтью

1. Первая программа — поставщик. Она создает канал, если требуется, и затем записывает в него данные как можно быстрее.

Поскольку пример иллюстративный, нас не интересуют конкретные данные, и мы не беспокоимся об инициализации буфера, В обоих листингах затененные строки содержат изменения, внесенные в программу fifo2.c помимо удаления кода со всеми аргументами командной строки.

#include <unistd.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <fcntl.h>

#include <limits.h>

#include <sys/types.h>

#include <sys/stat.h>

#define FIFO_NAME "/tmp/my_fifo"

#define BUFFER_SIZE PIPE_BUF

#define TEN_MEG (1024 * 1024 * 10)

int main() {

 int pipe_fd;

 int res;

 int open_mode = O_WRONLY;

 int bytes_sent = 0;

 char buffer[BUFFER_SIZE + 1];

 if (access(FIFO_NAME, F_OK) == -1) {

  res = mkfifo(FIFO_NAME, 0777);

  if (res != 0) {

   fprintf(stderr, "Could not create fifo %sn", FIFO_NAME);

   exit(EXIT_FAILURE);

  }

 }

 printf("Process %d opening FIFO O_WRONLYn", getpid());

 pipe_fd = open(FIFO_NAME, open_name);

 printf("Process %d result %dn", getpid(), pipe_fd);

 if (pipe_fd != -1) {

  while (bytes_sent < TEN_MEG) {

   res = write(pipe_fd, buffer, BUFFER_SIZE);

   if (res == -1) {

    fprintf(stderr, "Write error on pipen);

    exit(EXIT_FAILURE);

   }

   bytes_sent += res;

  }

  (void)close(pipe_fd);

 } else {

  exit(EXIT_FAILURE);

 }

 printf("Process %d finishedn", getpid());

 exit(EXIT_SUCCESS);

}

2. Вторая программа, потребитель, гораздо проще. Она читает и выбрасывает данные из канала FIFO.

#include <unistd.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <fcntl.h>

#include <limits.h>

#include <sys/types.h>

#include <sys/stat.h>

#define FIFO_NAME "/tmp/my_fifo"

#define BUFFER_SIZE PIPE_BUF

int main() {

 int pipe_fd;

 int res;

 int open_mode = O_RDONLY;

 char buffer[BUFFER_SIZE - 1];

 int bytes_read = 0;

 memset(buffer, '', sizeof(buffer));

 printf("Process %d opening FIFO O_RDONLYn", getpid());

 pipe_fd = open(FIFO_NAME, open_mode); 

 printf("Prосеss %d result %dn", getpid(), pipe_fd);

 if (pipe_fd != -1) {

  do {

   res = read(pipe_fd, buffer,BUFFER_SIZE);

   bytes_read += res;

  } while (res > 0);

  (void)close(pipe_fd);

 } else {

  exit(EXIT_FAILURE);

 }

 printf("Process %d finished, %d bytes readn", getpid(), bytes_read);

 exit(EXIT_SUCCESS);

}

Когда вы выполните эти программы одновременно, с использованием команды time для хронометража читающего процесса, то получите следующий (с некоторыми пропусками для краткости) вывод:

$ ./fifo3 &

[1] 375

Process 375 opening FIFO O_WRONLY

$ time ./fifo4

Process 377 opening FIFO O_RDONLY

Process 375 result 3

Process 377 result 3

Process 375 finished

Process 377 finished, 10485760 bytes read

real 0m0.053s

user 0m0.020s

sys  0m0.040s

[1]+ Done   ./fifo3

Как это работает

Обе программы применяют FIFO в режиме блокировки. Вы запускаете первой программу fifo3 (пишущий процесс/поставщик), которая блокируется, ожидая, когда читающий процесс откроет канал FIFO. Когда программа fifo4 (потребитель) запускается, пишущий процесс разблокируется и начинает записывать данные в канал. В это же время читающий процесс начинает считывать данные из канала.

ОС Linux так организует планирование двух процессов, что они оба выполняются, когда могут, и заблокированы в противном случае. Следовательно, пишущий процесс блокируется, когда канал полон, а читающий — когда канал пуст.

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

Более сложная тема: применение каналов FIFO в клиент-серверных приложениях

Заканчивая обсуждение каналов FIFO, давайте рассмотрим возможность построения очень простого клиент-серверного приложения, применяющего именованные каналы. Вы хотите, чтобы один серверный процесс принимал запросы, обрабатывал их и возвращал результирующие данные запрашивающей стороне — клиенту.

Вам нужно разрешить множественным клиентским процессам отправлять данные серверу. Для простоты предположим, что данные, которые нужно обработать, можно разбить на блоки, каждый из которых меньше PIPE_BUF байтов. Конечно, реализовать такую систему можно разными способами, но мы рассмотрим только один, как иллюстрацию применения именованных каналов.

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

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

Выполните упражнение 13.13.

1. Прежде всего, вам нужен заголовочный файл client.h, в котором определены данные, общие для серверных и клиентских программ. В приложение также для удобства включены требуемые системные заголовочные файлы.

#include <unistd.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <fcntl.h>

#include <limits.h>

#include <sys/types.h>

#include <sys/stat.h>

#define SERVER_FIFO_NAME "/tmp/serv_fifo"

#define CLIENT_FIFO_NAME "/tmp/cli_%d_fifo"

#define BUFFER_SIZE 20

struct data_to_pass_st {

 pid_t client_pid;

 char some_data[BUFFER_SIZE - 1];

};

2. Теперь займемся серверной программой server.c. В этом разделе вы создаете и затем открываете канал сервера. Он задается в режиме "только для чтения" и с блокировкой. После засыпания (из демонстрационных соображений) сервер читает данные от клиента, у которого есть структура типа data_to_pass_st.

#include "client.h"

#include <ctype.h>

int main() {

 int server_fifo_fd, client fifo_fd;

 struct data_to_pass_st my_data;

 int read_res;

 char client_fifo[256];

 char *tmp_char_ptr;

 mkfifo(SERVER_FIFO_NAME, 0777);

 server_fifo_fd = open(SERVER_FIFO_NAME, O_RDONLY);

 if (server_fifo_fd == -1) {

  fprintf(stderr, "Server fifo failuren");

  exit(EXIT_FAILURE);

 }

 sleep(10); /* для целей демонстрации разрешает клиентам создать очередь */

 do {

  read_res = read(server_fifo_fd, &my_data, sizeof(my_data));

  if (read res > 0) {

3. На следующем этапе вы выполняете некоторую обработку данных, только что полученных от клиента: преобразуете все символы в некоторых данных в прописные и соединяете CLIENT_FIFO_NAME с полученным идентификатором client_pid.

   tmp_char_ptr = my_data.some_data;

   while (*tmp_char_ptr) {

    *tmp_char_ptr = toupper(* tmp_char_ptr);

    tmp_char_ptr++;

   }

   sprintf(client_fifo, CLIENT_FIFO_NAME, my_data.client_pid);

4. Далее отправьте обработанные данные назад, открыв канал клиентской программы в режиме "только для записи" и с блокировкой. В заключение закройте серверный FIFO с помощью закрытия файла и отсоединения FIFO.

   client_fifo_fd = open(client_fifo, O_WRONLY);

   if (client_fifo_fd ! = -1) {

    write(client_fifo_fd, &my_data, sizeof(my_data));

    close(client_fifo_fd);

   }

  }

 } while (read_res > 0);