Common Gateway Interface (CGI). Hvorfor nettsteder bruker CGI

Når en bruker fyller ut et html-skjema og klikker på send, sendes dataene til webserveren. Nettserveren, enten det er Apache, IIS eller noe annet, kjører programmet spesifisert som verdien av handlingsattributtet. I vårt tilfelle er dette test.cgi. Nettserveren kjører test.cgi og sender dens parametere i form av en tekststreng med følgende innhold: navn1=verdi1&navn2=verdi2&....navnN=verdiN, dvs. parameter_name=verdi. Denne strengen sendes til standardinndata (STDIN) eller som verdien av miljøvariabelen QUERY_STRING. Følgelig kan denne linjen leses i programmet på en av to måter:

I det første tilfellet overføres parametere ved hjelp av POST-metoden, og i det andre ved hjelp av GET-metoden. I det første tilfellet leser vi strengen fra STDIN. Vi finner ut lengden på linjen fra verdien til miljøparameteren CONTENT_LENGTH. I den andre lagres den i miljøvariabelen QUERY_STRING. Verdien av en miljøvariabel kan fås ved å kalle getenv-funksjonen. Metoden som en streng med parametere sendes til et CGI-program med kan defineres som følger: strcmp(getenv("REQUEST_METHOD"),"POST"). Deretter må du analysere strengen og få de nødvendige parameterverdiene. For ikke å måtte gjøre dette hver gang, skrev vi et lite, men veldig praktisk ITCGI-bibliotek for å skrive CGI-skript. Dette biblioteket lar deg abstrahere fullstendig fra metoden som parametere sendes med, fra kodingen, fra parsing av strengen. Du kaller ganske enkelt funksjonen GetParamByName, som du sender navnet på parameteren du er interessert i og adressen til linjen hvor du skal lagre verdien. Biblioteket gir deg også en rekke funksjoner for å skrive effektive og manipulasjonssikre CGI-skript.
I det enkleste tilfellet, når programmet ditt ikke trenger parametere, trenger du ikke å analysere og dekode strengen selv, og heller ikke bruke biblioteket vårt til dette. Det enkleste CGI-programmet vil være: Tittelen er en obligatorisk del. Den sendes til webserveren og bestemmer hva som følger etter den. I de fleste tilfeller er dette hva tittelen din vil være. Den forteller webserveren hvilken HTML-kode som kommer etterpå. Vi vil bli kjent med andre typer overskrifter litt senere. Tittelen kan inneholde flere linjer. Slutten av overskriften er indikert med to nye linjer - \n\n. Kompiler dette programmet og plasser den kjørbare filen i /cgi-bin-katalogen på nettstedet ditt. Gi nytt navn til test.cgi. Dette skriptet kan nås direkte gjennom en nettleser ved å skrive URL-en på kommandolinjen, for eksempel ser det slik ut for meg http://site/cgi-bin/test.cgi Som et resultat vil du i nettleseren din se linjen: «Hei, verden!» .
Deretter skal vi se på et CGI-program av samme type. Den godtar ingen parametere, men den produserer mer nyttig informasjon - en liste og verdier av alle miljøvariabler. Dette skriptet vil komme godt med når du feilsøker CGI-programmene dine på forskjellige webservere. Faktum er det Miljøvariabler varierer på ulike webservere. Så for eksempel for Apache webserver, er banen til nettstedkatalogen lagret i miljøvariabelen DOCUMENT_ROOT. For Microsoft Internet Information Server-webserveren er denne verdien lagret i PATH_TRANSLATED-variabelen. På UNIX-operativsystemet er skriptet for å vise alle variabler som følger.
#!/bin/sh echo "content-type: text/plain\n\n" echo env
Legg merke til CGI-tittelen. Den er forskjellig fra den vi hadde i forrige eksempel. plain betyr at skriptet ikke vil sende ut HTML-kode, men ren tekst. Nettleseren vil behandle den som vanlig tekst og vise den nøyaktig som den er. Det er ikke nødvendig å erstatte spesialtegn som< на их эквиваленты <. Скопируйте этот скрипт в директорию /cgi-bin с именем env. Установите атрибут 755 (rwxr-xr-x). Вот результат выполнения такого скрипта на моем unix-сервере:
GATEWAY_INTERFACE=CGI/1.1 REMOTE_USER=itsoft REMOTE_ADDR=192.168.34.134 QUERY_STRING= REMOTE_PORT=1781 HTTP_USER_AGENT=Mozilla/4.0 (kompatibel; MSIE 5.0; Windows 98=wwwDOUS_AUTH/DIGROOT/locit) Grunnleggende SERVER_SIGNATURE=
Apache/1.3.12 Server på itsoft..3.12 (Unix) PHP/3.0.17 HTTP_CONNECTION=Keep-Alive HTTP_COOKIE=/cgi-bin/authenticate.cgi_LAST=956345778 PATH=/sbin:/usr/sbin:/bin:/ usr/bin:/usr/local/sbin: /usr/local/bin:/usr/X11R6/bin HTTP_ACCEPT_LANGUAGE=ru SERVER_PROTOCOL=HTTP/1..226.32.34 SERVER_PORT=80 SCRIPT_NAME=/cgi-bin/web/env SERVER_NAME=side
C-programmet for Windows og Internet Information Server-webserveren vil se slik ut:
#inkludere #inkludere void main() ( char *text; char str; int length; FILE *in; sprintf(str,"command.com /c set>%s\\temp\\env.dmp",getenv("PATH_TRANSLATED")) ; system(str); sprintf(str,"%s\\temp\\env.dmp",getenv("PATH_TRANSLATED")); i = fopen(str, "rb"); if(!in) ( printf( "Innholdstype: text/plain\n\nKan ikke åpne filen %s.", str); return; ) fseek(in, 0, SEEK_END); length = ftell(in); fseek(in, 0, SEEK_SET ); text = (char*)malloc(lengde+1); fread(tekst, 1, lengde, inn); tekst = 0; fclose(in); printf("Innholdstype: tekst/vanlig\n\n% s", tekst); fri(tekst); )
Kjør først kommandoen command.com /c set>c:\www\mysite\temp\env.dmp. Resultatet av å utføre en slik kommando vil være en liste over alle miljøvariabler, som deretter lagres i en fil. Deretter leser vi denne filen og returnerer innholdet til webserveren. Du legger kanskje merke til at i dette tilfellet, som i forrige eksempel, skriver vi ikke ut html-kode, men ren tekst, og derfor har vi tittelen: Innholdstype: tekst/vanlig. Ikke glem også at dette cgi-skriptet bare vil fungere under Internet Information Server. For Apache-nettserveren bør du erstatte getenv("PATH_TRANSLATED") med getenv("DOCUMENT_ROOT").
Nedenfor er resultatet av dette skriptet på WindowsNT, du kan se hvor mange parametere som er tilgjengelige gjennom miljøvariabler. Et slikt cgi-skript vil være nyttig for deg når du setter opp skriptene dine på andres server, hvor miljøvariablene kan avvike fra dine lokale. COMSPEC=C:\WINNT\SYSTEM32\COMMAND.COM COMPUTERNAME=JUPITER CONTENT_LENGTH=0 GATEWAY_INTERFACE=CGI/1.1 HTTP_ACCEPT=image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/vnd.ms-powerpoint , application/vnd.ms-excel, applic HTTP_ACCEPT_LANGUAGE=ru HTTP_CONNECTION=Keep-Alive HTTP_HOST=www.oxygensoftware.com HTTP_USER_AGENT=Mozilla/4.0 (kompatibel; MSIE 5.01; Windows NT 5.0) INC HTTP_ACCEPT_ENCODING=gLUSzip=g C:\Program Files\Mts\Include INSTANCE_ID=1410 LIB=C:\Program Files\Mts\Lib LOCAL_ADDR=168.144.29.178 NUMBER_OF_PROCESSORS=2 OS2LIBPATH=C:\WINNT\system32\os2\dll; OS=Windows_NT PATH=C:\WINNT\system32;C:\WINNT;C:\Program Files\Mts PATH_TRANSLATED=e:\InetPub\Clients\oxygensoftware.com PATHEXT=.COM;.EXE;.BAT;.CMD; .VBS;.JS;.VBE;.JSE;.WSF;.WSH PROCESSOR_ARCHITECTURE=x86 PROCESSOR_IDENTIFIER=x86 Family 6 Model 5 Stepping 1, GenuineIntel PROCESSOR_LEVEL=6 PROCESSOR_REVISION=0501 REMOTE3.4PADG REMOTE3.4PADG MO.4PADG MO.4.6 _VERT = 194.226.32.34 REQUEST_METHOD=GET SCRIPT_NAME=/cgi-bin/env.exe SERVER_NAME=www.oxygensoftware.com SERVER_PORT=80 SERVER_PORT_SECURE=0 SERVER_PROTOCOL=HTTP/1.1 SERVER_SOFTWARESYSTEM=Microsoft-DRIICSYSTEM=Microsoft-DRIVCSYSTEM=Microsoft-DRIVCSYSTEM :\ WINNT TEMP=C:\temp TMP=C:\temp USERPROFILE=C:\WINNT\Profiles\Default User Før vi går videre til vurderingen av cgi-skript som aksepterer og behandler skjemaparametere, vil vi skrive et enkelt program som produserer en linje html-skjemaparametere. Les ovenfor om hvordan skjemaparametrene leses; her gir jeg kildekoden til programmet og resultatet for html-skjemaet beskrevet i det fjerde kapittelet.
#inkludere #inkludere void main() ( char* query=NULL; if(!strcmp(getenv("REQUEST_METHOD"),"POST")) (usignert int len; len = atoi(getenv("CONTENT_LENGTH")); query = (char* )malloc(len+1); fread(query, 1, len, stdin); query = 0; ) else if(!strcmp(getenv("REQUEST_METHOD"),"GET")) ( query=(char*)malloc (strlen(getenv("QUERY_STRING"))); strcpy(query,getenv("QUERY_STRING")); ) else printf("ukjent REQUEST_METHOD\n"); printf("Innholdstype: text/plain\n\n %s", query); free(query); )
Kompiler denne koden. Den er plattformuavhengig, så du kan kompilere den under både Unix og Windows. Ta HTML-skjemaet fra det fjerde kapittelet, du kan ta et hvilket som helst annet. I handlingsfeltet skriver du inn banen til dette programmet på webserveren din. Resultat etter å ha klikket på "Publiser"-knappen:
text=null&text=null&list=0&list2=0&textarea=%C7%E4%E5%F1%FC+%F2%E5%EA%F1%F2+%EF%EE+%F3%EC%EE%EB%F7%E0%ED%E8 %FE

Dette er en streng som inneholder en liste over alle parametere. Deretter kan du bruke vårt ITCGI-bibliotek eller analysere denne strengen med parametere selv. Les om biblioteket og dets praktiske bruk i neste avsnitt.

Ny side 3

CGI

CGI-skript

For at nettsteder skal være virkelig interaktive, må de utveksle informasjon med brukeren, ikke bare la ham laste ned dokumenter. Bruke Common Gateway Interface-programmer (kalt CGI-skript), kan du opprette datadrevne nettsider. Som du vil lære, ved hjelp av CGI-skript, kan en node motta forespørsler og svare brukeren.

Fordi CGI-skript genererer HTML-dokumenter mens systemet kjører, står brukeren overfor dynamiske websider. Du kan til og med generere sider tilfeldig, slik at hver bruker som besøker nettstedet ditt vil se et litt annet bilde enn det forrige.

Hvorfor nettsteder bruker CGI

Det er ikke behov for CGI-skript for å lage dynamiske HTML-filer. Men uten slike skript, hver gang du trenger en ny interaktiv dynamisk webside, må du endre serverprogrammet. Over tid kan serverprogrammet bli eksepsjonelt stort. For å forhindre slik modifikasjon av serveren bruker utviklere CGI. Ved å bruke CGI-skript kan serveren overføre oppgaven med å lage dynamiske webdokumenter til et applikasjonsprogram bygget for de spesifikke behovene. Du vil lage applikasjonsprogrammet ditt ved å bruke C/C++, Perl, JavaScript, VBScript eller et annet programmeringsspråk.

Serverprogrammet må kalle CGI-skriptet

Du kan ikke kjøre et CGI-skript direkte fra et nettleserprogram. For å bruke skriptet må det være plassert på samme datamaskin der serveren er plassert. For at du skal kunne se utdataene generert av et skript i nettleseren din, må serveren kjøre skriptet. Men dette er spørsmål for serveradministratoren.

Nettleser, server og CGI

Som du vet, for at en nettleser skal motta HTML-dokumenter, oppretter den først kontakt med serveren, og ber deretter om dokumentet (vanligvis bestemmer nettleseren din FÅ- HTTP-metode for å motta informasjon fra serveren). Deretter, hvis dokumentet eksisterer, svarer serveren til nettleseren ved å sende HTML-dokumentet og lukker deretter tilkoblingen. Bruken av CGI-skript gjør endringer i denne prosessen kun på serversiden. Nettleseren vet ikke at serveren kaller CGI-skriptet, og den bryr seg ikke om hvordan serveren sender data til den. Som webprogrammerer bryr du deg kun om serverens innganger og utganger når du skriver CGI-skript. Nettleseren vil etablere kontakt med serverprogrammet, som i sin tur kjører CGI-skriptet. Skriptet ditt utfører på sin side den nødvendige databehandlingen for å formatere den nødvendige utdata. Serveren din vil vanligvis sende utdataene fra skriptet i skjemaet til HTML-nettleseren. For å oppnå dette legger serverprogrammet til den nødvendige headerinformasjonen til utdataene generert av skriptet og sender denne headerinformasjonen sammen med dataene tilbake til nettleseren. Serveren lukker deretter tilkoblingen og venter på nye forespørsler.

Som du kanskje vet kan servere som kjører 32-bits operativsystemer som f.eks Windows 95/98 eller Windows NT, kan behandle forespørsler fra mange brukere samtidig. Dette betyr at flere brukere kan bruke skriptet samtidig. Derfor vil hver av dem, avhengig av forespørselen, se sitt eget bilde av serverens svar.

Forholdet mellom serveren og CGI-skriptet

Når et serverprogram kaller et skript, må serveren utføre flere grunnleggende operasjoner: kall opp skriptet og gi det de nødvendige dataene sendt fra nettleseren til skriptet ditt, gi skriptet verdier Miljøvariabler, tilgjengelig for skriptet, og behandle skriptets utdata, inkludert å sikre at tilleggshodeinformasjon er inkludert som er nødvendig for at nettleseren skal tolke skriptets data.

Som du allerede vet, er HTTP protokollen som nettklienter og servere får informasjon gjennom. HTTP-hodeinformasjon hjelper programmer med å kommunisere effektivt. Derfor er det nødvendig å være spesielt oppmerksom på overskriftsinformasjonen som serveren leverer til nettleseren. For eksempel, når et serverprogram er klart til å sende data til nettleseren, sender det overskrifter som beskriver statusen til dataene, typen data osv. På sin side bruker nettleseren overskriften ( Innholdstype) for å forberede for visning av data på skjermen. Serveren er ansvarlig for å gi denne metainformasjonen til nettleseren hver gang den sender data til den.

CGI-database

Brukere bruker ofte skript for å gi tilgang til databaser. Fordi databaser kan lagre utrolige mengder informasjon, skriver programmerere skript som fungerer som et grensesnitt ikke bare til klienten, men også til databasen. Som du vil se senere, er typen transaksjon mellom klient og server for utveksling av dynamiske data ganske generell. Du må forstå hvordan skript lages som samhandler med databasen for å motta og sende informasjon. Men før du jobber med CGI-databaseprogrammer, må du lære de grunnleggende programmeringsteknikkene for å lage profesjonelle CGI-programmer.

Hvor ligger skriptene?

CGI-standarder foreskriver ikke hvor skript skal plasseres, det vil si at de ikke forhåndsbestemmer stasjonen og katalogen. Vanligvis forventer webserveren å finne skript i katalogen /CGI-BIN som ligger i katalogen til selve serverprogrammet. Hvis du legger skriptene dine på en annens server, må du definere en katalog for filene dine som inneholder skriptene.

CGI script filnavn

HTTP-servere for Windows-systemer bruker vanligvis utvidelsen EXE eller PL for CGI-filer. For eksempel, hvis du oppretter et CGI-program (skript) ved å bruke C-programmeringsspråket, vil utvidelsen av skriptfilene sannsynligvis være EXE. På samme måte, hvis du oppretter et skript ved å bruke Perl-språket, vil utvidelsen av filene dine være PL.

