CGI Common Gateway Interface

Kommunikation zwischen Browser und serverseitigen Programmen

• Browser schickt URL request an Webserver

• Statische Webseite: Webserver liest Inhalt von .html Datei und schickt ihn zurück

• Dynamisch generierte Webseiten: Webserver startet ein Programm, dessen Ausgabe an den Browser zurückgeschickt wird

CGI Scripts

#!/usr/bin/perl

print "Content-type: text/html\n\n";
print "Good Morning!\n";

• Der Content-type beschreibt den folgenden Inhalt
• Nach den Header Zeilen (im Beispiel nur eine) folgt eine Leerzeile
• Nach der Leerzeile beginnt der Content

HTML Formulare

<form action=http://fwin12.kem.ac.at/cgi-bin/login1.pl>
Email:    <input type=text     name=email>  <br>
Password: <input type=password name=passwd> <br>
          <input type=submit   value=Login>
</form>

• Das Script login1.pl wird serverseitig gestartet
• es erhält Werte für email und passwd über die CGI Schnittstelle

Verarbeitung von Formulardaten

#!/usr/bin/perl

use CGI;
$c = new CGI;
$email = $c->param('email');
$passwd = $c->param('passwd');
print $c->header();
if ($passwd eq "friend") {
  print "Welcome, $email!\n";
} else {
  print "Wrong password!\n";
}

• Mit use wird das CGI Modul verwendet
• Mit new wird ein CGI Objekt $c erzeugt
• Die Formulardaten werden über die Funktion param() bezogen
• Texte werden mit eq verglichen, nicht mit ==

Beispiel: Web-Rechner

Hier ein etwas längeres Beispiel für einen Rechner, der Eingaben über ein HTML-Formular erhält:

<form action=http://miss:81/USERCGI/j8325200/rechner 
  method=POST>
<input type=text name=x> <br>
<input type=text name=y> <br>
<select name=op>
  <option> Addieren
  <option> Subtrahieren
  <option> Multiplizieren
  <option> Dividieren
</select> <br>
<input type=submit value=Berechnen>
</form>

Beispiel: Web-Rechner (2)

Das zugehörige CGI-Script holt die Eingaben vom CGI-Modul und wendet die gewüschte Rechenoperation an. Beachte: in Perl heißt es 'elsif' und nicht 'else if'.

#!/usr/bin/perl

use CGI;
$c = new CGI;
$x = $c->param('x');
$y = $c->param('y');
$op = $c->param('op');

print $c->header();
if ($op eq 'Addieren') {
  $z = $x + $y;
} elsif ($op eq 'Subtrahieren') {
  $z = $x - $y;
} elsif ($op eq 'Multiplizieren') {
  $z = $x * $y;
} elsif ($op eq 'Dividieren') {
  $z = $x / $y;
}
print "$op von $x und $y ergibt $z.\n";

Testen von CGI Scripts

CGI-Scripts sind Perl-Scripts und können auch ohne Webserver/browser getestet werden. Das CGI-Modul akzeptiert Parameter in der Form name=wert auf der Kommandozeile. Beispiel: das Script login1.pl soll getestet werden und benötigt die beiden Parameter email und passwd. Wir sind am miss-Rechner eingeloggt, haben ins usercgi-Verzeichnis gewechselt und können das dort befindliche login1.pl testen, indem wir eingeben:

login1.pl email=muster passwd=friend

Das Testen auf der Kommandozeile ist zu bevorzugen, da wir hier genaue Fehlermeldungen sehen. Aber auch über den Browser können Scripts getestet werden: einerseits natürlich durch Ausfüllen des Formulars, aber auch durch Angabe von Scriptname und Parametern in der Location des Browsers:

http://miss:81/USERCGI/j8325200/login1.pl?email=muster&passwd=friend

Nachteil ist, daß bei einem Fehler nur die allgemeine Fehlermeldung des Webservers zu sehen ist.

Überblick Cookies

