# `cgi` — wsparcie dla wspólnego sprzęgu bramki - z ang. - Common Gateway Interface

Source code: Lib/cgi.py

Deprecated since version 3.11, will be removed in version 3.13: The `cgi` module is deprecated (see PEP 594 for details and alternatives).

The `FieldStorage` class can typically be replaced with `urllib.parse.parse_qsl()` for `GET` and `HEAD` requests, and the `email.message` module or multipart for `POST` and `PUT`. Most utility functions have replacements.

Wspierający moduł dla skryptów sprzęgu wspólnej bramki (z ang. CGI).

Ten moduł definiuje pewną liczbę użyteczności dla użycia przez skrypty CGI napisane w języku pytonowskim.

The global variable `maxlen` can be set to an integer indicating the maximum size of a POST request. POST requests larger than this size will result in a `ValueError` being raised during parsing. The default value of this variable is `0`, meaning the request size is unlimited.

Dostępność: not Emscripten, not WASI.

This module does not work or is not available on WebAssembly platforms `wasm32-emscripten` and `wasm32-wasi`. See WebAssembly platforms for more information.

## Wprowadzenie

Skrypt CGI jest wywoływany przez serwer HTTP, zwykle aby przetworzyć wejście użytkownika dostarczone przez HTML `<FORM>` lub element `<ISINDEX>`.

Najczęściej, Skrypty CGI przebywają w katalogu specjalnym serwera `cgi-bin`. Serwer HTTP umieszcza wszelkiego rodzaju informacje o zapytaniu (takie jak nazwa hosta klienta, oczekiwany adres URL, ciąg zapytania, i wiele innych dobrych rzeczy) w środowisku powłoki skryptu, wykonuje skrypt i wysyła wyjście skryptu z powrotem do klienta.

Wejście skryptu jest połączone z klientem także, i czasami dane formularza są wczytywane tą drogą także; innym razem dane formularza są przekazywane przez „ciąg zapytania” jako część adresu URL. Ten moduł jest przeznaczony do zajmowania się różnymi przypadkami i dostarczenia prostszego sprzęgu dla skryptu języka pytonowskiego. To także dostarcza pewną liczbę użyteczności które pomagają w odpluskwianiu skryptów zaś najnowszym dodatkiem jest wsparcie dla załadowywania plików przez formularz (jeśli twoja przeglądarka to wspomaga).

Wyjście skryptu CGI powinno składać się z dwóch sekcji, oddzielonych pustą linią. Pierwszy rozdział zawiera liczbę nagłówków, mówiąc klientowi jakiego rodzaju dane nastąpią potem. Kod języka pytonowskiego aby wytworzyć minimalny rozdział nagłówkowy wygląda następująco:

    print("Content-Type: text/html")    # HTML is following
    print()                             # blank line, end of headers

Drugi rozdziałem jest zwykle HTML, który pozwala oprogramowaniu klienta wyświetlić ładnie sformatowany tekst z nagłówkiem, obrazkami w-jednej-linii itp. Tu jest kod języka pytonowskiego który drukuje prosty kawałek HTML-a:

    print("<TITLE>CGI script output</TITLE>")
    print("<H1>This is my first CGI script</H1>")
    print("Hello, world!")

## Użycie modułu cgi

Zacznij przez napisanie `import cgi`.

Gdy piszesz nowy skrypt, rozważ dodanie tych linii:

    import cgitb
    cgitb.enable()

This activates a special exception handler that will display detailed reports in the web browser if any errors occur. If you’d rather not show the guts of your program to users of your script, you can have the reports saved to files instead, with code like this:

    import cgitb
    cgitb.enable(display=0, logdir="/path/to/logdir")

Jest bardzo przydatnym użycie tej właściwości w czasie rozwijania skryptu. Raporty produkowane przez `cgitb` dostarczają informację która może oszczędzić Ci wiele czasu w śledzeniu błędów. Możesz zawsze usunąć `cgitb` linię później gdy przetestowałeś swój skrypt i jesteś pewien że działa on prawidłowo.

