Небольшой сценарий вызывающий установленный на сервере cgi скрипт это

CGI — это аббревиатура от слов Common Gateway Interface. Так называется небольшая программа, которая предлагает надежный способ взаимодействия веб-серверов в браузере, выполняя это способами, которые были невозможны с помощью HTML. Большинство скриптов CGI написаны на Perl. Это обычный язык программирования, который используется для создания сценариев на стороне сервера со стандартным текстовым файлом с расширением (.cgi).

Основные условия работы программы

Вам будет интересно:Как пользоваться «Тим Спик 3»? Советы

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

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

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

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

Конфигурация и монтаж

Вам будет интересно:Как пользоваться «Лаки патчером»: советы

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

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

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

Разрешение для файлов

Существует три типа доступа к данным с тремя разными разрешениями для каждой группы.

Вам будет интересно:Три простых способа, как отключит уведомления в «Вайбере»

Серверы UNIX позволят установить разные уровни доступа. Важно знать, какие разрешения имеет сценарий:

Группа — состоит из добавленных пользователей на сервере. При необходимости будет разрешено удалить их разрешение.

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

Другое — группа состоит из всех других аспектов на сервере.

Чтение — позволяет пользователям читать и понимать данные, указанные в файле.

Write — разрешение на запись позволит пользователям расшифровать и записать новую дату, удалить старые данные из архива.

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

Пример использования Application

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

Имеет легкий вес (с точки зрения использования памяти), что делает его подходящим для обычных сред CGI, и высокий выбор производительности в таких постоянных средах, как FastCGI или mod_perl.

Добавляя PLUG-INS по мере роста потребностей, можно использовать сложные функции, когда они будут нужны, например, нужно написать приложение для поиска через базу данных виджетов. Скрипт экземпляра — это то, что фактически вызывается пользовательским веб-сервером. Это очень маленький простой файл, который просто создает экземпляр пользовательского приложения и вызывает унаследованный метод, run (). Ниже приведено полное описание «widgetview.cgi»:

#!/usr/bin/perl -wuse WidgetView

my $webapp = WidgetView->new()

$webapp->run()

Как можно видеть, widgetview.cgi просто использует прикладной модуль, который реализует пакет Perl под названием WidgetView.pm.

CGI Application заботится о внедрении методов new () и run (). При этом пользователь никогда не должен вызывать print () для отправки любого вывода в STDOUT. Вместо этого весь вывод возвращается, как скаляр.

CGI — самый значительный вклад в управление состоянием приложения. Все, что необходимо для продвижения приложения вперед, это установить значение параметра формы HTML «rm» в значение «режима выполнения», которое нужно обработать отправкой формы. Это ключ к CGI Application.

Методы сценариев

Используя CGI Application, пользователь получает доступ к целому ряду встроенных методов. Ниже перечислены те, которые, вызываются из скрипта.

Метод new () является конструктором для CGI. Он возвращает ссылку на пакет приложений (класс). Он может принимать набор параметров, как пары: ключ => значение.

Этот метод может принимать некоторые конкретные параметры:

TMPL_PATH — определяет путь к каталогу шаблонов.

QUERY — позволяет указать уже созданный объект запроса CGI.pm.

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

Вам будет интересно:Как создать свою программу: обзор инструментов

Run () вызывается на объект Application Module из скрипта. При вызове он выполняет функциональные возможности пользовательского прикладного модуля.

Этот метод сначала определяет состояние приложения, просматривая значение параметра CGI, заданного параметром mode_param (). По умолчанию В «rm» для В «Run Mode», который будет содержать имя режима работы. Если это не указано, состояние по умолчанию равно значению start_mode (). Как только режим определен, run () просматривает таблицу отправки, хранящуюся в run_modes (), и находит указатель функции, который вводится из имени режима. Если найден, функция вызывается, а возвращаемые данные print () ‘ed отправляются в STDOUT и в браузер. Если указанный режим не найден, в таблице run_modes (), run () будет croak ().

Поддержка PSGI

Приложение предлагает встроенную поддержку PSGI. Объектом запроса по умолчанию для этого является:

psgi_app ()

$psgi_coderef = WebApp->psgi_app({ … args to new() … })

Самый простой способ — создать и вернуть PSGI — совместимый coderef. Нужно передать аргументы в hashref так же, как и к новому. Это возвращает PSGI-совместимый coderef, используя CGI ::: PSGI в качестве объекта запроса. Чтобы использовать другой объект запроса, создают собственный объект run_as_psgi(), как показано ниже:

run_as_psgi ()

my $psgi_aref = $webapp->run_as_psgi

Точно так же, как run, печать, не выводит и не возвращает структуру данных, требуемую спецификацией PSGI. Используют это, если нужно запустить приложение поверх обработчика, совместимого с PSGI, например, Plack. Конечный результат может выглядеть так:

Спецификация PSGI позволяет возвращать дескриптор файла или ссылку подпрограммы вместо байтовых строк. В режиме PSGI это поддерживается непосредственно CGI Application.

Методы возможного переопределения

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

Настройка(). Этот метод вызывается унаследованным методом конструктора new ().

Метод setup () следует использовать для определения следующего свойства / методов.

Метод setup () может вызывать любой из методов экземпляра пользовательского приложения. Эта функция является хорошим местом для определения свойств, специфичных для приложения, с помощью $ webapp-> param ().

Метод setup () может быть реализован, как изображение ниже:

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

Метод teardown (). Если он реализован, то вызывается автоматически после создания CGI скриптов и запуска приложения. Его можно использовать для очистки после операций. Типичное использование функции teardown () — отключить соединение с базой данных, которое было установлено в функции setup (). Также можно использовать метод teardown () для хранения информации о состоянии приложения на сервере: cgiapp_init ().

Отправка чистых URI для запуска режимов

Современные веб-фреймворки обходятся без ограничений в URI, обеспечивая вместо этого чистые URI:

/cgi-bin/item.cgi?rm=view&id=15

Чистым URI для описания одного и того же ресурса может быть:

/item/15/view.

Процесс сопоставления этих URI для запуска режимов называется диспетчеризацией и обрабатывается CGI :: Application :: Dispatch. Дополнительный диспетчер не требуется.

Можно работать над проектом CGI :: Application на рабочем столе или ноутбуке без установки полнофункционального веб-сервера, такого как Apache. Вместо этого устанавливают CGI :: Application :: Server из CPAN. После нескольких минут установки у пользователя будет собственный сервер приложений.

Проводят автоматизированное тестирование. Test :: WWW :: Mechanize :: CGIApp позволяет выполнять функциональное тестирование проекта CGI :: App без запуска веб-сервера. Test :: WWW :: Mechanize можно использовать для проверки приложения через настоящий веб-сервер.

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

Пользовательский контент CGI

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

PHP — это язык, специально предназначенный для реализации динамического содержимого на веб-серверах. Это делает разработку скриптов CGI в PHP намного проще, чем на других языках. Когда сервер начинает выполнение, он предоставляет всю необходимую ему контекстную информацию:

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

Куки, связанные с запросом.

В случае запроса POST, в результате отправки веб-формы, имена и значения параметров.

Основной пример скрипта PHP

Сценарий должен выполнить процесс, а затем выводить допустимый HTML-код, включая заголовки HTTP. Пример скрипта PHP:

В этом скрипте первая и последняя строки являются HTML-кодом, а предложения PHP заключены в маркеры, затем получают скрипт из браузера, добавляя строку запроса из двух аргументов «data1» и «data2».

Помимо глобальной переменной $ _SERVER в скрипте доступны следующие ассоциативные массивы запуска CGI скриптов:

$ _GET — имена и значения аргументов, переданных серверу в запросе GET.

$ _POST — имена и значения параметров, отправленных на сервер в запросе POST, при отправке формы.

$ _COOKIE — имена и значения файлов cookie, прикрепленных к запросу.

