Шаг 1 - Что такое CGI ?

CGI - Common Gateway Interface

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

CGI-программа.

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

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

В web-сервере Apache такая настройка производится с помощью файла .htaccess в той директории, где содержится этот скрипт. Вот содержание такого файла:

 Options ExecCGI

Также Apache позволяет запускать все скрипты имеющие рассширение .cgi, если в файле настроек сервера httpd.cong есть настройка:

 AddHandler cgi-script .cgi

Чаще всего, хотя наверно почти всегда, скрипты используются для создания динамических страниц. Связано это с тем, что само содержимое веб-сервера является статическим и не будет меняться просто так, для этого должен приложить руку веб-мастер.

Технология CGI позволяет просто поменять содержимое веб-сервера.

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

Шаг 2 - Передача данных шлюзу.

Передача данных шлюзу осуществляется в следующем формате:

имя=значение&имя1=значение1&... 

Здесь "имя" это название параметра, а "значение" его содержимое.

Методов передачи данных в таком формате существует два - GET и POST.

При использовании метода GET данные передаются серверу вместе с URL:

http://.../cgi-bin/test.cgi?имя=значение&имя1=значение1&...

При использовании метода POST данные посылаются внутри самого HTTP запроса.

Так как длина URL ограничена, то методом GET нельзя передать  большой объем данных, а метод POST обеспечивает передачу данных не ограниченных по длинне.

Получение данных самим скриптом также различается. При использовании метода GET данные следующие за "?" помещаются в переменную среды QUERY_STRING.

При использовании POST содержимое запроса перенаправляется в стандартный поток ввода, т.е. в stdin.

Чтобы шлюз мог узнать какой метод используется для передачи данных, сервер создает переменную среды REQUEST_METHOD, в которую записывает GET или POST.

В имена и значения параметров при передаче кодируются браузером URL методом, т.е. все символы не принадлежащие к латинскому алфавиту и числам кодируются в виде %HH, где HH - шестнадцатеричное значение кода символа.

Также кодируются все символы , которые нельзя использовать, т.е. !#%^&()=+ и пробел.

Символ "&" используется, как мы уже видели для разделения пар "имя=значение", "=" используется в парах "имя=значение", "%" для кодирования символов, "пробел" кодируется символом "+"(плюс), сам же плюс кодируется через "%", и т.д.

Поэтому при анализе полученных данных требуется их переводить в нормальных вид.

Пример кодировки символов и букв при передаче:

Передается строка: !@#$%^&*()-=_+ абвгд
Скрипт получает  : %21@%23%24%25%5E%26*%28%29-%3D_%2B+%E0%E1%E2%E3%E4

Размер передаваемых данных методом POST содержится в переменной окружения CONTENT_LENGTH:

Передается : a=4&b=1
CONTENT_LENGTH = 7

Шаг 3 - Структура CGI программы.

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

Как получать данные ?

Весь процесс получения данных от веб-сервера можно представить следуюшим образом:

1. Получить все необходимые переменные окружения. Наиболее важной на  данном этапе является REQUEST_METHOD.

2. Получить данные от сервера в зависимости от метода передачи:

     Если (REQUEST_METHOD="GET") то
        Взять данные из переменной окружения QUERY_STRING
     Иначе
        Если (REQUEST_METHOD="POST") то
            Проанализировать переменную QUERY_STRING
            Получить длинну данных из CONTENT_LENGTH
            Если (CONTENT_LENGTH>0) то
                Считать CONTENT_LENGTH байт из sdtin как данные.
        Иначе
            Выдать сообщение об ошибке и выйти.
   

3. Декодировать все полученные данные и, если надо, разбить их на пары "имя=значение" в удобную для программы форму.

С анализом переменной REQUEST_METHOD думаю все ясно, а вот ,что значит в методе POST проанализировать QUERY_STRING, наверно, не все ясно.

При передаче методом POST сервер посылает данные через стандартный поток ввода, но это не значит, что пользователь не пользовался URL\'ом для передачи данных.

Примером может служить многопользовательский шлюз, в котором для идентификации пользователя используется URL, а для передачи данных stdin:

  http://.../cgi-bin/guestbook.cgi?user=bob&rec=0

В этом случае шлюзу гостевой книги (guestbook.cgi) сообщается два параметра

user и rec, с помощью которых она может узнать "куда записывать" или "как обрабатывать" данные поступающие через поток ввода.

Считывание данных через поток sdtin должно осуществляться в динамическую память, или же во временный файл, если размер памяти ограничен или данные слишком велики для полного размещения в ОЗУ. С чем это связано ?

Это связано с тем, что при использовании статичестких буферов может  произойти его переполнение.

Пример:

  char cgi_data[1000];
  ...
  long content_length=atol(getenv("CONTENT_LENGTH"));
  fread(cgi_data,content_length,1,stdin);
  ...

Надеюсь все сразу видно :-)). Если content_length>1000, то произойдет переполнение cgi_data. Переполнение буферов это излюбленный метод атаки хакеров. Вместо этого лучше выделять память динамически:

  char *cgi_data;
  ...
  long content_length=atol(getenv("CONTENT_LENGTH"));
  cgi_data=(char *)malloc(content_length);
  if (cgi_data!=NULL)
     fread(cgi_data,content_length,1,stdin);
  ...

После получения данных от сервера их надо еще декодировать. Можно это сделать сразу, а можно по мере надобности. Если Вы будете это делать сразу, то Вам также придется их разбить на куски, так как при декодировании могут появиться лишние знаки "&" и "=", которые больше не позволят вам отделять пары "имя=значение" друг от друга.

Вот пример процедуры, которая декодирует данные из буфера:

/* Возвращает верхний регистр символа*/
char upperchar(char ch)
{
  if ((ch>=\'a\') && (ch<=\'z\'))
  {
      ch=\'A\'+(ch - \'a\');
      return ch;
   }
  else return ch;
};
/* Переводит из Hex в Dec*/
char gethex(char ch)
{
  ch=upperchar(ch);
  if ((ch>=\'0\')&&(ch<= \'9\')) return (ch-\'0\');
  if ((ch>=\'A\')&&( ch<=\'F\')) return (ch-\'A\'+10);
};
/* 
  Ищет и возвращает параметр с именем name, в buffer.
  Если параметр name не найден, возвращает NULL.
  
Пример : message = getparam(post_buffer,"message=");
Замечание : символ "=" после имени параметра не удаляется
  и входит в возвращаемый результат, поэтому рекомендуется
  искать параметр вместе с символом "=".
 */
 
char *getparam(char *buffer,char *name)
{
 if (buffer==NULL) return NULL;
 char *pos;
 long leng=512,i=0,j=0;
 char h1,h2,Hex;
 char *p=(char *)malloc(leng);
 pos=strstr(buffer,name);
 if (pos == NULL) return NULL;
 if ((pos!=buffer) && (*(pos-1)!=\'&\')) return NULL; 
 pos+=strlen(name);
 
 while ( (*(pos+i)!=\'&\')&&( *(pos+i)!=\'\\0\' ))
 {
  if ( *(pos+i)==\'%\' )
  {
    i++;
    h1=gethex(*(pos+i));
    i++;
    h2=gethex(*(pos+i));
    h1=h1<<4;
    *(p+j)=h1+h2;
  }
  else
  {
    if (*(pos+i)!=\'+\') *(p+j)=*(pos+i);
     else *(p+j)=\' \';
  };
  i++;
  j++;
  if (j >= leng) p=(char*)realloc(p,leng+20);
  leng+=20;
 };
 if (j < leng) p=(char*)realloc(p,j+1);
      
 *(p+j)=\'\\0\';
 return p;
};

Теперь используя функцию getparam Вы сможете в любое время получить какой-нибудь параметр. Конечно эта процедура еще далека от совершенства, так как использует стандартный realloc и не обрабатывает ошибку нехватки памяти, но всеже ее можно использовать для данных не особо больших размеров.

Кстати надо еще сказать, что нецелесообразно размещать поступающие данные размером >64 Кб. в памяти, если, например, скрипт предназначен для закачки файлов, то можно (а вернее нужно) напрямую организовать запись в файл, иначе  файл размером в пару мегабайт ваш скрипт не обработает :-)).

Шаг 4 - Обработка данных шлюзом.

Тут советов не много, а тем более наставлений, так как разработчик должен решать сам, что ему разместить внутри своей программы. Давайте поговорим о том как защитить, или лучше сказать, организовать эту работу.

Естественно, первое о чем Вы должны подумать, это как организовать возможность мнопользовательской работы скрипта. Т.е. скрипт должен отслеживать одновременный запуск нескольких копий программы. Почти все шлюзы в процессе работы производят запись или чтение каких-либо данных с диска. А одновременно записать в конец  одного файла две запущенные программы не могут. Для этого и требуется отделить  их друг от друга, чтобы не испортить результат их работы.

Думаю способов сделать это можно найти достаточно много, и в каждой  операционной системе обязательно найдутся необходимые процедуры. Например, в Юниксах можно заблокировать на запись или чтение определенный участок файла.

Такие способы могут очень помочь, но они зачастую достаточно сложны и в повседневной жизни (вернее программировании :-) редко используются, поэтому у вас могут возникнуть определенные сложности на начальном этапе.

Есть способ, который просто реализовать и он не требует больших сил.

Он заключается в следующем. Ваша программа при запуске создает временный файл, например с именем lock.$. Такой же скрипт при запуске проверяет наличие  этого файла, и если он не находит его, то создает его и продолжает работу, если же он его находит, то ждет несколько секунд и снова проверяет его наличие.

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

Пример реализации данного метода:

 FILE f_lock;
/* ..... */
 int counter;
 /* Проверяем наличие временного файла */
 while ((f_lock = fopen("lock.$", "r")) != NULL)
   {
      fclose(f_lock);
      counter++;
      if (counter>15000)
      {
       /*Сообщаем об ошибке и выходим */
       printf("Error !!! Can\'t delete lock.$ file.");
       return 1;
      };
   };
  /* Создаем временный файл */
   f_lock = fopen("lock.$", "w");
   fclose(f_lock);
  /*... Работа основной части скрипта ...*/
  /* Удаляем временный файл */
   while (remove("lock.$")!=0);

Как видно этот способ достаточно прост в реализации и точно убережет

Вас от неправильной работы скрипта.

Думаю к минусам этого метода надо отнести то, что он не позволяет выполнять свою работу другим запущенным скриптам, из-за того что и им приходится ждать.

Если у Вас происходят десятки обращений в минуту или даже секунду, то  лучше конечно блокировать части файлов. Но это уже возможности самой системы, под которую расчитан скрипт (и не всегда это можно реализовать). А для обычных гостевых книг данный метод просто идеален.

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

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

Встроить код достаточно сложно, так как вы должны не только иметь код веб сервера (что иногда просто невозможно), но и знать как все это "чудо" работает.

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

Шаг 5 - Вывод информации.

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

Существуют два типа заголовков, вернее даже три, но один из них используется реже (о нем мы поговорим отдельно). Так вот, первый заголовок осуществляет переадресацию браузера на другой ресурс в сети и записывается вот как:

Location: URL-адрес ресурса

Под URL-адресом может быть что угодно, от заранее заготовленной страницы ответа, до страницы или файла на чужом сервере. Очень полезная штука для любителей преадресовки :-)

Пример:

Location: http://www.mjk.msk.ru/~dron/88.gif

Второй тип заголовка описывает данные которые будет выводить непосредственно скрипт. Задает их тип, длину и другие вспомогательные параметры. Самый простой заголовок записывается в виде:

Content-type: тип данных

Тип данных создается из двух составляющих: его типа и формата.

То есть, сначала указывается один из следующих типов:

• application - данные для какого-либо приложения

• audio - аудио данные, например RealAudio

• video - видео данные, например MPEG или AVI

• image - изображение

• text - текст

Далее через /(слэш) указывается формат данных.

Примеры заголовков:

Content-type: text/html
Content-type: image/gif
Content-type: video/mpeg

Еще заголовок может включать в себя вспомогательные параметры,

Content-length - длина содержимого, Expires - время существования в кэше и т.д.

Каждый параметр указывается в отдельной строке и заканчивается переносом строки \\n.

Пример:

Content-type: image/gif
Content-length: 1052

После того как заголовок сформирован и отправлен надо отправить пустую строку, для того, чтобы отделить его от основных данных.

 ...
 printf("Content-type: text/html\\n");
 printf("\\n");
 printf("<html><h1>Simple CGI for example !!!</h1></html>");
 ...

Если отделяющая пустая строка (я ее сделал отдельной строкой в коде) не будет отправлена, то сервер выдаст ошибку 500 Internal Server Error : Bad header.

После отправки заголовка скрипт может приступать к выводу данных, но естественно только в указанном им формате.

Шаг 6 - Переменные среды о сервере.

Как я уже говорил, сервер и шлюз общаются между собой через стандартные потоки ввода/вывода и переменные среды. Незная названий этих переменных среды сложно что-либо получить от сервера :-).

Давайте рассмотрим какие же переменные среды устанавливает сервер в момент запуска шлюза.

Переменные среды о сервере

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

GATEWAY_INTERFACE

Указывает версию интерфейса CGI, который поддерживает сервер. Например:

CGI/1.1

SERVER_NAME

Содержит IP адрес сервера или его доменное имя. Например:

www.mjk.msk.ru

SERVER_PORT

Номер порта, по которому сервер получает http запросы. Стандартный порт для этого 80.

SERVER_PROTOCOL

Версия протокола Http, который использует сервер для обработки запросов. Например:

 HTTP/1.1

SERVER_SOFTWARE

Название и версия программы сервера. Например:

Apache/1.3.3 (Unix) (Red Hat/Linux)

Эти переменные обеспечивают все необходимые данные о сервере, на котором запускается скрипт.

Если Ваш сервер сконфигурирован для работы с одним хостом, то скорее информация эта вам не понадобится.

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

Тут уже могут понадобиться данные о портах сервера (т.к. многие хосты просто "сидят" на других портах, например 8080, 8081 и т.д.) и его IP адрес с именем.

Шаг 7 - Переменные среды о запросе.

При помощи переменных данного типа шлюз узнает полную информацию о запросе к нему.

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

AUTH_TYPE

Тип авторизации используемой сервером. Например:

Basic

Подробнее об авторизации в сервере Apache читайте в "Шаг 18 - Авторизация посетителей"(Html&Web).

CONTENT_FILE

Путь к файлу с полученными данными. Используется только в серверах под Windows. Например:

c:\\website\\cgi-temp\\103421.dat

CONTENT_LENGTH

Длинна переданной информации в байтах. То бишь сколько надо считать байтов из stdin. Например:

10353

CONTENT_TYPE

Тип содержимого посланного серверу клиентом. Например:

text/html

OUTPUT_FILE

Файл для вывода данных, используется только серверами под Windows. Аналогично CONTENT_FILE.

PATH_INFO и PATH_TRANSLATED

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

Но видимо некоторым он сможет пригодиться. Эти переменные работают следующим образом.

Предположим существует скрипт с именем 1.cgi в каталоге сервера /cgi-bin, тогда при вызове скрипта в таком виде:

  http://.../cgi-bin/1.cgi/dir1/dir2

данные переменные установятся следующим образом:

PATH_INFO=/dir1/dir2
PATH_TRANSLATED=/home/httpd/html/dir1/dir2

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

/home/httpd/html/, и еще замечу, что это путь в Unix системах.

Под dos/win системами переменная PATH_INFO не изменится, а

PATH_TRANSLATED будет содержать d:\\apache\\htdocs\\dir1\\dir2 (в данном случае корнем сервера является директория d:\\apache\\htdocs\\).

QUERY_STRING

Содержит данные переданные через URL. Такие данные указываются после имени шлюза и знака ?. Пример:

http://.../cgi-bin/1.cgi?d=123&name=kostia

тогда переменная QUERY_STRING будет содержать

 d=123&name=kostia

и еще незабывайте, что данные передаваемые таким образом кодируются методом URL.

REMOTE_ADDR

Содержит IP адрес пользователя пославшего запрос шлюзу. Если Вы обращаетесь

к любому шлюзу в интернете, то данная переменная будет содержать ваш IP адрес. Пример:

 192.168.1.36

REMOTE_HOST

Содержит ваше доменное имя, при условии, что вы прописаны на каком-либо DNS сервере.

Например, если ваш Dial-UP провайдер регистрирует все свои динамические IP адреса на DNS сервере, то

при обращении к шлюзу, эта переменная может содержать примерно следующее:

d6032.dialup.cornell.edu
или
dial57127.mtu-net.ru
или
ppp-130-66.dialup.metrocom.ru

(брал прямо из логов сервера :-)

REQUEST_METHOD

Мы раньше говорили об этой переменной. Она содержит метод передачи данных шлюзу: GET или POST.

REQUEST_LINE

Содержит строку из запроса протокола HTTP. Например:

GET /cgi-bin/1.cgi HTTP/1.0

SCRIPT_NAME

Содержит имя вызванного скрипта. Например: 1.cgi.

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

Шаг 8 - Переменные среды о клиенте.

Осталось рассмотреть еще несколько переменных, которые несут в себе информацию о клиенте пославшем запрос.

Их не много, всего три:

HTTP_ACCEPT

Эта переменная пречисляет все типы данных, которые может получать и обрабатывать клиент.

Часто содержит просто */*, т.е. клиент может получать все подряд. Пример:

 */*,image/gif,image/x-xbitmap  

HTTP_REFERER

Содержит URL страницы, с которой был произведен запрос, т.е. которая

содержит ссылку на шлюз. Пример:

  http://www.mjk.msk.ru/~dron/index.html

HTTP_USER_AGENT

Содержит в себе название и версию браузера, которым пользуется клиент для запроса.

Полезно для того, чтобы игнорировать браузеры ненавистных вам фирм :-))). Пример:

MyBrowser/1.0 (MSIE 4.0 Compatible, Win98)

В большинстве случаев эти переменные не несут в себе полезной для скрипта информации, если только Вы не будете передавать все данные в формате MS Word , и вам не потребуется знать сможет ли клиент их обработать :-).

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

Еще существует несколько переменных, которые тоже относятся к переменным о клиенте, но почему-то не все браузеры их сообщают и поэтому пользоваться ими надо, как говорится: "на свой страх и риск" :-))). Вот они:

HTTP_ACCEPT_ENCODING

Указывает набор кодировок, которые может получать клиент. Например:

koi8-r, gzip, deflate

HTTP_ACCEPT_LANGUAGE

Содержит в себе список языков в кодах ISO, которые может принимать клиент. Например:

ru, en, fr

HTTP_IF_MODIFIED_SINCE

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

HTTP_FROM

Содержит список почтовых адресов клиента.

Вобщем-то весь этот список никем не ограничивается и любой браузер может сообщить кроме этих переменных еще добрый десяток. Правда уважающие себя разработчики не будут этого делать. А зачем ?

Шаг 9 - Обработка простой формы.

Понятие формы языка html описано в шаге 19 раздела Html&Web.

Давайте сделаем простую форму.

<form action="http://localhost/cgi-bin/primer.cgi" method=GET>
Введите свое имя пользователя:
<input type=text maxlength=150 name=user>
<p><input type=submit value=Send>
</form>

Мы уже обсуждали методы передачи данных в шлюз раньше. Какие тут могут быть советы ?

Лично мне кажется передавать такие маленькие формы лучше всего посредством метода GET.

С чем это связано ? Во-первых получить данные из переменной окружения намного легче, чем считать их из потока.

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

Например, многие программы для поиска информации в интернете используют различные поисковые сервера. Для того чтобы сделать запрос к одному из них требуется всего лишь вызвать браузер и сообщить ему URL. В Windows это делается просто в командной строке (а значит и просто сделать программе):

  start http://www.abc.com/cgi-bin/search.cgi?word=hello&language=ru

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

С методом POST в этом отношении сложнее, для этого программе нужно уметь работать по протоколу HTTP и связываться с серверами в интернете. Размер и сложность такой программы будет на порядок выше.

Поэтому, если Ваш ресурс может быть полезен и при этом передаваемые ему данные не будут превышать 32 Кб (это ограничение на длинну URL, если я все правильно помню :-), то лучше метода GET не найти.

Давайте напишем программу для обработки этой формы.

#include <stdio.h>
#include <stdlib.h>
//Здесь надо вставить процедуру получения
//параметра по его имени... Она была описана
//раньше.
char *getparam(...)
{
};
int main()
{
  char *user=NULL;
  char *content=NULL;
  char *request_method=getenv("REQUEST_METHOD");
  if (strcmp(request_method,"GET")!=0)
	{
		printf("Content-type: text/html\\n\\n");
		printf("Unknown REQUEST_METHOD. Use only GET !\\n");
		return -1;
	};
  
  content=getenv("QUERY_STRING");
  user=getparam(content,"user=");
  printf("Content-type: text/html\\n\\n");
  printf("User name=\\"%s\\"\\n",user);
};

После того как вся программа будет собрана и откомпилированна, расположите ее в директории cgi-bin вашего вебсервера. Теперь можно смело пробовать форму написанную выше. Я для теста использовал браузер напрямую... Как я уже говорил, достаточно набрать

   http://localhost/cgi-bin/primer.cgi?user=hello

И Вы увидите тот же результат, что и при использовании формы. Кстати вот он:

  User name="hello" 

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

Я по ходу шагов еще тысячу раз упомяну Вам об этом, но только потому, что это действительно очень важно.

Шаг 10 - Как запускать CGI.

Если у Вас от чего-то все работает, то очень СТРАННО. Как правило новичку, чтобы запустить скрипт приходится попотеть. Какие же основные проблемы возникают при запуске скрипта ?

Настройки сервера

Первой, но не главной причиной может послужить неправильная настройка сервера.

Скорее всего попросту он не имеет права запускать скрипты из этой директории.

Я всегда рассматриваю только Web-сервер Apache, поэтому приведу настройки для него. Кстати сегодня в ComputerWorld(8.02.2000) опубликовали результаты исследований RUNet\'a. Оказалось, что Apache установлен на 78% всех серверов, веб-сервера от Microsoft - 19%, доля остальных серверов составляет по 1%.

Так что я опять говорю, лучше Apache Вы не найдете !!!

Ладно отвлеклись от темы... Все настройки Apache для каждой директории задаются

с помощью файла .htaccess. Если такового в вашей директории не имеется, то

создавайте его. В него запишите следующее:

Options ExecCGI

Или даже посоветую обратиться к документации, но думаю она не понадобится.

Теперь любые скрипты в этом каталоге будут загружаться без проблем.

Неверные атрибуты на файле скрипта

Если на вашем сервере установлена система подобная Windows, то эта проблема

вас не касается, так как все программы *.exe "эта" система загружает без вопросов.

В случае если Ваша система Unix, то вам повезло меньше, особенно если

Вы до этого видели только Windows.

В кратце поясню... Во всех системах Unix для каждого файла устанавливаются атрибуты файлов. Этих атрибутов (как правило) девять. Даю список таковых.

Owner Read
Owner Write
Owner Execute
Group Read
Group Write
Group Execute
Other Read
Other Write
Other Execute

Если кратко, то в Unix системах создаются пользователи и разделяются на группы. Вы вот при входе в систему набираете свой логин и пароль, т.е. Вы являетесь пользователем. Также по FTP и т.д. Все кто имеет доступ к системе является ее пользователем.

Атрибуты типа Owner задают параметры для Вас, т.е. для владельца файлов.

Атрибуты Group определяют уровень доступа для вашей группы, т.е. если Вы принадлежите к группе

Webmasters, то при установке атрибута Group Write любой другой пользователь, который принадлежит к группе Webmasters сможет записывать в этот файл информацию.

Думаю для чего Other понятно, это значит всем остальным.

При записывании файла через FTP атрибуты файла устанавливаются по умолчанию

 rw.r..r..

Т.е. Вы можете писать и читать, а остальные могут только читать. Как видите ни один атрибут не указывает на то, что файл загружаемый.

Вы должны добиться такого:

 rwxr.xr.x

Т.е. установить атрибут Execute во всех группах.

Как это сделать это другой вопрос, давайте рассмотрим с вами работу с некоторыми FTP клиентами.

Сразу скажу, что не использую никакие Виндовые программы, т.е. графические "проги" рассчитанные на любителей делать все одним кликом мыши...

Я пользуюсь нашим, т.е. российским файловым менеджером FAR, если у вас его нет, то Вы много потеряли... И я вам сочувствую.

Так вот в нем надо нажать Ctrl-A на том файле, который Вы закачали на сервер (только делаете это не на локальном диске, а на FTP, а то увидите вместо атрибутов Unix атрибуты Досовской файловой системы)

Делаете следующую картинку:

  R  W  X   R  W  X   R  W  X
 [x][x][x] [x][ ][x] [x][ ][x]

И нажимаете Okey. Теперь все классно.

Если у Вас нет FAR, то у Вас ОБЯЗАНА быть программа в системе, которая занимается сервисом FTP. В большинстве систем (и в Винде) такая программа называется ftp.

Запустите ее. Наверняка она обладает только командной строкой, так что потейте... :-) Я рассмотрю программу ftp.exe, которая входит в виндовс.

