Das deutsche Python-Forum

#!/usr/bin/python
# -*- coding: ISO-8859-1 -*-

import CGIHTTPServer
import BaseHTTPServer
import os, sys
import webbrowser

# Zum Root-Verzeichnis der Webseite wechseln
# (Das Verz. mit der Einstiegts-"index.html" Seite)
os.chdir("/daten/MeineWebseite")

# Verz. in dem CGIs ausgeführt werden sollen. Leer lassen (="") für alle Verz.
cgiVerz = ""

# Port auf dem der Server anfragen entgegen nehmen soll.
ListenPort = 80

# Umgebungsvariablen setzten, die man in CGI-Skripten abfragen kann und normalerweise
# von einem echten WebServer automatisch gesetzt werden
# Evtl. selber erweitern ;)
os.environ['DOCUMENT_ROOT']=os.getcwd()
os.environ['HTTP_USER_AGENT']="Mozilla/5.0 (Windows; U; Windows NT 5.1; de-DE; rv:1.7.5) Gecko/20041108 Firefox/1.0"
os.environ['HTTP_HOST']="localhost"
os.environ['REMOTE_ADDR']="localhost"


class MyHandler(CGIHTTPServer.CGIHTTPRequestHandler):
    "Modifizieren des Ursprünglichen Servers"

    print "Lese Verzeichnisbaum für CGI-Ausführung...",
    # Liste aller Unetrverzeichnisse erzeugen, damit überall CGIs ausgeführt werden.
    cgi_directories = ["/"+i[0].replace("\\","/") for i in os.walk(cgiVerz)]
    print "OK",len(cgi_directories),"Verz. gefunden\n"

    def is_python(self, path):
        "Endungen, die als Python-Skript ausgeführt werden sollen."
        head, tail = os.path.splitext(path)
        return tail.lower() in (".py", ".pyw", ".cgi")

    def is_cgi(self):
        "Ausführen eines Python-Skript"
        path = self.path
        for x in self.cgi_directories:
            i = len(x)
            if path[:i] == x and (path[i+1:] and path[i] == '/'):
                self.cgi_info = path[:i], path[i+1:]
                return True
        return False


httpd = BaseHTTPServer.HTTPServer(("", ListenPort), MyHandler)

print "ROOT-Pfad:", os.getcwd()
print "Starte CGI-HTTP-Server auf Port",ListenPort
print "Seiten sind nun unter [http://localhost:%s] erreichbar!\n" % ListenPort

# Öffne Browser
webbrowser.open_new("http://localhost")

httpd.serve_forever()

import webbrowser

webbrowser.open_new("http://localhost")
 

import SocketServer,socket
class MyServer(SocketServer.ThreadingTCPServer):
    allow_reuse_address = 1    # Seems to make sense in testing environment
    def server_bind(self):
        """Override server_bind to store the server name."""
        SocketServer.ThreadingTCPServer.server_bind(self)
        host, port = self.socket.getsockname()[:2]
        self.server_name = socket.getfqdn(host)
        self.server_port = port

#!/usr/bin/python
# -*- coding: ISO-8859-1 -*-

__version__ = "0.0.5"

__history__ = """
v0.0.5
    - os.environ["QUERY_STRING"] wird richtig übergeben
"""


import CGIHTTPServer, SocketServer
import os, sys, time, socket


class RedirectStdOut:
    def __init__( self, File, stdoutObj ):
        self.MyStdOut = stdoutObj
        self.File = File

    def write( self, *txt ):
        txt = " ".join([str(i) for i in txt])
        # Auf Konsole Ausgeben
        self.MyStdOut.write( txt )
        # In Log-Datei schreiben
        FileHandle = file( self.File, "a" )
        FileHandle.write( txt )
        FileHandle.close()