To get at submitted form data, use the `FieldStorage` class. If the form contains non-ASCII characters, use the encoding keyword parameter set to the value of the encoding defined for the document. It is usually contained in the META tag in the HEAD section of the HTML document or by the Content-Type header. This reads the form contents from the standard input or the environment (depending on the value of various environment variables set according to the CGI standard). Since it may consume standard input, it should be instantiated only once.

The `FieldStorage` instance can be indexed like a Python dictionary. It allows membership testing with the `in` operator, and also supports the standard dictionary method `keys()` and the built-in function `len()`. Form fields containing empty strings are ignored and do not appear in the dictionary; to keep such values, provide a true value for the optional keep_blank_values keyword parameter when creating the `FieldStorage` instance.

Dla przykładu, następujący kod (który zakłada, że nagłówek Content-Type i puste linie zostały już wydrukowane) sprawdza czy pola `nazwa` i `addr` zostały oba ustawione na nie-pusty ciąg znaków:

    form = cgi.FieldStorage()
    if "name" not in form or "addr" not in form:
        print("<H1>Error</H1>")
        print("Please fill in the name and addr fields.")
        return
    print("<p>name:", form["name"].value)
    print("<p>addr:", form["addr"].value)
    ...further form processing here...

Here the fields, accessed through `form[key]`, are themselves instances of `FieldStorage` (or `MiniFieldStorage`, depending on the form encoding). The `value` attribute of the instance yields the string value of the field. The `getvalue()` method returns this string value directly; it also accepts an optional second argument as a default to return if the requested key is not present.

If the submitted form data contains more than one field with the same name, the object retrieved by `form[key]` is not a `FieldStorage` or `MiniFieldStorage` instance but a list of such instances. Similarly, in this situation, `form.getvalue(key)` would return a list of strings. If you expect this possibility (when your HTML form contains multiple fields with the same name), use the `getlist()` method, which always returns a list of values (so that you do not need to special-case the single item case). For example, this code concatenates any number of username fields, separated by commas:

    value = form.getlist("username")
    usernames = ",".join(value)

If a field represents an uploaded file, accessing the value via the `value` attribute or the `getvalue()` method reads the entire file in memory as bytes. This may not be what you want. You can test for an uploaded file by testing either the `filename` attribute or the `file` attribute. You can then read the data from the `file` attribute before it is automatically closed as part of the garbage collection of the `FieldStorage` instance (the `read()` and `readline()` methods will return bytes):

    fileitem = form["userfile"]
    if fileitem.file:
        # It's an uploaded file; count lines
        linecount = 0
        while True:
            line = fileitem.file.readline()
            if not line: break
            linecount = linecount + 1

`FieldStorage` objects also support being used in a `with` statement, which will automatically close them when done.

If an error is encountered when obtaining the contents of an uploaded file (for example, when the user interrupts the form submission by clicking on a Back or Cancel button) the `done` attribute of the object for the field will be set to the value -1.