Первое, что надо сделать открыть Ваш сайт, делается это командой open

ftp> open www.mjk.msk.ru
Связь с mjk.
220 mjk-gw.mjk.msk.ru FTP server (Version wu-2.4.2-academ[BETA-18](1)
Mon Aug 3 19:17:20 EDT 1998) ready.
Пользователь (mjk:(none)): dron
331 Password required for dron.
Пароль:
230-Please read the file README.linux
230-  it was last modified on Sat Feb  5 16:31:50 2000 - 3 days ago
230 User dron logged in.
ftp>

Теперь Вы в системе. Наберите help для получения основных команд. Попробуйте набрать dir. Пример вывода:

200 PORT command successful.
150 Opening ASCII mode data connection for /bin/ls.
total 48
drwx------   3 dron     mjkusers     1024 Feb  6 16:58 .
drwxr-xr-x  75 root     root         2048 Feb  1 00:03 ..
-rw-r--r--   1 dron     mjkusers     1155 Jun 24  1999 .Xdefaults
-rw-------   1 dron     mjkusers       24 Jan  8 11:35 .bash_history
-rw-r--r--   1 dron     mjkusers       24 Jun 24  1999 .bash_logout
-rw-r--r--   1 dron     mjkusers      230 Jun 24  1999 .bash_profile
-rw-r--r--   1 dron     mjkusers      124 Jun 24  1999 .bashrc
-rw-r--r--   3 dron     mjkusers     1324 Jan  8 11:32 123.cgi
-rw-r--r--   1 dron     mjkusers    37165 Feb  5 16:31 README.linux
226 Transfer complete.
691 байт получено за 0.33 с (2.09 КБ/с)

Мне например надо теперь установить атрибут загрузки на файл 123.cgi, как видите у него такого атрибута нет.

Такую возможность ftp.exe не предоставляет, зато он может посылать команды непосредственно FTP - серверу, т.е. что нам и требуется.

Если вы вызывали помощь, то знаете, что такую функцию выполняет команда quote. Чтобы Вам особо не разбираться просто приведу команду.

quote SITE CHMOD 755 123.cgi

Теперь на файле 123.cgi будут установлены необходимые атрибуты. Если Ваш файл располагается в другой директории, то пользуйтесь командой cd (change directory).

Неправильный атрибут на каталоге скрипта

Многие скрипты не только выводят какую-то информацию, но и еще записывают что-то в определенные папки или файлы. Тут надо предусмотреть правильный доступ к этим ресурсам.

Любой Web-сервер работает не от вашего имени, а от другого, поэтому запуская скрипт он не предоставляет ему Ваши возможности. Вы должны поставить атрибуты на директорию, в которую записан скрипт, для полного доступа, т.е. для записи всем кому угодно.

Для установки таких атрибутов в FAR\'е поставьте все крестики. В ftp.exe команда такая

 quote SITE CHMOD 777 <директория>

Хочу Вас также предостеречь, делая полный доступ на директорию помните, что любой "злоумышленник" может вам подпортить жизнь, стереть Ваш скрипт и например записать свой, или записывать неправильные данные в ваши файлы. Короче он может делать, что угодно. Особенно опасно делать полный доступ к директории в которой лежит страничка, потому как рано или поздно вы ее там не обнаружите :-(.

Поэтому СОВЕТ. Создавайте специально для скриптов отдельные каталоги и используйте их для записи данных. А лучше всего делать доступ только отдельному файлу (в этом случае маска доступа не 777, а 666 !!!)

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

Вобщем-то все, надеюсь у Вас все заработает :-)

Шаг 11 - Как работают гостевые книги ?

Гостевая книга очень полезная штука на сайте, да и что тут объяснять ? Все хотят иметь на сайте хоть какой-то механизм обратной связи. Именно для этого и существуют гостевые книги.

Общий метод, я думаю, прост и ясен всем. Вы создаете страничку с формой, которую будут заполнять ваши посетители и посылать вам. С этим думаю не будет возникать проблем. Проблемы возникнут, когда надо будет писать обрабатывающий скрипт. Я могу лишь дать некоторые советы для создания хороших гостевых книг.

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

Второе, что я считаю важным - это обеспечение настроек формата вывода данных. Очень важно для того, чтобы использовать один и тот же скрипт где угодно и когда угодно. Если Ваш скрипт "не мобилен", то Вам прийдется для добавления какой-нибудь новой информации переписывать скрипт.

Ну, а третье может всем и не нужно, хотя стоило бы обеспечить обработку сразу нескольких гостевых книг одним скриптом. Это позволит пользоваться гостевыми книгами не только Вам.

Если соблюдать такие вот простые правила можно создать не плохие скрипты, обеспеченные стойкостью и мобильностью.

О том как контролировать одновременные вызовы скрипта несколькими клиентами я писал раньше... Если Вы не помните, то "алгоритм" прост. При запуске скрипт создает какой-либо файл на время работы, затем его удаляет. Другой же запущенный скрипт контролирует появление этого файла, и если он есть, то ждет некоторое время пока он не исчезнет.

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

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

Как их обозначить ? Это тоже Вам решать... Я обозначал просто, между двумя амперсандами & задается имя поля формы, значение которого надо записать в гостевую книгу. Таким образом изначально сам скрипт гостевой книги даже не знает какие поля формы ему сообщаются.