$ _REQUEST — все элементы в $ _GET, $ _POST и $ _COOKIEnpm для запуска php-скриптов с nodejs через cgi. Этот модуль был разработан для deskshell, чтобы обеспечить беспрепятственную обработку сценариев php.

Учитывая, что разработчик получает запрос в nodejs и имеет объект запроса, называемый req, и объект ответа, называемый res, он должен использовать этот модуль, как представлено ниже:

Таким образом запрос на /test.php будет отвечать модулю php для скриптов CGI. Функция paramsForRequest считывает объект запроса и устанавливает правильные переменные среды cgi для запроса. Это предоставляется, как отдельная функция, поэтому при необходимости можно добавлять дополнительные переменные запроса. Функция detectBinary в окнах ищет дополнительный модуль узла «php-bin-win32», который предоставляет переносимый php-файл. Этот код работает для deskshell и в том случае, если необходимо использовать его для каких-либо других целей и дополнительных функциях.

Первая программа

Вам будет интересно:Установить переводчик в «Яндекс.Браузер»: пошаговая инструкция, настройка, советы

Чтобы написать простую программу CGI в Perl, придерживаясь традиции, используют фразу «привет мир». Здесь она представлена полностью. Сохраняют это в файл с именем «hello» в каталоге cgi-bin и запускают его, указав URL-адрес:localhost/cgi-bin/hello в браузере. Пользователь должен увидеть текст «Hello world» в браузере. Если нет, знакомятся с разделом boxout для отладки программ CGI, чтобы получить помощь в отслеживании проблемы.

Это простая программа. Есть только несколько моментов, которые отличают разработку CGI скриптов на Perl от стандартной программы, запускающейся из командной строки. Первой из них является опция -T на линии shebang. Это переводит Perl в режим «taint». В этом режиме Perl автоматически будет игнорировать любые данные, поступающие от пользователя, и не позволит передавать эти данные в операционную систему до тех пор, пока они не будут очищены. В этом смысле taint-режим — хорошая идея.

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

Все программы CGI должны выводить набор заголовков в браузер пользователя. В большинстве случаев единственным заголовком, который нужно будет вернуть, является контент. Это сообщает браузеру, какие данные программа отправляет. В этом примере возвращается простой текст, поэтому тип содержимого был «text/plain».

Обычно возвращают HTML, поэтому тип контента будет «text / html». Нет причин, по которым программа не может вернуть более сложные данные, например PNG («image / png»). Набор заголовков должен быть отделен от фактических данных пустой строкой. Это достигается путем печати двух символов новой строки после финального заголовка CGI скриптов на сервере.Также обращают внимание, что программа записывает свой вывод в STDOUT.

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

Этот скрипт работает по тому же принципу, что и последний, но выдает системное время, используя функцию при разработке CGI скриптов на Perl — «localtime» и печатает это значение. Каждый раз, когда перезагружается скрипт, время будет обновляться. Еще раз этот скрипт выводит обычный текст. Требуется рассмотреть версию, которая возвращает HTML:

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

Если пользователь когда-либо просматривал настройки своего браузера, вероятно, видел флажки или переключатели для включения или отключения Javascript и Java, но никогда не видел их для CGI или PHP. Это потому, что Javascript и Java выполняются браузером (или нет, если пользователь отключит их). Браузер ничего не знает о CGI или PHP. Он просто получает чистый HTML-код после выполнения сценариев на сервере. Встроенный способ создания CGI скриптов — PHP, ColdFusion, ASP, в основном, используется разработчиками, создающим веб-страницы «front end», которые будут обращаться к базам данных «назад», например, клиент/серверные веб-приложения.

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

Стандарт cgi. Сценарии. Сценарные языки: классификация по быстродействию. Язык Python. Язык Ruby. Технология asp. Интерфейс isapi.

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

Плагин
(plug-in) — независимо компилируемый
программный модуль, динамически
подключаемый к основной программе,
предназначенный для расширения или
использования ее возможностей. Обычно
выполняются в виде разделяемых библиотек.

Сценарий
(скрипт,
script) — программа, которая автоматизирует
некоторую задачу, которую пользователь
выполняет вручную используя интерфейсы
программы.

Стандарт cgi

Круг
задач, решаемых Web-сервером, ограничен.
В основном он сводится к поддержке
НТТР-взаимодействия и доставке клиенту
Web-документов. Любые «нестандартные»
действия реализуются с помощью специальной
программы, которая взаимодействует с
веб-сервером и клиентом. Это взаимодействие
подчиняется определенным правилам.

Основной
набор таких правил — стандарт CGI (Common
Gateway Interface — интерфейс общего шлюза),
который определяет порядок запуска
программы на компьютере-сервере, способы
передачи программе параметров и доставки
результатов ее выполнения клиенту.
Программа, написанная по правилам CGI,
называется CGI-сценарием (script CGI), хотя
это не означает, что на сервере не может
выполняться двоичный файл.

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

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

1. Запуск
   программы.

2. Инициализация
   и чтение выходных данных.

3. Обработка
   данных.

4. Вывод
   результатов выполнения.

5. Завершение
   программы.

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

Каждый
раз, когда веб-сервер получает запрос
от клиента, он анализирует содержимое
запроса и возвращает соответствующий
ответ:

• Если
  запрос содержит указание на файл,
  находящийся на жестком диске, то сервер
  возвращает в составе ответа этот файл;

• Если
  запрос содержит указание на программу
  и необходимые для нее аргументы, то
  сервер исполняет программу и результат
  ее работы возвращает клиенту.

Cgi определяет:

• каким
  образом информация о сервере и запросе
  клиента передается программе в форме
  аргументов и переменных окружения;

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

В
подавляющем большинстве случаев запуск
CGI-сценария осуществляется щелчком на
кнопке Submit, сформированной с помощью
дескриптора <input tyре = «submit»>,
который находится на HTML-странице между
<form> и </form>. Не зная назначения
атрибутов action и method, невозможно понять,
как происходит вызов программы и передача
параметров.

Значением
атрибута action дескриптора <form> является
URL файла, содержащего код CGI-сценария.
Так, приведенное ниже выражение означает,
что файл с кодом CGI-сценария находится
на сервере www.myhp.edu в каталоге cgi-bin в файле
script.рl.

<form
action=»http://www.myhp.edu/cgi-bin/script.pl»
method=»post»>

Как
веб-сервер различает, что надо сделать
с файлом, на который указывает URL, —
передать его содержимое клиенту или
запустить файл на выполнение? Существует
два способа распознавания файлов,
содержащих тексты CGI-сценариев.

Первый
способ
заключается в том, что при установке
веб-сервера один из каталогов специально
выделяется для хранения сценариев.
Обычно такой каталог получает имя
cgi-bin (или Scripts для веб-сервера IIS). В этом
случае, если клиент запрашивает файл
из каталога cgi-bin, сервер воспринимает
такой запрос как команду на запуск
сценария. Файлы из других каталогов
интерпретируются как HTML-документы.

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

Идентификация
по расширению используется относительно
редко. Чаще всего все сценарии помещаются
в cgi-bin, /Scripts или в другой каталог,
специально выделенный для их хранения.

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

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

НТТР/1.0
200 OK

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

Самый
естественный формат для браузера —
формат HTML. Результаты работы сценария
обычно оформляются в виде веб-страницы,
т.е. возвращаемые данные следует дополнить
дескрипторами HTML. Таким образом, ответ
CGI-сценария клиенту обычно выглядит
так:

Content-type:
text/html

<html>

<hеаd>

<titlе>ответ
сценария</titlе>

</hеаd>

<body>

……………………

</body>

</html>

Обратите
внимание на пустую строку после выражения
Content-type: text/html. Она обязательно должна
присутствовать в ответе, в противном
случае клиент воспримет все последующие
данные как продолжение заголовка.

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

Для
вызова данного сценария достаточно
включить в веб-страницу следующий
фрагмент HTML-кода:

<form
method=»post»
action=»http://www.intuit.ru/cgi-bin/hello.exe»>

<input
type=»submit»>

</form>

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

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

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

Каждый
параметр представляет собой имя
управляющего элемента и его значение,
разделенные знаком равенства, а несколько
таких пар объединяют строку с помощью
символа «&». Если в состав имени
или значения входит символ «&»
или «=», то подобные символы кодируются
последовательность знака процента «%»,
за которым следуют две шестнадцатеричные
цифры, определяющие код символа. Так,
например, последовательностью «%21»
кодируется восклицательный знак «!».
Как правило, при передаче параметров
трехсимвольными последовательностями
заменяются все знаки, кроме латинских
букв, цифр и символа пробела (последний
заменяется знаком «+»).

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

• Выделить
  из строки параметров пары имя = значение.

• Выделить
  из каждой пары имя и значение.

• В
  каждом имени и каждом значении заменить
  символы «+» пробелами.

• Каждую
  последовательность из символа «%»
  и двух шестнадцатеричных и преобразовать
  в ASCII-символ.

Атрибут
method дескриптора <form> имеет либо
значение «GET», либо значение «POST».
Значения «GET» и «POST» определяют
два различных метода передачи параметров
сценарию:

• Если
  атрибут method имеет значение «GET»,
  строка параметров передается вместе
  с URL вызываемого сценария. Разделителем
  между URL и строкой параметров является
  символ «?».

• Если
  атрибут method имеет значение «POST»,
  строка параметров передается в теле
  HTTP-запроса.

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

Если
атрибут METHOD дескриптора <FORM> имел
значение «GET», строка параметр
передается серверу в качестве значения
переменной окружения QUERY_STRING.

При
использовании метода POST данные
доставляются сценарию по-другому. Они
передаются через стандартный поток
ввода (STDIN). Чтобы сценарий смог определить,
сколько символов следует читать из
стандартного ввода, веб-сервер
устанавливает значение переменной
окружения CONTENT_LENGTH, равным длине строки
параметров.

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

Таким
образом, в простейшем случае, чтобы
выполнить обработку строки параметров,
достаточно знать назначение трех
переменных окружения: REQUEST_METHOD, QUERY_STRING
и CONTENT_LENGTH.

Пример
сценария на языке Perl, который возвращает
клиенту строку параметров, приведен
ниже. Сценарий определяет, какой метод
использовался для передачи данных,
читает строку параметров и передает ее
клиенту, предварительно дополнив
HTML-дескрипторами.

$method
= $ENV{‘REQUEST_METHOD’};

if
($method eq «GET»)

{
$pars = $ENV{‘QUERY_STRING’}; }

else

{
$length =$ENV{‘CONTENT_LENGTH’}; }

read
(STDIN, $pars, $ length);

print
«Content-type: text/htmlnn»;

print
«<HTML><BODY>n»;

print
«<P>METHOD = «, $method;

print
«<P>String of parameters: <P>n»;

print
$pars;

print
«</HTML></BODY>n»;

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

REMOTE_ADDR
IP-адрес узла, с которого поступил запрос

REMOTE_HOST
Доменное имя узла, с которого поступил
запрос

SERVER_PORT
Номер порта, который использовался при
обращении к серверу

SERVER_SOFTWARE
Имя и версия сервера, посредством
которого был запущен сценарий

SERVER_NAME
Имя или адрес узла, на котором выполняется
сервер

SERVER_PSOTOCOL
Название и версия протокола, с помощью
которого был передан запрос

HTTP_USER_AGENT
Клиентская программа, отправившая
запрос серверу

HTTP_REFERER
URL документа, отображаемого браузером
при вызове сценария

Соседние файлы в папке +Web-технол 1-36

• #
• #
• #
• #
• #
• #
• #
• #

Основные элементы web-страницы:

1. Заголовок/Логотип (Шапка)
2. Поиск
3. Рекламный Баннер
4. Содержание (Текстовое поле)
5. Элементы навигации
6. Информация о разработчиках сайта
7. Счетчик посещаемости

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

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

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

Непосредственно под/над заголовком документа, как правило, располагается пространство, отведенное для размещения рекламного Баннера. Включение баннера именно в верхнюю часть web-страницы в большинстве случаев является обязательным условием регистрации сайта в службах баннерного обмена — системах, рекламирующих созданный вами ресурс в обмен на показ на страницах вашего сайта рекламы других участников баннерообменной сети. В некоторых случая вместо заимствованного баннера включаются собственные баннеры промоакций (Мегафон).

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

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

Следующей обязательной составляющей частью web-страницы являются Элементы навигации — гиперссылки, связывающие данный документ с другими разделами сайта. Элементы навигации могут быть выполнены в виде текстовых строк, графических объектов, то есть кнопок, либо активных компонентов.

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

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

Ну, в общем, это основные элементы веб-страниц.

• Скрипты CGI
• Почему Web-узлы используют CGI
• Программа-сервер должна вызвать CGI-скрипт
• Броузер, сервер и CGI
• Взаимосвязь сервера и CGI-скрипта
• CGI и базы данных
• Где находятся скрипты
• Расширение имен файлов CGI-скриптов
• Основы взаимодействия между Web-сервером и CGI-скриптом
• Переменные окружения
• Переменная AUTH_TYPE
• Переменная CONTENT_LENGTH
• Переменная CONTENT_TYPE
• Переменная GATEWAY_INTERFACE
• Переменная PATH_INFO
• Переменная PATH_TRANSLATED
• Переменная QUERY_STRING
• Переменная REMOTE_ADDR
• Переменная REMOTE_HOST
• Переменная REMOTE_IDENT
• Переменная REMOTE_USER
• Переменная REQUEST_METHOD
• Переменная SCRIPT_NAME
• Переменная SERVER_NAME
• Переменная SERVER_PORT
• Переменная SERVER_PROTOCOL
• Переменная SERVER_SOFTWARE
• Дополнительные переменные окружения
• Переменная HTTP_ACCEPT
• Переменная HTTP_USER_AGENT
• Опции командной строки CGI
• Стандартный ввод ( STDIN )
• Стандартный вывод ( STDOUT )
• Прямой ответ CGI-скрипта броузеру
• Заголовки CGI

CGI

Скрипты CGI

Для того, чтобы
Web-узлы были действительно
интерактивными, она должны
обмениваться информацией с
пользователем, а не только
позволять ему загружать документы.
Используя программы Common Gateway Interface (
называемые CGI-скриптами ),
можно создавать Web-страницы,
управляемые данными. Как вы
узнаете, используя скрипты CGI, узел
может получать запросы и отвечать
пользователю.

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

Почему
Web-узлы используют CGI

Для создания
динамических файлов HTML нет
необходимости в применении
CGI-скриптов. Однако без таких
скриптов всякий раз, когда
понадобится новая интерактивная
динамическая страница Web, придется
модифицировать программу-сервер.
Спустя какое-то время
программа-сервер может стать
исключительно большой. Для того
чтобы исключить такую модификацию
сервера, разработчики используют
CGI. Используя CGI-скрипты, сервер
может переложить задачу создания
линамических Web-документов на
прикладную программу, созданную
для этих специфических
потребностей. Вы будете создавать
вашу прикладную программу,
используя C/C++, Perl, JavaScript, VBScript, или
какой-либо другой язык
программирования.

Программа-сервер
должна вызвать CGI-скрипт

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

Броузер, сервер и
CGI