class MyRequestHandler( CGIHTTPServer.CGIHTTPRequestHandler ):
    "Modifizieren des Standart RequestHandlers"

    # Damit auch unter Linux, welches fork unterstützt, das Python-CGI-Skript
    # unter dem User ausgeführt wird, mit dem der CGIHTTPServer gestartet wurde
    # und nicht mit User nobody...
    have_fork = False
    have_popen2 = False
    have_popen3 = False

    def is_cgi(self):
        "Modifikation, sodas man im CGI-Verzeichnis ein Dir-Listing bekommt"

        try:
            self.path, query_string = self.path.split("?",1)
        except ValueError:
            query_string = ""

        base, file = os.path.split( self.path )
        if file=="": return False

        base = os.path.normpath( base )
        for x in self.cgi_directories:
            if x == base:
                self.cgi_info = base, file+"?"+query_string
                os.environ['SCRIPT_FILENAME'] = file
                return True
        return False



class MyThreadingServer( SocketServer.ThreadingTCPServer ):
    """
    Verbesserung des Standart Servers:
     - ermöglicht das abarbeiten mehrere Anfragen parallel (z.B. Download mehrere Dateien gleichzeitig)
     - Ermöglicht das einschränken des IP-Bereiches aus denen der Server Anfragen behandelt
    """
    allow_reuse_address = 1    # Seems to make sense in testing environment

    def __init__(self, server_address, request_handler, AllowIPs):
        SocketServer.ThreadingTCPServer.__init__(self, server_address, request_handler)
        self.AllowIPs = [mask.split('.') for mask in AllowIPs]

    def server_bind(self):
        """Override server_bind to store the server name. (Parallele Anfragen)"""
        SocketServer.ThreadingTCPServer.server_bind(self)
        host, port = self.socket.getsockname()[:2]
        self.server_name = socket.getfqdn(host)
        self.server_port = port

    def verify_request(self, dummy, client_address):
        """Checkt ob die IP-Adresse der Anfrage in 'AllowIPs' vorhanden ist"""
        def check_ip(mask):
            for mask_part, ip_part in zip(mask, ip):
                if mask_part != ip_part and mask_part != '*':
                    return False
            return True

        ip = client_address[0].split('.')

        for mask in self.AllowIPs:
            if check_ip(mask):
                return True

        print "IP [%s] not allowed!" % client_address

        # Beugt DOS Attacken vor, in dem die Rückmeldung verzögert und
        # somit CPU-Zeit freigegeben wird.
        time.sleep(1)

        return False




def ServerStart( cgiVerz, ListenPort, AllowIPs, LogFile ):
    if LogFile!=False:
        # Ausgaben in Datei mitloggen:
        sys.stdout = RedirectStdOut( LogFile, sys.stdout )
        sys.stderr = RedirectStdOut( LogFile, sys.stderr )

    print "="*80

    # Umgebungsvariablen setzten, die man in CGI-Skripten abfragen kann und normalerweise
    # von einem echten WebServer automatisch gesetzt werden
    os.environ['DOCUMENT_ROOT']     = os.getcwd()

    # Liste aller Unetrverzeichnisse erzeugen, damit überall CGIs ausgeführt werden.
    print "Lese Verzeichnisbaum für CGI-Ausführung...",
    cgi_directories = [os.path.normpath( os.sep + i[0] ) for i in os.walk(cgiVerz)]
    print "OK",len(cgi_directories),"Verz. gefunden\n"
    #~ for i in cgi_directories: print i

    print "ROOT-Pfad .......................:", os.getcwd()
    if LogFile!=False:
        print "Log-Datei .......................:", os.path.join( os.getcwd(), LogFile )
    print "Starte CGI-HTTP-Server auf Port .:", ListenPort
    print "Zugelassener IP-Bereich .........:", AllowIPs
    print
    print "Seiten sind nun unter [http://localhost:%s] erreichbar!\n" % ListenPort

    # Variablen in MyRequestHandler setzten:
    MyRequestHandler.cgi_directories    = cgi_directories

    httpd = MyThreadingServer( ("", ListenPort), MyRequestHandler, AllowIPs )

    print "*** Server gestartet ***"

    httpd.serve_forever()




if __name__=="__main__":
    cgiVerz = "." # CGI's in jedem Pfad erlauben
    ListenPort = 9000
    AllowIPs = ('127.0.0.1', '192.168.*.*')
    #~ LogFile = "logs\\LogFile.txt"
    LogFile = False # Keine Log erstellen

    ServerStart( cgiVerz, ListenPort, AllowIPs, LogFile )