Давайте приведу кусок кода, который реализует чтение файла с форматом и подставляет вместо полей их содержимое.

char parname[150];
char *par;
int parnamelen=0;
char charbuf;
int ampfound=0, dolfound=0;
if ( (f_form=fopen(guest_path,"rt")) != NULL )
{
 if ( (f_guest = fopen(guestbook,"at")) != NULL)
 {
   while (!feof(f_form))
   {
     fscanf(f_form,"%c",&charbuf);
     if ((ampfound==0)&&(dolfound==0))
      {
        if ((charbuf!=\'&\') && (charbuf!=\'$\'))
	{ 
	  fprintf(f_guest,"%c",charbuf);
	}
        else
	 {
           if (charbuf==\'&\') ampfound=1; else dolfound=1;
	   parnamelen=0;
	 };
      }
     else
      {
        if ((charbuf==\'&\') || (charbuf==\'$\'))
	 {
           if (parnamelen==0)
	   {
             if (charbuf==\'&\') fprintf(f_guest,"&");
	     else fprintf(f_guest,"$");
           }
           else
	    {
              parname[parnamelen]=\'\\0\';
              if (ampfound==1) par=getparam(buf,parname);
	      else par=getenv(parname);
	      fprintf(f_guest,"%s",par);
	    };
	   if (ampfound==1) ampfound=0; else dolfound=0;
	 }
	 else
	 {
           parname[parnamelen]=charbuf;
	   parnamelen++;
	 };
      };
  
   };
   fclose(f_guest);
 };
 
fclose(f_form);
};

Алгоритм прост, считываете посимвольно, если встречается амперсанд, то начинаете накапливать имя поля, которое необходимо вставить в гостевую книгу. Ну, а когда дойдете до второго амперсанда, то выводите содержимое этого параметра в файл гостевой книги.

Забыл сказать, да Вы наверно это уже заметили, что я еще использую знак доллара, он служит для того чтобы выводить не содержимое формы, а переменные среды. Это очень полезно, если Вы хотите записывать в гостевую книгу какие-то данные о соединении, например, IP адрес клиента.

Ну, а третье условие "хорошей" гостевой книги - один скрипт на всех :), попробуйте реализовать сами, это не очень сложно... Создайте конфигурационный файл для гостевой книги, в котором Вы будете прописывать положение файлов других гостевых книг.

Тут также надо будет позаботиться о выборе гостевой книги, т.е. в какую гостевую книгу будут записываться поступаемые данные. Я для этого рекомендую использовать метод GET, а сами данные будете посылать через POST.

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

Шаг 12 - Посылка письма.

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

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

Ну, а теперь от слов к делу. Сразу вопрос: Вы знаете как работать по протоколу SMTP ? Я вообще-то знаю, но реализовывать этот механизм в каждом скрипте что-то не хочется. Слишком это сложно и громоздко.

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

программы работающие через командную строку. На большинстве серверов, да и вообще компьютерах с Unix системами, функцию отправки писем может

возлагать на себя непосредственно SMTP демон. Их существует достаточно много, хотя если я скажу, что самый распространенный из них это sendmail, то не сильно ошибусь.

Конкретно sendmail позволяет посылать письмо из командной строки. Как это делать лучше посмотреть (да и вообще лучше всегда смотреть :) в мануале к программе. В моем случае :) чтобы послать письмо надо набрать следующую командную стоку:

 /usr/lib/sendmail -t

Далее набирается письмо в формате:

To: email@adr
From: mymail@adr
Subject: Hello !!!
  This Is Letter !!!
.

Признаком конца письма служит строка с одной единственной точкой, поэтому прошу Вас обратить на это внимание.

Все хорошо, но как все это дело использовать в скрипте ? А просто !!! В Юниксе существует уникальная просто возможность запускать программу и ассоциировать с ней файловые потоки для обмена информацией !!!

Делает такой вызов программы функция практически аналогичная fopen, но только popen :-) !!! Так что теперь делаем просто файловый указатель и открываем нашу программу посылки письма.

#include ...
 FILE *sendmail;
 
 sendmail=popen("/usr/lib/sendmail -t","w");
   fprintf(sendmail,"To: email@adr\\n");
   fprintf(sendmail,"From: myemail@adr\\n");
   fprintf(sendmail,"Subject: Hello\\n");
   fprintf(sendmail," HEHEHEHEH !!!\\n");
   fprintf(sendmail,".\\n");
 pclose(sendmail);

Теперь ваше письмо пошлется другу :). Можно ли использовать такой механизм в Виндовсе ? Не знаю :). По крайней мере стандартная программа посылки почты, т.е. OutLook не позволит вам этого сделать совершенно точно, да и кроме того ДОС-система не умеет вызывать программу как файл !!! У Юникса здесь нет конкурентов :).

Остается только найти программу под Виндовс, которая будет посылать письма из командной строки, а у меня такая раньше была. И вызывать ее через стандартую exec-процедуру. Только при этом не забывайте создавать временный файл с почтовым сообщением !!! :)

Хотя если Вы будете писать программы только для Unix, то у Вас не возникнет проблем :)

Шаг 13 - Разработка класса CGIContent.

Код получения параметров во многих скриптах CGI одинаков и кочует от одного скрипта к другому практически без изменений.

Поэтому стоит написать библиотеку классов для работы с CGI и подключать ее при разработке нового скрипта.

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

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

До сих пор мы просто выделяли кусок памяти и целиком помещали в него все переданные данные. Из-за этого при передаче огромного количества данных скрипт мог зависнуть. Кроме того наши данные никогда не декодировались и хранились закодированными, что сильно тратило нашу память и содержимое параметров могло занимать в три раза больше, чем на самом деле.

Первое, что нам потребуется для разработки нашего класса - это класс для хранения больших объемов данных. Самым простым способом хранения помоему является список. Поэтому создадим класс CGIContentItem, который будет элементом списка управляемого классом CGIContent:

class CGIContent;
class CGIContentItem{
friend CGIContent;
	char *Content;
	CGIContentItem *Next;
public:
	CGIContentItem();
	~CGIContentItem();
};

Простой элемент списка у нас будет содержать текстовую строку Content и указывать на следующий элемент. Реализация деструктора и конструктора тоже просты:

CGIContentItem::CGIContentItem(){
	Content=NULL;
	Next=NULL;
};
CGIContentItem::~CGIContentItem(){
	if (Content!=NULL) free(Content);
	if (Next!=NULL) delete Next;
};

Для всех классов элементы нашей ячейки скрыты, поэтому класс CGIContent, который является управляющей оболочкой для списка описан как дружественный.

Теперь требуется реализовать сам этот класс, чтобы получить полнофункциональный список со всякими возможностями.

class CGIContent{
public:
	CGIContentItem *Content;
	CGIContent();
	~CGIContent();
	CGIContentItem* Add(char *Buffer);
	int Write(FILE *f_out);
};

Самое главное в списке это указатель на его начало, эту функцию у нас выполняет указатель Content.

Для начала нам потребуется только функция добавления в список Add() и вывода Write(). Для возможности вывода содержимого списка в любое место в функции Write() надо использовать указатель типа FILE, вместо которого можно будет поставлять поток stdout или любой другой открытый файл. Вот реализация методов этого класса:

CGIContent::CGIContent(){
	Content=NULL;
};
CGIContent::~CGIContent(){
	if (Content!=NULL) delete Content;
};
CGIContentItem* CGIContent::Add(char *Buffer){
	CGIContentItem *temp,*p;
	temp=new CGIContentItem();
	temp->Content=strdup(Buffer);
	if (Content==NULL){
		Content=temp;
	} else {
		p=Content;
		while (p->Next!=NULL) p=p->Next;
		p->Next=temp;
	};
	return temp;
};
int CGIContent::Write(FILE *f_out){
	CGIContentItem *temp=Content;
	while (temp!=NULL){
		fprintf(f_out,"%s",temp->Content);
		temp=temp->Next;
	};
	return 0;
};

Теперь у нас готов полнофункциональный класс способный хранить в себе большие массивы информации.

Шаг 14 - Класс CGIParam.

Вторым классом, который требуется для класса CGIApp должен быть класс хранящий имена передаваемых параметров и их значение.

Для хранения значений параметров мы уже сделали класс CGIContent. Нам осталось добавить в класс переменную для имени и методы для обеспечения добавления параметров и их быстрого поиска.

Структура класса очень похожа на класс CGIContent. Класс CGIParamItem будет элементом списка, а класс CGIParam управляющим:

class CGIParam;
class CGIParamItem {
friend CGIParam;
	char *Name;
	CGIContent *Content;
	CGIParamItem *Next;
public:
	CGIParamItem();
	~CGIParamItem();
};
CGIParamItem::CGIParamItem(){
	Name=NULL;
	Next=NULL;
	Content=new CGIContent();
};
CGIParamItem::~CGIParamItem(){
	if (Name!=NULL) free(Name);
	delete Content;
	if (Next!=NULL) delete Next;
};

Класс CGIParamItem содержит имя параметра в переменной Name, а содержимое в Content.

Теперь класс CGIParam:

class CGIParam{
	CGIParamItem *List;
public:
	CGIParam();
	~CGIParam();
	CGIContent *Add(char *name,char *Buffer);
	CGIContent *Find(char *name);
};
CGIParam::CGIParam(){
	List=NULL;
};
CGIParam::~CGIParam(){
	if (List!=NULL) delete List;
};
CGIContent *CGIParam::Add(char *name,char *Buffer){
	CGIParamItem *temp,*p;
	temp=new CGIParamItem();
	temp->Name=strdup(name);
	temp->Content->Add(Buffer);
	if (List==NULL){
		List=temp;
	} else {
		p=List;
		while (p->Next!=NULL) p=p->Next;
		p->Next=temp;
	};
	return temp->Content;
};
CGIContent *CGIParam::Find(char *name){
	CGIParamItem *temp=List;
	while (temp!=NULL){
		if (strcmp(temp->Name,name)==0) return temp->Content;
		temp=temp->Next;
	};
	return NULL;
};

Удобство этого класса очевидно. Позволяет хранить большие объемы, обеспечивает очень быстрый поиск нужного параметра. Теперь вместо просмотра всех данных, как раньше, требуется всего лишь просмотреть имена параметров, что, собственно говоря, и требуется.