Как
известно, для получения броузером
HTML-документов, он сначала
устанавливает контакт с сервером,
затем запрашивает документ ( обычно
ваш броузер определяет GET-метод
HTTP для получения информации от
сервера ). Далее, если документ
существует, сервер отвечает
броузеру, посылая ему HTML-документ, и
затем закрывает соединение.
Применение CGI-скриптов вносит
изменения в этот процесс только на
стороне сервера. Броузер не знает,
что сервер вызывает CGI-скрипт, и он
не заботится о том, каким именно
способом поступают к нему данные от
сервера. Как Web-программист, при
написании CGI-скриптов вы заботитесь
только о входах и выходах сервера.
Броузер будет устанавливать
контакт с программой сервера,
которая, в свою очередь, исполняет
CGI-скрипт. Ваш скрипт, в свою
очередь, выполняет необходимую
обработку данных, чтобы
сформатировать требуемый выход.
Обычно ваш сервер передает
выходные данные из скрипта в форме
HTML-броузеру. Чтобы выполнить это,
верверная программа добавляет
необходимую заголовочную
информацию к выходным данным,
сформированным скриптом, и
посылает эту заголовочную
информацию вместе с данными
обратно броузеру. Затем сервер
закрывает соединение и ждет новых
запросов.

Как вы,
возможно, знаете, серверы, которые
работают под 32-битными
операционными системами, такими
как Windows 95/98 или
Windows NT, могут
обрабатывать запросы от многих
пользователей одновременно. Отсюда
следуте, что несколько
пользователей могут одновременно
использовать скрипт. Поэтому
каждый из них, в зависимости от
запроса, будет видетьь свою картину
ответа сервера.

Взаимосвязь
сервера и CGI-скрипта

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

Как вы
уже знаете, HTTP является протоколом,
с помощью которого клиенты и
серверы Web обеспечиваются
информацией. Заголовочная HTTP
информация помогает программам
эффективно выполнять обмен
данными. Поэтому необходимо
уделить особое внимание
заголовочной информации, которой
сервер снабжает броузер. Например,
когда программа-сервер готова
послать данные броузеру, она
посылает заголовки, описывающие
статус данных, тип данных и т.д. В
свою очередь броузер использует
заголовок ( Content-type
) для подготовки к выводу данных на
экран. Сервер отвечает за то, чтобы
обеспечить этой метаинформацией
броузер каждый раз, когда он
посылает ему данные.

CGI т базы данных

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

Где находятся
скрипты

Стандарты
CGI не предписывают, куда должны
помещаться скрипты, то есть не
определяют заранее диск и каталог.
Обычно Web-сервер ожидает найти
скрипты в каталоге /CGI-BIN,
который расположен
нажи каталога самой программы
сервера. Если вы помещаете свои
скрипты на чей-то сервер,
необходимо определить каталог для
своих файлов, содержащих скрипты.

Расширение имен
файлов CGI-скриптов

Серверы
HTTP для Windows-систем обычно для
CGI-файлов используют расшерение EXE
или PL. Например, если вы создаете
CGI-программу ( скрипт ), используя
язык программирования С, то
расширение ваших файлов-скриптов
будет, вероятно, ЕХЕ. Аналогично,
если вы создаете скрипт с помощью
языка Perl, расширение ваших файлов
будет PL.

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

Основы
взаимодействия между Web-сервером и
CGI-скриптом

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

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

Переменные
окружения

Переменная AUTH_TYPE

Скрипты
CGI используют переменную окружения AUTH_TYPE
для идентификации
пользователя, который пытается
получить доступ к скрипту. Если
сервер сконфигурирован так, чтобы
поддерживать идентификацию
пользователя, то пользователь,
пытающийся получить доступ к
скрипту, должен назвать свое имя и
пароль. Например, следующее
значение переменной означет, что от
пользователя требуется основной
уровень идентификации:

AUTH_TYPE = Basic

Переменная
CONTENT_LENGTH

Скрипты
используют переменную окружения CONTENT_LENGTH
для того, чтобы
определить точное число байт,
содержащихся в просоединенных
данных. Например, если запрос
содержит документ длиной в 1,024
байта, то переменной окружения
присваивается следующее значение:

CONTENT_LENGTH = 1024

Переменная
CONTENT_TYPE

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

CONTENT_TYPE = text/html

Переменная GATEWAY_INTERFACE

Скрипты
используют эту переменную для того,
чтобы определить версию, номер
выпуска спецификации CGI, которой
удовлетворяет Web-сервер. Формат
номера выпуска спецификации
следующий: CGI/номер выпуска.
Например, для CGI выпуска 1.1
переменная окружения будет иметь
следующий вид:

GATEWAY_INTERFACE = CGI/1.1

Переменная PATH_INFO

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

Путь
записывается в относительной
форме, где за базу
берется корневой каталог сервера.
Иными словами, корневой каталог
сервера является базисом для
относительного пути, который и
присваивается переменной PATH_INFO.
Например, если задан путь c:/cgi-bin/example1.exe/sports.html,
то переменная
окружения будет иметь следующий
вид:

PATH_INFO = /sports.html

Переменная PATH_TRANSLATED

Скрипты
используют эту переменную для
получения окончательной, пригодной
для непосредственного
использования информации
относительно пути. Сервер
переводит информацию переменной
путем выполнения необходимых
преобразований пути. Например, если
переменная PATH_TRANSLATED имеет
значение /sports.html, а
корневым дирикторием сервера
служит c:, то
переменная окружения будет иметь
следующее значение:

PATH_TRANSLATED = c:sports.html

Переменная QUERY_STIRNG

Скрипты
используют эту переменную для того,
чтобы получить информацию в
текстовой форме ( состоящую из
аргументов ), которая следует
справа от знака вопроса после URL,
переданного от пользователя
скрипту для обработки. Эта
текстовая сторока содежит вход для
скрипта. Далее сервер заменяет в
данном тексте каждый пробел на знак
» + «, а все непечатные символы
знаком » %dd», где d
является базой десятичной системы
счисления.

Скрипт
должен содержать код для
расшифровки этой текстовой строки.
Сервер, передавая эту информацию
скрипту, не должен заниматься
декодированием информации запроса
каким-либо образом. Сервер должен
также установить переменную QUERY_STRING
в случае, если пользователь
обеспечивает какую-то информацию
запроса. Например, для URL http://www.jamsa.com/cgi-bin/grandma.exe?name=margaret+alarcon
переменная окружения
имеет значением следующую
величину:

QUERY_STRING = name=margaret+alarcon

Переменная REMOTE_ADDR

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

REMOTE_ADDR = 204.212.52.209

Переменная REMOTE_HOST

Скрипты
используют эту переменную для того,
чтобы получить имя узла, с которого
делается запрос. Если сервер не
знает имя узла, делающего запрос, то
сервер должен присвоить значение
переменной окружения REMOTE_ADDR
и не присваивать
значения переменной REMOTE_HOST
. Напрмиер, для узла jamsa.com переменная окружения
будет содержать следующее
значение:

REMOTE_HOST = jamsa.com

Переменная REMOTE_IDENT

Используется
для того, чтобы получиь имя
удаленного пользователя, делающего
запрос к серверу. Программа
Web-сервера представляет собой
программное обеспечение.
вызывающее ваш скрипт. Если HTTP
Web-сервер поддерживает протокол RFS
931 (Authentication Server Protocol), то сервер
установит эту переменную равной
значению имени пользователя,
которое имеется у сервера. Скрипты
могут использовать эту переменную
только для регестрации
пользователя. Напрмер, если имя
удаленного пользователя pschmauder и
он назодится на удаленном узле jamsa.com ,
то переменная примет следующее
значение:

REMOTE_IDENT = pschmauder.www.jamsa.com

Переменная REMOTE_USER

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

REMOTE_USER = pschmauder

Переменная REQUEST_METHOD

Используется
для того, чтобы определить тип
HTTP-запроса, который послан
броузером серверу и служит для
вызова скриптов. Эта переменная
может принимать значения GET,
HEAD или POST. Например,
если броузер посылает GET-метод,
то переменная окружения содержит
следующее:

REQUEST_METHOD = GET

Переменная SCRIPT_NAME

Используется
для того, чтобы определить
виртуальный путь к скрипту, который
будет запущен сервером. Например,
если имеется URL http://www.jamsa.com/cgi-bin/someprog.exe, то переменная
окружения примет следующее
значение:

SCRIPT_NAME = cgi-bin/example1.exe

Переменная SERVER_NAME

Использутся
для того, чтобы определитьимя
домена ли IP-адрес комрьютера, на
котором раположен Web-сервер.
Например, когда сервер возвращает
IP-адрес, переменная окружения будет
иметь вид, подобный следующему:

SERVER_NAME = 204.212.52.209

Переменная SERVER_PORT

Используется
для того, чтобы определить номер
порта, который пользователь
(броузер) использует для связи с
Web-сервером. Если используется
HTTP-порт по умолчанию, то эта
величина равна 80. Если используется
какой-то другой порт, например, http://www.jamsa.com:3000, то переменная
принимает следующее значение:

SERVER_PORT = 3000

Переменная SERVER_PROTOCOL

Используется
для того, чтобы определить имя и
номер выпуска протокола,
используемогоклиентом (броузером)
для того, чтобы послать запрос к
Web-серверу. Анализируя содержание
переменной, скрипт может
идентифицировать имя и номер
выпуска протокола, который он
должен использовать при передаче
данных серверу. Формат имени
протокола и номера выпуска
следующий: протокол/номер выпуска.
Например, для HTTP 1.1 переменная
окружения будет иметь следующий
вид:

SERVER_PROTOCOL = HTTP/1.1

Переменная SERVER_SOFTWARE

Как вы
знаете, Web-сервер исполняет скрипты
CGI. Поскольку скрипт может
испольняться по-разному для
различных серверных программ,
скрипты используют эту переменную
для того, чтобы определить имя
программы Web-сервера и ее номер
версии. Формат имени Web-сервера и
номер версии должен передаваться CGI
следующим образом: имя/версия.
Например, для FOLK WEB — сервера
версии 1.01 переменная окружения
будет иметь седующий вид:

SERVER_SOFTWARE = FolkWeb/1.01 (Windows-32bit)

Дополнительные
переменные окружения

В дополнение к
переменным окружения.
обсуждавшимся ранее, сервер также
помещает данные из заголовка
запроса, полученного от клиента, в
переменные окружения. Сервер
присваивает значения переменным,
чьи имена начинаются с префикса HTTP_,
после которого идет имя заголовка.
Сервер заменяет все символы
переноса (-) в заголовке на (_). Сервер
может также исключать любые
заголовки, которые он уже
обработал, используя переменные
окружения, такие как AUTH_TYPE,
CONTENT_TYPE и CONTENT_LENGTH.

Переменная HTTP_ACCEPT

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

HTTP_ACCEPT = audio/aif, text/html, text/plain

Переменная HTTP_USER_AGENT

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

HTTP_USER_AGENT = Mozilla/2.01 Gold(Win95PE)

Опции командной
строки CGI

Обычно
CGI-скрипты используют командную
строку в качестве входа
для того, чтобы выполнить запрос ISINDEX,
позволяющий добавить
интерактивный поиск по ключевому
слову к вашему HTML-документы. Однако
не все серверные программы
поддерживают ISINDEX-запрос.
Броузер посылает запрос в виду
командкной строки серверу.
Программа сервера может
идентифицировать входную
командную строку, устанавливая,
использовал ли броузер GET-метод
HTTP и содержит ли строка URL символы uuencoded =.

Если
броузер использует GET-метод
HTTP и строка URL-поиска не содержит
символы uuencoded
=, то
запрос осуществляется в форме
командной строки. Перед тем как
сервер вызовет соответствующий
скрипт, серверная программа должна
расщепить командную строку,
используя знак (+), для отделения
параметров. Затем сервер выполняет
дополнительное декодирование (
если необходимо ) каждого
параметра, переданного в URL-строке
поиска, и хранит каждый
параметр-строку в массиве,
названную argv.

Дополнительное
декодирование, выполняемое
сервером, состоит в разделении
отдельных строк, используя
амперсанда (&) в качестве
разделителя. Далее сервер
расщепляет каждую из этих строк
снова, используя знак (=) для того,
чтобы отделить имя переменной,
которое ставиться слева от знака (=),
от значения переменной, которое
стоит справа от (=). Сервер хранит
число элементов, содержащихся в
массиве argv, в переменной целого
типа argс.

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

Стандартный
ввод ( STDIN )

Когда броузер
запрашивает сервер ( например,
используя HTTP-метод POST ),
информация, которую получает
скрипт, приходит со стандартного
дескриптора ввода stdin. Серверная
программа посылает скрипту
переменную окружения CONTENT_LENGTH.
Эта переменная
содержит число байт, которое сервер
посылает скрипту через этот
дескриптор. Скрипт может
использовать значение переменной CONTENT_LENGTH
для того, чтобы
определить, сколько данных должно
поступить со стандартного ввода.
Сервер также снабжает скрипт
переменной окружения CONTENT_TYPE,
которая помогает скрипту
определить, как обрабатывать
получаемые данные. В конце этого
потока данных сервер может послать
( а может и не посылать ) маркер
конца файла. Однако именно скрипт
обязан определить, какой объем
данных читать, и использует он для
этого переменную окружения CONTENT_LENGTH.

Например, если форму
использует HTTP-метод POST (
<form method =
«POST»> ) и посланные
серверу данные закодированы
следующим образом: name=alberta&husband=art,
то сервер присвоит переменным
CONTENT_LENGHT и CONTENT_TYPEследующие
значения:

CONTENT_LENGHT = 24
CONTENT_TYPE = APPLICATION/x-www-form-urlencoded

Стандартный
вывод (STDOUT)

После
того как CGI-скрипт закончит
обрабатывать полученные от сервера
данные, он должен посылать свой
ответ серверу. Для того, чтобы
послать свои данные серверу, он
должен посылать их файловому
дескриптору стандартного выводы STDOUT.
В общем случае данные, которые
скрипт посылает назад серверу,
представляет собой HTTP-ответ,
включающий заголовок, после
которого идет пустая строка и за
ней остальная часть ответа. Обычно
выходом скрипта служат документы
HTML, созданные скриптом.

Прямой ответ
скрипта броузеру

Обычно скрипт выдает
ответ, который сервер
интерпретирует и посылает назад
броузеру. Преимуществом посылки
выходных данных от скрипта серверу
служит то, что скрипт в таком случае
не обязан посылать полный
заголовок HTTP на каждый запрос.
Однако некоторые скрипты
разгружают сервер и шлют свои
выходные данные прямо броузеру. Для
того, чтобы можно было отличить
такие скрипты, которые шлют данные
непосредственно броузеру, от
скриптов, которые направляют их
серверу, протокол CGI требует, чтобы
имена скриптов, осуществляющих
прямую посылку броузеру,
начинались с букв nph-
( которые
говорят серверу Not to Parse
the Header — не
инициализировать заголовок ). Если
имя скрипта начинается так, то
сервер не будет вставлять
заголовок в данные скрипта. В таком
случае ответственность
возлагается на сам скрипт.

Заголовки
CGI

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

• CONTENT-TYPE
• LOCATION
• STATUS

Поле Content-type
в заголовке CGI
определяет тип/расширение
MIME-данных, которые скрипт посылает
назад броузеру. Обычно скрипты
выдают на выходе документ HTML. В этом
случае заголовок CGI Content-type
содержит следующее:

Content-type: text/html

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

Location: htpp://www.cetis.ru

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

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

Content-type: text/html 
<! Blank line follows >
<html>
<head>
<title>
This is the title
</title>
</head>
<body>
This is body generated by your CGI script.
</body>
</html>

Обратите
внимание на пустую строку меду
первыми строками. Эта пустая строка
абсолютно необходима. Следующий
фрагмент кода на языке С создает
записанный выше документ с
использованием функции printf:

// More code above:
printf("Content-type: text/htmln");
printf("n"); // Make sure to include this blank line
printf("<html>n");
printf("<head>n");
printf("<title>This is the title</title>n");
printf("</head>n");
printf("<body>n");
printf("This is the body generated by your CGI script.n");
printf("</body>n");
printf("</html>n");
// More code bellow...