#!/usr/bin/python
# -*- coding: ISO-8859-1 -*-

__version__ = "0.0.6"

__history__ = """
v0.0.6
    - Überschreiben der CGIHTTPServer.execfile() damit Skripte nicht per
        execfile() sondern per subprocess ausgeführt werden. Damit alle
        "Sub"-Module immer neu geladen werden.
v0.0.5
    - os.environ["QUERY_STRING"] wird richtig übergeben
"""

import CGIHTTPServer, SocketServer
import os, sys, socket, webbrowser, subprocess



class execscript:
    def __call__( self, scriptfile, dummy ):
        p = subprocess.Popen(
                "%s %s" % ( sys.executable, scriptfile ),
                cwd     = ".",
                shell   = True,
                stdin   = subprocess.PIPE,
                stdout  = subprocess.PIPE,
                stderr  = subprocess.PIPE
            )
        p.stdin = sys.stdin

        sys.stdout.write( p.stdout.read() )
        sys.stderr.write( p.stderr.read() )

# Überschreiben der execscript() Funktion, mit der subprocess-Variante ;)
CGIHTTPServer.execfile = execscript()



class MyRequestHandler( CGIHTTPServer.CGIHTTPRequestHandler ):
    "Modifizieren des Standart RequestHandlers"

    # Damit auch unter Linux, welches fork unterstützt, das Python-CGI-Skript
    # unter dem User ausgeführt wird, mit dem der CGIHTTPServer gestartet wurde
    # und nicht mit User nobody...
    have_fork = False
    have_popen2 = False
    have_popen3 = False


    def is_cgi(self):
        "Modifikation, sodas man im CGI-Verzeichnis ein Dir-Listing bekommt"
        if "?" in self.path:
            script_file, query_string = self.path.split("?",1)
            query_string = "?" + query_string
        else:
            query_string = ""
            script_file = self.path

        script_base, script_filename = os.path.split( script_file )
        if script_filename=="":
            return False

        if os.path.splitext( script_filename )[1] != ".py":
            return False

        script_base = os.path.normpath( script_base )

        # Wird für self.run_cgi() benötigt
        self.cgi_info = script_base, script_filename + query_string

        os.environ['DOCUMENT_ROOT']     = os.getcwd()
        os.environ["SCRIPT_FILENAME"]   = script_filename

        return True # Ist ein "CGI"


class MyThreadingServer( SocketServer.ThreadingTCPServer ):
    """
    Verbesserung des Standart Servers:
     - ermöglicht das abarbeiten mehrere Anfragen parallel (z.B. Download mehrere Dateien gleichzeitig)
     - Ermöglicht das einschränken des IP-Bereiches aus denen der Server Anfragen behandelt
    """
    allow_reuse_address = 1    # Seems to make sense in testing environment


    def __init__(self, server_address, request_handler, AllowIPs):
        SocketServer.ThreadingTCPServer.__init__(self, server_address, request_handler)
        self.AllowIPs = [mask.split('.') for mask in AllowIPs]

    def server_bind(self):
        """Override server_bind to store the server name. (Parallele Anfragen)"""
        SocketServer.ThreadingTCPServer.server_bind(self)
        host, port = self.socket.getsockname()[:2]
        self.server_name = socket.getfqdn(host)
        self.server_port = port

    def verify_request(self, dummy, client_address):
        """Checkt ob die IP-Adresse der Anfrage in 'AllowIPs' vorhanden ist"""
        def check_ip(mask):
            for mask_part, ip_part in zip(mask, ip):
                if mask_part != ip_part and mask_part != '*':
                    return False
            return True

        ip = client_address[0].split('.')

        for mask in self.AllowIPs:
            if check_ip(mask):
                return True

        print "IP [%s] not allowed!" % client_address

        return False




def ServerStart( cgiVerz, ListenPort, AllowIPs ):
    print "="*80
    print "ROOT-Pfad .......................:", os.getcwd()
    print "Starte CGI-HTTP-Server auf Port .:", ListenPort
    print "Zugelassener IP-Bereich .........:", AllowIPs
    print
    print "Seiten sind nun unter [http://localhost:%s] erreichbar!\n" % ListenPort

    httpd = MyThreadingServer( ("", ListenPort), MyRequestHandler, AllowIPs )

    # Öffne Browser
    webbrowser.open_new("http://localhost/index.py")

    httpd.serve_forever()