Standard ładowania pliku przewiduje możliwość załadowania wielu plików z jednego pola (używając rekursywnego kodowania multipart/*). Gdy to się zdarzy, element będzie słowniko-podobnym elementem `FieldStorage`. To może być określone przez sprawdzenie właściwości `type`, która powinna być multipart/form-data (lub byćmoże inny typ MIME pasujący do multipart/*). W tym przypadku może być on iterowany rekursywnie tak, jak przedmiot formularza nadrzędnego poziomu.

Gdy formularz jest podawany w „starym” formacie (jako ciąg zapytania lub pojedyncza część danych typu application/x-www-form-urlencoded), wszystkie elementy właściwie będą przykładami uogólnienia `MiniFieldStorage`. W tym przypadku, właściwości `list`, `file`, i `filename` są zawsze `None`.

Formularz podany przez sposób postępowania POST który także zawiera ciąg zapytania będzie zawierał zarówno elementy `FieldStorage` jak i `MiniFieldStorage`.

Zmienione w wersji 3.4: The `file` attribute is automatically closed upon the garbage collection of the creating `FieldStorage` instance.

Zmienione w wersji 3.5: Added support for the context management protocol to the `FieldStorage` class.

## Sprzęg Wyższego Poziomu (Higher Level Interface)

Poprzednia sekcja wyjaśnia jak czytać dane z formularza CGI używając uogólnienia `FieldStorage`. Ten rozdział opisuje sprzęg wyższego rzędu, który został dodany do tego uogólnienia aby pozwolić robić to w bardziej czytelny i intuicyjny sposób. Sprzęg nie powoduje że techniki opisane w poprzednich rozdziałach stają się zbędne — one są wciąż użyteczne aby wykonywać ładowanie plików efektywnie, dla przykładu.

Sprzęg składa się z dwóch prostych sposobów postępowania. Używając sposobów postępowania możesz przetwarzać dane w zastępczy sposób bez konieczności martwienia się czy tylko jedna czy więcej danych zostało opublikowanych pod daną nazwą.

W poprzednim rozdziale, dowiedziałeś się jak pisać następujący kod za każdym razem gdy spodziewałeś się że użytkownik opublikuje więcej niż jedną wartość pod jedną nazwą:

    item = form.getvalue("item")
    if isinstance(item, list):
        # The user is requesting more than one item.
    else:
        # The user is requesting only one item.

Ta sytuacja jest obecna dla przykładu gdy formularz zawiera grupę wielu pól zaznaczania o tej samej nazwie:

    <input type="checkbox" name="item" value="1" />
    <input type="checkbox" name="item" value="2" />

W większości przypadków, jednakże, istnieje tylko jedna urządzenie formularza o określonej nazwie w formularzu i wtedy oczekujesz i potrzebujesz tylko jednej wartości powiązanej z tą nazwą. Więc piszesz skrypt zawierający dla przykładu ten kod:

    user = form.getvalue("user").upper()

Problem z kodem polega na tym, że nigdy nie powinieneś oczekiwać, że klient dostarczy właściwe wpisy do twoich skryptów. Dla przykładu, jeśli ciekawy użytkownik dołoży jeszcze jedną parę `user=foo` do ciągu zapytania, wtedy skrypt ulegnie wypadkowi, ponieważ w tej sytuacji wywołanie sposobu postępowania `getvalue("user")` zwróci listę zamiast ciągu znaków. Wywołanie sposobu postępowania `upper()` na liście nie jest prawidłowe (gdyż listy nie mają sposobów postępowania o tej nazwie) i kończy się wyjątkiem `AttributeError`.

Zatem, właściwym sposobem aby wczytywać dane formularza było zawsze używanie kodu który sprawdza czy otrzymana wartość jest pojedynczą wartością czy listą wartości. To jest irytujące i prowadzi do mniej czytelnych skryptów.

A more convenient approach is to use the methods `getfirst()` and `getlist()` provided by this higher level interface.

FieldStorage.getfirst(name, default=None)

  Ten sposób postępowania zawsze zwraca tylko jedną wartość związaną z polem formularza name. Sposób postępowania zwraca tylko pierwszą wartość w przypadku gdy więcej wartości zostało opublikowanych pod taką nazwą. Proszę zauważ że kolejność w jakiej wartości są otrzymywane może różnić się między przeglądarkami i nie powinien liczyć się. [1] Jeśli żadne takie pole formularza ani wartość nie istnieje wtedy sposób postępowania zwraca wartość określoną przez opcjonalny parametr domyślny - z ang - default. Ten parametr domyślnie równy jest `None` jeśli nie jest określony.

FieldStorage.getlist(name)

  Ten sposób postępowania zawsze zwraca listę wartości związaną z polem formularza name. Ten sposób postępowania zwraca pustą listę jeśli żadne pole ani wartość nie istnieje dla nazwy - z ang. - name. Zwraca listę składającą się z jednego elementu jeśli tylko jedna taka wartość istnieje.

Używając tych sposobów postępowania możesz napisać ładny zgrabny kod:

    import cgi
    form = cgi.FieldStorage()
    user = form.getfirst("user", "").upper()    # This way it's safe.
    for item in form.getlist("item"):
        do_something(item)

## Zadania

Te są użyteczne jeśli chcesz więcej kontrolować, lub jeśli chcesz zatrudnić niektóre z algorytmów wypełnionych w tym module w innych przypadkach.

cgi.parse(fp=None, environ=os.environ, keep_blank_values=False, strict_parsing=False, separator='&')

  Parse a query in the environment or from a file (the file defaults to `sys.stdin`). The keep_blank_values, strict_parsing and separator parameters are passed to `urllib.parse.parse_qs()` unchanged.

  Deprecated since version 3.11, will be removed in version 3.13: This function, like the rest of the `cgi` module, is deprecated. It can be replaced by calling `urllib.parse.parse_qs()` directly on the desired query string (except for `multipart/form-data` input, which can be handled as described for `parse_multipart()`).

cgi.parse_multipart(fp, pdict, encoding='utf-8', errors='replace', separator='&')

  Parse input of type multipart/form-data (for file uploads). Arguments are fp for the input file, pdict for a dictionary containing other parameters in the Content-Type header, and encoding, the request encoding.

  Returns a dictionary just like `urllib.parse.parse_qs()`: keys are the field names, each value is a list of values for that field. For non-file fields, the value is a list of strings.

  This is easy to use but not much good if you are expecting megabytes to be uploaded — in that case, use the `FieldStorage` class instead which is much more flexible.

  Zmienione w wersji 3.7: Added the encoding and errors parameters. For non-file fields, the value is now a list of strings, not bytes.

  Zmienione w wersji 3.10: Added the separator parameter.

  Deprecated since version 3.11, will be removed in version 3.13: This function, like the rest of the `cgi` module, is deprecated. It can be replaced with the functionality in the `email` package (e.g. `email.message.EmailMessage`/`email.message.Message`) which implements the same MIME RFCs, or with the multipart PyPI project.

cgi.parse_header(string)

  Wczytaj nagłówek MIME (taki, jak Content-Type) do głównej wartości i słownika parametrów.

  Deprecated since version 3.11, will be removed in version 3.13: This function, like the rest of the `cgi` module, is deprecated. It can be replaced with the functionality in the `email` package, which implements the same MIME RFCs.

  For example, with `email.message.EmailMessage`:

      from email.message import EmailMessage
      msg = EmailMessage()
      msg['content-type'] = 'application/json; charset="utf8"'
      main, params = msg.get_content_type(), msg['content-type'].params

cgi.test()

  Robust test CGI script, usable as main program. Writes minimal HTTP headers and formats all information provided to the script in HTML format.

cgi.print_environ()

  Formatuje środowisko powłoki w HTML-u

cgi.print_form(form)

  Formatuje formularz w HTML-u.

cgi.print_directory()

  Formatuje obecny katalog w HTML-u.

cgi.print_environ_usage()

  Drukuje listę użytecznych (używanych przez CGI) zmiennych środowiskowych w HTML-u.

## Troska o bezpieczeństwo

There’s one important rule: if you invoke an external program (via `os.system()`, `os.popen()` or other functions with similar functionality), make very sure you don’t pass arbitrary strings received from the client to the shell. This is a well-known security hole whereby clever hackers anywhere on the web can exploit a gullible CGI script to invoke arbitrary shell commands. Even parts of the URL or field names cannot be trusted, since the request doesn’t have to come from your form!

Aby trzymać się bezpiecznej strony, jeśli przekazujesz ciąg znaków otrzymany z formularza do polecenia powłoki, powinieneś upewnić się, że ciąg znaków zawiera tylko znaki alfanumeryczne, ukośniki, podkreślenia i kropki.

## Instalowanie twojego skryptu CGI na systemie Unix-owym

Przeczytaj dokumentację dla twojego serwera HTTP i sprawdź u swojego administratora systemu aby dowiedzieć się który katalog powinien być użyty dla instalowania skryptów CGI; zwykle to jest katalog `cgi-bin` w drzewie serwera.

Upewnij się że twój skrypt jest czytelny i wykonywalny przez „innych”; tryb pliku Unix-a powinien być `0o755` ósemkowo (użyj `chmod 0755 nazwa-pliku`). Upewnij się, że pierwsza linia skryptu zawiera `#!` zaczynając w kolumnie 1 po której następuje ścieżka dostępu do pliku programu interpretującego polecenia języka pytonowskiego, dla przykładu:

    #!/usr/local/bin/python

Upewnij się że program interpretujący polecenia języka pytonowskiego istnieje i jest wykonywalny przez „innych”.

Upewnij się, że jakiekolwiek pliki które twój skrypt chce odczytać lub zapisać są czytelne i możliwe do zapisania odpowiednio, przez „innych” — ich tryb powinien być `0o644` dla czytelnych i `0o666` dla możliwych do zapisania. To jest ponieważ z powodów bezpieczeństwa, serwer HTTP wykonuje twój skrypt jako użytkownik „nikt” - z ang. - „nobody” bez żadnych szczególnych przywilejów. Może tylko wczytywać (zapisywać, wykonywać) pliki które wszyscy mogą czytać (zapisać, wykonać). Bierzący katalog w czasie wykonania jest także inny (jest to zwykle katalog serwera cgi-bin) i ustawienie zmiennych środowiskowych jest także inne od tego które dostajesz gdy się zalogujesz. W szczególności, nie licz na ścieżkę przeszukiwania pod kątem plików wykonywalnych (`PATH`) ani na ścieżkę przeszukiwania modułów języka pytonowskiego (`PYTHONPATH`), że będą ustawione na cokolwiek interesującego.

Jeśli potrzebujesz załadować moduły z katalogu który nie jest domyślną ścieżką przeszukiwania modułów języka pytonowskiego, możesz zmienić ścieżkę w twoim skrypcie, przez importowaniem innych modułów. Dla przykładu:

    import sys
    sys.path.insert(0, "/usr/home/joe/lib/python")
    sys.path.insert(0, "/usr/local/lib/python")

(W ten sposób, katalog wstawiony jako ostatni będzie przeszukiwany jako pierwszy!)

Instrukcje dla nie-Unixowych systemów będą różne; Sprawdź dokumentację serwera HTTP (będzie zwykle miała sekcję o skryptach CGI).

## Sprawdzanie twoich skryptów CGI

Niestety, skrypt CGI zwykle nie uruchomi się gdy spróbujesz go uruchomić z wiersza poleceń i skrypt który działa dobrze z wiersza polecenia może zawieźć nieoczekiwanie gdy uruchomiony z serwera. Jest jeden powód dla którego wciąż powinieneś testować swój skrypt z wiersza polecenia: jeśli zawiera błąd składniowy, program interpretujący polecenia języka pytonowskiego nie wykona go w ogóle, a serwer HTTP najprawdopodobniej wyśle tajemniczy komunikat o błędzie do klienta.

Zakładając, że twój skrypt nie ma błędów składniowych, a jednak wciąż nie działa, nie masz wyboru, tylko musisz czytać dalej.

## Odpluskwianie skryptów CGI

First of all, check for trivial installation errors — reading the section above on installing your CGI script carefully can save you a lot of time. If you wonder whether you have understood the installation procedure correctly, try installing a copy of this module file (`cgi.py`) as a CGI script. When invoked as a script, the file will dump its environment and the contents of the form in HTML format. Give it the right mode etc., and send it a request. If it’s installed in the standard `cgi-bin` directory, it should be possible to send it a request by entering a URL into your browser of the form:

    http://yourhostname/cgi-bin/cgi.py?name=Joe+Blow&addr=At+Home

Jeśli zwróci błąd typu 404, wtedy serwer nie może znaleźć skryptu – być może potrzebujesz zainstalować go w innych katalogu. Jeśli daje inny błąd, istnieje problem instalacji który powinieneś naprawić zanim spróbujesz iść dalej. Jeśli otrzymujesz ładnie sformatowany wypis środowiska i zawartości formularza (w tym przypadku, pola powinny być wypisane jako „addr” z wartością „At Home” i „name” z wartością „Joe Blow”), plik skryptu `cgi.py` zostały zainstalowane poprawnie. Jeśli wykonasz tę samą procedurę dla twojego własnego skryptu, powinieneś móc go teraz odpluskwiać.

Następnym krokiem mogłoby być wezwanie zadania `test()` modułu `cgi` z twojego skryptu: zamiana jej głównego kodu na pojedyncze stwierdzenie:

    cgi.test()

To powinno dać te same wyniki jak te otrzymane z zainstalowania samego pliku `cgi.py`.

Gdy zwykły skrypt języka pytonowskiego zgłasza nieobsłużony wyjątek (dla jakiegokolwiek powodu: z powodu literówki w nazwie modułu, pliku który nie może być otwarty, itp.), program interpretujący polecenia języka pytonowskiego wypisuje ładny wypis i wychodzi. Podczas gdy program interpretujący polecenia języka pytonowskiego będzie wciąż to robił gdy twój skrypt CGI zgłosi wyjątek, najprawdopodobniej wypis skończy w jednym z plików logów serwera HTTP, lub zostanie odrzucony całkowicie.

Fortunately, once you have managed to get your script to execute some code, you can easily send tracebacks to the web browser using the `cgitb` module. If you haven’t done so already, just add the lines:

    import cgitb
    cgitb.enable()

na górę twojego skryptu. Wtedy spróbuj uruchomić go jeszcze raz; gdy problem pojawi się znów, powinieneś zobaczyć szczegółowy raport, który prawdopodobnie uczyni jasnym powód wypadku.

Jeśli podejrzewasz, że może być problem w importowaniu modułu `cgitb`, możesz użyć nawet jeszcze bardziej wydajnego podejścia (które używa tylko modułów wbudowanych):

    import sys
    sys.stderr = sys.stdout
    print("Content-Type: text/plain")
    print()
    ...your code here...

To opiera się na programie interpretującym polecenia języka pytonowskiego, że wydrukuje swój wypis. Typ treści wyjścia jest ustawiony na zwykły tekst, co wyklucza całą obsługę HTML. Jeśli twój skrypt działa, surowy HTML zostanie pokazany przez twojego klienta. Jeśli zgłasza wyjątek, najprawdopodobniej po tym jak pierwsze linie zostaną wypisane, wypis wsteczny zostanie wyświetlony. Ponieważ żadna interpretacja HTML-a nie miejsca, wypis wsteczny będzie czytelny.

## Typowe problemy i ich rozwiązania

- Większość serwerów HTTP przechowuje w przestrzeni wymiany wyjście ze skryptów CGI dopóki skrypt się nie zakończy. To oznacza, że nie jest możliwe wyświetlenie raportu postępu na wyświetlaczu klienta kiedy skrypt działa.

- Sprawdź instrukcje instalacyjne powyżej.

- Sprawdź pliki logu serwera HTTP. (`tail -f logfile` w oddzielnym oknie może być użyteczne!)

- Zawsze sprawdzaj skrypt dla błędów składniowych najpierw, przez wykonanie czegoś podobnego do `python script.py`.

- Jeśli twój skrypt nie ma żadnych błędów składniowych, spróbuj dodać `import cgitb; cgitb.enable()` na górze skryptu.

- Gdy wywoływane są zewnętrzne programy upewnij się że mogą być znalezione. Zwykle to oznacza, że używanie nazw ścieżek absolutnych — `PATH` nie jest zwykle ustawiana na użyteczną wartość skryptu CGI.

- Gdy wczytujesz lub zapisujesz zewnętrzne pliki, upewnij się że mogą one być wczytane lub zapisane przez userid pod którym twój skrypt CGI będzie działał: to jest typowo userid pod którym serwer sieci działa, lub pewny jawnie określony userid dla właściwości sieciowego serwera `suexec`.

- Nie próbuj nadawać skryptowi CGI trybu set-uid. To nie działa na większości systemów, i jest odpowiedzialnością za bezpieczeństwo także.

Przypisy

[1]

Zauważ że pewne niedawne wersje specyfikacji HTML-a określają w jakiej kolejności wartości pól powinny być dostarczone, ale wiedzieć czy zapytanie zostało otrzymane z odpowiadającej przeglądarki, czy też w ogóle z przeglądarki jest nużące i podatne na błędy.