Разработчики сайтов и администраторы нередко сталкиваются со скриптами CGI (микросценариями обработки текстовых данных). Они применяются при создании интерактивных страниц, содержание которых зависит от действий пользователя. Например, это могут быть формы регистрации или отправки комментариев. Также есть «невидимая» область применения – сбор и обработка информации о посетителях при помощи файлов cookies.

Что такое CGI и PERL

Важно понимать, что CGI – не язык программирования, а протокол передачи данных веб-серверу через stdin и их прием из stdout. В качестве обработчика команд используется любая программа с поддержкой функций потокового ввода-вывода. Например, написанная на языке Perl. Главное, что от скрипта требуется «умение» заполнять таблицы в базе данных и получать данные из них путем подачи запроса, чего никогда не сделать средствами HTML.

Особенности применения языка Perl:

1. Подходит для парсинга текстовых данных в справочных системах.
2. Он удобен при обработке массивов непонятных данных в БД веб-ресурсов.
3. Требуется вывод информации на экран, в файл или график на сайте.

В качестве альтернативы Perl все чаще применяется язык программирования Python, но администраторы «старой закалки» продолжают придерживаться классики создания CGI-скриптов, так как поддержка Perl «по умолчанию» имеется в большинстве дистрибутивов Linux. Поэтому программы на нем начинают работать без предварительной подготовки сервера. Формально же скрипты можно писать на чем угодно – хоть на C/C++, Pascal, Java или Visual Basic.

Использование готовых скриптов

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

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

1. Perl – /usr/bin/perl.
2. Python – /usr/local/bin/python.

Если здесь допустить ошибку, программный код исполнятся не будет. То же происходит, если в ПО предусмотрено обращение к базе данных MySQL – пользователю понадобится внести в программу путь к ней, логин и пароль доступа. При изменении последнего корректировка CGI-скрипта обязательна, иначе он перестанет работать. Местоположение файлов в популярных CMS выясняется в службе технической поддержки или в служебной документации.

Написание простейшего CGI-скрипта

При работе в среде операционной системы Windows для написания кода понадобится специальная программа. Например, подойдет специализированный текстовый редактор Notepad++ (стандартный Блокнот для таких целей не подходит). Сам код строится вокруг переменных окружения и потоков ввода-вывода информации. По сути, CGI-скрипты являются обработчиками отдельных команд и не являются «полноценной» программой.

Более детально:

1. Стандартный поток ввода (stdin) – скрипт получает информацию с клавиатуры, сокета, из локального (удаленного) файла или из результатов работы основной программы.
2. Переменные окружения (Environment Variables) – переменные, требуемые при выполнении кода скрипта. Определяются пользователем или сервером.
3. Стандартный поток вывода (stdout) – означает вывод на экран результатов вычислений или их сохранение в файл, передача в сокет, входной поток другой программы или на принтер.

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

#!/bin/sh

 echo Content-type: text/html

 echo

 echo "<h2>Today is "

 date

 echo "</h2>"

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

<a href="/cgi-bin/examples/today.cgi">

В приведенном примере решена типовая ошибка новичков. Она заключается в отсутствии метки о типе выводимого результата (строка Content-type: text/html). После нее располагается пустая строка для указания, что следом идет непосредственно программный код.

Просмотр установленных модулей PERL

Проверить ранее подключенные PERL-модули можно командой vim. Перед ее вводом необходимо подключиться к серверу хостинга по защищенному каналу SSH. После авторизации нужно ввести в консоли:

vim modules.pl

В результате будет создан файл с указанным названием. Следующий шаг – открыть его в текстовом редакторе и изменить содержимое на следующий код:

#!/usr/bin/perl -w

                use ExtUtils::Installed;


                $installed = ExtUtils::Installed->new();

                foreach $module ($installed->modules()){

                   printf "Module: %sttVersion: %sn", $module, $installed->version($module);

                }

Выйти из файла с сохранением и запустить его на исполнение можно командой perl ./modules.pl. Процедура по поиску подключенных CGI-скриптов востребована, еслина сайте возникают ошибки 403 или 500. Первая появляется из-за некорректной настройки прав доступа (необходимо установить на файлах скриптов доступ 755), вторая же происходит из-за сбоя транслятора Perl или из-за синтаксической/логической ошибки в самом коде. В любом случае сначала нужно убедиться в том, что скрипт подключен.

Статья гуляет в интернете уже довольно давно, но, как автор думаю имею право на ее перепост здесь. Многое (если не все) написаное здесь устарело, и может показаться бесполезным с первого взгляда, однако пройдя этот путь, спустя 6 лет могу сказать, это не оказалось лишним. Итак.
В этой статье я хочу рассказать о CGI интерфейсе вообще, его реализации для windows и использовании при написании CGI-программ языка ассемблер в частности. В рамки этой статьи не входит полное описание CGI, так-как в Интернете материала по этому вопросу просто море и пересказывать все это здесь я просто не вижу смысла.

Теория CGI

CGI – (Common Gateway Interface) – Общий Шлюзовый Интерфейс. Как не трудно догадаться интерфейс этот служит шлюзом между сервером (здесь я подразумеваю программу — сервер) и какой-либо внешней программой написанной для ОС на которой этот самый сервер запущен. Таким образом CGI отвечает за то, каким именно образом данные будут переданы от программы-сервера к CGI-программе и обратно. Интерфейс не накладывает никаких ограничений на то, на чем должна быть написана CGI-программа, это может быть как обычный исполнимый файл, так и любой другой файл – главное, чтобы сервер смог его запустить (в среде windows это например может быть файл с расширением, привязанным к какой-либо программе).
С момента когда Вы вызвали (например нажали кнопку формы, к которой привязан вызов CGI-программы) CGI-программу до получения вами результата в окно браузера происходит следующее:
— Вэб-клиент (например браузер) создает подключение к серверу, указанному в URL;
— Вэб-клиент посылает запрос серверу, запрос этот обычно делается с помощью двух методов GET или POST;
— Данные из запроса клиента (например значения полей формы) передаются сервером, используя CGI-интерфейс, CGI-программе, указанной в URL;
— CGI-программа обрабатывает данные клиента, полученные от сервера и генерирует на основе этой обработки ответ клиенту, который она передает по все тому же CGI-интерфейсу серверу, а он в свою очередь передает его уже непосредственно клиенту;
— Сервер разрывает соединение с клиентом.
В стандартной спецификации CGI принято, что сервер может обмениваться с программой следующими способами:
— Переменные окружения – они могут быть установлены сервером при запуске программы;
— Стандартный поток ввода (STDIN) – с его помощью сервер может передать данные программе;
— Стандартный поток вывода (STDOUT) – программа может писать в него свой вывод, передающийся серверу;
— Командная строка – в ней сервер может передать некоторые параметры программе.
Стандартные потоки ввода/вывода весьма удобны и широко используются на UNIX-системах, чего не скажешь о windows, поэтому существует спецификация CGI, разработанная специально для windows-систем так и называемая «Windows CGI». Но, естественно, и стандартные потоки ввода/вывода так же можно использовать в windows CGI программировании. Здесь я не буду затрагивать стандарт «Windows CGI», и на это существует по крайней мере две причины – первая, и самая главная – на данный момент не все http-сервера под windows поддерживают эту спецификацию (в частности мой любимый Apache 1.3.19). Вторую причину вы можете наблюдать набрав в любой поисковой системе строчку «Windows CGI». Отмечу относительно этого интерфейса лишь общие детали – все данные от сервера к клиенту передаются посредством обычного для windows *.ini файла, имя которого передается программе в командной строке. При этом все данные в файле уже заботливо разбиты по секциям сервером и вам лишь остается используя функции «GetPrivateProfile*» извлечь их оттуда. Ответ серверу передается опять же посредством файла, имя которого указано в соответствующей записи ini-файла.
Какие же данные могут быть переданы клиентом CGI-программе? – практически любые. В общем случае программе передаются значения полей формы, которые заполняет клиент, но это также могут быть и какие-либо двоичные данные, например файл с картинкой или музыкой. Данные могут быть переданы на сервер двумя различными методами – это метод GET и метод POST. Когда мы создаем форму для заполнения на нашей страничке мы явно указываем каким из приведенных методов мы хотим отправить введенные пользователем данные, делается это в основном тэге формы примерно так:
При отправке данных методом GET, данные браузером считываются из формы и помещаются следом за URL скрипта, за знаком вопроса, если значимых полей в форме несколько, то они передаются все через значёк «&», имя поля и его значение пишутся в URL через знак «=». Например запрос, сгенерированный браузером из формы при нажатии на кнопку, к которой привязан скрипт «/cgi-bin/test.exe», при учете что первое поле формы называется «your_name», второе – «your_age», может выглядеть так:
GET /cgi-bin/test.exe?your_name=Pupkin&your_age=90 HTTP/1.0
Использование метода GET имеет сразу несколько слабых сторон – первое и самое главное – т.к. данные передаются в URL то он имеет ограничение на количество этих самых передаваемых данных. Вторая слабость опять же вытекает из URL – это конфиденциальность, при такой передаче данные остаются абсолютно открытыми. Итак, хорошо если у нас в форме 2-3 небольших поля… встает вопрос что же делать если данных больше? Ответ – использовать метод POST!
При использовании метода POST данные передаются серверу как блок данных, а не в URL, что несколько развязывает нам руки для увеличения объема передаваемой информации, для вышеприведенного примера формы POST блок, посылаемый серверу будет примерно такой:

POST /cgi-bin/test.exe HTTP/1.0
Accept: text/plain
Accept: text/html
Accept: */*
Content-type: application/x-www-form-urlencoded
Content-length: 36
your_name=Pupkin&your_age=90

Как уже говорилось выше, после получения данных сервер должен преобразовать их и передать CGI программе. В стандартной спецификации CGI введенные клиентом данные при запросе GET помещаются сервером в переменную среды программы «QUERY_STRING». При запросе POST данные помещаются в стандартный поток ввода приложения, откуда могут быть им считаны. Кроме того, при таком запросе сервером устанавливаются еще две переменные среды — CONTENT_LENGTH и CONTENT_TYPE, по которым можно судить о длине запроса в байтах и о его содержании.
Помимо самих данных сервером устанавливаются и другие переменные окружения вызываемой программы, приведу некоторые из них:

REQUEST_METHOD
Описывает каким именно методом получены данные
Пример:REQUEST_METHOD=GET

QUERY_STRING
Строка запроса, если использовался метод GET
Пример:QUERY_STRING= your_name=Pupkin&your_age=90&hobby=asm

CONTENT_LENGTH
Длина в байтах тела запроса
Пример:CONTENT_LENGTH=31

CONTENT_TYPE
Тип тела запроса

GATEWAY_INTERFACE
Версия протокола CGI
Пример:GATEWAY_INTERFACE=CGI/1.1

REMOTE_ADDR
IP-Адрес удаленного хоста, то бишь клиента, нажавшего кнопочку в форме
Пример:REMOTE_ADDR=10.21.23.10

REMOTE_HOST
Имя удаленного хоста, это может быть его доменное имя или например имя компьютера в среде Windows, если таковые получены быть не могут, то поле содержит его IP
Пример:REMOTE_HOST=wasm.ru

SCRIPT_NAME
Имя скрипта, использованное в запросе.
Пример:SCRIPT_NAME=/cgi-bin/gols.pl

SCRIPT_FILENAME
Имя файла скрипта на сервере.
Пример:SCRIPT_FILENAME=c:/page/cgi-bin/gols.pl

SERVER_SOFTWARE
Программное обеспечение сервера
Пример:Apache/1.3.19 (WIN32)
Вызываемая CGI-программа может прочитать любую из переменных своего окружения, установленных сервером и использовать ее в своих интересах.
В общем-то это вкратце все, для получения более подробной информации о Общем Шлюзовом Интерфейсе смотрите специализированную документацию, это описание я сделал для того, чтобы напомнить вам, а если не знали то ввести в курс дела. Давайте попробуем что-нибудь сделать на практике.

Практическая часть

Для практики нам понадобятся как минимум 3 вещи – какой-нибудь http-сервер для Windows, все примеры я пробовал на Apache 1.3.19 для Windows, сервер бесплатный, скачать его можно с i
Да, и сервер нам понадобится не абы – какой, а настроенный для запуска cgi-скриптов! Как это делается для сервера используемого вами смотрите документацию. Вторая вещь, которая нам понадобится это, естественно, ассемблер, так же необходимо, чтобы компилятор поддерживал создание консольных WIN32 приложений, я использую Tasm, но прекрасно подойдут и Fasm и Masm и множество других *asm’ов. Ну и наконец самое главное, что потребуется это желание.
Итак, я допускаю, что сервер был вами благополучно поставлен и настроен, так, что в корневой директории документов сервера лежит файлик index.html, который замечательно показывается в браузере, когда вы набираете адрес 127.0.0.1. Так же я учту, что где-то в дебрях папок сервера существует папочка «cgi-bin», в которой разрешен запуск скриптов.
Давайте проверим настройку сервера, а заодно и напишем небольшой скрипт. Скрипт наш будет обычным *.bat файлом. Предвижу вопросы – как? неужели? Да, это обычный командный файл, как уже говорилось выше спецификация CGI не делает различий между типами файлов, главное, чтобы сервер мог его запустить, а он в свою очередь, имел доступ к stdin/stdout и переменным окружения, bat-файл, пусть и не в полной мере, но для примера нас вполне устроит. Создадим файл примерно такого содержания:

@echo off
rem Заголовок апроса
echo Content-type: text/html
echo.
rem Тело запроса
echo "Привет!<br>
echo "С запросом GET пришли данные: %QUERY_STRING%

Файл назовем test.bat и поместим его в директорию для запуска скриптов, скорее всего это будет директория «cgi-bin». Следующее, что нам нужно будет сделать, это каким либо образом вызвать этот скрипт, в принципе, сделать это можно напрямую набрав в окошке адреса браузера примерно следующее «http://127.0.0.1/cgi-bin/test.bat», но давайте сделаем его вызов с нашей главной странички, заодно проверим работу метода GET. Создадим в корне сервера файл index.html со следующим содержанием:

<html><head>
<meta content="text/html; charset=windows-1251" http-equiv=Content-Type>
</head>
<form name="Test" method=get action="/cgi-bin/test.bat">
<center><table border=1 cellspacing=0>
<tr bgcolor="#e0e0e0"><td colspan=2><font face=arial size=2>
<center><b>Введите данные для передачи серверу:</b></center>
</font></td></tr>
<tr><td><font face=arial size=2>
<b>Данные:</b></font></td>
<td><font face=arial size=2>
<textarea rows="3" cols="55" warp="physical" name="data"></textarea>
</font></td></tr><tr bgcolor="#e0e0e0">
<td colspan=2><center>
<input type="submit" value="Послать!">
</center></td>
</tr></table></center></form></body></html>

Теперь при входе на сервер (http://127.0.0.1 в строке адреса браузера) должна появиться форма, наберите в ней что-нибудь и нажмите кнопку «послать», если все было сделано правильно, Вы увидите в окне браузера ответ нашего bat-скрипта. Теперь давайте посмотрим что же мы там намутили.
Как можно догадаться команда «echo» осуществляет вывод в stdout, первым делом мы передаем серверу заголовок нашего ответа – «echo Content-type: text/html». Это есть стандартный заголовок спецификации CGI, говорящий о том, что передавать мы хотим текст или документ html, существуют и другие заголовки. Очень важный момент – заголовок должен отделяться от тела ответа пустой строкой, что мы и делаем следующей командой «echo.». Дальше передается тело самого ответа – это обычный html-документ, в теле документа я для наглядности отображая одну из переменных среды, переданной нам сервером – «QUERY_STRING», как уже говорилось при методе GET (а это именно наш случай) в этой переменной передаются все введенные пользователем данные, что мы и можем наблюдать в ответе скрипта. Вы могли заметить «кавычки не к месту» в последних 2-х строках файла, сразу после «echo», стоят они там из-за специфичности bat-файлов, как можно заметить тэги html обрамляются символами «<» и «>», в тоже время эти символы служат перенаправлением ввода/вывода в bat-файлах, а посему мы не можем их здесь свободно использовать.
Рекомендую немного побаловаться с подобными bat-скриптами, это бывает очень полезно, попробуйте посмотреть другие переменные окружения. Немного скажу, отступив от темы, на UNIX-системах языки командных интерпретаторов очень сильно развиты и грань между программированием на языке командного интерпретатора и программированием на «реальном» языке программирования весьма и весьма размыта в некоторых случаях, поэтому на UNIX-системах частенько простенькие скрипты пишутся именно на языках командных интерпретаторов, но windows-интерпретатор cmd.exe или, ранее, command.com явно слабоваты для этих целей.
Теперь перейдем к самой главной задаче этой статьи, к собственно написанию CGI-программы на ассемблере. В принципе, если учесть все вышесказанное о CGI мы можем сделать вывод о том, что требует CGI-интерфейс от нашей программы:

• Программа должна уметь читать стандартный поток ввода (stdin), чтобы получить доступ к данным, переданным методом POST;
• Программа должна уметь писать в стандартный поток вывода (stdout), чтобы передать результат своей работы серверу;
• Из первых двух пунктов следует, то, что для того, чтобы сервер мог передать нашей программе что-либо в stdin, а она могла ему что-либо ответить в stdout CGI-программа должна быть консольным приложением;
• Наша программа должна уметь читать переменные своего окружения.

Этого вполне достаточно для создания полноценного CGI-приложения.
Начнем с последнего пункта. Для получения доступа к переменным окружения Windows-приложения используется функция API «GetEnvironmentStrings», функция не имеет аргументов и возвращает указатель на массив переменных окружения (ИМЯ=ЗНАЧЕНИЕ) разделенных между собой нулем, массив закрывается двойным нулем, при запуске программы сервером в окружение программы помимо стандартных переменных добавляются специфические CGI-переменные, описанные выше, при запуске программы из командной строки вы их не увидите, естественно.
Для того, что бы писать что-то в stdout или читать из stdin сначала мы должны получить хэндлы этих потоков, делается это с помощью функции API «GetStdHandle», в качестве параметра функции передается одно из следующих значений:

• STD_INPUT_HANDLE — для stdin (стандартный ввод);
• STD_OUTPUT_HANDLE — для stdout (стандартный вывод);
• STD_ERROR_HANDLE — для stderr.

Функция возвратит необходимый нам для операций чтения/записи хэндл. Следующее что нам необходимо делать это писать/читать эти потоки. Делается это обычными операциями чтения/записи файлов, т.е. ReadFile и WriteFile. Тут есть одна тонкость, можно подумать, что для этих целей можно использовать WriteConsole/ReadConsole, да это действительно справедливо для консоли и будет прекрасно работать, результаты, так же как и с WriteFile будут выводиться на консоль, но продолжаться это будет пока мы не запустим нашу программу как скрипт на сервере. Происходит это потому что, когда нашу программу запускает сервер хндлы, возвращаемые функцией «GetStdHandle» уже не будут хндлами консоли как таковыми, они будут хэндлами pipe, что необходимо для связи двух приложений.
Вот небольшой пример того, как должна выглядеть CGI-программа на ассемблере:

.386
.model flat,stdcall
includelib import32.lib
.const
PAGE_READWRITE = 4h
MEM_COMMIT = 1000h
MEM_RESERVE = 2000h
STD_INPUT_HANDLE = -10
STD_OUTPUT_HANDLE = -11

.data
hStdout dd ?
hStdin dd ?
hMem dd ?
header:
db 'Content-Type: text/html',13,10,13,10,0
start_html:
db 'Окружение CGI-программы выглядит так:<br>',13,10,0
for_stdin:
db 'STDIN программы содержит:<br>',13,10,0
end_html:

db '',13,10,0
nwritten dd ?
toscr db 10 dup (32)
db ' - Тип файла',0
.code
_start:

xor ebx,ebx
call GetStdHandle,STD_OUTPUT_HANDLE
mov hStdout,eax
call GetStdHandle,STD_INPUT_HANDLE
mov hStdin,eax

call write_stdout, offset header
call write_stdout, offset start_html

call VirtualAlloc,ebx,1000,MEM_COMMIT+MEM_RESERVE,PAGE_READWRITE
mov hMem,eax
mov edi,eax
call GetEnvironmentStringsA
mov esi,eax
next_symbol:
mov al,[esi]
or al,al
jz end_string
mov [edi],al
next_string:
cmpsb
jmp short next_symbol
end_string:
mov [edi],'>rb<'
add edi,3
cmp byte ptr [esi+1],0
jnz next_string
inc edi
stosb
call write_stdout, hMem
call write_stdout, offset for_stdin

call GetFileSize,[hStdin],ebx
mov edi,hMem
call ReadFile,[hStdin],edi, eax,offset nwritten, ebx
add edi,[nwritten]
mov byte ptr [edi],0
call write_stdout, hMem
call write_stdout, offset end_html
call VirtualFree,hMem
call ExitProcess,-1

write_stdout proc bufOffs:dword
call lstrlen,bufOffs
call WriteFile,[hStdout],bufOffs,eax,offset nwritten,0
ret
write_stdout endp
extrn GetEnvironmentStringsA:near
extrn GetStdHandle:near
extrn ReadFile:near
extrn WriteFile:near
extrn GetFileSize:near
extrn VirtualAlloc:near
extrn VirtualFree:near
extrn ExitProcess:near
extrn lstrlen:near
ends
end _start

Исполняемый файл строится командами:
tasm32.exe /ml test.asm
tlink32.exe /Tpe /ap /o test.obj
Не забудьте, что программа должна быть консольной.
Вызывать эту программу можно используя вышеописанную html-форму, нужно только поменять имя test.bat в форме на test.exe и скопировать его в /cgi-bin/ соответственно, при том можно выставить в методе запроса POST, программа его обрабатывает.
Еще хочу отметить, что можно вызывать программу и по-другому, можно создать в каталоге cgi-bin файл например test.cgi с одной единственной строчкой «#!c:/_путь_/test.exe» и вызывать в запросах его, а сервер в свою очередь будет читать первую его строчку и запускать exe-файл, для этого необходимо, чтобы в настройках http-сервера было прописано расширение *.cgi как расширение для скриптов. При таком подходе сервер запустит нашу программу с командной строкой «test.exe путь_к_test.exe» это имеет несколько плюсов – первое, это то, что человек, запускающий наш скрипт не будет даже догадываться на чем скрипт написан, второе – так-как нам передается имя файла с нашей строчкой мы можем например дописать в этот файл какие-либо настройки для нашего скрипта, что упрощает отладку, кстати именно так работают все интерпретаторы – вы успели заметить, что во всех perl/php/итд программах, присутствует подобная строка – указывающая на сам командный интерпретатор. Так вот сервер при запуске cgi-программы, если расширение программы прописано у него как скрипт в настройках читает первую строку файла, и если она оказывается описанного выше формата, то запускает указанную в строчке программу с именем этого файла ч/з пробел, допустим что в строчке указан интерпретатор перла, он получив такой подарок начинает его выполнение, т.к. комментарий в перле это символ «#», то первую строчку он пропускает и идет дальнейшее выполнение скрипта, в общем штука удобная.