if __name__=="__main__":
    cgiVerz = "." # CGI's in jedem Pfad erlauben
    ListenPort = 80
    AllowIPs = ('127.0.0.1', '192.168.*.*')

    ServerStart( cgiVerz, ListenPort, AllowIPs )

    have_fork = False
    have_popen2 = False
    have_popen3 = False

#!/usr/bin/python
# -*- coding: ISO-8859-1 -*-

__version__ = "0.0.7"

__history__ = """
v0.0.7
    - subprocess unnötig, da have_fork, have_popen2 und have_popen3 unnötigerweise
        auf False im RequestHandler gesetzt wurden. Das bedeutetet das die CGI
        Skripte immer mit der Notlösung execfile() ausgeführt wurden.
v0.0.6
    - Überschreiben der CGIHTTPServer.execfile() damit Skripte nicht per
        execfile() sondern per subprocess ausgeführt werden. Damit alle
        "Sub"-Module immer neu geladen werden.
v0.0.5
    - os.environ["QUERY_STRING"] wird richtig übergeben
"""

import CGIHTTPServer, SocketServer
import BaseHTTPServer
import os, sys, socket, webbrowser


class MyRequestHandler( CGIHTTPServer.CGIHTTPRequestHandler ):
    """Modifizieren des Standart RequestHandlers"""

    def is_cgi(self):
        """
        Einfachere Variante, sodas alle Python-Skripte überall ausgeführt werden#
        """
        base, filename = os.path.split( self.path )

        if ".py" in filename:
            if "?" in filename:
                os.environ["SCRIPT_FILENAME"] = filename.split("?",1)[0]
            else:
                os.environ["SCRIPT_FILENAME"] = filename

            os.environ['DOCUMENT_ROOT']     = os.getcwd()
            self.cgi_info = base, filename
            return True

class MyThreadingServer( SocketServer.ThreadingTCPServer ):
    """
    Verbesserung des Standart Servers:
     - ermöglicht das abarbeiten mehrere Anfragen parallel (z.B. Download mehrere Dateien gleichzeitig)
     - Ermöglicht das einschränken des IP-Bereiches aus denen der Server Anfragen behandelt
    """
    allow_reuse_address = 1    # Seems to make sense in testing environment


    def __init__(self, server_address, request_handler, AllowIPs):
        SocketServer.ThreadingTCPServer.__init__(self, server_address, request_handler)
        self.AllowIPs = [mask.split('.') for mask in AllowIPs]

    def server_bind(self):
        """Override server_bind to store the server name. (Parallele Anfragen)"""
        SocketServer.ThreadingTCPServer.server_bind(self)
        host, self.server_port = self.socket.getsockname()[:2]
        self.server_name = socket.getfqdn(host)

    def verify_request(self, dummy, client_address):
        """Checkt ob die IP-Adresse der Anfrage in 'AllowIPs' vorhanden ist"""
        def check_ip(mask):
            for mask_part, ip_part in zip(mask, ip):
                if mask_part != ip_part and mask_part != '*':
                    return False
            return True

        ip = client_address[0].split('.')

        for mask in self.AllowIPs:
            if check_ip(mask):
                return True

        print "IP [%s] not allowed!" % client_address

        return False




def ServerStart( ListenPort, AllowIPs ):
    print "="*80
    print "ROOT-Pfad .......................:", os.getcwd()
    print "Starte CGI-HTTP-Server auf Port .:", ListenPort
    print "Zugelassener IP-Bereich .........:", AllowIPs
    print
    print "Seiten sind nun unter [http://localhost:%s] erreichbar!\n" % ListenPort

    httpd = MyThreadingServer( ("", ListenPort), MyRequestHandler, AllowIPs )

    # Öffne Browser
    webbrowser.open_new("http://localhost/index.py")

    httpd.serve_forever()


if __name__=="__main__":
    ServerStart(
        ListenPort  = 80,
        AllowIPs    = ('127.0.0.1', '192.168.*.*')
    )