Noen servere forventer imidlertid at CGI-utvidelser skal brukes til skript. Faktisk inkluderer mange systemer CGI-utvidelsen som en del av serverkonfigurasjonsfilen. Hvis du ikke er sikker på hvilken filtype serveren støtter, ta kontakt med webansvarlig. Ellers vil serveren kalle opp skriptene dine feil.

Grunnleggende om interaksjon mellom en webserver og et CGI-skript

CGI-spesifikasjonen definerer informasjonen som serveren må gi til skriptet, samt informasjonen fra skriptet som serveren krever. For at skriptet ditt skal oppfylle spesifikasjonen og fungere korrekt med serveren, må du følge kravene definert av spesifikasjonen.

Når en nettbruker oppretter en tilkobling som får serveren til å starte skript, krever serveren et stort antall miljøvariabler som skriptet bruker for å få informasjon. Disse miljøvariablene inneholder informasjon om nettleseren som sender forespørselen, serveren som behandler den og dataene som sendes til skriptet ditt. CGI-miljøvariabler skiller mellom store og små bokstaver, og hver variabel er definert i CGI-spesifikasjonen.

Miljøvariabler

Variabel AUTH_TYPE

CGI-skript bruker en miljøvariabel AUTH_TYPE for å identifisere brukeren som prøver å få tilgang til skriptet. Hvis serveren er konfigurert til å støtte brukerautentisering, må brukeren som prøver å få tilgang til skriptet oppgi brukernavn og passord. For eksempel indikerer følgende variabelverdi at brukeren må ha et grunnleggende identifikasjonsnivå:

AUTH_TYPE = Grunnleggende

CONTENT_LENGTH variabel

Skript bruker miljøvariabel CONTENT_LENGTH for å bestemme det nøyaktige antallet byte i de tilkoblede dataene. For eksempel, hvis forespørselen inneholder et dokument som er 1,024 byte langt, settes miljøvariabelen til følgende verdi:

CONTENT_LENGTH = 1024

Variabel INNHOLDSTYPE

Skript bruker denne miljøvariabelen for forespørsler som inneholder vedlagt informasjon. Denne typen forespørsel refererer til en HTTP-operasjon POST. Informasjonen i variabelen indikerer type data vedlagt (MIME type.subtype). For eksempel, hvis forespørselen inneholder et HTML-dokument vedlagt, vil miljøvariabelen ha følgende verdier:

CONTENT_TYPE = tekst/html

Variabel GATEWAY_INTERFACE

Skript bruker denne variabelen til å bestemme versjonen, utgivelsesnummeret, av CGI-spesifikasjonen som webserveren overholder. Spesifer CGI/utgivelsesnummer. For eksempel, for CGI-utgivelse 1.1 vil miljøvariabelen være:

GATEWAY_INTERFACE = CGI/1.1

Variabel PATH_INFO

Skript bruker denne variabelen til å bestemme ytterligere baneinformasjon som skal gis til klienter. Med andre ord kan serveren få tilgang til skriptet ved å bruke den virtuelle skriptbanen etterfulgt av ytterligere baneinformasjon. Serverprogrammet må dekode denne tilleggsinformasjonen, hvis den kommer fra en URL, før serveren sender den til skriptet. Vanligvis indikerer denne tilleggsinformasjonen en ressurs som skriptet skal returnere hvis forespørselen er vellykket.

Stien er skrevet til slektning form, der rotkatalogen til serveren tas som base. Med andre ord er serverrotkatalogen grunnlaget for den relative banen, som er tilordnet variabelen PATH_INFO. For eksempel hvis banen er gitt c:/cgi-bin/example1.exe/sports.html, da vil miljøvariabelen se slik ut:

PATH_INFO = /sports.html

Variabel PATH_TRANSLATED

Skript bruker denne variabelen for å få endelig, direkte brukbar baneinformasjon. Serveren oversetter den variable informasjonen ved å utføre de nødvendige banetransformasjonene. For eksempel hvis variabelen PATH_TRANSLATED har betydningen /sports.html, og rotkatalogen til serveren er c:\, da vil miljøvariabelen ha følgende verdi:

PATH_TRANSLATED = c:\sports.html

Variabel QUERY_STIRNG

Skript bruker denne variabelen for å få informasjon i tekstform (bestående av argumenter) som vises til høyre for spørsmålstegnet etter at URL-en ble sendt fra brukeren til skriptet for behandling. Denne tekststrengen inneholder inndata for skriptet. Deretter erstatter serveren hvert mellomrom i denne teksten med "+"-tegnet, og alle ikke-utskrivbare tegn med "%dd"-tegnet, der d er grunnlaget for desimaltallsystemet.

Skriptet må inneholde kode for å dekryptere denne tekststrengen. Når serveren sender denne informasjonen til skriptet, må den ikke dekode forespørselsinformasjonen på noen måte. Serveren må også angi variabelen QUERY_STRING i tilfelle brukeren gir noen forespørselsinformasjon. For eksempel for URL http://www.jamsa.com/cgi-bin/grandma.exe?name=margaret+alarcon Miljøvariabelen har følgende verdi:

QUERY_STRING = navn=margaret+alarcon

Variabel REMOTE_ADDR

Skript bruker denne variabelen for å få IP-adressen til den eksterne verten (nettleseren) som gjør forespørselen. For eksempel kan verdien av en miljøvariabel være:

REMOTE_ADDR = 204.212.52.209

Variabel REMOTE_HOST

Skript bruker denne variabelen for å få navnet på verten som forespørselen er laget fra. Hvis serveren ikke kjenner navnet på verten som sender forespørselen, må serveren tilordne en verdi til miljøvariabelen REMOTE_ADDR og ikke tilordne verdier til variabelen REMOTE_HOST. For eksempel for en node jamsa.com Miljøvariabelen vil inneholde følgende verdi:

REMOTE_HOST = jamsa.com

Variabel REMOTE_IDENT

Brukes for å få navnet på den eksterne brukeren som sender en forespørsel til serveren. Webserverprogrammet er programvare. kaller manuset ditt. Hvis HTTP-webserveren støtter RFS 931 (Authentication Server Protocol), vil serveren sette denne variabelen til verdien av brukernavnet som serveren har. Skript kan bare bruke denne variabelen til å registrere en bruker. For eksempel hvis det eksterne brukernavnet pschmauder og den vil være plassert på den eksterne noden jamsa.com, vil variabelen ha følgende verdi:

REMOTE_IDENT = pschmauder.www.jamsa.com

Variabel REMOTE_USER

Brukes for å få navnet på den eksterne brukeren uten navnet på verten han sender forespørselen fra. Hvis serveren støtter brukerautentisering og skriptet er sikkert, vil serveren angi brukernavnet og tilordne det til denne variabelen. Anta for eksempel at den eksterne brukerens navn er pschmauder. Da vil variabelen se slik ut:

REMOTE_USER = pschmauder

Variabel REQUEST_METHOD

Brukes til å bestemme typen HTTP-forespørsel som sendes av nettleseren til serveren og brukes til å starte skript. Denne variabelen kan ta verdier FÅ, HODE eller POST. For eksempel hvis nettleseren sender FÅ- metoden inneholder miljøvariabelen følgende:

REQUEST_METHOD = GET

Variabel SCRIPT_NAME

Brukes til å definere den virtuelle banen til skriptet som vil bli lansert av serveren. For eksempel hvis det er en URL http://www.jamsa.com/cgi-bin/someprog.exe, vil miljøvariabelen ha følgende verdi:

SCRIPT_NAME = cgi-bin/example1.exe

Variabel SERVER NAVN

Brukes til å bestemme domenenavnet eller IP-adressen til datamaskinen som webserveren er plassert på. For eksempel, når serveren returnerer en IP-adresse, vil miljøvariabelen se slik ut:

SERVER_NAME = 204.212.52.209

Variabel SERVER_PORT

Brukes til å bestemme portnummeret som brukeren (nettleseren) bruker for å kommunisere med webserveren. Hvis standard HTTP-porten brukes, er denne verdien 80. Hvis en annen port brukes, f.eks. http://www.jamsa.com:3000, så tar variabelen følgende verdi:

SERVER_PORT = 3000

Variabel SERVER_PROTOCOL

Brukes til å spesifisere navnet og utstedelsesnummeret til protokollen som brukes av klienten (nettleseren) for å sende en forespørsel til webserveren. Ved å analysere innholdet i variabelen kan skriptet identifisere navnet og utstedelsesnummeret til protokollen det skal bruke når data sendes til serveren. Protokollnavnet og utstedelsesnummerformatet er som følger: protokoll/utstedelsesnummer. For eksempel, for HTTP 1.1 vil miljøvariabelen se slik ut:

SERVER_PROTOCOL = HTTP/1.1

Variabel SERVER_SOFTWARE

Som du vet, kjører en webserver CGI-skript. Fordi et skript kan kjøres forskjellig for forskjellige serverprogrammer, bruker skript denne variabelen til å bestemme navnet på webserverprogrammet og dets versjonsnummer. Formatet på webservernavnet og versjonsnummeret må sendes til CGI-en som følger: navn/versjon. For eksempel for FOLKENETT - serverversjon 1.01, vil miljøvariabelen se slik ut:

SERVER_SOFTWARE = ​​​​FolkWeb/1.01 (Windows-32bit)

Ytterligere miljøvariabler

I tillegg til miljøvariabler. diskutert tidligere, plasserer serveren også data fra forespørselshodet mottatt fra klienten i miljøvariabler. Serveren tildeler verdier til variabler hvis navn begynner med HTTP_-prefikset etterfulgt av overskriftsnavnet. Serveren erstatter alle bindestreker (-) i overskriften med (_). Serveren kan også ekskludere alle overskrifter den allerede har behandlet ved å bruke miljøvariabler som AUTH_TYPE, CONTENT_TYPE Og CONTENT_LENGTH.

Variabel HTTP_ACCEPT

Brukes til å bestemme hvilke MIME-typer nettleseren kan akseptere. De er definert i HTTP-hodene som nettleseren sender til serveren. Som du vet er MIME-typen spesifisert i skjemaet type/utvidelse. Hvis det er flere MIME-typer, er de atskilt med komma. En miljøvariabel kan for eksempel ha følgende verdi:

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

Variabel HTTP_USER_AGENT

Brukes til å identifisere typen nettleser som sender forespørselen til serveren. En miljøvariabel kan for eksempel inneholde følgende:

HTTP_USER_AGENT = Mozilla/2.01 Gold(Win95PE)

CGI kommandolinjealternativer

Vanligvis bruker CGI-skript kommando streng som input for å utføre spørringen ISINDEX, slik at du kan legge til interaktive nøkkelordsøk i HTML-dokumentene dine. Imidlertid støtter ikke alle serverprogrammer ISINDEX- be om. Nettleseren sender en kommandolinjeforespørsel til serveren. Serverprogrammet kan identifisere inngangskommandolinjen ved å bestemme om nettleseren brukes FÅ- HTTP-metoden og om URL-strengen inneholder tegn uuencoded =.

Hvis nettleseren bruker FÅ- HTTP-metoden og URL-søkestrengen inneholder ikke tegn uuencoded=, deretter utføres forespørselen i form av en kommandolinje. Før serveren kaller det riktige skriptet, må serverprogrammet dele kommandolinjen ved å bruke (+) tegnet for å skille parametrene. Serveren utfører deretter ytterligere dekoding (om nødvendig) av hver parameter som sendes i URL-søkestrengen, og lagrer hver strengparameter i en matrise kalt argv.

Ytterligere dekoding utført av serveren består av å skille individuelle linjer ved å bruke og-tegnet (&) som skilletegn. Serveren deler deretter hver av disse strengene igjen ved å bruke (=)-tegnet for å skille variabelnavnet, som vises til venstre for (=)-tegnet, fra variabelverdien, som vises til høyre for (=)-tegnet . Serveren lagrer antall elementer i arrayet argv, i en variabel av heltallstype argс.

Hvis serveren fant et likhetstegn inne i strengen QUERY_STRING miljøvariabel, vil den ikke sende kommandolinjen som input til skriptet. Også hvis serverprogrammet av en eller annen grunn ikke kan sende arrayet argv skript, vil det gi den ukodede forespørselsinformasjonen i en miljøvariabel QUERY_STRING.

Standard inngang ( STDIN)

Når nettleseren ber om serveren (for eksempel ved å bruke HTTP-metoden POST), informasjonen skriptet mottar kommer fra standard inndatahåndtak stdin. Serverprogrammet sender en miljøvariabel til skriptet CONTENT_LENGTH. Denne variabelen inneholder antall byte som serveren sender til skriptet gjennom dette håndtaket. Skriptet kan bruke verdien til en variabel CONTENT_LENGTH for å bestemme hvor mye data som skal komme fra standard input. Serveren forsyner også skriptet med en miljøvariabel INNHOLDSTYPE, som hjelper skriptet med å finne ut hvordan det skal behandle dataene det mottar. På slutten av denne datastrømmen kan det hende at serveren sender en filsluttmarkør eller ikke. Det er imidlertid skriptet som må bestemme hvor mye data som skal leses, og det bruker en miljøvariabel for dette CONTENT_LENGTH.

For eksempel hvis skjemaet bruker HTTP-metoden POST(

) og dataene som sendes til serveren er kodet som følger: navn=alberta&mann=kunst, så vil serveren tilordne variablene CONTENT_LENGHT Og INNHOLDSTYPE følgende verdier:

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

Standard utgang ( STDOUT)

Etter at CGI-skriptet er ferdig med å behandle dataene mottatt fra serveren, må det sende svaret til serveren. For å sende dataene til serveren, må den sende dem til standard utdatafilbeskrivelse STDOUT. Generelt er dataene som skriptet sender tilbake til serveren et HTTP-svar, inkludert en header, etterfulgt av en tom linje, og etterfulgt av resten av svaret. Vanligvis er utdataene til et skript HTML-dokumentene som genereres av skriptet.

Skriptet er direkte respons på nettleseren

Vanligvis produserer skriptet et svar som serveren tolker og sender tilbake til nettleseren. Fordelen med å sende skriptets utdata til serveren er at skriptet ikke trenger å sende hele HTTP-headeren for hver forespørsel. Noen skript laster imidlertid av serveren og sender utdataene direkte til nettleseren. For å skille skript som sender data direkte til nettleseren fra skript som sender det til serveren, krever CGI-protokollen at navnene på skript som sender data direkte til nettleseren begynner med bokstavene nph-(som forteller serveren Ikke for å analysere overskriften - ikke initialiser overskriften). Hvis skriptnavnet starter slik, vil ikke serveren sette inn overskriften i skriptdataene. I dette tilfellet hviler ansvaret på selve manuset.

CGI-titler

Som du lærte tidligere, starter produksjonen av et skript med en overskrift. Denne overskriften består av en tekstlinje i samme format som HTTP-overskriften, som slutter med en tom linje (en linje som kun inneholder CRLF). Hvis skriptutgangen inneholder andre overskrifter enn direktiver til serveren, så sender serveren disse overskriftene til nettleseren som svar på forespørselen. Den nåværende CGI-spesifikasjonen definerer tre direktiver:

  • INNHOLDSTYPE
  • PLASSERING
  • STATUS

Felt Innholdstype i CGI-overskriften spesifiserer typen/utvidelsen av MIME-data som skriptet sender tilbake til nettleseren. Vanligvis produserer skript et HTML-dokument som utdata. I dette tilfellet CGI-overskriften Innholdstype inneholder følgende:

Innholdstype: tekst/html

Felt plassering topptekst angir dokumentet. Skript bruker vanligvis feltet plassering for å angi plasseringen av dokumentet. Hvis dokumentet ikke er plassert på serveren og innholdet i feltet er en URL, omdirigerer serveren nettleseren til riktig node. Hvis dokumentet er på serveren og feltet er en virtuell bane, sender serveren dette dokumentet til nettleseren. For å peke på et dokument på en ekstern server, kan overskriftsfeltet for eksempel se slik ut:

Sted: http://www.cetis.ru

Felt Status Overskriften inneholder HTTP-statusverdien som serveren sender fra skriptet til nettleseren. Serveren som kaller skriptet bruker forskjellige HTTP-statuskoder. Det kan være lurt å sende statuskoden direkte til nettleseren, spesielt hvis det oppstår feil.

Følgende eksempel illustrerer den typiske utgangen et skript vil produsere når data sendes til en server. Etter at dataene når serverprogrammet, vil serveren videresende dataene til nettleseren:

Innholdstype: tekst/html Dette er tittelen Dette er kroppen generert av CGI-skriptet ditt.