Mit Cookies können Variablen im Browser gespeichert werden. CGI-Scripts können dann auf einmal gespeicherte Werte zugreifen. Damit können bestimmte Aufgaben sehr viel einfacher gelöst werden, weil nicht ständig Werte zwischen Server und Browser hin und hergeschickt werden müssen (z.B. über hidden fields). Login ist eine mögliche Anwendung, aber auch z.B. Warenkorb.

• Browserseitig gespeicherte Name/Wert Kombinationen

  Z.B. userid=muster

• Steuerung über Header: Setzen, Abfragen
• Gültigkeitsdauer kann gesetzt werden, sonst für die Dauer der Session
• Nützlich zur Speicherung von Zuständen im Browser

Setzen eines Cookies

#!/usr/bin/perl

use CGI;
$c = new CGI;
$cook = $c->cookie(-name=>'userid', -value=>'Muster', -path=>'/');
print $c->header(-cookie=>$cook);
print "Hello, you have your cookie now!\n";

• Mit $c->cookie(-name=>..., -value=>...) wird ein cookie erzeugt und in der Variablen $cook gespeichert
• Das cookie in der Variablen $cook wird im Header an den Browser übergeben
• In der Folge wird der Browser das Cookie speichern mit allen Requests an diesen Server mitschicken. Das kann mit den Optionen path (wo im Dateisystem auf diesem Server) und domain (auch auf andere Server) gesteuert werden.

Abfragen eines Cookies

#!/usr/bin/perl

use CGI;
$c = new CGI;
$userid = $c->cookie(-name=>'userid');
print $c->header();
if ($userid) {
  print "You have your cookie, $userid.\n";
} else {
  print "You do not have the cookie!\n";
}

• Mit $c->cookie(-name=>...) wird das cookie abgefragt, d.h. es kommt ein Wert zurück
• Der Wert wird in der Variablen $userid gespeichert

Zusammenfassung Cookies

• Zugriff über Header mittels CGI Objekt d.h.

  $c = new CGI;

• $val = $c->cookie(-name=>...) fragt den Wert eines Cookies ab

  $val ist leer, wenn das Cookie im Browser nicht gesetzt ist

• $cook = $c->cookie(-name=>... , -value=>... , -path=>'/') erzeugt ein Cookie

  Das Cookie wird im Browser gesetzt, wenn es im Header mitgegeben wird:

  print $c->header(-cookie=>$cook)

Session IDs

Eine Sitzung besteht aus einer Folge von Zugriffen vom selben Client auf den selben Server. Das Modul CGI::Session unterstützt solche Sessions, indem IDs generiert werden, die eine bestimmte Session identifizieren. Diese können dann z.B. für Warenkörbe und ähnliches verwendet werden.

#!/usr/bin/perl

use CGI::Session;
use CGI;

$cgi = new CGI;
$session = new CGI::Session(undef, $cgi, {Directory=>'/tmp'});
$sid = $session->id();

print $session->header();
print "The session id is $sid.\n";

Wird dieses Skript zum ersten Mal aufgerufen, so wird eine neue Session ID generiert. Bei den weiteren Aufrufen aus diesem oder anderen Skripts am selben Server wird das bestehende Session ID verwendet. Das Session ID ist ein Text mit 32 Zeichen.

Aufrufen von Scripts in anderen Scripts

Ein modulares Design kann viel Arbeit ersparen und eine Aufgabe übersichtlicher lösen als der gefürchtete 'Spaghetti-Code'. Hier ist eine (von mehreren) Varianten, bereits erstellte Scripts zu verwenden. prog1 möchte prog2 aufrufen und dessen Ausgabe zurückgeben (z.B. an den Browser, wenn prog1 über CGI aufgerufen wurde):

print `/usr/logins/usercgi/j8325200/prog2 nr=$n`;

Damit wird prog2 gestartet. Verwendet prog2 das CGI-Modul, so erhält es auch den Parameter nr mit dem aktuellen Wert der Perl-Variable $n. Die Hochkommas sind die Back-Quotes, also die nach links geneigten Hochkommas.

Natürlich kann die Ausgabe von prog1 auch in einer Variablen gespeichert werden:

$var = `/usr/logins/usercgi/j8325200/prog2 nr=$n`;

Offenlegung gem. §25 MedienG