Кроме того эти классы в будущем будут хранить уже декодированные данные. Раньше нам нельзя было декодировать данные потому, что мы могли потерять связки разделяющие имена параметров и их содержимое между собой, т.е. могли бы появиться нежелательные символы & и = и испортить все картину.

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

Шаг 15 - Класс CGIApp.

Давайте теперь подведем черту под тем, что было сделано в прошлых шагах. Все эти классы были предназначены для одного самого главного CGIApp.

Вот его описание:

class CGIApp{
public:
	CGIParam *Param;
	int Method;
	char *Query_String;
	long Content_Length;
	CGIApp();
	~CGIApp();
	int Init();
	CGIContent *FindParam(char *name);
};

Все просто как всегда, Param хранит полученные данные, Method содержит данные о методе передачи данных, который определяется следующими константами:

#define METHOD_GET 1
#define METHOD_POST 2

Переменные Query_String и Content_Length содержат значения полученные из соответствующих переменных окружения.

В конструкторе и деструкторе класса также все по старому:

CGIApp::CGIApp(){
	Param=new CGIParam();
	Query_String=NULL;
	Method=0;
	Content_Length=0;
};
CGIApp::~CGIApp(){
	delete Param;
	if (Query_String!=NULL) free(Query_String);
};

Особую "ценность" содержит в себе метод Init(). Эта процедура инициализирует все данные необходимые для работы приложения CGI, т.е. получает и декодирует все полученные от клиента данные. Сначала приведу текст этого метода:

int CGIApp::Init(){
	char *Buffer;
	char *Content_Len=NULL;
	char *Query_Str=NULL;
	char *ParamName=NULL;
	long Buffer_Len=0;
	long Buffer_Size=0;
	char Mode=0, ToMode=0;
	long i=0;
	char ch=0;
	CGIContent *temp=NULL;
	Buffer=getenv("REQUEST_METHOD");//получаем метод передачи данных
	if (Buffer==NULL) return 0;//если нет такой переменной то ошибка 
	
	Query_Str=getenv("QUERY_STRING");//строка в URL после "?"
	Content_Len=getenv("CONTENT_LENGTH");//длинна передаваемых данных
	if (strcmp(Buffer,"GET")==0){
		if (Query_Str!=NULL) Content_Length=strlen(Query_Str);
		else Content_Length=0;
		Method=METHOD_GET;
		
	} else {
		if (strcmp(Buffer,"POST")==0){
			Method=METHOD_POST;
			if (Content_Len!=NULL) Content_Length=atol(Content_Len);
			else Content_Len=0;
		} else goto proc_exit;
	};
	Buffer=NULL;
	Buffer_Size=10000;
	//инициализируем буффер для работы
	while (Buffer==NULL){
		Buffer=(char *)malloc(Buffer_Size);
		if (Buffer==NULL){
			if ((Buffer_Size-=1000)<0) return 0;
		};
	};
	//основной цикл
	while (i<Content_Length){
		//получаем следующий байт данных в 
		//зависимости от метода передачи
		switch (Method){
			case METHOD_GET:{
				ch=*(Query_Str+i);
				break;
			};
			case METHOD_POST:{
				fread(&ch,1,1,stdin);
				break;
			};
		};//switch;
		switch (Mode){
			case 0:{//режим накопления имени параметра
				if (ch!=\'=\'){
					if (ch==\'+\') ch=\' \'; else
					if (ch==\'%\'){
						ToMode=0;
						Mode=2;
						break;
					};
					*(Buffer+Buffer_Len)=ch;
					Buffer_Len++;
				} else {
					Mode=1;
					*(Buffer+Buffer_Len)=0;
					if (ParamName!=NULL) free(ParamName);
					ParamName=strdup(Buffer);
					Buffer_Len=0;
				};
				break;
			};//case 0;
			case 1:{//режим накопления содержимого атрибута
				if (ch!=\'&\'){
					if (ch==\'+\') ch=\' \'; else
					if (ch==\'%\'){
						ToMode=1;
						Mode=2;
						break;
					};
					*(Buffer+Buffer_Len)=ch;
					if ((Buffer_Len+=1)>=Buffer_Size){
						*(Buffer+Buffer_Len)=0;
						if (ParamName!=NULL){
						        temp=Param->Add(ParamName,Buffer);
							free(ParamName);
							ParamName=NULL;
						} else {
							temp->Add(Buffer);
						};
						Buffer_Len=0;
					};
				} else {//если найден символ &, то добавляется параметр и значение
					*(Buffer+Buffer_Len)=0;
					if (ParamName!=NULL)
						temp=Param->Add(ParamName,Buffer);
					else
						temp->Add(Buffer);
					Buffer_Len=0;
					Mode=0;
				};
				break;
			};//case 1;
			case 2:{//режим преобразования из HEX первого символа после %
				*(Buffer+Buffer_Len)=(gethex(ch)<<4);
				Mode=3;
				break;
			};//case
			case 3:{//второго символа HEX
				*(Buffer+Buffer_Len)+=gethex(ch);
				Buffer_Len++;
				Mode=ToMode;
				break;
			};
		};//switch (Mode)
		i++;
	};
	//если осталось что-то после работы то добавляем
	if (Buffer_Len>0){
		*(Buffer+Buffer_Len)=0;
		if (ParamName!=NULL)
			temp=Param->Add(ParamName,Buffer);
		else
			temp->Add(Buffer);
	};
proc_exit:
	if ((Method==METHOD_GET)&&(Query_Str!=NULL))
	    Query_String=strdup(Query_Str);
	return 0;
};

Этот метод получает все переменные окружения необходимые для считывания приходящих данных. После чего инициализирует буффер и считывает их в зависимости от метода передачи.

В зависимости от считанного символа происходит смена режима и символ добавляется либо в имя параметра, либо в содержимое, либо декодируется.

Последний на этот момент необходимый метод поиска:

CGIContent *CGIApp::FindParam(char *name){
	CGIContent *temp=Param->Find(name);
	return temp;
};

Стоило бы заметить о некоторых особенностях работы класса на разных платформах. Изначально писал я его в среде Borland C++ 3.1 и в среде Windows все скрипты просто "летали".

При отладке в Linux начались большие проблемы. После поиска ошибок, которых по идее не было, в течении получаса оказалось, что нельзя использовать процедуру free(*char), если

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

В Досе таких ошибок не возникало, правда тут нельзя утверждать, что getenv() создает отдельную строку для этого, вероятно процедура free() просто не вызывает того аварийного завершения, которое получается в Линуксе.

Вобщем, что не система, то свои проблемы, да и что вообще там система... Компиляторы чего только стоят :-) Отладка CGI написанных на языке С++ всегда будет иметь некоторую зависимость от платформы или реализации компилятора, хотя считается, что все везде работает по одному алгоритму. Оказывается, что не все и не всегда.

Шаг 16 - Графика на лету это просто.

Не буду продолжать рассказ о классе CGIApp, потому что считаю там должно быть все ясно. У него конечно еще много недочетов, и вероятно будут проявляться глюки, но всеже это лучше чем раньше.

Единственное, что там еще надо доработать это разбор данных из строки QUERY_STRING при обращении методом POST, а то получается, что данные просто хранятся в переменной класса и не разобраны в приемлимый вид. Так что работайте...

Сейчас думаю многим будет интересна возможность создания графики на "лету". Наверняка тысячи раз видели графики на сайтах, диаграммы, таблички и т.д. Все это не рисуют бедные вебмастера каждый час или даже минуту :-)

Вывод графики интересная скажу вам штука... Особенно когда эта операция должна выполняться быстро. Пару лет назад я крепко этим занимался и целыми днями сидел за оптимизацией ассемблерного кода. Иногда уменьшив размер процедуры на пару байт (например, заменив add ax,1 на inc ax) скорость возрастала на 50 и больше процентов. Странно было, но очень приятно... Сейчас уже никто не думает о скоростях и оптимизации, пишут на 500Мб то, что можно "упаковать" в 100 :-))

Вобщем хватит философии, приступим...

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

Чтобы зря не тратить память лучше при инициализации приложения выделить память под виртуальный экран ровно столько, сколько потребуется для создания картинки. Для начала опишем "болванку" класса, который потом будем постоянно наращивать.

class CGIScreen {
protected:
	int width, height;
	char *scr;
public:
	CGIScreen(int w,int h);
	~CGIScreen();
};

Переменные width и height хранят размеры виртуального экрана, которые необходимы для процедур вывода, чтобы отрезать все ненужные или по другому не видимые пикселы.

Указатель scr это и есть тот самый экран. Теперь конструктор и деструктор:

CGIScreen::CGIScreen(int w,int h)
{
	if (w*h<=64000)
		scr=(char *)malloc(w*h);
	else {
		scr=NULL;
		return;
	}
	width=w;
	height=h;
};
CGIScreen::~CGIScreen()
{
	if (scr!=NULL) free(scr);
};

В конструкторе я не стал выделять много памяти. Во-первых, 64000=320*200 чего вполне хватит, чтобы создать картинку немеренного размера (в байтах :-) и разозлить посетителя :-). Во-вторых, я не могу предугадать в каких системах будет использоваться этот код. В ДОСе максимальный блок памяти 64Кб, ну а если у Вас возможно хранить больше, то меняйте код сами :-)

Следующей думаю будет процедура заполнения "экрана" одним цветом. Догадались как это можно быстро сделать ?

int CGIScreen::FillScreen(char color)
{
	if (scr!=NULL) setmem((void *)scr,width*height,color);
};

Теперь не забудьте вставить заголовок процедуры в описание класса и можно начинать работать :-)

Будете получать виртуальные экранчики заполненные одним цветом. Помоему не плохо для начала... Подойдет для создания фонов :-)

Шаг 17 - Вывод примитивов на экран.

Экран у нас теперь готов, научимся выводить примитивы на этот экран. Самым "примитивным" из примитивов является точка или пиксел, как кто хочет. Если Вы никогда не занимались графикой, то Вам вероятно будет сложно сообразить, что значит вывести точку.

Видео память в PC-совместимых системах линейна, если не считать древних режимов EGA или CGA. Поэтому для того, чтобы вывести точку на экран достаточно просто записать байт-цвет в соответствующую ячейку в памяти. "Линейная память" надо понимать так: каждая последующая строка пикселов размещается в памяти точно за предыдущей строчкой. Небольшой пример:

RRRGGGGBBB
GGGBBBRRRB
..........

Допустим это картинка на экране, тут буквы RBG это какие-то цвета. Так вот в нашей линейной памяти эти строчки будут располагаться так:

RRRGGGGBBBGGGBBBRRRB..........

Думаю Вам уже должна быть понятна следующая формула: адрес_ячейки=Y_точки * Ширину_Экрана + Х_точки. Именно по ней мы будем вычислять адрес пиксела в памяти. Так вот давайте напишем процедуру вывода этого пиксела:

int CGIScreen::PutPixel(int x,int y,char color)
{
	if ((x<0)||(x>=width)||(y<0)||(y>=width))
		return -1;
	*(scr+y*width+x)=color;
};

Естественно надо не забывать, что точка может заходить за границы экрана, поэтому ее надо проверять. Это делает оператор if (...). Теперь Вы можете выводить точку в любое место и все, что надо будет отображаться.

Дальнейней процедурой должна быть линия. Алгоритмов вычерчивания линии насколько я знаю есть предостаточно, но повсюду используется один - это алгоритм Брезенхейма.

Объяснить по нормальному это дело я Вам сейчас без подготовки не смогу, да и не та у нас тут тематика, по этому просто принимаем "as is" :-)

int  CGIScreen::Line(int x1,int y1,int x2,int y2, unsigned char Color)
{
  int dx=abs(x2-x1);
  int dy=abs(y2-y1);
  int sx=x2 >= x1 ? 1:-1;
  int sy=y2 >= y1 ? 1:-1;
  int d,d1,d2,x,y,i;
  if (dy<=dx)
  { d=(dy << 1)-dx;
    d1=dy << 1;
    d2=(dy - dx) << 1;
    PutPixel(x1,y1,Color);
    for (x=x1+sx,y=y1,i=1;i<=dx;i++,x+=sx)
    {
      if (d>0){d+=d2;y+=sy;}
      else d+=d1;
      PutPixel(x,y,Color);
    }
  }
  else
  {
    d=(dx << 1) - dy;
    d1=dx << 1;
    d2=(dx - dy) << 1;
    PutPixel(x1,y1,Color);
    for (x=x1,y=y1+sy,i=1;i<=dy;i++,y+=sy)
    {
      if (d>0){d+=d2; x+=sx;}
      else d+=d1;
      PutPixel(x,y,Color);
    }
  }
  return 0;
};/*Line*/

Вычерчивание линии происходит по точкам, а значит будет действовать наш механизм "отсечки" ненужных пикселов.

Помоему уже не плохо. Самые главные можно сказать примитивы мы научились строить. Дело за немногим, использовать их для создания более сложных объектов.

Шаг 18 - Вывод примитивов на экран (часть 2).

Еще остался один примитив, который является одним из главных. Это естественно окружность, а как примитив с расширенными возможностями лучше сразу рассмотреть эллипс.

Над прорисовкой эллипса тоже постарался Брезенхейм и облегчил задачу всем программистам до сегодняшних дней.

Вот код рисования эллипса:

int CGIScreen::Ellipse(int exc, int eyc, int ea, int eb , unsigned char Color)
{
  int elx, ely;
  long aa, aa2, bb, bb2, d, dx, dy;
  elx = 0; ely = eb; aa = (long)ea * ea; aa2 = 2 * aa;
  bb = (long)eb * eb; bb2 = 2 * bb;
  d = bb - aa * eb + aa/4; dx = 0; dy = aa2 * eb;
  PutPixel(exc, eyc - ely, Color); PutPixel(exc, eyc + ely, Color);
  PutPixel(exc - ea, eyc, Color); PutPixel(exc + ea, eyc, Color);
  while (dx < dy)
  {
    if (d > 0) { ely--; dy-=aa2; d-=dy;}
    elx++; dx+=bb2; d+=bb+dx;
    PutPixel(exc + elx, eyc + ely, Color);
    PutPixel(exc - elx, eyc + ely, Color);
    PutPixel(exc + elx, eyc - ely, Color);
    PutPixel(exc - elx, eyc - ely, Color);
  };
  d+=(3 * (aa - bb)/2 - (dx + dy))/2;
  while (ely > 0)
  {
    if (d < 0) {elx++; dx+=bb2; d+=bb + dx;}
    ely--; dy-=aa2; d+=aa - dy;
    PutPixel(exc + elx, eyc + ely, Color);
    PutPixel(exc - elx, eyc + ely, Color);
    PutPixel(exc + elx, eyc - ely, Color);
    PutPixel(exc - elx, eyc - ely, Color);
  };
  return 0;
};/*Ellipse*/

Здесь координатами центральной точки эллипса являются параметры exc,eyc. Параметры ea,eb это ширина и высота эллипса, подставив вместо них одинаковые значения Вы сможете нарисовать окружность.

Теперь еще два более крупных примитива состоящих из линий. Первый это прямоугольник:

int CGIScreen::Rectangle(int x1,int y1,int x2,int y2, unsigned char color)
{
	Line(x1,y1,x2,y1,color);
	Line(x1,y1,x1,y2,color);
	Line(x2,y1,x2,y2,color);
	Line(x1,y2,x2,y2,color);
}/*Rectangle*/

и закращенный прямоугольник:

int CGIScreen::FillRectangle(int X1,int Y1,int X2,int Y2, unsigned char Color)
{
	int I;
	if (Y1>Y2) {I=Y1;Y1=Y2;Y2=I;};
	for (I=Y1;I<=Y2;I++) line(X1,I,X2,I,Color);
}/*FillRectangle*/

Теперь на этой базе вы сможете строить более сложные объекты.

Шаг 19 - Вывод спрайтов на экран.

Эта возможность должна всем очень понравиться, т.к. наверняка кто-то из Вас захочет кроме вывода простых линий вывести какую-то картинку нарисованную в Фотошопе :-)

Естественно запрограммировать вывод этой картинки попиксельно в программе очень сложно. Тут приходят на помощь спрайты. Спрайтами принято называть графические объекты(кусочки изображения) помещенные в память или в файл на диске. Для тех кто слабо себе представляет понятие спрайт поясню: в играх, например, это любой человечек, цветочек, стена и т.д. Когда много спрайтов одного и того же объекта(но с изменениями) быстро выводят на экран получается анимация. Но нам анимация естественно не пригодится :-)

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

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

void MoveLineOfImage(char *Source,char *Dest,unsigned int Count,char Bol)
{
	for (int i=0; i<Count; i++){
		if ((*Source)!=0)
			*Dest=*Source;
		else {
			if (Bol!=1)
				*Dest=*Source;
		};
		Source++;
		Dest++;
	};
}

Здесь Source - указатель на источник в памяти, Dest - указатель на получателя, Count - количество копируемых байт.

Признак Bol - это признак копирования нулевых байтов. Если этот признак установлен в 1, то процедура не копирует нулевые байты, при этом не стирается изображение, которое уже было на экране, т.е. достигается эффект прозрачности областей спрайта, которые состоят из нулей.

Теперь на базе этой процедуры можно строить процедуру, которая будет выводить спрайт на виртуальный экран. Разработка данной процедуры и доведение ее до окончательного нормального вида заняла у меня в свое время пару месяцев. Сейчас я Вам привожу код этой процедуры, но только пришлось убрать все ассемблерные вставки (над которыми я так долго работал) на их менее быстродействующие аналоги языка C++. Рассказывать о выводе спрайта не буду, так как сам доходил до этого долго и не та у нас тематика.

void CGIScreen::PutImage(char *p,int x,int y,int bol)
{
	int xs = *p; //ширина изображения
	int ys = *(p+2); //высота изобажения
	int lsx;
	if ((x>width) || (y>height) || (x+xs<=0) || (y+ys<=0)) return;
	int x1,y1,x2,y2;
	x1=y1=0;
	x2=xs;
	y2=ys;
	if (x<0) x1=-x;
	if (y<0) y1=-y;
	if (x+xs>width) x2=width-x;
	if (y+ys>height) y2=height-y;
	lsx=x2-x1;
	char *p1=p+4+y1*xs+x1;
	int i;
	long Addr=(y+y1)*width+x+x1;
	for (i=y1;i<y2;i++)
	{
		MoveLineOfImage(p1,scr+Addr,lsx,bol);
		p1+=xs;
		Addr+=width;
	}
};/*PutImage*/

Указатель *p указывает на область памяти, в которой содержится спрайт. Координаты вывода задаются параметрами x,y причем они могут быть меньше нуля. Если при этом кусок спрайта попадает на экран, то будет выводиться именно этот кусок. Признак bol указывает на прозрачность спрайта и используется процедурой копирования строк изображения описанной выше.

Осталось только сказать о формате хранения спрайта в памяти. Как некоторые наверно уже успели заметить кроме самого содержимого спрайта в нем еще содержатся его физические размеры. Эти размеры записаны в самом начале спрайта и занимают 4 байта, т.е. два числа типа int - горизонтальный и вертикальный размер. Естественно формат спрайтов не подчиняется ни одному стандартному формату графических данных и при загрузке спрайта надо обеспечить его преобразование во внутренний формат. В будущем для облегчения работы мы напишем процедуру считывания спрайтов из файлов какого-нибудь типа, например, как самый легкий возьмем BMP.

Но для этого надо еще обеспечить работу с палитрами. Скорее всего этим займемся в дальнейших шагах.

Шаг 20 - Внутренняя палитра.

Для будущей работы с изображениями нам потребуется палитра цветов. До сих пор мы на экран выводили просто номера цветов. Но сам номер цвета без своих основных параметров не несет в себе полезной информации. Поэтому давайте введем массив для палитры.

class CGIScreen{
	...
	unsigned char Palette[768];
	...
};

Сегодня редко требуется цветов для графики больше 256, не считая конечно фотографии. Практически весь Web пытается обходиться 32-64 цветами. Кроме того основные распространенные палитровые форматы графических изображений, такие как GIF, BMP не могут содержать в себе больше 256 цветов.

Поэтому размер палитры равен 256*3, где число три - это количество основных составляющих цвета: красный, зеленый и синий. В мире принят формат хранения цветов в формате RGB, т.е. сначала красный, потом зеленый и синий. Мы будем использовать тот же формат, потому что вероятнее всего в будущем он поможет избавиться от преобразования формата палитры.