Legg merke til den tomme linjen mellom de første linjene. Denne tomme linjen er helt nødvendig. Følgende C-kodebit oppretter dokumentet ovenfor ved å bruke funksjonen printf:

// Mer kode ovenfor: printf("Innholdstype: text/html\n"); printf("\n"); // Sørg for å inkludere denne tomme linjen printf(" \n"); printf(" \n"); printf(" Dette er tittelen\n"); printf("\n"); printf(" \n"); printf("Dette er kroppen generert av CGI-skriptet ditt.\n"); printf("\n"); printf("\n"); // Mer kode nedenfor...

Takket være World Wide Web kan nesten hvem som helst gi informasjon på nettet i en form som er lett for øynene og som kan spres bredt. Du har uten tvil surfet på Internett og sett andre sider, og nå vet du sikkert at skumle akronymer som "HTTP" og "HTML" ganske enkelt er en forkortelse for "Web" og "måten informasjon uttrykkes på Internett." Du har kanskje allerede litt erfaring med å presentere informasjon på Internett.

Internett har vist seg å være et ideelt medium for å distribuere informasjon, noe man kan se av dets enorme popularitet og utbredte utvikling. Selv om noen har stilt spørsmål ved nytten av Internett og tilskriver dens utbredte utvikling og popularitet hovedsakelig påtrengende reklame, er Internett unektelig et viktig medium for å presentere all slags informasjon. Ikke bare er det mange tjenester tilgjengelig for å gi oppdatert informasjon (nyheter, vær, direktesendte sportsbegivenheter) og referansemateriale elektronisk, det er også betydelige mengder andre typer data tilgjengelig. IRS, som distribuerte alle 1995 selvangivelsesskjemaer og annen informasjon via World Wide Web, innrømmet nylig å ha mottatt fanmail for nettstedet. Hvem hadde trodd at skattemyndighetene noen gang ville motta fanmail? Dette var ikke fordi nettstedet hans var godt designet, men fordi det hadde vist seg å være et virkelig nyttig verktøy for tusenvis, kanskje millioner, av mennesker.

Hva gjør nettet unikt og en så attraktiv informasjonstjeneste? Først av alt gir det et hypermedia-grensesnitt til data. Tenk på datamaskinens harddisk. Vanligvis uttrykkes data på en lineær måte, som ligner på et filsystem. For eksempel har du en rekke mapper, og inne i hver mappe er det enten dokumenter eller andre mapper. Nettet bruker et annet paradigme for å uttrykke informasjon kalt hypermedia. Et hypertekstgrensesnitt består av et dokument og lenker. Lenker er ord som klikkes for å se andre dokumenter eller finne andre typer informasjon. Nettet utvider konseptet hypertekst til å omfatte andre typer medier, som grafikk, lyder, video (derav navnet "hypermedia"). Ved å velge tekst eller grafikk på et dokument kan du se relatert informasjon om det valgte elementet i et hvilket som helst antall former.

Nesten alle kan dra nytte av denne enkle og unike måten å presentere og distribuere informasjon på, fra akademikere som umiddelbart ønsker å bruke data med sine kolleger til forretningsfolk som deler informasjon om bedriften sin med alle. Men selv om det å gi informasjon er ekstremt viktig, har mange de siste årene følt at det å motta informasjon er en like viktig prosess.

Selv om nettet gir et unikt hypermedia-grensesnitt for informasjon, er det mange andre effektive måter å distribuere data på. For eksempel eksisterte nettverkstjenester som File Transfer Protocol (FTP) og Gopher-nyhetsgruppen lenge før World Wide Web. Elektronisk post har vært det primære mediet for kommunikasjon og informasjonsutveksling på Internett og de fleste andre nettverk nesten helt fra begynnelsen av disse nettverkene. Hvorfor har Internett blitt en så populær måte å distribuere informasjon på? Multimediaaspektet ved Internett har bidratt betydelig til dets enestående suksess, men for at Internett skal være mest effektivt, må det være interaktivt.

Uten muligheten til å motta brukerinndata og gi informasjon, ville nettet vært et fullstendig statisk miljø. Informasjonen vil kun være tilgjengelig i formatet spesifisert av forfatteren. Dette ville undergrave en av egenskapene til databehandling generelt: interaktiv informasjon. For eksempel, i stedet for å tvinge brukeren til å se flere dokumenter som om han eller hun ser gjennom en bok eller ordbok, ville det være bedre å la brukeren identifisere nøkkelord om et emne av interesse. Brukere kan tilpasse presentasjonen av data i stedet for å stole på en rigid struktur definert av innholdsleverandøren.

Begrepet "webserver" kan være misvisende fordi det kan referere til både den fysiske maskinen og programvaren den bruker for å kommunisere med nettlesere. Når en nettleser ber om en gitt webadresse, kobles den først til maskinen via Internett, og sender webserverprogramvaren en forespørsel om dokumentet. Denne programvaren kjører kontinuerlig, venter på at slike forespørsler kommer og svarer deretter.

Selv om servere kan sende og motta data, har selve serveren begrenset funksjonalitet. For eksempel kan den mest primitive serveren bare sende den nødvendige filen til nettleseren. Serveren vet vanligvis ikke hva den skal gjøre med denne eller den ekstra inngangen. Hvis Internett-leverandøren ikke forteller serveren hvordan denne tilleggsinformasjonen skal håndteres, vil serveren mest sannsynlig ignorere inndataene.

For at serveren skal kunne utføre andre operasjoner i tillegg til å søke og sende filer til nettleseren, må du vite hvordan du utvider funksjonaliteten til serveren. En webserver kan for eksempel ikke søke i en database basert på et nøkkelord angitt av en bruker og returnere flere samsvarende dokumenter med mindre en slik funksjon er programmert inn i serveren på en eller annen måte.

Hva er CGI?

Common Gateway Interface (CGI) er et grensesnitt til serveren som lar deg utvide funksjonaliteten til serveren. Ved å bruke CGI kan du interagere interaktivt med brukere som har tilgang til nettstedet ditt. På et teoretisk nivå lar CGI serveren kunne parse (tolke) input fra nettleseren og returnere informasjon basert på brukerens input. På et praktisk nivå er CGI et grensesnitt som lar en programmerer skrive programmer som enkelt kommuniserer med en server.

Vanligvis, for å utvide serverens muligheter, må du endre serveren selv. Denne løsningen er uønsket fordi den krever forståelse for det nedre laget av Internett-protokollnettverksprogrammering. Dette vil også kreve redigering og rekompilering av serverkildekoden eller skriving av en tilpasset server for hver oppgave. La oss si at du vil utvide serverens muligheter slik at den fungerer som en nett-til-e-post-gateway, som tar brukerangitt informasjon fra nettleseren og sender den til en annen bruker. Serveren må sette inn kode for å analysere inngangen fra nettleseren, videresende den via e-post til den andre brukeren og videresende svaret tilbake til nettleseren over nettverkstilkoblingen.

For det første krever en slik oppgave tilgang til serverkoden, noe som ikke alltid er mulig.

For det andre er det vanskelig og krever omfattende teknisk kunnskap.

For det tredje gjelder dette bare en bestemt server. Hvis du trenger å flytte serveren til en annen plattform, må du kjøre eller i det minste bruke mye tid på å portere kode til den plattformen.

Hvorfor CGI?

CGI tilbyr en bærbar og enkel løsning på disse problemene. CGI-protokollen definerer en standard måte for programmer å kommunisere med en webserver. Uten noen spesiell kunnskap kan du skrive et program på et hvilket som helst maskinspråk som grensesnitt og kommuniserer med webserveren. Dette programmet vil fungere med alle webservere som forstår CGI-protokollen.

CGI-kommunikasjon gjøres ved å bruke standard input og output, noe som betyr at hvis du vet hvordan du skriver ut og leser data ved å bruke programmeringsspråket ditt, kan du skrive en webserverapplikasjon. Bortsett fra å analysere input og output, er programmering av CGI-applikasjoner nesten tilsvarende å programmere alle andre applikasjoner. For å programmere "Hello, World!"-programmet for eksempel, bruker du språkets utskriftsfunksjoner og formatet som er definert for CGI-programmer for å skrive ut den aktuelle meldingen.

Velge et programmeringsspråk

Fordi CGI er et universelt grensesnitt, er du ikke begrenset til noe spesifikt maskinspråk. Et viktig spørsmål som ofte stilles er: hvilke programmeringsspråk kan brukes til CGI-programmering? Du kan bruke et hvilket som helst språk som lar deg gjøre følgende:

  • Skriv ut til standard utskrift
  • Les fra standard input
  • Les fra variable moduser

Nesten alle programmeringsspråk og mange skriptspråk gjør disse tre tingene, og du kan bruke hvilken som helst av dem.

Språk faller inn i en av følgende to klasser: oversatt og tolket. Et oversatt språk som C eller C++ er vanligvis mindre og raskere, mens tolkede språk som Perl eller Rexx noen ganger krever at en stor tolk lastes ved oppstart. I tillegg kan du distribuere binære koder (kode som oversettes til maskinspråk) uten kildekode hvis språket ditt er oversettbart. Å distribuere tolkbare skript betyr vanligvis å distribuere kildekode.

Før du velger språk, må du først vurdere prioriteringene dine. Du må veie fordelene med hastigheten og effektiviteten til ett programmeringsspråk opp mot programmeringsvennligheten til et annet. Hvis du har et ønske om å lære et annet språk, i stedet for å bruke det du allerede kan, vei nøye fordelene og ulempene med begge språkene.

De to mest brukte språkene for CGI-programmering er C og Perl (som begge er dekket i denne boken). Begge har klare fordeler og ulemper. Perl er et språk på meget høyt nivå, og samtidig et kraftig språk, spesielt egnet for å analysere tekst. Selv om dens brukervennlighet, fleksibilitet og kraft gjør det til et attraktivt språk for CGI-programmering, gjør dens relativt store størrelse og langsommere drift det noen ganger uegnet for noen applikasjoner. C-programmer er mindre, mer effektive og gir systemkontroll på lavere nivå, men er mer komplekse å programmere, har ikke lette innebygde tekstbehandlingsrutiner og er vanskeligere å feilsøke.

Hvilket språk er best egnet for CGI-programmering? Den som du anser som mer praktisk fra et programmeringssynspunkt. Begge er like effektive for programmering av CGI-applikasjoner, og med de riktige bibliotekene har begge lignende funksjoner. Men hvis du har en vanskelig tilgjengelig server, kan du bruke mindre, oversatte C-programmer. Skal du raskt skrive en applikasjon som krever mye tekstbehandlingsarbeid, kan du bruke Perl i stedet.

Advarsler

Det er noen viktige alternativer til CGI-applikasjoner. Mange servere inkluderer nå API-programmering, som gjør det enklere å programmere direkte serverutvidelser i motsetning til frittstående CGI-applikasjoner. API-servere er generelt mer effektive enn CGI-programmer. Andre servere inkluderer innebygd funksjonalitet som kan håndtere spesielle ikke-CGI-elementer, for eksempel databasekobling. Til slutt kan noen applikasjoner håndteres av noen nye klient-side (i stedet for server-side) teknologier som Java. Med så raske endringer i teknologi, vil CGI raskt bli foreldet?

Neppe. CGI har flere fordeler i forhold til nyere teknologier.

  • Den er allsidig og bærbar. Du kan skrive en CGI-applikasjon ved å bruke nesten alle programmeringsspråk på hvilken som helst plattform. Noen av alternativene, som server-API, begrenser deg til visse språk og er mye vanskeligere å lære.
  • Det er lite sannsynlig at klientsideteknologier som Java vil erstatte CGI, fordi det er noen applikasjoner som serversideapplikasjoner er mye bedre egnet til å kjøre.
  • Mange av begrensningene til CGI er begrensninger for HTML eller HTTP. Ettersom Internett-standarder som helhet utvikler seg, utvikler CGI-funksjonene seg også.

Sammendrag

Common Gateway Interface er protokollen som programmer samhandler med webservere med. Allsidigheten til CGI gir programmerere muligheten til å skrive gateway-programmer på nesten alle språk, selv om det er mange avveininger knyttet til forskjellige språk. Uten denne muligheten ville det være vanskelig å lage interaktive nettsider, i beste fall kreve servermodifikasjoner, og interaktivitet ville være utilgjengelig for de fleste brukere som ikke er nettstedadministratorer.

Kapittel 2: Grunnleggende

For flere år siden opprettet jeg en side for en høyskole ved Harvard der folk kunne sende inn kommentarer om dem. På den tiden var Internett ungt og dokumentasjon var knapp. Jeg, som mange andre, stolte på kort dokumentasjon og programmeringssystemer laget av andre for å lære meg selv CGI-programmering. Selv om denne studiemetoden krevde litt søking, mange eksperimenter og skapte mange spørsmål, var den veldig effektiv. Dette kapittelet er resultatet av mitt tidlige arbeid med CGI (med noen få justeringer, selvfølgelig).

Selv om det tar litt tid å forstå og mestre det vanlige gateway-grensesnittet, er selve protokollen ganske enkel. Alle som har noen grunnleggende programmeringskunnskaper og er kjent med nettet kan raskt lære å programmere ganske komplekse CGI-applikasjoner akkurat som jeg og andre lærte å gjøre for flere år siden.

Formålet med dette kapittelet er å presentere det grunnleggende om CGI på en omfattende, om enn fortettet måte. Hvert konsept som diskuteres her presenteres i detalj i påfølgende kapitler. Men etter å ha fullført dette kapittelet, kan du umiddelbart begynne å programmere CGI-applikasjoner. Når du har nådd dette nivået, kan du lære detaljene med CGI, enten ved å lese resten av denne boken eller ganske enkelt eksperimentere på egen hånd.

Du kan koke ned CGI-programmering til to oppgaver: motta informasjon fra nettleseren og sende informasjon tilbake til nettleseren. Dette gjøres ganske intuitivt når du blir kjent med normal bruk av CGI-applikasjoner. Ofte blir brukeren bedt om å fylle ut et skjema, for eksempel sette inn navnet sitt. Når brukeren fyller ut skjemaet og trykker Enter, sendes denne informasjonen til CGI-programmet. CGI-programmet må da konvertere denne informasjonen til noe den forstår, behandle den deretter, og deretter sende den tilbake til nettleseren, enten det er en enkel bekreftelse eller et resultat av et søk i en flerbruksdatabase.

Med andre ord krever programmering av CGI å forstå hvordan man mottar input fra nettleseren og hvordan man sender utdata tilbake. Hva som skjer mellom input- og output-stadiene til et CGI-program avhenger av utviklerens mål. Du vil finne at hovedvanskeligheten i CGI-programmering ligger i dette mellomstadiet; Når du først har lært å jobbe med input og output, er det egentlig nok til å bli en CGI-utvikler.

I dette kapittelet lærer du prinsippene bak CGI-inndata og -utdata, samt andre grunnleggende ferdigheter du trenger for å skrive og bruke CGI, inkludert ting som å lage HTML-skjemaer og navngi CGI-programmene dine. Dette kapittelet dekker følgende emner:

  • Tradisjonelt program "Hei, verden!";
  • CGI Output: Sender informasjon tilbake for visning i en nettleser;
  • Konfigurere, installere og kjøre programmet. Du vil lære om ulike nettplattformer og servere;
  • CGI-inngang: Tolkning av informasjon sendt av nettleseren. Introduksjon til noen nyttige programmeringsbiblioteker for å analysere slike input;
  • Et enkelt eksempel: det dekker alle leksjonene i et gitt kapittel;
  • Programmeringsstrategi.

På grunn av dette kapitlets natur berører jeg bare noen emner. Ikke bekymre deg; Alle disse emnene dekkes mye mer i dybden i andre kapitler.

Hei Verden!

Du starter med et tradisjonelt innledende programmeringsproblem. Du skal skrive et program som viser "Hello, World!" på nettleseren din. Før du skriver dette programmet, må du forstå hvilken informasjon nettleseren forventer å motta fra CGI-programmer. Du må også vite hvordan du kjører dette programmet slik at du kan se det i aksjon.

CGI er språkuavhengig, så du kan implementere dette programmet på alle språk. Flere forskjellige språk brukes her for å demonstrere uavhengigheten til hvert språk. I Perl, "Hello, World!"-programmet vist i oppføring 2.1.

Oppføring 2.1. Hei Verden! i Perl. #!/usr/local/bin/perl # Hello.cgi - Min første CGI-programutskrift "Content-Type: text/html\n\n"; skrive ut " \n"; skriv ut " Hei Verden!"; skrive ut "\n"; skriv ut " \n"; skriv ut "

