コード例 #1
0
ファイル: data-backend-file.py プロジェクト: we-mi/lcm
def modifyScript(name, options):
    """ Beschreibung: Aktualisiert ein Skript. Angegeben werden muss der Name
                      des zu aktualisierenden Skriptes und die Werte die
                      aktualisiert werden sollen. Die Werte müssen im
                      Dictionary-Format angegeben werden.
        Parameter:    (string)name: Name des Skripts
                      (dict)options: Werte, die aktualisiert werden sollen.
        Rückgabewert: (int)errorcode, der über LCMP verschickt werden kann. Mögliche Errorcodes sind:
                          ScriptNotRegistered
                          CouldNotModifyScript
                          CouldNotModifyScriptName
                          CouldNotWriteScripts
                          ScriptDoesNotExistInFilesystem
        Exceptions: Wirft selbst keine
    """
    scripts = _readScripts()
    errorcode = error.ERRORS['NoError']
    
    # Prüfe, ob das Skript existiert
    if not scripts.has_section(name):
        return error.ERRORS['ScriptNotRegistered']
    else:
        # Aktualisiere Optionen, oder lege sie an, wenn sie nicht existieren
        try:
            for key in options:
                if key == 'path':
                    if not core.doesFileExist(options[key]):
                        errorcode = error.ERRORS["ScriptDoesNotExistInFilesystem"]
                    else:
                        scripts.set(name,key,options[key])
                        scripts.set(name,'md5',core.getMD5(options[key]))
                elif not key == 'name':
                    scripts.set(name, key, options[key])

            # Aktualisiere den Namen des Skriptes, wenn 'name' übergeben wurde
            if 'name' in options:
                if options['name'] not in getScriptnames():
                    scripts.add_section(options['name'])
                    for key in scripts.items(name):
                        scripts.set(options['name'], key[0], key[1])
                    scripts.remove_section(name)
                else:
                    errorcode = error.ERRORS['CouldNotUpdateScriptName']
        except:
            errorcode = error.ERRORS['CouldNotUpdateScript']
        
        if _writeScripts(scripts):
            return errorcode
        else:
            return error.ERRORS['CouldNotWriteScripts']