Для установки цветов палитры создадим следующую процедуру:

void CGIScreen::SetPalette(unsigned char Color,unsigned char Red,
		unsigned char Green,unsigned char Blue){
    Palette[Color*3]=Red;
	Palette[Color*3+1]=Green;
	Palette[Color*3+2]=Blue;	
};

Здесь Color - это номер цвета в палитре, а Red, Green, Blue - соответствующие составляющие цвета.

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

void CGIScreen::GetPalette(unsigned char Color,unsigned char *Red,
		unsigned char *Green,unsigned char *Blue){
	*Red=Palette[Color*3];
	*Green=Palette[Color*3+1];
	*Blue=Palette[Color*3+2];
};

Теперь давайте договоримся всегда перед рисованием сначала инициализировать соответствующий цвет в палитре.

И старайтесь, чтобы все используемые цвета шли последовательно и их использовалось как можно меньше.

Шаг 21 - Класс шрифтов CGIFont.

Вроде все научились выводить, а вот шрифты еще пока нет. Давайте создадим новый класс для шрифтов. Или Вы их хотите сами рисовать попиксельно ?!

Думаю не надо объяснять, что существует два вида шрифтов: векторные и растровые. Векторные шрифты не плохи (даже круты :-), но на данном этапе лично мне сложно написать за час класс выводящий шрифты Windows TTF или хотя бы Borland CHR. Так что давайте не будем мучиться и разработаем класс для работы с растровыми шрифтами.

Формат наших шрифтов будет чуть похож на формат спрайтов, описанных ранее. Вообще-то видимо я не с этого начинаю :-) Давайте разберемся как мы вообще будем представлять шрифты в памяти.

Для начала надо выбрать размер шрифтов. Горизонтальный размер символа в этом конкретном случае не будет превышать 8 пикселов. По высоте он не ограничен. С чем это связано ? С тем, что мы будем хранить в памяти битовую маску символов. Т.е. если бит в байте равен единице, значит в соответствующем положении на экране будет выведен пиксел. Пример символа "A":

...oo...  0x18
..oooo..  0x3C
.oo..oo.  0x66
oo....oo  0xC3
oooooooo  0xFF
oo....oo  0xC3
oo....oo  0xC3

В памяти этот символ будет представлен в виде массива байтов:

	{0x18,0x3C,0x66,0xC3,0xFF,0xC3,0xC3}

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

В памяти будем представлять шрифт таким способом:

1 байт - Ширина символа
2 байт - Высота символа
3 байт - Первая битовая маска первого символа
.....

Если коротко, то первые два байта это физические размеры символов шрифта, а далее битовые образы всех 256 символов. У меня на компьютере имеется несколько интересных шрифтов такого формата. Но для вас напишем утилитку, которая сможет генерить такие шрифты, хотя многие из Вас смогут написать и сами.

Теперь описание класса CGIFont:

class CGIFont{
	char *Font;
public:
	CGIFont(char *FileName);
	~CGIFont();
	void WriteChar(CGIScreen *scr,int x,int y, unsigned char color,
		 unsigned char color1,
		 int bol,unsigned char ch);
	void WriteString(CGIScreen *scr,int x,int y, unsigned char color,
		 unsigned char color1,
		 int bol,unsigned char *S);
};

Конструктор будет сразу инициализировать шрифт и загружать его из файла с именем FileName:

CGIFont::CGIFont(char *FileName){
	FILE *f;
	unsigned char l,k;
	long len;
	Font=NULL;
	if ((f = fopen(FileName, "rb")) == NULL) return;
	fread(&k,1,1,f);
	fread(&l,1,1,f);
	rewind(f);
	len=l*256+2;
	if((Font=(char *)malloc(len))==NULL){
		fclose(f);
		return;
	};
	fread(Font,len,1,f);
	fclose(f);
};

Деструктор, можно сказать, в старом стиле:

CGIFont::~CGIFont(){
	if (Font!=NULL) free(Font);
};

Теперь осталась процедура вывода символа и строки.

void CGIFont::WriteChar(CGIScreen *scr,int x,int y, unsigned char color,
		 unsigned char color1,
		 int bol,unsigned char ch)
{
  unsigned char i,j,Number,N;
  if (Font==NULL) return;
  char l=*Font;
  char k=*(Font+1);
  for (j=0;j<=k-1;j++)
  {
	Number=*(Font+2+ch*k+j);
	for (i=0;i<=l-1;i++)
	{
		N = Number << i;
		N >>= 7;
	  if (N==1) scr->PutPixel(x+i,y+j,color);
	  else if (bol==0) scr->PutPixel(x+i,y+j,color1);
    }
  }
};

Здесь scr - это тот виртуальный экран, на который нам надо вывести символ. Позиция для вывода символа задается координатами x,y. Цвет символов задается параметром color, а фон цветом color1. При этом, если признак bol равен 1, то фон не выводится. Этот эффект похож на прозрачность в спрайтах. Параметр ch задает тот символ, который надо вывести.

Теперь на базе этой процедуры строим процедуру вывода строки на экран:

void CGIFont::WriteString(CGIScreen *scr,int x,int y, unsigned char color,
		 unsigned char color1,
		 int bol,unsigned char *S)
{
  unsigned char l;
  if (Font==NULL) return;
  l=*Font;
  int i=0;
  while (*S!=\'\\0\')
  {
    if (*S!=\'\\n\')
     {
	  WriteChar(scr,x+(i*l),y,color,color1,bol,*S);
      i++;
     }
    else {i=0;y+=*(Font+1);}
	S++;
  };
};

Все параметры аналогичны предыдущей процедуре. Строка задается указателем *S.

Теперь можно выводить символы на виртуальный экран. Графические возможности нашего CGI приложения постоянно растут :-)

Шаг 22 - Скрипт и базы данных.

Такое громкое название, как "База данных" зачастую скрывает в себе лишь один или несколько файлов, в которых хранятся в определенном формате данные. Каждый способен придумать свой формат файла базы данных, но в компьютерном мире уже существуют общепринятые форматы баз данных, которые понимают многие СУБД и программы.

Одним из таких форматов является DBF (Data Base File). Наша задача проста: разобраться с форматом файлов DBF и написать соответствующую библиотеку классов для работы с ними. Я конечно понимаю, что это уже старо как мир и существует много готовых библиотек, но давайте напишем что-то сами для развития мозгов и своего навыка программирования.

Первым делом надо разобраться с форматом файлов DBF. На данном этапе я считаю важным разобраться только с форматом записи файла, а если быть точным, то с форматом описания структуры этой записи.

Вкратце и упрощенно о формате файла DBF. Сначала идет заголовок файла, с ним мы познакомимся чуть позже. Далее идет список полей в записи файла, т.е. имя, тип, длина соответствующего поля в записи. После этого списка идут подряд все записи файла, которые организуются по структуре описанной в списке полей.

Для полного описания поля записи используется структура длинной 32 байта, в которой:

class DBFRecordType;//класс для структуры записи
class DBFRecordTypeField {
friend DBFRecordType;
	DBFRecordTypeField *Next, *Pred;//Переменные для списка
public:
	char Name[11]; //имя поля
	char Type; //тип поля
	long Position; //Позиция поля в записи
	unsigned char TotalLen;//Длина поля
	unsigned char DecimalLen;//Длина дробной части
	DBFRecordTypeField(char *name_,char type_, 
		unsigned char len_, unsigned char declen_);
	~DBFRecordTypeField();
};

DBFRecordTypeField::DBFRecordTypeField(char *name_,
	char type_, unsigned char len_, unsigned char declen_)
{
	int i=0;
	char b=0;
	for (i=0;i<11;i++){
		if ((*(name_+i)!=0)&&(b==0))
			Name[i]=*(name_+i);
		else {
			Name[i]=0;
			b=1;
		};
	};
	Type=type_;
	TotalLen=len_;
	if ((Type==\'F\')||(Type==\'N\')){
		DecimalLen=declen_;
	} else {
		DecimalLen=0;
	};
	if (Type==\'L\') TotalLen=1;
	Next=NULL;
	Pred=NULL;
};// DBFRecordTypeField;

DBFRecordTypeField::~DBFRecordTypeField(){
	if (Pred!=NULL) Pred->Next=Next;
	if (Next!=NULL) Next->Pred=Pred;
};//~DBFRecordType;

class DBFRecordType {
	DBFRecordTypeField *List;
public:
	DBFRecordType();
	~DBFRecordType();
	void Add(DBFRecordTypeField *New);
	DBFRecordTypeField *FindField(char *name_);
	unsigned int Length();
};

DBFRecordType::DBFRecordType(){
	List=NULL;
};

DBFRecordType::~DBFRecordType(){
	DBFRecordTypeField *temp;
	temp=List->Next;
	while (List!=NULL){
		delete List;
		List=temp;
		temp=temp->Next;
	};
};

void DBFRecordType::Add(DBFRecordTypeField *New){
	DBFRecordTypeField *temp=List;
	if (List==NULL){
		List=New;
		New->Position=1;
		return;
	};
	while (temp->Next!=NULL) {
		temp=temp->Next;
	};
	temp->Next=New;
	New->Pred=temp;
	New->Position=temp->Position+temp->TotalLen;
};

DBFRecordTypeField *DBFRecordType::FindField(char *name_){
	DBFRecordTypeField *temp;
	temp=List;
	while (temp!=NULL){
		if (stricmp(temp->Name,name_)==0){
			return temp;
		};
		temp=temp->Next;
	};
	return NULL;
};

unsigned int DBFRecordType::Length(){
	DBFRecordTypeField *temp;
	unsigned int c=0;
	temp=List;
	while (temp!=NULL){
		c+=temp->TotalLen;
		temp=temp->Next;
	};
	return c;
};

/////////////////////////////////////////
////
///			DBFRecord Class
//
class DBFRecord {
	DBFRecordType *Type;
	char *Content;
	int Length;
	DBFRecordTypeField *Temp;
public:
	DBFRecord(DBFRecordType *type_);
	~DBFRecord();
	void SetField(char *name_,void *var);
	void GetField(char *name_,void *var);
	void Write(FILE *f_out);
};

#define MAX_DBF_FIELD 257
char dbfbuffer[MAX_DBF_FIELD];
char dbfpattern[10];

DBFRecord::DBFRecord(DBFRecordType *type_){
	Content=(char *)malloc(Length=type_->Length());
	if (Content!=NULL){
		memset(Content,\' \',Length);
	};
	Temp=NULL;
	Type=type_;
};

DBFRecord::~DBFRecord(){
	if (Content!=NULL) free(Content);
};

void DBFRecord::SetField(char *name_,void *var){
	long l=0;
	if (Temp!=NULL){
		if (strcmp(Temp->Name,name_)==0) goto cont;
	};
	Temp=Type->FindField(name_);
	if (Temp==NULL) return;
cont:
	switch (Temp->Type) {
		case \'F\': case \'N\':{
			sprintf(dbfpattern,"%%%d.%df",Temp->TotalLen,Temp->DecimalLen);
			sprintf(dbfbuffer,dbfpattern,*(float *)var);
			memmove(Content+Temp->Position-1,
				dbfbuffer+(strlen(dbfbuffer)-Temp->TotalLen),Temp->TotalLen);
			break;
		};//case \'F\'
		case \'C\':{
			l=strlen((char*)var);
			memset(Content+Temp->Position-1,\' \',Temp->TotalLen);
			if (Temp->TotalLen>l)
				memmove(Content+Temp->Position-1+Temp->TotalLen-l,var,l);
			else
				memmove(Content+Temp->Position-1,
				(char*)var+l-Temp->TotalLen,Temp->TotalLen);
			break;
		};//case \'C\'
		case \'L\':{
			if (*(char *)var==0)
				*(Content+Temp->Position-1)=\'F\';
			else
				*(Content+Temp->Position-1)=\'T\';
			break;
		};//case \'L\'
	};//switch
};

void DBFRecord::GetField(char *name_,void *var){
	long i,l;
	char *t=NULL;
	if (Temp!=NULL){
		if (strcmp(Temp->Name,name_)==0) goto cont;
	};
	Temp=Type->FindField(name_);
	if (Temp==NULL) return;
cont:
	switch (Temp->Type) {
		case \'F\': case \'N\':{
			memmove(dbfbuffer,Content+Temp->Position-1,Temp->TotalLen);
			dbfbuffer[Temp->TotalLen]=0;
			*(float *)var=atof(dbfbuffer);
			break;
		};//case \'F\'
		case \'C\':{
			t=Content+Temp->Position-1;
			l=0;
			while ((*t==\' \')&&(l<Temp->TotalLen)){t++; l++;}
			i=0;
			while (l<Temp->TotalLen){
				*((char *)var+i)=*t;
				t++;l++;i++;
			};
			*((char *)var+i+1)=0;
			break;
		};//case \'C\'
		case \'L\':{
			if (*(Content+Temp->Position-1)==\'F\')
				*(char *)var=0;
			else
				*(char *)var=1;
			break;
		};//case \'L\'
	};//switch
};

void DBFRecord::Write(FILE *f_out){
	if (Content!=NULL)
		for (long i=0;i<Length;i++)
			fprintf(f_out,"%c",*(Content+i));
};

/////////////////////////////////////
////
///         DBFFile Class
//
class DBFFile {
	char Version;//версия DBF файла
	char ModifyDate[3]; //Дата модификации ГГММДД
	unsigned long RecordsCount; //количество записей в файле.
	unsigned int FullHeaderLen;//полная длина заголовка
		//(положение первой записи в файле)
	unsigned int RecordLen;//длина записи + признак удаления(1 байт)
	DBFRecordType *Struct;//структура записи файла
	FILE *DBF;
public:
	DBFFile();
	~DBFFile();
	int Open(char *name_);
	int ReadRecord(unsigned long Num, DBFRecord *Buf);
	int WriteRecord(unsigned long Num, DBFRecord *Buf);
	unsigned long AppendRecord(DBFRecord *Buf);
	int CheckRecord(long Num);
	DBFRecordType *GetStruct();
};

DBFFile::DBFFile(){
	RecordsCount=0;
	FullHeaderLen=0;
	RecordLen=0;
	Struct=NULL;
	DBF=NULL;
};
DBFFile::~DBFFile(){
	if (DBF!=NULL) fclose(DBF);
	if (Struct!=NULL) delete Struct;
};

int DBFFile::Open(char *name_){
	int i;
	char type,len,declen;
	DBF=fopen(name_,"rb+");
	if (DBF==NULL) return -1;
	fread(&Version,1,1,DBF);
	fread(ModifyDate,1,3,DBF);
	fread(&RecordsCount,4,1,DBF);
	fread(&FullHeaderLen,2,1,DBF);
	fread(&RecordLen,2,1,DBF);
	fseek(DBF,32,SEEK_SET);
	i=((FullHeaderLen-1)/32)-1;
	Struct=new DBFRecordType();
	while (i>0){
		fread(dbfbuffer,11,1,DBF);
		dbfbuffer[11]=0;
		fread(&type,1,1,DBF);
		fseek(DBF,4,SEEK_CUR);
		fread(&len,1,1,DBF);
		fread(&declen,1,1,DBF);
		Struct->Add(new DBFRecordTypeField(dbfbuffer,type,len,declen));
		fseek(DBF,14,SEEK_CUR);
		i--;
	};
	return 0;
};

int DBFFile::ReadRecord(unsigned long Num, DBFRecord *Buf){
	char Deleted;
	if ((DBF==NULL)||(Num>RecordsCount)) return -1;
	fseek(DBF,FullHeaderLen+(RecordLen)*(Num-1),SEEK_SET);
	fread(&Deleted,1,1,DBF);
	Buf->Read(DBF);
	if (Deleted==\' \') return 1; else return 0;
};

int DBFFile::WriteRecord(unsigned long Num, DBFRecord *Buf){
	char Deleted=\' \';
	if ((DBF==NULL)||(Num>RecordsCount)) return -1;
	fseek(DBF,FullHeaderLen+(RecordLen)*(Num-1),SEEK_SET);
	fwrite(&Deleted,1,1,DBF);
	Buf->Write(DBF);
	return 0;
};

unsigned long DBFFile::AppendRecord(DBFRecord *Buf){
	if (DBF==NULL) return -1;
	char Deleted=\' \';
	RecordsCount++;
	fseek(DBF,4,SEEK_SET);
	fwrite(&RecordsCount,4,1,DBF);
	fseek(DBF,FullHeaderLen+(RecordLen)*(RecordsCount-1),SEEK_SET);
	fwrite(&Deleted,1,1,DBF);
	Buf->Write(DBF);
	Deleted=0x1A;
	fwrite(&Deleted,1,1,DBF);
	fflush(DBF);
	return RecordsCount;
};

int DBFFile::CheckRecord(long Num){
	char Deleted;
	if ((DBF==NULL)||(Num>RecordsCount)) return -1;
	fseek(DBF,FullHeaderLen+(RecordLen)*(Num-1),SEEK_SET);
	fread(&Deleted,1,1,DBF);
	if (Deleted==\' \') return 1; else return 0;
};

DBFRecordType *DBFFile::GetStruct(){
	return Struct;
};

void DBFRecord::Write(FILE *f_out){
	if (Content!=NULL){
		fwrite(Content,1,Length,f_out);
		fflush(f_out);
	};
};
void DBFRecord::Read(FILE *f_in){
	if (Content!=NULL)
		fread(Content,1,Length,f_in);
};

	Не могли вы бы подсказать, как передать данные 
	из javascript програмы в perl (CGI). 
	Меня в частности интересует вопрос об разрешении 
	монитора пользователя, но я это могу определить 
	только с помощью javascript, а как передать эти 
	данные через CGI на сервер незнаю.
	--
	Женя Краус

<script language=javascript1.2>
	document.write(screen.width,\'x\'+screen.height); 
</script>

1024x768

<script language=javascript1.2> 
document.write("<a href=test.cgi?screen=",
screen.width+\'x\'+screen.height,">Click</a>"); 
</script>

<a href=test.cgi?screen=1024x768>Click</a>

<form action=test.cgi method=POST name=form1>
<input type=text name=data>
<input type=hidden name=scr>
<input type=submit>
</form>

<script language=javascript1.2>
 document.form1.scr.value=screen.width+\'x\'+screen.height; 
</script>

data=hehehe
scr=1024x768

Здравствуйте! Пишу вам почти отчаившись создать что-то работающее для web
странички на perl. Перечитал сотни страниц доков, FAQ, пособий и.т.д. но
ничего не помогает.
Все предложенные варианты, программы не работают. Все грузят про CGI.pm а я
не пойму как с ним работать. Уже десять дней ломаю голову как сделать
рабочую web-программу (которая могла бы работать дома без сервера интернет и
на виндах).
Объясните пожалуйста как можно сделать самую примитивную гостевую книгу.
Чтобы из текстовой формы браузера, введенная информация пересылалась на
сервер и записывалась в htm вайл? Что для этого нужно, писать файл *.cgi или
*.pl. Можно ли сделать так, чтобы гостевая книга работала у себя дома на
компе и без интернет сервера. Как избежать у себя на PC сообщения брайзера
сохранить ли *.pl или открыть его на месте.
(комп с WINDOWS 98). Извините за такое количество вопросов,
я буду Вам очень благодарен если Вы ответите хотя бы на некоторые из них.
С уважением, Артем.

[Sat Oct 21 10:00:00 2000] [error] [client 123.45.67.89] Premature end of script headers: с:/apache/cgi-bin/1.cgi

	printf("Content-type: text/html\\n\\n");

	printf("Content-type: text/html\\n");

	Segmentation fault

Вот у меня возник такой вопрос. Вы очень часто говорите о защите от
атак всяких злых дядек, именующих себя "хакерами". Мой будущий сайт
представляет собой биржу труда и образовательных услуг на WEB
технологиях, следовательно его нужно сделать достаточно устойчивым от
всяких некорректных действий. Если можно, расскажите мне о наиболее
часто применяемых методах хакерских атак, наверняка Вы сталкивались с
ними очень часто. А я попробую учесть Ваш опыт и принять меры по
защите от деструктивных действий. Был бы очень Вам благодарен.
С уважением, Денис.