Hei Verden!

\n"; skriv ut " \n";

Lagre dette programmet som hello.cgi, og installer det på riktig sted. (Hvis du ikke er sikker på hvor det er, ikke bekymre deg; du vil finne ut av det i delen "Installere og kjøre et CGI-program" senere i dette kapittelet.) For de fleste servere er katalogen du trenger cgi-bin . Ring nå programmet fra nettleseren din. For de fleste betyr dette å åpne følgende enhetlige ressurslokalisator (URL):

http://vertsnavn/katalognavn/hello.cgi

Vertsnavn er navnet på webserveren din, og katalognavn er katalogen der du legger hello.cgi (sannsynligvis cgi-bin).

Splitting hello.cgi

Det er et par ting å merke seg om hello.cgi.

Først bruker du enkle utskriftskommandoer. CGI-programmer krever ingen spesielle filbeskrivelser eller utdatabeskrivelser. For å sende utdata til nettleseren, bare skriv ut til stdout.

For det andre, merk at innholdet i den første utskriftserklæringen (Content-Type: text/html) ikke vises i nettleseren din. Du kan sende all informasjon du vil tilbake til nettleseren (HTML-side, grafikk eller lyd), men først må du fortelle nettleseren hva slags data du sender den. Denne linjen forteller nettleseren hva slags informasjon du kan forvente - i dette tilfellet en HTML-side.

For det tredje heter programmet hello.cgi. Du trenger ikke alltid å bruke .cgi-utvidelsen med navnet på CGI-programmet. Selv om kildekoden for mange språk også bruker filtypen .cgi, brukes den ikke til å angi språktypen, men er en måte for serveren å identifisere filen som en kjørbar fil i stedet for en grafikkfil, HTML-fil eller tekstfil. Servere er ofte konfigurert til å bare forsøke å kjøre de filene som har denne utvidelsen, og viser innholdet til alle andre. Selv om det ikke er nødvendig å bruke .cgi-utvidelsen, anses det fortsatt som god praksis.

Generelt består hello.cgi av to hoveddeler:

  • forteller nettleseren hvilken informasjon de kan forvente (Innholdstype: text/html)
  • forteller nettleseren hva den skal vise (Hei, verden!)

Hei Verden! i C

For å vise språkuavhengigheten til CGI-programmer, viser Listing 2.2 ekvivalenten til hello.cgi-programmet skrevet i C.

Oppføring 2.2. Hei Verden! i C. /* hello.cgi.c - Hei, World CGI */ #include int main() ( printf("Innholdstype: text/html\r\n\r\n"); printf(" \n"); printf(" Hei Verden!\n"); printf("\n"); printf(" \n"); printf("

Hei Verden!

\n"); printf(" \n"); )

Merk

Merk at Perl-versjonen av hello.cgi bruker Content-Type print ": text/html\n\n "; Mens versjon C bruker Printf("Content-Type: text/html\r\n\r\n");

Hvorfor skriver Perl ut operatøren med to nye linjer (\n) mens C printf slutter med to vognretur og nye linjer (\r\n)?

Teknisk sett forventes overskrifter (alle utdata før den tomme linjen) å være atskilt med vognretur og nye linjer. Dessverre, på DOS- og Windows-maskiner, oversetter Perl \r som en ny linje i stedet for som en vognretur.

Selv om Perls unntak er teknisk feil, vil det fungere på nesten alle protokoller og er like bærbart på tvers av alle plattformer. Derfor, i alle Perl-eksemplene i denne boken, bruker jeg linjeseparerende overskrifter i stedet for vognretur og linjeskift.

En passende løsning på dette problemet er presentert i kapittel 4, konklusjon.

Verken webserveren eller nettleseren bryr seg om hvilket språk som brukes til å skrive programmet. Selv om hvert språk har fordeler og ulemper som et CGI-programmeringsspråk, er det best å bruke det språket du er mest komfortabel med å jobbe med. (Valget av programmeringsspråk er diskutert mer detaljert i kapittel 1, "Common Gateway Interface (CGI)").

CGI-gjengivelse

Nå kan du se nærmere på problemet med å sende informasjon til nettleseren. Fra "Hello, World!"-eksemplet kan du se at nettlesere forventer to sett med data: en header, som inneholder informasjon som hvilken informasjon som skal vises (f.eks. Content-Type: line) og faktisk informasjon (hva nettleseren skjermer). Disse to opplysningene er atskilt med en tom linje.

Overskriften kalles HTTP-overskriften. Den gir viktig informasjon om informasjonen som nettleseren skal motta. Det finnes flere forskjellige typer HTTP-headere, og den vanligste er den du har brukt før: Content-Type: header. Du kan bruke forskjellige kombinasjoner av HTTP-hoder, atskilt med vognretur og nylinjer (\r\n). Den tomme linjen som skiller overskriften fra dataene består også av en vognretur og en ny linje (hvorfor begge er nødvendig er kort diskutert i det foregående notatet og detaljert i kapittel 4). Du vil lære om andre HTTP-hoder i kapittel 4; For øyeblikket har du å gjøre med Content-Type: header.

Content-Type: Overskriften beskriver typen data som CGI returnerer. Det riktige formatet for denne overskriften er:

Innholdstype: undertype/type

Der undertype/type er den riktige typen Multipurpose Internet Mail Extensions (MIME). Den vanligste MIME-typen er HTML-typen: text/html. Tabell 2.1 viser noen flere vanlige MIME-typer som vil bli diskutert; En mer fullstendig liste og analyse av MIME-typer er gitt i kapittel 4.

Merk

MIME ble opprinnelig oppfunnet for å beskrive innholdet i e-postmeldinger. Det har blitt en ganske vanlig måte å representere informasjon av innholdstype. Du kan lese mer om MIME i RFC1521. RFC-er på Internett står for Requests for Comments, som er sammendrag av beslutninger tatt av grupper på Internett som prøver å sette standarder. Du kan se resultatene av RFC1521 på følgende adresse: http://andrew2.andrew.cmu.edu/rfc/rfc1521.html

Tabell 2.1. Noen vanlige MIME-typer. MIME-type Beskrivelse Tekst/html Hypertekst Markup Language (HTML) Tekst/ren tekstfiler Bilde/gif Grafikkfiler GIF Bilde/jpeg Komprimerte grafikkfiler JPEG-lyd/grunnleggende lydfiler Sun *.au Audio/x-wav Windows-filer *. wav

Etter overskriften og en tom linje skriver du ganske enkelt ut dataene i skjemaet du trenger. Hvis du sender HTML, skriv ut HTML-taggene og dataene til stdout etter overskriften. Du kan også sende grafikk, lyd og andre binære filer ved ganske enkelt å skrive ut innholdet i filen til stdout. Det er gitt flere eksempler på dette i kapittel 4.

Installere og kjøre et CGI-program

Denne delen avviker noe fra CGI-programmering og snakker om å konfigurere webserveren til å bruke CGI, installere og kjøre programmer. Du vil bli introdusert til forskjellige servere for forskjellige plattformer mer eller mindre detaljert, men du må grave dypere i serverens dokumentasjon for å finne det beste alternativet.

Alle servere krever plass til serverfiler og plass til HTML-dokumenter. I denne boken heter serverområdet ServerRoot, og dokumentområdet heter DocumentRoot. På UNIX-maskiner er ServerRoot vanligvis i /usr/local/etc/httpd/, og DocumentRoot er vanligvis i /usr/local/etc/httpd/htdocs/. Dette vil imidlertid ikke utgjøre noen forskjell for systemet ditt, så bytt ut alle referanser til ServerRoot og DocumentRoot med din egen ServerRoot og DocumentRoot.

Når du får tilgang til filer ved hjelp av nettleseren, spesifiserer du filen i URL-en i forhold til DocumentRoot. For eksempel, hvis serveradressen din er mymachine.org, får du tilgang til denne filen med følgende URL: http://mymachine.org/index.html

Konfigurere serveren for CGI

De fleste webservere er forhåndskonfigurert for å tillate bruk av CGI-programmer. Vanligvis indikerer to parametere for serveren om filen er en CGI-applikasjon eller ikke:

  • Utpekt katalog. Noen servere lar deg bestemme at alle filene i en utpekt katalog (vanligvis kalt cgi-bin som standard) er CGI.
  • Filnavnutvidelser. Mange servere har denne forhåndskonfigurasjonen som gjør at alle filer som slutter på .cgi kan defineres som CGI.

Den utpekte katalogmetoden er noe av en relikvie fra fortiden (de aller første serverne brukte den som den eneste metoden for å avgjøre hvilke filer som var CGI-programmer), men den har flere fordeler.

  • Det holder CGI-programmer sentralisert, og forhindrer at andre kataloger blir rotete.
  • Du er ikke begrenset til noen bestemt filtype, så du kan navngi filene dine hva du vil. Noen servere lar deg angi flere forskjellige kataloger som CGI-kataloger.
  • Det gir deg også mer kontroll over hvem som kan ta opp CGI. For eksempel, hvis du har en server og støtter et system med flere brukere og ikke vil at de skal bruke sine egne CGI-skript uten først å ha gjennomgått programmet av sikkerhetsgrunner, kan du angi bare disse filene i en begrenset, sentralisert katalog som CGI . Brukere må da gi deg CGI-programmer for å installere, og du kan først revidere koden for å sikre at programmet ikke har noen store sikkerhetsproblemer.

CGI-notasjonen via filtypen kan være nyttig på grunn av dens fleksibilitet. Du er ikke begrenset til én enkelt katalog for CGI-programmer. De fleste servere kan konfigureres til å gjenkjenne CGI via filtypen, selv om ikke alle er konfigurert på denne måten som standard.

Advarsel

Husk viktigheten av sikkerhetsproblemer når du konfigurerer serveren din for CGI. Noen tips vil bli dekket her, og kapittel 9, Protecting CGI, dekker disse aspektene mer detaljert.

Installere CGI på UNIX-servere

Uansett hvordan UNIX-serveren din er konfigurert, er det flere trinn du må ta for å sikre at CGI-applikasjonene kjører som forventet. Webserveren din vil vanligvis kjøre som en ikke-eksisterende bruker (det vil si UNIX-brukeren ingen - en konto som ikke har filrettigheter og ikke kan logges på). CGI-skript (skrevet i Perl, Bourne-skallet eller et annet skriptspråk) må være kjørbare og lesbare over hele verden.

Clue

For å gjøre filene dine verdenslesbare og kjørbare, bruk følgende UNIX-tillatelseskommando: chmod 755 filnavn.

Hvis du bruker et skriptspråk som Perl eller Tcl, oppgi hele banen til tolken din på den første linjen i skriptet. For eksempel vil et Perl-skript som bruker perl i /usr/local/bin-katalogen begynne med følgende linje:

#!/usr/local/bin/perl

Advarsel

Plasser aldri tolken (perl, eller Tcl Wish binær) i /cgi-bin-katalogen. Dette skaper en sikkerhetsrisiko på systemet ditt. Dette diskuteres mer detaljert i kapittel 9.

Noen generiske UNIX-servere

NCSA- og Apache-serverne har lignende konfigurasjonsfiler fordi Apache-serveren opprinnelig var basert på NCSA-koden. Som standard er de konfigurert slik at enhver fil i cgi-bin-katalogen (som ligger som standard i ServerRoot) er et CGI-program. For å endre plasseringen av cgi-bin-katalogen, kan du redigere konfigurasjonsfilen conf/srm.conf. Formatet for å konfigurere denne katalogen er

ScriptAlias ​​​​fakedirectoryname realdirectoryname

der fakedirectoryname er pseudokatalognavnet (/cgi-bin) og realdirectoryname er hele banen der CGI-programmene faktisk er lagret. Du kan konfigurere mer enn ett ScriptAlias ​​ved å legge til flere ScriptAlias-linjer.

Standardkonfigurasjonen er tilstrekkelig for de fleste brukeres behov. Du må redigere linjen i srm.conf-filen i begge tilfeller for å finne riktig realdirectoryname. Hvis for eksempel CGI-programmene dine er plassert i /usr/local/etc/httpd/cgi-bin, skal ScriptAlias-linjen i srm.conf-filen din være omtrent slik:

ScriptAlias ​​​​/cgi-bin/ /usr/local/etc/httpd/cgi-bin/

For å få tilgang til eller koble til CGI-programmer i denne katalogen, bruk følgende URL:

Http://vertsnavn/cgi-bin/programnavn

Der vertsnavn er navnet på verten til webserveren din, og programnavn er navnet på CGI-en din.

La oss for eksempel si at du kopierer hello.cgi-programmet til cgi-bin-katalogen din (f.eks. /usr/local/etc/httpd/cgi-bin) på webserveren din kalt www.company.com. For å få tilgang til din CGI, bruk følgende URL: http://www.company.com/cgi-bin/hello.cgi

Hvis du vil konfigurere NCSA- eller Apache-serveren til å gjenkjenne en fil med en .cgi-utvidelse som en CGI, må du redigere to konfigurasjonsfiler. Først, i srm.conf-filen, fjerner du følgende linje:

AddType application/x-httpd-cgi .cgi

Dette vil knytte MIME-typen CGI til .cgi-utvidelsen. Nå må vi endre filen access.conf slik at vi kan kjøre CGI i hvilken som helst katalog. For å gjøre dette, legg til ExecCGI-alternativet på Option-linjen. Det vil se omtrent ut som følgende linje:

Opsjonsindekser FollowSymLinks ExecCGI

Nå regnes enhver fil med filtypen .cgi som CGI; få tilgang til den som en hvilken som helst fil på serveren din.

CERN-serveren er konfigurert på samme måte som Apache- og NCSA-servere. I stedet for ScriptAlias ​​bruker CERN-serveren Exec-kommandoen. For eksempel, i httpd.conf-filen vil du se følgende linje:

Exec /cgi-bin/* /usr/local/etc/httpd/cgi-bin/*

Andre UNIX-servere kan konfigureres på samme måte; Dette er beskrevet mer detaljert i serverdokumentasjonen.

Installere CGI på Windows

De fleste servere som er tilgjengelige for Windows 3.1, Windows 95 og Windows NT er konfigurert ved hjelp av "filnavnsutvidelse"-metoden for CGI-gjenkjenning. Generelt krever endring av konfigurasjonen til en Windows-basert server ganske enkelt å kjøre serverkonfigurasjonsprogrammet og gjøre de nødvendige endringene.

Noen ganger kan det være vanskelig å konfigurere en server til å kjøre et skript (som Perl) riktig. I DOS eller Windows vil du ikke kunne spesifisere tolken på den første linjen i skriptet, slik tilfellet er med UNIX. Noen servere har en forhåndsdefinert konfigurasjon for å knytte visse filnavn til tolken. For eksempel antar mange Windows-webservere at filer som slutter på .pl er Perl-skript.

Hvis serveren ikke utfører denne typen filtilknytning, kan du definere en pakkefil som kaller både tolken og skriptet. Som med UNIX-serveren, ikke installer tolken verken i cgi-bin-katalogen eller noen netttilgjengelig katalog.

Installere CGI på Macintosh

De to mest kjente serveralternativene for Macintosh er WebStar StarNine og forgjengeren MacHTTP. Begge gjenkjenner CGI ved filtypen.

MacHTTP forstår to forskjellige utvidelser: .cgi og .acgi, som står for asynkron CGI. Vanlige CGI-programmer installert på en Macintosh (med en .cgi-utvidelse) vil holde webserveren i en opptatt tilstand til CGI kjører ferdig, noe som får serveren til å suspendere alle andre forespørsler. Asynkron CGI, derimot, lar serveren godta forespørsler selv mens den kjører.

En CGI Macintosh-utvikler som bruker en av disse webserverne, bør, hvis mulig, bare bruke .acgi-utvidelsen i stedet for .cgi-utvidelsen. Det skal fungere med de fleste CGI-programmer; hvis det ikke fungerer, endre navn på programmet til .cgi.

Utfører CGI

Når du har installert CGI, er det flere måter å utføre den på. Hvis CGI-programmet ditt er et program med kun utdata, for eksempel Hello,World!-programmet, kan du kjøre det ganske enkelt ved å gå til URL-en.

De fleste programmer kjører som en serverapplikasjon på et HTML-skjema. Før du lærer hvordan du får informasjon fra disse skjemaene, bør du først lese en kort introduksjon om hvordan du lager slike skjemaer.

En rask veiledning om HTML-skjemaer

De to viktigste kodene i et HTML-skjema er Og . Du kan lage de fleste HTML-skjemaer ved å bruke bare disse to kodene. I dette kapittelet vil du utforske disse kodene og et lite undersett av mulige typer eller attributter. . En komplett veiledning og lenke til HTML-skjemaer er i kapittel 3, HTML og skjemaer.

stikkord

stikkord brukes til å bestemme hvilken del av HTML-filen som skal brukes for brukeroppgitt informasjon. Dette refererer til hvordan de fleste HTML-sider kaller et CGI-program. Tag-attributter spesifiserer programmets navn og plassering - enten lokalt eller som en fullstendig URL, typen koding som brukes, og dataoverføringsmetoden som brukes av programmet.

Den neste linjen viser spesifikasjonene for taggen :

< ACTION FORM = "url" METHOD = ENCTYPE = "..." >

ENCTYPE-attributtet spiller ingen spesiell rolle og er vanligvis ikke inkludert i taggen . Detaljert informasjon om ENCTYPE-taggen er gitt i kapittel 3. En måte å bruke ENCTYPE på er vist i kapittel 14, "Branded Extensions."

ACTION-attributtet refererer til URL-en til CGI-programmet. Når brukeren fyller ut skjemaet og gir informasjon, blir all informasjon kodet og overført til CGI-programmet. CGI-programmet løser selv problemet med dekoding og prosessering av informasjon; Dette aspektet er diskutert i "Godta inndata fra nettleseren," senere i dette kapittelet.

Til slutt beskriver METHOD-attributtet hvordan CGI-programmet skal motta input. De to metodene, GET og POST, er forskjellige i hvordan de sender informasjon til CGI-programmet. Begge er omtalt i "Godta inndata fra nettleseren."

For at nettleseren skal tillate brukerinndata, må alle skjematagger og informasjon være omgitt av taggen . Ikke glem den avsluttende taggen

for å indikere slutten av skjemaet. Du kan ikke ha et skjema i et skjema, selv om du kan sette opp et skjema som lar deg presentere deler av informasjon på forskjellige steder; Dette aspektet er grundig omtalt i kapittel 3.

stikkord

Du kan opprette tekstinndatafelter, alternativknapper, avmerkingsbokser og andre måter å godta inndata ved å bruke taggen . Denne delen dekker bare tekstinntastingsfelt. For å implementere dette feltet, bruk taggen med følgende attributter:

< INPUT TYPE=text NAME = "... " VALUE = "... " SIZE = MAXLENGTH = >

NAME er det symbolske navnet på variabelen som inneholder verdien angitt av brukeren. Hvis du inkluderer tekst i VALUE-attributtet, vil denne teksten bli plassert som standard i tekstinntastingsfeltet. SIZE-attributtet lar deg spesifisere den horisontale lengden på inndatafeltet slik det vil vises i nettleservinduet. Til slutt spesifiserer MAXLENGTH maksimalt antall tegn brukeren kan skrive inn i feltet. Vær oppmerksom på at attributtene VALUE, SIZE, MAXLENGTH er valgfrie.

Skjemainnlevering

Hvis du bare har ett tekstfelt i et skjema, kan brukeren sende inn skjemaet ved å skrive inn informasjon på tastaturet og trykke Enter. Ellers må det være en annen måte for brukeren å presentere informasjonen på. Brukeren sender inn informasjon ved å bruke en send-knapp med følgende tag:

< Input type=submit >

Denne taggen oppretter en Send-knapp inne i skjemaet ditt. Når brukeren er ferdig med å fylle ut skjemaet, kan han eller hun sende inn innholdet til URL-en spesifisert av skjemaets ACTION-attributt ved å klikke på Send-knappen.

Godtar input fra nettleseren

Ovenfor var eksempler på opptak av et CGI-program som sender informasjon fra serveren til nettleseren. I virkeligheten har ikke et CGI-program som bare sender ut data mange applikasjoner (noen eksempler er gitt i kapittel 4). Den viktigste evnen til CGI er å motta informasjon fra nettleseren - funksjonen som gir nettet dens interaktive karakter.

CGI-programmet mottar to typer informasjon fra nettleseren.

  • Først innhenter den ulike deler av informasjon om nettleseren (type, hva den kan se, vertsvert og så videre), serveren (navn og versjon, utførelsesport og så videre), og CGI-programmet seg selv (programnavn og hvor det er plassert). Serveren gir all denne informasjonen til CGI-programmet gjennom miljøvariabler.
  • For det andre kan CGI-programmet motta brukerinndata. Denne informasjonen, etter å ha blitt kodet av nettleseren, sendes enten gjennom en miljøvariabel (GET-metoden) eller gjennom standardinndata (stdin - POST-metoden).

Miljøvariabler

Det er nyttig å vite hvilke miljøvariabler som er tilgjengelige for et CGI-program, både under trening og for feilsøking. Tabell 2.2 viser noen av de tilgjengelige CGI-miljøvariablene. Du kan også skrive et CGI-program som sender ut miljøvariabler og deres verdier til en nettleser.

Tabell 2.2. Noen viktige CGI-miljøvariabler Miljøvariabel Formål REMOTE_ADDR IP-adressen til klientmaskinen. REMOTE_HOST Verten for klientmaskinen. HTTP _ACCEPT Viser MIME-datatypene som nettleseren kan tolke. HTTP _USER_AGENT Nettleserinformasjon (nettlesertype, versjonsnummer, operativsystem osv.). REQUEST_METHOD GET eller POST. CONTENT_LENGTH Størrelsen på inndata hvis det sendes via POST. Hvis det ikke er noen inndata eller hvis GET-metoden brukes, er denne parameteren udefinert. QUERY_STRING Inneholder inndatainformasjonen når den sendes med GET-metoden. PATH_INFO Lar brukeren spesifisere en bane fra CGI-kommandolinjen (for eksempel http://vertsnavn/cgi-bin/programnavn/bane). PATH_TRANSLATED Oversetter den relative banen i PATH_INFO til en faktisk bane på systemet.

For å skrive en CGI-applikasjon som viser miljøvariabler, må du vite hvordan du gjør to ting:

  • Definer alle miljøvariabler og deres tilsvarende verdier.
  • Skriv ut resultater til nettleseren.

Du vet allerede hvordan du utfører den siste operasjonen. I Perl lagres miljøvariabler i den assosiative matrisen %ENV, som introduseres av navnet på miljøvariabelen. Oppføring 2.3 inneholder env.cgi, et Perl-program som oppnår målet vårt.

Oppføring 2.3. Et Perl-program, env.cgi, som skriver ut alle CGI-miljøvariablene.

#!/usr/local/bin/perl print "Innholdstype: text/html\n\n"; skrive ut " \n"; skriv ut " CGI-miljø\n"; skriv ut "\n"; skriv ut " \n"; skriv ut "

CGI-miljø

\n"; foreach $env_var (nøkler %ENV) ( skriv ut " $env_var= $ENV($env_var)
\n"; ) skriv ut " \n";

Et lignende program kan skrives i C; den fullstendige koden er i oppføring 2.4.

Oppføring 2.4. Env.cgi.c i C. /* env.cgi.c */ #include ekstern røye **miljø; int main() ( char **p = environ; printf("Innholdstype: text/html\r\n\r\n"); printf(" \n"); printf(" CGI-miljø\n"); printf("\n"); printf(" \n"); printf("

CGI-miljø

\n"); while(*p != NULL) printf("%s
\n",*p++); printf(" \n"); )

FÅ eller POST?

Hva er forskjellen mellom GET- og POST-metodene? GET sender den kodede inndatastrengen gjennom miljøvariabelen QUERY_STRING, mens POST sender den gjennom stdin. POST er den foretrukne metoden, spesielt for skjemaer med mye data, fordi det ikke er noen begrensninger på mengden informasjon som sendes, mens med GET-metoden er mengden medieplass begrenset. GET har imidlertid en viss nyttig egenskap; dette er dekket i detalj i kapittel 5, Innspill.

For å finne ut hvilken metode som brukes, sjekker CGI-programmet miljøvariabelen REQUEST_METHOD, som settes til enten GET eller POST. Hvis den er satt til POST, lagres lengden på den kodede informasjonen i miljøvariabelen CONTENT_LENGTH.

Kodet inngang

Når en bruker sender inn et skjema, koder nettleseren først informasjonen før den sendes til serveren og deretter til CGI-applikasjonen. Når du bruker taggen , får hvert felt et symbolsk navn. Verdien angitt av brukeren er representert som verdien av variabelen.

For å fastslå dette bruker nettleseren en URL-kodingsspesifikasjon, som kan beskrives som følger:

  • Skiller forskjellige felt med et og-tegnet (&).
  • Skiller navn og verdier med likhetstegn (=), med navnet til venstre og verdien til høyre.
  • Erstatter mellomrom med plusstegn (+).
  • Erstatter alle "unormale" tegn med et prosenttegn (%) etterfulgt av en tosifret sekskantkode for tegnet.

Den endelige kodede strengen din vil ligne på følgende:

Navn1=verdi1&navn2=verdi2&navn3=verdi3 ...

Merk: Spesifikasjoner for URL-koding finnes i RFC1738.

La oss for eksempel si at du hadde et skjema som spurte om navn og alder. HTML-koden som ble brukt til å vise dette skjemaet er vist i oppføring 2.5.

Oppføring 2.5. HTML-kode for å vise navn og aldersskjema.

Navn og alder

Skriv inn navnet ditt:

Skriv inn alderen din:

La oss si at brukeren skriver inn Joe Schmoe i navnefeltet og 20 i aldersfeltet. Inndataene vil bli kodet i inndatastrengen.

Navn=Joe+Schmoe&age=20

Parsing input

For at denne informasjonen skal være nyttig, må du bruke informasjonen om noe som kan brukes av CGI-programmene dine. Strategier for å analysere input er dekket i kapittel 5. I praksis vil du aldri trenge å tenke på hvordan du analyserer input, fordi flere eksperter allerede har skrevet biblioteker som gjør parsingen, tilgjengelig for alle. To slike biblioteker presenteres i dette kapittelet i følgende avsnitt: cgi -lib.pl for Perl (skrevet av Steve Brenner) og cgihtml for C (skrevet av meg).

Det generelle målet for de fleste biblioteker skrevet på forskjellige språk er å analysere en kodet streng og sette navn og verdipar inn i en datastruktur. Det er en åpenbar fordel med å bruke et språk som har innebygde datastrukturer som Perl; Imidlertid inkluderer de fleste biblioteker for lavnivåspråk som C og C++ datastruktur og subrutinekjøring.

Det er ikke nødvendig å oppnå en fullstendig forståelse av biblioteker; det er viktigere å lære å bruke dem som verktøy for å gjøre jobben til CGI-programmereren enklere.

Cgi-lib.pl

Cgi-lib.pl bruker Perl assosiative arrays. &ReadParse-funksjonen analyserer inndatastrengen og legger inn hvert navn/verdipar etter navn. For eksempel vil de tilsvarende Perl-strengene som trengs for å dekode "navn/alder"-inndatastrengen som nettopp ble presentert være

&ReadParse(*input);

Nå, for å se verdien angitt for "navn", kan du få tilgang til den assosiative matrisen $input("navn"). På samme måte, for å få tilgang til verdien av "alder", må du se på variabelen $input ("alder").

Cgihtml

C har ingen innebygde datastrukturer, så cgihtml implementerer sin egen lenkeliste for bruk med sine CGI-parseringsrutiner. Dette definerer entrytype-strukturen som følger:

Typedef struct ( Char *navn; Char *verdi; ) Entrytype;

For å analysere inndatastrengen "navn/alder" i C ved hjelp av cgihtml, brukes følgende:

/* erklærer en koblet liste kalt input */ Llist input; /* analyser input og plassering i koblet liste */ read_cgi_input(&input);

For å få tilgang til aldersinformasjon kan du enten analysere listen manuelt eller bruke den tilgjengelige cgi _val()-funksjonen.

#inkludere #inkludere Char *alder = malloc(sizeof(char)*strlen(cgi_val(input, "alder")) + 1); Strcpy(alder, cgi_val(input, "alder"));

"Alder"-verdien er nå lagret i aldersstrengen.

Merk: I stedet for å bruke en enkel matrise (som char age ;), tildeler jeg dynamisk minneplass for strengalderen. Selv om dette gjør programmering vanskeligere, er det likevel viktig fra et sikkerhetssynspunkt. Dette er nærmere omtalt i kapittel 9.

Et enkelt CGI-program

Du skal skrive et CGI-program kalt nameage.cgi som håndterer navn/alder-skjemaet. Databehandling (det jeg vanligvis kaller "ting i mellom") er minimal. Nameage.cgi dekoder ganske enkelt inndataene og viser brukerens navn og alder. Selv om det ikke er mye bruk for et slikt verktøy, demonstrerer det det mest kritiske aspektet ved CGI-programmering: input og output.

Du bruker samme skjema som ovenfor, og ringer opp "navn og alder"-feltene. Ikke bekymre deg for robusthet og effektivitet ennå; løse det eksisterende problemet på den enkleste måten. Perl- og C-løsningene er vist i henholdsvis lister 2.6 og 2.7.

Oppføring 2.6. Nameage.cgi i Perl

#!/usr/local/bin/perl # nameage.cgi krever "cgi-lib.pl" &ReadParse(*input); print "Innholdstype: tekst/html\r\n\r\n"; skrive ut " \n"; skriv ut " Navn og alder\n"; skriv ut "\n"; skriv ut " \n"; skriv ut "Hei, " . $input("navn") . ". Du er\n"; print $input("alder") . " år gammel.

\n"; skriv ut " \n";

Oppføring 2.7. nameage.cgi i C

/* nameage.cgi.c */ #include #include "cgi-lib.h" int main() ( llist input; read_cgi_input(&input); printf("Content-Type: text/html\r\n\r\n"); printf(" \n"); printf(" Navn og alder\n"); printf("\n"); printf(" \n"); printf("Hei, %s. Du er\n",cgi_val(input,"navn")); printf("%s år gammel.

\n",cgi_val(input,"alder")); printf(" \n"); )

Vær oppmerksom på at disse to programmene er nesten likeverdige. De inneholder begge parseringsrutiner som kun opptar én linje og behandler hele inndataene (takket være de tilsvarende biblioteksrutinene). Utdataene er i hovedsak en modifisert versjon av hovedprogrammet Hello, World!.

Prøv å kjøre programmet ved å fylle ut skjemaet og klikke på Send-knappen.

Generell programmeringsstrategi

Du kjenner nå alle de grunnleggende prinsippene som kreves for CGI-programmering. Når du forstår hvordan CGI mottar informasjon og hvordan den sender den tilbake til nettleseren, avhenger den faktiske kvaliteten på det endelige produktet av dine generelle programmeringsevner. Nemlig, når du programmerer CGI (eller noe i det hele tatt, for den saks skyld), husk følgende egenskaper:

  • Enkelhet
  • Effektivitet
  • Allsidighet

De to første egenskapene er ganske vanlige: prøv å gjøre koden så lesbar og effektiv som mulig. Allsidighet gjelder mer for CGI-programmer enn for andre programmer. Når du begynner å utvikle dine egne CGI-programmer, vil du lære at det er flere grunnleggende applikasjoner som alle ønsker å lage. For eksempel er en av de vanligste og mest åpenbare oppgavene til et CGI-program å behandle et skjema og sende resultatene på e-post til en bestemt mottaker. Du kan ha flere separate skjemaer behandlet, hver med en annen mottaker. I stedet for å skrive et CGI-program for hvert enkelt skjema, kan du spare tid ved å skrive et mer generelt CGI-program som gjelder alle skjemaer.

Ved å dekke alle de grunnleggende aspektene ved CGI, har jeg gitt deg nok informasjon til å komme i gang med CGI-programmering. For å bli en effektiv CGI-utvikler må du imidlertid ha en dypere forståelse av hvordan CGI kommuniserer med serveren og nettleseren. Resten av denne boken dekker i detalj problemene som kort ble nevnt i dette kapittelet, samt applikasjonsutviklingsstrategi og fordelene og begrensningene ved protokollen.

Sammendrag

Dette kapittelet introduserte kort det grunnleggende om CGI-programmering. Du lager utdata ved å formatere dataene dine riktig og skrive ut til stdout. Å motta CGI-inndata er litt mer komplisert fordi det må analyseres før det kan brukes. Heldigvis finnes det allerede flere biblioteker som utfører parsing.

Nå bør du være ganske komfortabel med å programmere CGI-applikasjoner. Resten av denne boken går mer i detalj om spesifikasjoner, tips og programmeringsstrategier for mer avanserte og komplekse applikasjoner.