コード例 #2
0
ファイル: servercore.py プロジェクト: we-mi/lcm
def LCMPRequestHandler(connection, lcmpPacket, connectionTable, sessionID):
    """ Beschreibung: wird von connectionHandler() aufgerufen und bearbeitet
                        LCMP-Pakete mit "Request"-Typ. Der OpType des Pakets
                        wird mit geprüft und je nach Wert, werden andere Aktionen
                        ausgeführt. Diese Aktionen generieren mind. einen Fehler-
                        code und oft auch Daten. Beides wird am Ende an den Client
                        zurückgesendet (als "Answer"-Typ und mit dem gleichen
                        OpType, wie der, der Request-Anforderung)
        Parameter: (socket)connection: Enthält die Verbindungsinformationen des
                    Client.
                    (tuple)lcmpPacket: Enthält die Daten eines LCMP-Paketes
                    (list)connectionTable: Enthält alle noch aktiven Verbindungen
                    (int)sessionID: Die aktuelle ID der Session
                    
        Rückgabewert: Keiner
        Exceptions: LCMPError
    """
    
    
    errorcode = 0
    data = ""
    opType = lcmp.OPTYPES_REVERSE[lcmpPacket[lcmp.LCMP_INDICES["OpType"]]]
    
    sessionName = ""
    connectionTable_sessionIDs = getSessionIDs(connectionTable)

    # Hat die Session schon einen zugehörigen Computernamen? Dann zeige ihn an.
    if connectionTable[connectionTable_sessionIDs.index(sessionID)][2] == "":
        sessionName = "Session %s" % sessionID
    else:
        sessionName = connectionTable[connectionTable_sessionIDs.index(sessionID)][2]
    
    log.writeLogLV(config_backend.getLogfile(),
                    "%s: %s: Client requests: %s with data: %s\n" % (threading.currentThread().name,
                        sessionName,
                        lcmp.OPTYPES_REVERSE[lcmpPacket[lcmp.LCMP_INDICES["OpType"]]],
                        lcmpPacket[lcmp.LCMP_INDICES["Data"]]),
                    log.LOGLEVEL["info"])

    # Dieser Try-Block soll alle Fehler abfangen, die innerhalb des Data-Backends auftreten
    # natürlich können damit auch andere Fehler abgefangen werden, die dann gesondert behandelt
    # werden müssen
    try:
        if (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["quitConnection"]):
            errorcode = 0
            data = "Goodbye"
            connectionTable_sessionIDs = getSessionIDs(connectionTable)
            
            # Entferne sessionID aus connectionTable, wenn der Client die Verbindung beendet.
            connectionTable.remove(connectionTable[connectionTable_sessionIDs.index(sessionID)])
            
        # Client Operationen
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["addClient"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, name, options = parseNameAndOptions(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
                
                # Setze interne Optionen und überschreibe benutzerdefinierte Optionen, wenn jemand versucht
                # die internen Optionen so zu überschreiben
                options["last-seen"] = "never"
                options["created-on"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                if "scriptmember" in options:
                    del options["scriptmember"]
        
                if errorcode == 0:
                        errorcode = data_backend.addClient(name, options)
                else: # parseNameAndOptions() hat nicht funktioniert
                    pass
                    # der errorcode von parseNameAndOptions wird im LCMP-Errorfeld
                    # zurückgesendet und muss nicht mehr gesetzt werden
                data = "" # Es müssen keine Nutzdaten zurückgesendet werden, also kann das Feld leer bleiben
                
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["removeClient"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, name, options = parseNameAndOptions(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
                
                if errorcode == 0:
                    errorcode = data_backend.removeClient(name)

                else: # parseNameAndOptions() hat nicht funktioniert
                    pass
                    # der errorcode von parseNameAndOptions wird im LCMP-Errorfeld
                    # zurückgesendet und muss nicht mehr gesetzt werden
                data = "" # Es müssen keine Nutzdaten zurückgesendet werden, also kann das Feld leer bleiben
                
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
       
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["modifyClient"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, name, options = parseNameAndOptions(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
        
                if errorcode == 0:
                        errorcode = data_backend.modifyClient(name, options)
                else: # parseNameAndOptions() hat nicht funktioniert
                    pass
                    # der errorcode von parseNameAndOptions wird im LCMP-Errorfeld
                    # zurückgesendet und muss nicht mehr gesetzt werden
                data = "" # Es müssen keine Nutzdaten zurückgesendet werden, also kann das Feld leer bleiben
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
    
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["getClients"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                
                errorcode, data = data_backend.getClients()
            
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        # Gruppen Operationen
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["addGroup"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, name, options = parseNameAndOptions(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
                
                # Wenn keine Parent-Gruppe angegeben ist, nehme die 'root'-Gruppe
                if not 'parent' in options:
                    options["parent"] = "root"
                else:
                    # Prüfen, ob die parentGruppe existiert
                    if not options["parent"] in data_backend.getGroupNames()[1]:
                        errorcode = error.ERRORS["ParentGroupDoesNotExist"]
        
                # Lösche interne Optionen, wenn jemand versucht, die internen Optionen so zu überschreiben
                if "member" in options:
                    del options["member"]
                if "scriptmember" in options:
                    del options["scriptmember"]
                
                if errorcode == 0:
                        errorcode = data_backend.addGroup(name, options)
                data = ""
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                           
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["removeGroup"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, name, options = parseNameAndOptions(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
        
                if errorcode == 0:
                        errorcode = data_backend.removeGroup(name)
                else: # parseNameAndOptions() hat nicht funktioniert
                    pass
                    # der errorcode von parseNameAndOptions wird im LCMP-Errorfeld
                    # zurückgesendet und muss nicht mehr gesetzt werden
                data = "" # Es müssen keine Nutzdaten zurückgesendet werden, also kann das Feld leer bleiben

            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["modifyGroup"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, name, options = parseNameAndOptions(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
        
                if errorcode == 0:
                        errorcode = data_backend.modifyGroup(name, options)
                else: # parseNameAndOptions() hat nicht funktioniert
                    pass
                    # der errorcode von parseNameAndOptions wird im LCMP-Errorfeld
                    # zurückgesendet und muss nicht mehr gesetzt werden
                data = "" # Es müssen keine Nutzdaten zurückgesendet werden, also kann das Feld leer bleiben
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["getGroups"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, data = data_backend.getGroups()
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
        
        # Script Operationen
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["addScript"]):
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, name, options = parseNameAndOptions(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
        
                if errorcode == 0:
                    if 'path' in options:
                        if not core.doesFileExist(options['path']):
                            errorcode = error.ERRORS['ScriptDoesNotExistInFilesystem']
                        else:
                            options["md5"] = core.getMD5(options['path'])
                            if not 'active' in options:
                                options['active'] = "true"
                            elif options['active'] == "true" or\
                                 options['active'] == "yes" or\
                                 options['active'] == "1":
                                options['active'] = "true"
                            elif options['active'] == "false" or\
                                 options['active'] == "no" or\
                                 options['active'] == "0":
                                options['active'] = "false"
                            else:
                                options['active'] = "true"
                            
                            errorcode = data_backend.addScript(name, options)
                    else:
                        errorcode = error.ERRORS['IllegalNumberOfParameters'] # TODO: Neuen Errorcode
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
            
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["removeScript"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, name, options = parseNameAndOptions(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
        
                if errorcode == 0:
                        errorcode = data_backend.removeScript(name)
                else: # parseNameAndOptions() hat nicht funktioniert
                    pass
                    # der errorcode von parseNameAndOptions wird im LCMP-Errorfeld
                    # zurückgesendet und muss nicht mehr gesetzt werden
                data = "" # Es müssen keine Nutzdaten zurückgesendet werden, also kann das Feld leer bleiben
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
            
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["modifyScript"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, name, options = parseNameAndOptions(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
        
                if errorcode == 0:
                    errorcode = data_backend.modifyScript(name, options)
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
            
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["getScripts"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, data = data_backend.getScripts()
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["getScripts"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, data = data_backend.getScriptsFull()
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
           
        # Client & Gruppen Operationen
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["addClientToGroup"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode = data_backend.addClientToGroup(lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[0], lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[1])   
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["removeClientFromGroup"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode = data_backend.removeClientFromGroup(lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[0], lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[1])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["showClientsOfGroup"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, data = data_backend.showClientsOfGroup(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["showGroupsOfClient"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, data = data_backend.showGroupsOfClient(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
            
        # Client & Skript Operationen
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["addScriptToClient"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode = data_backend.addScriptToClient(lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[0], lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[1])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["removeScriptFromClient"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode = data_backend.removeScriptFromClient(lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[0], lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[1])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["showScriptsOfClient"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, data = data_backend.showScriptsOfClient(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["showClientsOfScript"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, data = data_backend.showClientsOfScript(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        # Gruppen & Skript Operationen
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["addScriptToGroup"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode = data_backend.addScriptToGroup(lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[0], lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[1])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["removeScriptFromGroup"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode = data_backend.removeScriptFromGroup(lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[0], lcmpPacket[lcmp.LCMP_INDICES["Data"]].split(' ')[1])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["showScriptsOfGroup"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, data = data_backend.showScriptsOfGroup(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
        
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["showGroupsOfScript"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                errorcode, data = data_backend.showGroupsOfScript(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""
    
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["sendScript"]):
            # prüfe zuerst ob der Hostname in der Verbindungstabelle verfügbar ist
            connectionTable_sessionIDs = list()
            for i in connectionTable:
                connectionTable_sessionIDs.append(i[0])
            hostname = connectionTable[connectionTable_sessionIDs.index(sessionID)][2]
            if  hostname != "":
                # Es ist ein Hostname vorhanden, fahre fort
                scripts = data_backend.getScriptsForClient(hostname)[1]
                
                if lcmpPacket[lcmp.LCMP_INDICES["Data"]] in scripts:
                    errorcode, scriptpath = data_backend.getScriptpath(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
                    
                    if errorcode == 0:
                        if data_backend.getScriptActive(lcmpPacket[lcmp.LCMP_INDICES["Data"]]):
                            if core.doesFileExist(scriptpath):
                                scriptFd = open(scriptpath)
                                scriptcontent = ""
                                for line in scriptFd:
                                    scriptcontent += line
                                
                                log.writeLogLV(config_backend.getLogfile(),
                                                "%s: %s: Sende Skript '%s' (%s) an Client\n" % 
                                                    (threading.currentThread().name,
                                                     sessionName,
                                                     lcmpPacket[lcmp.LCMP_INDICES["Data"]],
                                                     scriptpath),
                                                log.LOGLEVEL["info"])
                            
                                errorcode = 0
                                data = scriptcontent
                            else:
                                log.writeLogLV(config_backend.getLogfile(),
                                            "%s: %s: Das Skript wurde im Dateisystem nicht gefunden\n" % 
                                                (threading.currentThread().name,
                                                 sessionName),
                                            log.LOGLEVEL["warning"])
                                errorcode = error.ERRORS["ScriptDoesNotExistInFilesystem"]
                                data = ""                       
                        else:
                            log.writeLogLV(config_backend.getLogfile(),
                                            "%s: %s: Das Skript wurde von einem Administrator deaktiviert\n" % 
                                                (threading.currentThread().name,
                                                 sessionName),
                                            log.LOGLEVEL["warning"])
                            errorcode = error.ERRORS["ScriptIsDeactivated"]
                            data = ""
                            
                    else:
                        log.writeLogLV(config_backend.getLogfile(),
                                        "%s: %s: Das Skript ist in der Datenbank des Servers nicht vorhanden\n" % 
                                            (threading.currentThread().name,
                                             sessionName),
                                        log.LOGLEVEL["warning"]) 
                        errorcode = error.ERRORS["ScriptNotRegistered"]
                        data = ""
                else:
                    log.writeLogLV(config_backend.getLogfile(),
                                    "%s: %s: Das Skript ist diesem Client nicht zugewiesen\n" % 
                                        (threading.currentThread().name,
                                         sessionName),
                                    log.LOGLEVEL["warning"])
                    errorcode = error.ERRORS["ScriptDoesntBelongToClient"]
                    data = ""
            else:
                core.writeLogLV(config_backend.getLogfile(),
                              "%s: %s: Dem Server ist der Hostname dieses Clients noch nicht bekannt" % 
                                (threading.currentThread().name,
                                 sessionName),
                              log.LOGLEVEL["warning"])
                errorcode = error.ERRORS["NoHostnameGiven"]
                data = ""
                    
            
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["getScriptsForClient"]):
            # Berechne Skripte für Client (Achtung: scriptsForClient ist eine Liste!!
            errorcode, scriptsForClient = data_backend.getScriptsForClient(lcmpPacket[lcmp.LCMP_INDICES["Data"]])
            
            # Ist der Client überhaupt registriert? Data_Backend gibt Fehler wenn Client nicht vorhanden ist
            if errorcode == error.ERRORS["ClientNotRegistered"]:
                log.writeLogLV(config_backend.getLogfile(),
                                "%s: %s: Client ist nicht im Data-Backend vorhanden\n" % 
                                    (threading.currentThread().name,
                                     sessionName),
                                log.LOGLEVEL["warning"])
                errorcode = error.ERRORS["ClientNotRegistered"] # TODO: überflüssig?
                data = "[]"
                
            # sind überhaupt scripte für den client vorhanden?
            elif scriptsForClient == list(): # leere Liste
                log.writeLogLV(config_backend.getLogfile(),
                                "%s: %s: Dem Client sind keine Skripte zugewiesen:\n" % 
                                    (threading.currentThread().name,
                                     sessionName),
                                log.LOGLEVEL["warning"])
                errorcode = error.ERRORS["NoScriptsForClient"]
                data = "[]"
                
                # aktualisiere das Feld 'last-seen' beim Client
                data_backend.modifyClient(lcmpPacket[lcmp.LCMP_INDICES["Data"]], {'last-seen':datetime.now().strftime("%Y-%m-%d %H:%M:%S")})
                
            else:
                log.writeLogLV(config_backend.getLogfile(), 
                                "%s: %s: Dem Client sind diese Skripte zugewiesen: %s\n" % 
                                    (threading.currentThread().name, sessionName, scriptsForClient),
                                log.LOGLEVEL["info"])
                
                # Hostnamen in ConnectionTable eintragen
                connectionTable_sessionIDs = list()
                for i in connectionTable:
                    connectionTable_sessionIDs.append(i[0])
                connectionTable[connectionTable_sessionIDs.index(sessionID)][2] = lcmpPacket[lcmp.LCMP_INDICES["Data"]]
                
                # aktualisiere das Feld 'last-seen' beim Client
                data_backend.modifyClient(lcmpPacket[lcmp.LCMP_INDICES["Data"]], {'last-seen':datetime.now().strftime("%Y-%m-%d %H:%M:%S")})
                
                data = str(scriptsForClient)
                
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["sendReturnCode"]):
            
            connectionTable_sessionIDs = list()
            for i in connectionTable:
                connectionTable_sessionIDs.append(i[0])
                
            scriptname = lcmpPacket[lcmp.LCMP_INDICES["Data"]]
            rc = lcmpPacket[lcmp.LCMP_INDICES["Errorcode"]]
            clientname = connectionTable[connectionTable_sessionIDs.index(sessionID)][2]
            
            log.writeLogLV(config_backend.getLogfile(), 
                            "%s: %s: Client %s hat das Skript %s mit Code %s ausgeführt\n" % 
                                (threading.currentThread().name, sessionName, clientname, scriptname, rc),
                            log.LOGLEVEL["info"])
            
            errorcode = 0
            data = "thx"
        
        elif (lcmpPacket[lcmp.LCMP_INDICES["OpType"]] == lcmp.OPTYPES["printSessions"]):
            
            # prüfe, ob die Session dazu berechtigt ist diesen OpType auszuführen
            if getSession(connectionTable, sessionID)[1] in config_backend.getAdminIPs():
                print connectionTable
                errorcode = 0
                data = ""
            else:
                errorcode  = error.ERRORS["NotAllowed"]
                data = ""        
        
        # Wenn OpType nicht bekannt ist
        else:
            errorcode = error.ERRORS["NotImplemented"]
            data = lcmp.OPTYPES_REVERSE[lcmpPacket[lcmp.LCMP_INDICES["OpType"]]]
            
    except error.DataBackendReturnTypeError as e:
        errorcode = error.ERRORS["DataBackendReturnTypeError"]
        log.writeLogLV(config_backend.getLogfile(),
                       "%s: %s: "\
                       "%s hat einen falschen Rückgabetypen zurückgegeben "\
                       "(%s; erwartet wurde %s), "\
                       "eventuell liegt im Data-Backend-Modul eine fehlerhafte Implementierung von %s "\
                       "vor. Die aktuelle Operation wird abgebrochen!\n" % 
                           (threading.currentThread().name, sessionName, opType, e.getWrongType(), e.getRightType(), opType),
                           log.LOGLEVEL["error"])
        
        if config_backend.getDebug():
            print traceback.print_exc()
            
    except error.DataBackendReturnValueError as e:
        errorcode = error.ERRORS["DataBackendReturnValueError"]
        log.writeLogLV(config_backend.getLogfile(),
                       "%s: %s: "\
                       "'%s' hat einen falschen Rückgabewert zurückgegeben(%s). "\
                       "Eventuell liegt im Data-Backend-Modul eine fehlerhafte Implementierung von '%s' "\
                       "vor. Die aktuelle Operation wird abgebrochen!\n" % 
                           (threading.currentThread().name, sessionName, opType, e.getValue(), opType),
                           log.LOGLEVEL["error"])
        
        if config_backend.getDebug():
            print traceback.print_exc()
                            
    except error.DataBackendInternalError as e:
        errorcode = error.ERRORS["DataBackendInternalError"]
        log.writeLogLV(config_backend.getLogfile(),
                       "%s: %s: "\
                       "%s wurde nicht ordnungsgemäß ausgeführt, "\
                       "die Fehlermeldung lautet: '%s'. "
                       "Eventuell liegt im Data-Backend-Modul eine fehlerhafte Implementierung von %s "\
                       "vor. Die aktuelle Operation wird abgebrochen!\n" % 
                           (threading.currentThread().name, sessionName, opType, e.getValue(), opType),
                           log.LOGLEVEL["error"])

        if config_backend.getDebug():
            print traceback.print_exc()
            
    except Exception as e:
        errorcode = error.ERRORS["InternalServerError"]
        log.writeLogLV(config_backend.getLogfile(),
                       "%s: %s: "\
                       "Bei der Bearbeitung von '%s' ist ein Fehler aufgetreten (%s). "\
                       "Die aktuelle Operation wird abgebrochen!\n" % 
                           (threading.currentThread().name, sessionName, lcmp.OPTYPES_REVERSE[lcmpPacket[lcmp.LCMP_INDICES["OpType"]]], e.args),
                           log.LOGLEVEL["error"])
        
        if config_backend.getDebug():
            print traceback.print_exc()

    # Statusmeldung ausgeben
    log.writeLogLV(config_backend.getLogfile(),
                            "%s: %s: %s executed with Code %s [%s]\n" %
                                (threading.currentThread().name,
                                 sessionName,
                                 lcmp.OPTYPES_REVERSE[lcmpPacket[lcmp.LCMP_INDICES["OpType"]]],
                                 errorcode,
                                 error.ERRORS_REVERSE[errorcode]),
                            log.LOGLEVEL["debug"])

    # sende Paket (immer von Type: Answer, OpType ist derselbe wie beim eigentlichen Request, errorcode und data ist variabel
    answer = lcmp.genLCMPPacket(int(sessionID),
                                    "Answer", 
                                    lcmp.OPTYPES_REVERSE[lcmpPacket[lcmp.LCMP_INDICES["OpType"]]],
                                    errorcode,
                                    data)
    
    log.writeLogLV(config_backend.getLogfile(),
                    "%s: %s: sending this lcmpPacket: %s\n" %
                        (threading.currentThread().name,
                        sessionName,
                        answer),
                    log.LOGLEVEL["debug"])
    
    network.send(connection, answer)
# Ende: RequestHandler()