Side 1 av 30

I dag er slike ting som en gjestebok, serversøk og et skjema for å sende meldinger en integrert egenskap for nesten alle seriøse nettsider. Problemet med å introdusere disse og andre bjeller og plystre vekker selvfølgelig på alle mulige måter fantasien til en nybegynner webmaster, og berøver ham søvn, appetitt og sug etter øl. Dessverre gir det å studere HTML-kildene til konkurrentenes sider ikke annet enn lenker til en viss "cgi-bin", og i nyhetsgrupper er det noen ganger en omtale av noen cgi-skript. Denne artikkelen er viet til det grunnleggende om å bruke de samme CGI-skriptene for ære og velstand til nettstedet ditt.

Til å begynne med tror jeg vi må forstå begrepene. Et CGI-skript er et program som kjører på en webserver på forespørsel fra en klient (det vil si en besøkende på nettstedet). Dette programmet er fundamentalt ikke forskjellig fra vanlige programmer som er installert på datamaskinen din - det være seg MS Word eller Quake-spillet. CGI er ikke programmeringsspråket som skriptet er skrevet på, men Common Gateway Interface er et spesielt grensesnitt som skriptet lanseres og samhandles med.

En kort digresjon om CGI

Så hva er det CGI- manus og lignende ting generelt. La oss starte med det faktum at nettleseren din (da du skrev URL) kobles til via protokoll HTTP med den angitte serveren og ber den om den nødvendige filen, noe som dette:

GET /~paaa/cgi-bin/guestbbok.cgi HTTP/1.0-Dette er det viktigste i forespørselen

Vel, hvis en enkel fil er forespurt, for eksempel .html så hvis det er en slik fil, vil serveren sende et svar til nettleseren:

HTTP/1.0 200 Ok
Innholdstype: tekst/html

Videre etter den tomme linjen (det er nødvendig for å skille tittel fra kropp) informasjon kommer fra URL"EN ...
Det er i grunnen alt WWW....du går fra lenke til lenke....
Hva om du trenger å legge til noe i denne kjedelige prosessen? på ekte interaktiv, dynamisk, vakker og storslått....? Vel, det er et svar på dette spørsmålet. Bare hva hvis i den forespurte URL angi et spesielt program ( CGI,program Felles gateway-grensesnitt - Felles gateway-grensesnitt) og det dette programmet produserer sendes så til nettleseren.... Serveren starter .cgi programmet, og for eksempel etter å ha behandlet skjemadataene, legger det deg et sted inn i databasen, og det vil fortelle deg at du er en flott fyr :)
Vel, jeg håper jeg har fascinert deg......?

Kort informasjon om hva du trenger å vite for å skrive CGI skript: Vel, først og fremst må du vite hva det er Internett og hvordan det fungerer (vet du? ;))) ) Vel, og litt programmeringsevne (dette er det viktigste)
La oss skrive et enkelt manus sammen, og så skal jeg fortelle deg hvor hunden rotet...
Vel, først lag en katalog i hjemmekatalogen din cgi-bin:

cd public_html
mkdir cgi-bin
chmod 0777 cgi-bin

Den siste linjen vil være veldig viktig.
Ta redaktøren og skriv: #!/usr/bin/perl
#first.cgi
print "Innholdstype: tekst/html\n\n";
skrive ut " ";
skrive ut "

Hei du!!!

";
skrive ut "";

Lagre den i en katalog cgi-bin under navnet første.cgi.Vel, hvordan reddet du det?
Gjør det nå kjørbart (det er tross alt et program):

chmod +x først.cgi

Vel, vi nærmer oss det høytidelige øyeblikket... skriv inn nettleserlinjen http://www.uic.nnov.ru/~your_login/cgi-bin/first.cgi
og se hva som skjer. Det vil være en av to ting, enten vil skriptet fungere og du vil se siden det genererte (gratulerer, regimentet vårt har kommet!) eller intern server feil- Ikke vær lei deg, du har gjort noe galt. Da trenger du en guide til å fange lopper. Vel, for det første kan syntakskontroll gjøres som følger:

perl -med først.cgi

Perl vil umiddelbart gi deg enten feilmeldinger (vel, noen ganger har du gått glipp av et semikolon, glemt å lukke parenteser eller anførselstegn...) dette kan rettes umiddelbart underveis.
En mer logisk tilnærming er å hoppe over utdataene fra den tomme linjen som skiller overskriften fra hovedteksten:
print "Innholdstype: tekst/html\n\n"; #Alt er rett
print "Innholdstype: tekst/html\n"; #FEIL!!!

La oss analysere manuset:
Første linje #!/usr/bin/perl Det indikerer ganske enkelt hvor Perl er plassert på systemet. Det andre er bare en kommentar - du kan stikke hva som helst etter skiltet #
Så kommer print "Innholdstype: tekst/html\n\n"; Dette er en overskrift som indikerer innholdstypen; alt som skriptet skriver ut til standardutgangen STDOUT går til serveren for behandling. En tom linje skiller overskriften fra kroppen, som i vårt tilfelle er

Hei du!!!



Serveren vil behandle skriptsvaret og, basert på det, generere og sende et svar til nettleseren. (Tjeneren endrer vanligvis ikke teksten i meldingen, den supplerer bare overskriften med feltene som er nødvendige for HTTP-protokollen)

Vel, det grunnleggende er allerede mestret, alt er ikke så vanskelig og deprimerende som det kan virke med det første
Nå kan du øve deg på å skrive slike enkle manus selv for å bli bedre på det.

Kapittel #9.

Programmering med CGI

Å inkludere en del om CGI i en bok om databaser kan virke like merkelig som å inkludere et kapittel om bilreparasjon i en kokebok. For å gå til matbutikken trenger du selvfølgelig en fungerende bil, men passer det å snakke om dette? En fullstendig diskusjon av CGI og webprogrammering generelt ligger utenfor denne bokens omfang, men en kort introduksjon til disse emnene er nok til å utvide mulighetene til MySQL og mSQL for å presentere data i nettets rike.

Dette kapittelet er først og fremst ment for de som studerer databaser, men som ønsker å få litt kunnskap om webprogrammering. Hvis etternavnet ditt er Berners-Lee eller Andreessen, vil du neppe finne noe her som du ikke allerede vet. Men selv om du ikke er ny til CGI, kan det være ganske nyttig å ha en rask referanse mens du dykker inn i mysteriene til MySQL og mSQL.

Hva er CGI?

Som de fleste akronymer sier ikke Common Gateway Interface (CGI) så mye. Grensesnitt med hva? Hvor er denne porten? Hva slags fellesskap snakker vi om? For å svare på disse spørsmålene, la oss gå litt tilbake og ta en titt på WWW som helhet.

Tim Berners-Lee, en fysiker som jobbet ved CERN, kom opp med ideen om nettet i 1990, selv om planen dateres tilbake til 1988. Ideen var å gjøre det mulig for partikkelfysikkforskere å enkelt og raskt dele multimediedata - tekst , bilder og lyd - gjennom Internett. WWW besto av tre hoveddeler: HTML, URL og HTTP. HTML - Et formateringsspråk som brukes til å presentere innhold på nettet. URL - dette er adressen som brukes til å hente HTML (eller annet) innhold fra webserveren. Og endelig HTTP - det er et språk som forstås av webserveren og lar klienter be om dokumenter fra serveren.

Muligheten til å sende informasjon av alle typer over Internett var revolusjonerende, men en annen mulighet ble snart oppdaget. Hvis du kan sende hvilken som helst tekst over nettet, hvorfor kan du da ikke sende tekst opprettet av et program, og ikke hentet fra en ferdig fil? Dette åpner et hav av muligheter. Et enkelt eksempel: du kan bruke et program som viser gjeldende tid slik at leseren ser riktig tid hver gang han ser på siden. Noen smarte hoder ved National Center for Supercomputing Applications (NCSA), som laget en webserver, så denne muligheten, og snart ble CGI født.

CGI er et sett med regler som lar programmer på en server sende data til klienter gjennom en webserver. CGI-spesifikasjonen ble ledsaget av endringer i HTML og HTTP som introduserte en ny funksjon kjent som skjemaer.

Hvis CGI tillater programmer å sende data til klienten, utvider skjemaer denne muligheten ved å la klienten sende data til det CGI-programmet. Nå kan brukeren ikke bare se gjeldende tid, men også stille klokken! CGI-former har åpnet døren til ekte interaktivitet i nettverdenen. Vanlige CGI-applikasjoner inkluderer:

  • Dynamisk HTML. Hele nettsteder kan genereres av ett CGI-program.
  • Søkemotorer som finner dokumenter som inneholder brukerspesifiserte ord.
  • Gjestebøker og oppslagstavler der brukere kan legge til meldinger.
  • Bestillingsskjemaer.
  • Spørreskjemaer.
  • Henter informasjon fra en database som ligger på serveren.

I påfølgende kapitler vil vi diskutere alle disse CGI-applikasjonene, så vel som noen andre. De gir alle en flott måte å koble CGI til en database, som er det vi er interessert i i denne delen.

HTML-skjemaer

Før du utforsker detaljene til CGI, er det nyttig å se på den vanligste måten sluttbrukere gir et grensesnitt til CGI-programmer på: HTML-skjemaer. Skjemaer er en del av HTML-språket som gir sluttbrukeren ulike typer felt. Data som legges inn i felt kan sendes til webserveren. Felter kan brukes til å skrive inn tekst eller være knapper som brukeren kan klikke eller sjekke. Her er et eksempel på en HTML-side som inneholder et skjema:

<НТМL><НЕАD><ТITLЕ>Min skjemaside


<р>Dette er en side med et skjema.


Skriv inn navnet ditt:



Dette skjemaet lager en streng på 40 tegn der brukeren kan skrive inn navnet sitt. Under inngangslinjen er det en knapp, når den klikkes, overføres skjemadataene til serveren. Nedenfor er skjemarelaterte koder som støttes av HTML 3.2, den mest brukte standarden i dag. Tag- og attributtnavn kan angis uansett, men vi følger den valgfrie konvensjonen om at startkoder skrives med store bokstaver og avsluttende tagger skrives med små bokstaver.


Denne taggen indikerer begynnelsen av skjemaet. En avsluttende kode er påkrevd på slutten av skjemaet

. Mellom tagger
Tre attributter er tillatt: ACTION spesifiserer URL-en eller den relative banen til CGI-programmet som dataene skal sendes til; METHOD spesifiserer HTTP-metoden som skjemaet skal sendes gjennom (dette kan være GET eller POST, men vi vil nesten alltid bruke POST); ENCTYPE spesifiserer datakodingsmetoden (denne bør kun brukes hvis du har en klar forståelse av hva du gjør).


Gir den mest fleksible måten for brukerinndata. Det er faktisk ni forskjellige typer tagger . Typen er spesifisert av TYPE-attributtet. Det forrige eksemplet bruker to tagger : en med type SUBMIT og en annen med standard type TEXT. De ni typene er som følger:

TEKST

Et felt der brukeren kan skrive inn én tekstlinje.

PASSORD

Samme som TEKST, men teksten du skriver inn vises ikke på skjermen.

SJEKKER

En avmerkingsboks som brukeren kan velge og fjerne.

RADIO

En alternativknapp som må kombineres med minst én annen alternativknapp. Brukeren kan bare velge én av dem.

SENDE INN

En knapp som, når den klikkes, sender skjemaet til webserveren.

NULLSTILLE

En knapp som, når den klikkes, gjenoppretter skjemaet til standardverdiene.

FIL

Ligner på et tekstvindu, men krever at du skriver inn navnet på filen som skal sendes til serveren.

SKJULT

Et usynlig felt der data kan lagres.

BILDE

Ligner på SUBMIT-knappen, men du kan angi et bilde for bildet på knappen.

I tillegg til TYPE-attributt-taggene har vanligvis et NAME-attributt som assosierer dataene som er angitt i feltet med et eller annet navn. Navnet og dataene sendes til serveren i stilen verdi=verdi. I forrige eksempel ble tekstfeltet kalt fornavn . Du kan bruke VALUE-attributtet til å tilordne forhåndsdefinerte verdier til felt av typen TEXT, PASSWORD, FILE og HIDDEN. Det samme attributtet, brukt med knapper som SUBMIT eller RESET, viser den angitte teksten på dem. Felt av typen RADIO og CHECKBOX kan vises som kontrollert ved å bruke CHECKED-attributtet uten å spesifisere en verdi.

SIZE-attributtet brukes til å angi lengden på TEXT, PASSWORD og FILE-feltene. MAXLENGTH-attributtet kan brukes til å begrense lengden på innskrevet tekst. SRC-attributtet spesifiserer URL-en til bildet som brukes i IMAGE-typen. Til slutt spesifiserer ALIGN-attributtet justeringen av bildet for BILDE-typen og kan være TOP, MIDDLE, BOTTOM (standard), LEFT eller RIGHT (opp, midt, ned, venstre, høyre).

.

Samme som tag , ved taggen , og all tekst mellom taggene vil bli akseptert som standardtekst , som ligner på VALUE-attributtet for en tag . For tag

, som gir plass til å skrive inn et essay. Dataene heter "essay". En tekstblokk er 70 tegn bred og 10 linjer dyp. Mellomrom mellom tagger

kan brukes til en prøveoppgave. -->

typer "SEND" og "TILLBAKEL" henholdsvis. "SUBMIT"-knappen har en overstyrt "Enter data"-etikett, og "RESET"-knappen har en standardetikett (definert av nettleseren). Ved å klikke på "SUBMIT"-knappen vil du sende dataene til webserveren. "RESET"-knappen vil gjenopprette dataene til dens opprinnelige tilstand, og slette alle brukerangitte data. -->


Den eneste inndatatypen vi ikke har brukt her er IMAGE-typen for taggen . Det kan brukes som en alternativ metode for innsending av skjema. Imidlertid er IMAGE-typen sjelden kompatibel med tekstbaserte og mindre responsive nettlesere, så det er lurt å unngå det med mindre nettstedet ditt har en grafisk-tung stil.

Når du har lært det grunnleggende om HTML-skjemaer, kan du begynne å lære om selve CGI.

CGI-spesifikasjon

Så hva er egentlig "reglene" som lar et CGI-program i for eksempel Batavia, Illinois, kommunisere med en nettleser i Ytre Mongolia? Den offisielle CGI-spesifikasjonen, sammen med et vell av annen informasjon om CGI, kan finnes på NCSA-serveren på http://hoohoo . ncsa.uluc.edu/cgi/. Dette kapittelet eksisterer imidlertid av denne grunn, slik at du ikke trenger å reise lenge og lete etter det selv.

Det er fire måter CGI overfører data mellom CGI-npor-rammen og webserveren, og dermed webklienten:

  • Miljøvariabler.
  • Kommandolinje.
  • Standard inndataenhet.
  • Standard utgangsenhet.

Med disse fire metodene videresender serveren alle dataene som sendes av klienten til CGI-programmet. CGI-programmet gjør deretter sin magi og sender utdataene tilbake til serveren, som videresender det til klienten.

Disse dataene er basert på Apache HTTP-serveren. Apache er den vanligste webserveren som kjører på nesten alle plattformer, inkludert Windows 9x og Windows NT. De kan imidlertid gjelde for alle HTTP-servere som støtter CGI. Noen proprietære servere, for eksempel de fra Microsoft og Netscape, kan ha tilleggsfunksjoner eller fungere litt annerledes. Siden ansiktet til nettet fortsetter å endre seg i en utrolig hastighet, utvikler standarder seg fortsatt, og det vil utvilsomt være endringer i fremtiden. Når det gjelder CGI, ser det imidlertid ut til at teknologien er etablert – på bekostning av å bli erstattet av andre teknologier, for eksempel appleter. Eventuelle CGI-programmer du skriver ved hjelp av denne informasjonen vil nesten helt sikkert kunne kjøre i mange år på de fleste webservere.

Når et CGI-program kalles opp gjennom et skjema, det vanligste grensesnittet, sender nettleseren serveren en lang streng som begynner med banen til CGI-programmet og navnet. Dette etterfølges av diverse andre data kalt baneinformasjon, som sendes til CGI-programmet gjennom PATH_INFO miljøvariabelen (Figur 9-1). Baneinformasjonen etterfølges av et "?"-tegn, etterfulgt av skjemadataene, som sendes til serveren ved hjelp av HTTP GET-metoden. Disse dataene gjøres tilgjengelig for CGI-programmet gjennom miljøvariabelen QUERY_STRING. Eventuelle data som siden sender ved hjelp av HTTP POST-metoden, som oftest brukes, vil bli sendt til CGI-programmet via standard enhet input. En typisk streng som en server kan motta fra en nettleser er vist i fig. 9-1. Program navngitt formlest i katalogen cgi-bin kalt opp av serveren med tilleggsbaneinformasjon ekstra informasjon og choice=help request-data - antagelig som en del av den opprinnelige URL-en. Til slutt sendes selve skjemadataene (teksten «CGI-programmering» i «søkeord»-feltet) via HTTP POST-metoden.

Miljøvariabler

Når serveren kjører et CGI-program, sender den først noen data som skal kjøres i form av miljøvariabler. Spesifikasjonen definerer offisielt sytten variabler, men mange flere brukes uformelt gjennom mekanismen beskrevet nedenfor, kalt HTTP_/nec/zams/n. CGI-program

har tilgang til disse variablene akkurat som alle shell-miljøvariabler når de kjøres fra kommandolinje. I et shell-skript, for eksempel, kan F00-miljøvariabelen nås som $F00; i Perl ser dette kallet ut som $ENV("F00"); i C - getenv("F00"); osv. Tabell 9-1 viser variablene som alltid settes av serveren - selv om de er null. I tillegg til disse variablene, blir dataene som returneres av klienten i forespørselshodet tilordnet variabler av formen HTTP_F00, der F00 er navnet på overskriften. For eksempel inkluderer de fleste nettlesere versjonsinformasjon i en overskrift kalt USEfl_AGENT. Din CGI-npor-ramma kan hente disse dataene fra HTTP_USER_AGENT-variabelen.

Tabell 9-1.CGI miljøvariabler

Miljøvariabel

Beskrivelse

CONTENT_LENGTH

Lengde på data overført ved bruk av POST- eller PUT-metoder, i byte.

INNHOLDSTYPE

MIME-typen til dataene vedlagt ved bruk av POST- eller PUT-metodene.

GATEWAY_INTERFACE

Versjonsnummeret til CGI-spesifikasjonen som støttes av serveren.

PATH_INFO

Ytterligere baneinformasjon sendt av klienten. For eksempel for forespørselen http://www.myserver.eom/test.cgi/this/is/a/ sti?felt=grønn verdien av variabelen PATH_ INFO vil være /dette/er/en/bane.

PATH_TRANSLATED

Samme som PATH_INFO, men serveren produserer alle


Mulig oversettelse, for eksempel navneutvidelser som "-konto". »

QUERY_STRING

Alle data etter "?" i URL. Dette er også dataene som sendes når skjemaets REQ-UEST_METHOD er ​​GET.

REMOTE_ADDR

IP-adressen til klienten som sender forespørselen.

REMOTE_HOST

Vertsnavnet til klientmaskinen, hvis tilgjengelig.

REMOTE_IDENT

Hvis webserveren og klienten støtter typeidentifikasjon identd så er dette brukernavnet til kontoen som sender forespørselen.

REQUEST_METHOD

Metoden klienten bruker for å gjøre forespørselen. For CGI-programmene vi skal lage vil dette vanligvis være POST eller GET.

SERVER NAVN Vertsnavnet – eller IP-adressen hvis ikke noe navn er tilgjengelig – til maskinen som kjører webserveren.
SERVER_PORT Portnummeret som brukes av webserveren.
SERVER_PROTOCOL
Protokollen som brukes av klienten for å kommunisere med serveren. I vårt tilfelle er denne protokollen nesten alltid HTTP.
SERVER_SOFTWARE Informasjon om versjonen av webserveren som kjører CGI-programmet.

SCRIPT_NAME

Banen til skriptet som skal kjøres, som spesifisert av klienten. Kan brukes når en URL refererer til seg selv, og slik at skript referert på forskjellige steder kan utføres forskjellig avhengig av plasseringen.

Her er et eksempel på et CGI Perl-skript som skriver ut alle miljøvariablene satt av serveren, samt eventuelle arvede variabler, for eksempel PATH, satt av skallet som startet serveren.

#!/usr/bin/perl -w

skrive ut<< HTML;

Innholdstype: tekst/html\n\n

<р>Miljøvariabler

HTML

foreach (nøkler %ENV) ( skriv ut "$_: $ENV($_)
\n"; )

skrive ut<

HTML

Alle disse variablene kan brukes og til og med modifiseres av ditt CGI-program. Disse endringene påvirker imidlertid ikke webserveren som kjører programmet.

Kommandolinje

CGI lar argumenter sendes til CGI-programmet som kommandolinjeparametere, som sjelden brukes. Den brukes sjelden fordi dens praktiske anvendelser er få, og vi vil ikke dvele ved den i detalj. Poenget er at hvis miljøvariabelen QUERY_STRING ikke inneholder tegnet "=", vil CGI-programmet bli utført med kommandolinjeparameterne hentet fra QUERY_STRING. For eksempel, http://www.myserver.com/cgi- bin/finger?root vil kjøre fingerrot på www.minserver.com.

Det er to hovedbiblioteker som gir et CGI-grensesnitt til Perl. Den første er cgi-lib.pl Nytte cgi-lib.pl veldig vanlig fordi det lenge var det eneste store biblioteket som var tilgjengelig. Den er designet for å fungere i Perl 4, men fungerer med Perl 5. Det andre biblioteket, CGI.pm, nyere og på mange måter overlegen cgi-lib.pl. CGI.pm skrevet for Perl 5 og bruker en fullstendig objektorientert design for arbeid med CGI-data. Modul CGI.pm analyserer standardinndataenheten og QUERY_STRING-variabelen og lagrer dataene i et CGI-objekt. Programmet ditt trenger bare å lage et nytt CGI-objekt og bruke enkle metoder som paramQ for å hente dataene du trenger. Eksempel 9-2 fungerer som en kort demonstrasjon av hvordan CGI.pm tolker dataene. Alle Perl-eksempler i dette kapittelet vil bruke CGI.pm.

Eksempel 9-2. Parsing CGI-data i Perl

#!/usr/bin/perl -w

bruk CGI qw(:standard);

# CGI.pm-modulen brukes. qw(:standard) importerer

# navneområde for standard CGI-funksjoner å få

# klarere kode. Dette kan gjøres hvis i skriptet

# bare ett CGI-objekt brukes.

$mycgi = ny CGI; #Opprett et CGI-objekt som skal være inngangsporten til skjemadataene

@fields = $mycgi->param; # Hent navnene på alle utfylte skjemafelt

print header, start_html("CGI.pm test"); ft Metoder "header" og "start_html",

# sørget for

# CGI.pm, gjør det enklere å få HTML.

# "header" gir den nødvendige HTTP-headeren, en

#"start_html" gir ut en HTML-overskrift med det gitte navnet,

#a er også en tag .

skrive ut "<р>Skjemadata:
";

foreach (@fields) ( skriv ut $_, ":",- $mycgi->param($_), "
"; }

# For hvert felt, skriv ut navnet og verdien oppnådd med

# $mycgi->param("feltnavn").

print end_html; # Stenografi for visning av sluttkoder "".

Behandler inndata i C

Siden kjerne-API-ene for MySQL og mSQL er skrevet i C, vil vi ikke helt forlate C til fordel for Perl, men vi vil gi noen C-eksempler der det er hensiktsmessig. Det er tre mye brukte C-biblioteker for CGI-programmering: cgic Tom Boutell*; cgihtml Eugene Kim og libcgi fra EIT*. Vi tror at cgic er den mest komplette og enkle å bruke. Imidlertid mangler den muligheten til å liste opp alle danne variabler når de ikke er kjent for deg på forhånd. Faktisk kan det legges til med en enkel oppdatering, men det er utenfor rammen av dette kapittelet. Derfor bruker vi i eksempel 9-3 biblioteket cgihtml, for å gjenta Perl-skriptet ovenfor i C.

Eksempel 9-3.Parsing av CGI-data i C

/* cgihtmltest.c - Typisk CGI-program for visning av nøkler og deres verdier

fra data mottatt fra skjemaet */

#inkludere

#include "cgi-lib.h" /* Dette inneholder alle CGI-funksjonsdefinisjoner */

#include "html-lib.h" /* Dette inneholder "alle HTML-hjelpefunksjonsdefinisjoner */

void print_all(lliste 1)

/* Disse funksjonene sender ut dataene som sendes inn av skjemaet i samme format som Perl-skriptet ovenfor. Cgihtml har også en innebygd funksjon

Print_entries(), som gjør det samme ved å bruke HTML-listeformat. */ (

node*vindu;

/* "Node"-typen er definert i cgihtml-biblioteket og refererer til en koblet liste som lagrer alle skjemadataene. */

vindu = I.hode; /* Setter en peker til begynnelsen av skjemadataene */

while (vindu != NULL) ( /* Gå gjennom den koblede listen til det siste (første tomme) elementet */

printf(" %s:%s
\n",vindu->oppføring.navn,erstatt_ltgt(vindu->oppføring.verdi));

/* Skriv ut data. Replace__ltgt() er en funksjon som forstår HTML-kodingen av tekst og sørger for at den sendes ut riktig til klientnettleseren. */

vindu = vindu->neste; /* Flytt til neste listeelement. */

} }

int main() (

lister oppføringer; /* Peker til analyserte data*/

int status; /* Heltall som representerer status */

Html__header(); /* HTML-hjelpefunksjon som sender ut HTML-overskriften*/

Html_begin("cgihtml test");

/* En HTML-hjelpefunksjon som skriver ut begynnelsen av en HTML-side med den angitte tittelen. */

status = read_cgi_input(&entries); /* Produserer input og parsing skjemadata*/

Printf("<р>Skjemadata:
");

Skriv ut_alle(oppføringer); /* Kaller print_all() funksjonen definert ovenfor. */

html_end(); /* HTML-hjelpefunksjon som skriver ut slutten av HTML-siden. */

Liste_clear(&oppføringer); /* Frigjør minne okkupert av skjemadata. */

returner 0; )

Standard utgangsenhet

Dataene som sendes av CGI-programmet til standardutgangsenheten leses av webserveren og sendes til klienten. Hvis skriptnavnet begynner med nph-, da sendes dataene direkte til klienten uten innblanding fra webserveren. I dette tilfellet må CGI-programmet generere riktig HTTP-header som klienten vil forstå. Ellers lar du webserveren generere HTTP-headeren for deg.

Selv om du ikke bruker nph-scenario, serveren må gis ett direktiv som vil fortelle den informasjon om utdataene dine. Dette er vanligvis Content-Type HTTP-headeren, men kan også være Location-headeren. Overskriften må følges av en tom linje, det vil si en linjemating eller en CR/LF-kombinasjon.

Content-Type-overskriften forteller serveren hvilken type data CGI-programmet ditt produserer. Hvis dette er en HTML-side, bør strengen være Content-Type: tekst/html. Plasseringsoverskriften forteller serveren en annen URL - eller en annen bane på samme server - hvor klienten skal henvises. Overskriften skal se slik ut: Sted: http:// www. min server. no/et annet/sted/.

Etter HTTP-hodene og en tom linje, kan du sende de faktiske dataene produsert av programmet ditt - HTML-side, bilde, tekst eller noe annet. Blant CGI-programmene som leveres med Apache-serveren er nph-test-cgi Og test-cgi som på en fin måte viser forskjellen mellom henholdsvis nph- og ikke-nph-stiloverskrifter.

I denne delen vil vi bruke biblioteker CGI.pm Og cgic, som har funksjoner for å sende ut både HTTP- og HTML-hoder. Dette vil tillate deg å fokusere på å sende ut det faktiske innholdet. Disse hjelpefunksjonene er brukt i eksemplene gitt tidligere i dette kapittelet.

Viktige funksjoner i CGI-skript

Du vet allerede i utgangspunktet hvordan CGI fungerer. Klienten sender data, vanligvis ved hjelp av et skjema, til webserveren. Serveren kjører CGI-programmet og sender data til det. CGI-programmet utfører sin prosessering og returnerer utdataene til serveren, som sender den videre til klienten. Nå fra å forstå hvordan CGI npor-rammer fungerer, må vi gå videre til å forstå hvorfor de er så mye brukt.

Selv om du allerede vet nok fra dette kapittelet til å kunne sette sammen et enkelt fungerende CGI-program, er det noen flere viktige problemer å dekke før du kan lage faktisk fungerende programmer for MySQL eller mSQL. Først må du lære å jobbe med flere skjemaer. Deretter må du lære noen sikkerhetstiltak som vil forhindre at angripere ulovlig får tilgang til eller ødelegger serverfilene dine.

Lagringstilstand

Statlig huske er et viktig middel for å yte en god tjeneste til brukerne dine, og ikke bare for å bekjempe hardbarkede kriminelle som det kan virke. Problemet er forårsaket av det faktum at HTTP er en såkalt "minneløs" protokoll. Dette betyr at klienten sender data til serveren, serveren returnerer data til klienten, og så går alle sin vei. Serveren lagrer ikke data om klienten som kan være nødvendig i etterfølgende operasjoner. Likeledes er det ingen garanti for at klienten vil beholde noen data om transaksjonen som kan brukes senere. Dette setter en umiddelbar og betydelig begrensning på bruken Verdensomspennende Web.

Å skrive CGI med denne protokollen ligner på å ikke kunne huske en samtale. Når du snakker med noen, uansett hvor ofte du har snakket med dem før, må du presentere deg selv og se etter et felles samtaleemne. Det er ikke nødvendig å forklare at dette ikke bidrar til produktiviteten. Figur 9-2 viser at hver gang en forespørsel når et CGI-program, er det en helt ny forekomst av programmet, uten tilknytning til den forrige.

På klientsiden, med bruken av Netscape Navigator, dukket det opp en tilsynelatende raskt laget løsning kalt informasjonskapsler. Den består av å lage en ny HTTP-header som kan sendes frem og tilbake mellom klienten og serveren, på samme måte som Content-Type og Location-hodene. Klientens nettleser, når den mottar informasjonskapselhodet, må lagre den i informasjonskapseldata, samt navnet på domenet der denne informasjonskapselen opererer. Deretter, hver gang en URL innenfor det angitte domenet besøkes, må en cookie-header returneres til serveren for bruk av CGI-programmer på den serveren.

Informasjonskapselmetoden brukes hovedsakelig til å lagre bruker-ID. Informasjon om den besøkende kan lagres i en fil på servermaskinen. Denne brukerens unike ID kan sendes som en informasjonskapsel til brukerens nettleser, og hver gang brukeren besøker siden, sender nettleseren automatisk denne IDen til serveren. Server sender ID CGI-program, som åpner den tilsvarende filen og får tilgang til alle data om brukeren. Alt dette skjer ubemerket av brukeren.

Til tross for nytten av denne metoden, bruker de fleste store nettsteder den ikke som deres eneste måte å huske tilstand på. Det er en rekke årsaker til dette. For det første støtter ikke alle nettlesere informasjonskapsler. Inntil nylig støttet ikke hovednettleseren for personer med begrenset syn (for ikke å nevne personer med utilstrekkelig Internett-tilkoblingshastighet) - Lynx - informasjonskapsler. Den støtter dem fortsatt ikke "offisielt", selv om noen av dens allment tilgjengelige "sidegrener" gjør det. For det andre, og enda viktigere, knytter informasjonskapsler brukeren til en bestemt maskin. En av de store fordelene med nettet er at det er tilgjengelig fra hvor som helst i verden. Uansett hvor nettsiden din ble opprettet eller lagret, kan den vises fra hvilken som helst Internett-tilkoblet maskin. Imidlertid, hvis du prøver å få tilgang til en informasjonskapselaktivert side fra en annens maskin, vil all din personlige informasjon som vedlikeholdes av informasjonskapselen gå tapt.

Mange nettsteder bruker fortsatt informasjonskapsler for å tilpasse brukersider, men de fleste utfyller dem med et tradisjonelt grensesnitt for pålogging/passordstil. Hvis nettstedet åpnes fra en nettleser som ikke støtter informasjonskapsler, inneholder siden et skjema der brukeren skriver inn påloggingsnavnet og passordet han ble tildelt da han besøkte siden første gang. Vanligvis er denne formen liten og upretensiøs, for ikke å skremme av de fleste brukere som ikke er interessert i noen personalisering, men bare ønsker å gå videre. Etter at brukeren har skrevet inn et påloggingsnavn og passord i skjemaet, finner CGI en fil som inneholder data om den brukeren, som om navnet ble sendt med en informasjonskapsel. Ved å bruke denne metoden kan brukeren registrere seg på et personlig tilpasset nettsted fra hvor som helst i verden.

I tillegg til oppgavene med å ta hensyn til brukerpreferanser og langsiktig lagring av informasjon om ham, kan vi gi et mer subtilt eksempel på husketilstand, som leveres av populære søkemotorer. Når du søker ved hjelp av tjenester som AltaVista eller Yahoo, vil du vanligvis få mange flere resultater enn det som kan vises i et lettlest format. Dette problemet løses ved å vise et lite antall resultater - vanligvis 10 eller 20 - og gi noen navigasjonsmuligheter for å se neste gruppe resultater. Selv om denne oppførselen virker normal og forventet for den gjennomsnittlige nettsurferen, er implementeringen av den ikke-triviell og krever statlig lagring.

Når en bruker først gjør et søk til en søkemotor, samler den inn alle resultatene, kanskje begrenset til en forhåndsdefinert grense. Trikset er å produsere disse resultatene i små mengder om gangen, samtidig som du husker hva slags bruker som ba om disse resultatene og hvilken porsjon han forventer neste gang. Ser vi bort fra kompleksiteten til selve søkemotoren, står vi overfor problemet med konsekvent å gi brukeren noe informasjon på én side. Tenk på eksempel 9-4, som viser et CGI-skript som skriver ut ti linjer av en fil og gir den muligheten til å se på neste eller forrige ti linjer.

Eksempel 9-4. Lagrer tilstand i et CGI-skript

#!/usr/bin/perl -w

bruk CGI;

Open(F,"/usr/dict/words") or die("Han kan ikke åpne! $!");

#Dette er filen som skal sendes ut, den kan være hva som helst.

$output = ny CGI;

sub print_range ( # Dette hovedfunksjon programmer, min $start = shift;

# Startlinjen til filen, min $count = 0;

# Peker, min $line = "";

# Gjeldende fillinje, skriv ut $output->header,

$output->start_html("Min ordbok");

# Produserer HTML med tittelen "Min ordbok", skriv ut " \n";

mens (($count< $start) and ($line = )) ( $count++; )

# Hopp over alle linjer før den første, mens (($count< $start+10) and ($line ? )) ( skriv ut $line; $count++; )

# Skriv ut de neste 10 linjene.

min $newnext = $start+10; min $newprev = $start-10;

# Angi innledende linjer for nettadressene «Neste» og «Forrige»

skrive ut "

";

med mindre ($start == 0) ( # Inkluder "Forrige" URL med mindre du

# er ikke lenger i begynnelsen.

print qq%Forrige%; )

med mindre (eof) ( # Inkluder "Neste" URL med mindre du # ikke på slutten av filen.

print qq% Next%;

}

skriv ut "HTML;HTML

exit(0); )

# Hvis det ikke er data, start på nytt,

if (ikke $output->param) (

&print_range(0); )

# Ellers, start fra linjen spesifisert i dataene.

&print_range($output->param("start"));

I dette eksemplet lagres tilstanden ved hjelp av den enkleste metoden. Det er ingen problemer med å lagre data, siden vi holder dem i en fil på serveren. Vi trenger bare å vite hvor vi skal starte utdata, så skriptet inkluderer ganske enkelt startpunktet for neste eller forrige gruppe med linjer i URL-en - alt som trengs for å generere neste side.

Men hvis du trenger mer enn muligheten til å bla gjennom en fil, kan det være tungvint å stole på en URL. Du kan lindre denne vanskeligheten ved å bruke et HTML-skjema og inkludere tilstandsdata i tagger type SKJULT. Denne metoden har blitt brukt med suksess på mange nettsteder, slik at koblinger kan lages mellom relaterte CGI-programmer eller utvide bruken av et enkelt CGI-program, som i forrige eksempel. I stedet for å peke til et bestemt objekt, for eksempel en hjemmeside, kan URL-dataene peke til en automatisk generert bruker-ID.

Slik fungerer AltaVista og andre søkemotorer. Det første søket genererer en bruker-ID, som er skjult bak kulissene i påfølgende URL-er. Tilknyttet denne IDen er én eller flere filer som inneholder resultatene av spørringen. Nettadressen inneholder ytterligere to verdier: din nåværende posisjon i resultatfilen og retningen du vil navigere videre i den. Disse tre verdiene er alt du trenger for å få det til å fungere kraftige systemer navigering av store søkemotorer.

Det er imidlertid fortsatt noe som mangler. Filen som ble brukt i vårt eksempel /usr/diett/ord veldig stor. Hva om vi gir opp halvveis i å lese den, men ønsker å komme tilbake til den senere? Hvis du ikke husker URL-en til neste side, er det ingen måte å gå tilbake på, ikke engang AltaVista vil tillate det. Hvis du starter datamaskinen på nytt eller bruker en annen datamaskin, vil du ikke kunne gå tilbake til de tidligere søkeresultatene uten å gå inn i søket på nytt. Imidlertid er denne langsiktige tilstandslagringen kjernen i nettsidetilpasningen vi diskuterte ovenfor, og det er verdt å se på hvordan den kan brukes. Eksempel 9-5 er en modifisert versjon av eksempel 9-4.

Eksempel 9-5. Stabil tilstand utenat

#!/usr/bin/perl -w

bruk CGI;

umask 0;

Open(F,"/usr/dict/words") or die("Han kan ikke åpne! $!");

Chdir("brukere") or die("Jeg kan ikke gå til katalogen $!");

# Dette er katalogen der alle data vil bli lagret

# om brukeren.

Soutput = ny CGI;

if (ikke $output->param) (

skriv ut $output->header,

$output->start_html("Min ordbok");

skriv ut "HTML;


<р>Skriv inn brukernavnet ditt:


HTML

exit(0); )

$user = $output->param("brukernavn");

## Hvis det ikke er noen brukerfil, opprett den og installer den

## startverdi er "0",

if (ikke -e "$user") (

open (U, ">$user") or die("Jeg kan ikke åpne! $!");

skriv ut U "0\n";

lukke U;

&print_range("0");

## hvis brukeren eksisterer og ikke er spesifisert i URL-en

## startverdi, les siste verdi og start derfra.

) elsif (ikke $output->param("start")) (

Open(U,"Suser") or die("Jeg kan ikke åpne brukeren! $!");

$start = ; lukke U;

chomp $starl;

uprint range($start);

## Hvis brukeren eksisterer og ikke er spesifisert i URL-en

## startverdi, skriv ned startverdi

## til brukerfilen og start utdata.

)ellers(

Open(U,">$user") or die("Jeg kan ikke åpne brukeren for å skrive! $!");

print U $output->param("start"), "\n";

lukke U;

&print_range($output->param("start 1)); )

sub print_range(

min $start = skift;

min $telling = 0;

min $line = " "

skriv ut $output->header,

$output->start_html("Min ordbok");

skrive ut "

\n"; 

mens (($count< $start) and ($line = )) ( $count++; )

mens (($count< $start+10) and ($line = ))

print $line; $count++;

min $newnext = $start+10;

min $newprev = $start-10;

skrive ut "

med mindre (Sstart == 0)

{

skrive ut

qq%

Tidligere%;

}

med mindre (eof) ( print qq% Next%;

# Merk at brukernavnet "brukernavn" er lagt til URL-en.

# Ellers vil CGI-en glemme hvilken bruker den hadde å gjøre med.

}

skriv ut $output->end_html;

exit(0") ;

}

Sikkerhetstiltak

Når du bruker Internett-servere, enten de er HTTP eller andre typer servere, er sikkerhet et kritisk problem. Datautveksling mellom klient og server utført innenfor

CGI, skyv rad viktige saker knyttet til databeskyttelse. Meg selv CGI-protokoll tilstrekkelig beskyttet. Et CGI-program mottar data fra serveren via standard input eller miljøvariabler, som begge er sikre metoder. Men når et CGI-program først har kontroll over dataene, er det ingen begrensninger på hva det kan gjøre. Et dårlig skrevet CGI-program kan tillate en angriper å få tilgang til serversystemet. Tenk på følgende eksempel på et CGI-program:

#!/usr/bin/perl -w

bruk CGI;

min $output = ny CGI;

mitt $brukernavn = $output»param("brukernavn");

skriv ut $output->header, $output->start_html("Fingerutgang"),

"

", "finger $brukernavn", "
", $output->end_html;

Dette programmet gir et gyldig CGI-grensesnitt til kommandoen finger. Hvis du kjører programmet bare liker finger.cgi, den vil vise alle nåværende brukere på serveren. Hvis du kjører det som finger.cgi?brukernavn=fred, så vil den vise informasjon om brukeren "fred" på serveren. Du kan til og med kjøre det som finger. cgi?userna-me=bob@f oo.com for å vise informasjon om den eksterne brukeren. Men hvis du kjører det som finger.cgi?brukernavn=fred; [e-postbeskyttet] Uønskede ting kan skje. Backstroke-operatoren """" i Perl skaper en skallprosess og utfører en kommando som returnerer et resultat. I dette programmet " finger $brukernavn* brukes som en enkel måte å utføre fingerkommandoen og få utdata. De fleste kommandoprosessorer lar deg imidlertid kombinere flere kommandoer på én linje. For eksempel gjør enhver prosessor som Bourne-prosessoren dette ved å bruke symbolet "; " Derfor"finger fred;mail [e-postbeskyttet] vil kjøre kommandoen først finger, og deretter kommandoen post [e-postbeskyttet] som kan sende hele serverpassordfilen til en uønsket bruker.

En løsning er å analysere skjemadataene for å se etter skadelig innhold. Du kan for eksempel se etter symbolet ";" og slett alle tegnene etter den. Det er mulig å umuliggjøre et slikt angrep ved å bruke alternative metoder. Ovennevnte CGI-program kan skrives om som følger:

#!/usr/local/bin/perl -w

bruk CGI;

min $output = ny CGI;

mitt $brukernavn = $output->param("brukernavn");

$|++;

# Deaktiver buffering for å sende alle data til klienten,

skriv ut $output->header, $putput->start_html("Fingerutdata"), "

\n"; 

$pid = open(C_OUT, "-|");# Dette Perl-idiomet skaper en underordnet prosess og åpnes

# kanal mellom foreldre- og underordnede prosesser,

if ($pid) (# Dette er den overordnede prosessen.

skrive ut ; ft Skriv ut utdataene fra den underordnede prosessen.

skrive ut "

", $output->end_html;

exit(O); ft Avslutt programmet. )

elsif (definert $pid) ( # Dette er en underordnet prosess.

$|++; # Deaktiver bufring.

exec("/usr/bin/finger",$brukernavn) eller die("exec()-kallet mislyktes.");

# Utfører fingerprogrammet med brukernavn som det eneste
# kommandolinjeargument. ) else (die("gaffel() mislyktes"); )

# Feilkontroll.

Som du kan se, er ikke dette et mye mer komplekst program. Men hvis du kjører det som finger.cgi?brukernavn=fred; [e-postbeskyttet] da vil fingerprogrammet bli utført med argumentet fred;mail [e-postbeskyttet] som ett brukernavn.

Som et ekstra sikkerhetstiltak kjører dette skriptet eksplisitt som /usr/bin/finger. I det usannsynlige tilfellet at webserveren sender CGI-programmet ditt en uvanlig PATH, kan det å kjøre bare finger føre til at feil program kjøres. Et annet sikkerhetstiltak du kan ta er å undersøke PATH-miljøvariabelen og sørge for at den har en akseptabel verdi. Det er en god idé å fjerne den gjeldende arbeidskatalogen fra PATH med mindre du er sikker på at det ikke er tilfelle der du faktisk trenger å kjøre programmet i den.

Et annet viktig sikkerhetshensyn er knyttet til brukerrettigheter. Som standard kjører webserveren CGI-programmet med rettighetene til brukeren som startet selve serveren. Dette er vanligvis en pseudobruker som "ingen" som har begrensede rettigheter, så CGI-programmet har få rettigheter heller. Dette er vanligvis en god ting, for hvis en angriper kan få tilgang til serveren gjennom et CGI-program, vil han ikke kunne gjøre mye skade. Eksemplet med et program for å stjele passord viser hva som kan gjøres, men den faktiske skaden på systemet er vanligvis begrenset.

Men å kjøre som en begrenset bruker begrenser også mulighetene til CGI. Hvis et CGI-program trenger å lese eller skrive filer, kan det bare gjøre det der det har slik tillatelse. For eksempel, i det andre eksemplet på lagringstilstand, opprettholdes en fil for hver bruker. CGI-programmet må ha lese- og skrivetillatelse på katalogen som inneholder disse filene, for ikke å snakke om selve filene. Dette kan gjøres ved å opprette katalogen som samme bruker som serveren, med lese- og skriverettigheter kun for den brukeren. For en bruker som "ingen" har imidlertid bare root denne muligheten. Hvis du ikke er en superbruker, må du kommunisere med systemadministratoren hver gang du gjør en endring i CGI.

En annen måte er å gjøre katalogen fri til å lese og skrive, og i hovedsak fjerne all beskyttelse fra den. Siden disse filene bare kan nås fra omverdenen gjennom programmet ditt, er ikke faren så stor som den kan virke. Men hvis en feil oppdages i programmet, vil den eksterne brukeren ha full tilgang til alle filer, inkludert muligheten til å ødelegge dem. I tillegg vil legitime brukere som kjører på serveren også kunne endre disse filene. Hvis du skal bruke denne metoden, må alle brukere av serveren være pålitelige. Bruk også den åpne katalogen kun for filer som trengs av CGI-programmet; med andre ord, ikke utsett unødvendige filer i fare.

Hvis dette er første gang du går inn i CGI-programmering, er det en rekke måter du kan fortsette å utforske. Dusinvis av bøker er skrevet om dette emnet, hvorav mange ikke antar noen kunnskap om programmering. "CGI-programmering på World Wide Web" utgitt av O"Reilly and Associates, dekker materiale fra enkle skript på forskjellige språk til virkelig fantastiske triks og triks. Offentlig informasjon er også tilgjengelig i overflod på WWW. Et godt sted å starte er CGI gjort veldig enkelt(Egentlig bare om CGI) kl http://www.jmarshall.com/easy/cgi/ .

CGI og databaser

Siden begynnelsen av Internett-æraen har databaser samhandlet med utviklingen av World Wide Web. I praksis ser mange mennesker på nettet som bare én gigantisk database med multimedieinformasjon.

Søkemotorer gir et hverdagslig eksempel på fordelene med databaser. Søkemotoren går ikke rundt på hele Internett og leter etter søkeord i det øyeblikket du ber om dem. I stedet bruker nettstedsutviklere andre programmer for å lage en gigantisk indeks som fungerer som en database som søkemotoren henter oppføringer fra. Databaser lagrer informasjon i en form som tillater rask, tilfeldig tilgang.

Fordi de er flytende, gir databaser nettet enda mer kraft: de gjør det til et potensielt grensesnitt for hva som helst. Systemadministrasjon kan for eksempel gjøres eksternt via et webgrensesnitt i stedet for å kreve at en administrator logger inn på ønsket system. Å koble databaser til nettet er kjernen i et nytt nivå av interaktivitet på Internett.

En av grunnene til å koble databaser til nettet gjør seg jevnlig kjent: mye av verdens informasjon er allerede i databaser. Databaser som er før nettet kalles eldre databaser (i motsetning til ikke-netttilkoblede databaser som er opprettet i nyere tid, som bør kalles en "dårlig idé"). Mange selskaper (og til og med enkeltpersoner) står nå overfor utfordringen med å gi tilgang til disse eldre databasene via nettet. Med mindre den gamle databasen din er MySQL eller mSQL, er dette emnet utenfor denne bokens omfang.

Som nevnt tidligere er det bare fantasien som kan begrense mulighetene for kommunikasjon mellom databaser og nettet. For tiden er det tusenvis av unike og nyttige databaser tilgjengelig fra nettet. Databasetypene som opererer utenfor disse applikasjonene varierer mye. Noen av dem bruker CGI-programmer som grensesnitt til en databaseserver som MySQL eller mSQL. Disse typene er av størst interesse for oss. Andre bruker kommersielle applikasjoner til grensesnitt med populære skrivebordsdatabaser som Microsoft Access og Claris FileMaker Pro. Andre jobber ganske enkelt med flate tekstfiler, som er de enkleste databasene som er mulig.

Ved å bruke disse tre typene databaser kan du utvikle nyttige nettsteder av enhver størrelse eller kompleksitet. Et av målene våre i løpet av de neste kapitlene vil være å bruke kraften til MySQL mSQL på nettet ved hjelp av CGI-programmering.