示例#1
0
class ConnectionHandler:
    """
    Infolib.ConnectionHandler ist eine Klasse, die die Grundfunktionalitaet des Infoservers bereitstellt.
    Sie bindet einen Port, an dem alle Verbindungen eigehen und verteilt die Pakete nach den entsprechenden Kopfinformationen.
    Sie baut auf allen anderen Klassen in der Infolib auf.

    Eine Verwendung ausserhalb des Infobook-Projektes wird nicht empfohlen.

    Eine Dokumentation des Ablaufes finden Sie im GitHub-Wiki unter https://github.org/hansau22/infobook/
    """

    def __init__(self, port=False):
        """
        Initialisierung und Binden des Ports.
        Der Port kann via Shell-Argument uebergeben werden, sonst wird versucht, Port 32323 zu binden.

        @return: None
        """

        self.database = DatabaseHandler("gu.db")
        self.crypt = EncryptionHandler()
        self.sid_Pool = Pool(0)

        self.file_storage = "./files/"
        self.max_rcv = 2048

        self.users = []         # Nutzer, die zum Index Session-ID gehoeren
        self.ivs = []           # Initialiserungsvektoren
        self.ctr = []           # Counter
        self.sesskey = []       # Sessionkeys
        self.uidstrings = []    # User-ID-Strings
        
        #serv_soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        #file_soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        serv_soc = socket.socket()

        if port != False:
            serv_soc.bind(("", port))
        elif len(sys.argv) < 2:
            serv_soc.bind(("", 32323))
        else:
            serv_soc.bind(("", int(sys.argv[1])))

        serv_soc.listen(1)
        
        try:
            while True:

                komm, addr = serv_soc.accept()
                data = ""
                data = komm.recv(self.max_rcv)

                # Default-Antwort
                resp = "error - invalid-client-request"

                # Leere Verbindung
                if not data: 
                    komm.close()
                    continue

                # Datenpaket ist verschluesslt (= Kein DHEX-Paket)    
                if self.crypt.is_encrypted(data):
                    #body = self.decrypt(data)

                    tmp = split(";", data, 1)
                    body = tmp[1]
                    #print "getting messages :" + body

                    # Wenn nicht entschluesselbar -> Fehler
                    if body == None:
                       komm.send(resp)
                       komm.close()
                       continue 

                    body = body.decode("utf-8", "ignore")

                try:
                    # Kopfdaten und Nutzdaten trennen
                    data = split(";", data, 1)
                    self.header = self.parse_header(data[0])
                    data = data[1]
                except IndexError:
                    komm.send(resp)
                    komm.close()
                    continue

                # Datenpaket encoden
                #if self.header[0] != "dhex":

                try:

                    if self.header[0] == "dhex":
                        resp = self.init_dh(data)                      
                    elif self.header[0] == "auth":
                        resp = self.auth_user(body)
                    elif self.header[0] == "msg":
                        resp = self.recv_msg(body)
                    elif self.header[0] == "getmsg":
                        resp = self.get_msg(body)
                    elif self.header[0] == "gmsg":
                        resp = self.recv_gmsg(body)
                    elif self.header[0] == "getgmsg":
                        resp = self.get_gmsg(body)
                    elif self.header[0] == "reqfile":
                        resp = self.request_file()
                    elif self.header[0] == "regfile":
                        resp = self.register_file(body)
                    elif self.header[0] == "getfile":
                        resp = self.get_globalname(body)
                    elif self.header[0] == "getpic":
                        resp = self.get_profile_pic(body)
                    elif self.header[0] == "adduser":
                        resp = self.add_user(body)
                    elif self.header[0] == "adressbook":
                        resp = self.get_address_book(body)


                    # Antwortpaket senden
                    if self.header[0] == "dhex":
                        komm.send(resp)

                    elif isinstance(resp, list):
                        #for item in resp:
                            #item = (str(item[0]).encode("utf-8", "ignore"), item[1].encode("utf-8", "ignore"))

                        komm.send(self.build_pack(json.dumps(resp)))

                    else:
                        if self.is_error(resp):
                            print "error:  " + resp
                            komm.send(resp)
                        else:
                            resp = self.crypt.encode_string(resp)
                            komm.send(self.build_pack(resp))
                        
                    komm.close()

                except IndexError:
                    komm.send(resp)
                    komm.close()

                        
        finally:
            #for client in clients: 
            #    client.close() 
            serv_soc.close()



    def is_error(self, data):
        """
        Prueft ob eine Antwort eine Fehlermeldung ist

        @param data: Antwort
        @type data: str

        @return: Boolean Ergebnis
        """

        if string.find(data, "error", 0, 4) == -1 :
            return False
        else:
            return True


    def init_dh(self, data):
        """
        Initialisiert den DH-Schluesselaustausch anhand der Informationen aus der Anfrage des Clients.

        @param data: Enthaelt den Oeffentlichen Teil vom Partner
        @type data: str

        @return: str - Sessionkey
        """

        # DH-Antwort (B) auf die Anfrage (A)
        ret = self.crypt.init_dh_b(self.sid_Pool.give_next(),data)

        if ret == False:
            return "error - DH-initiation-error - DHEX"

        try:
            # Alle Felder fuer die neu Initialiserte Session reservieren (befuellen)
            self.users.append("")
            self.uidstrings.append("")
            self.ivs.append(ret[0])
            self.ctr.append(ret[1])
            self.sesskey.append(ret[2])

            #print "sesskey :  " + ret[2]

            return ret[3]
        except IndexError:
            return "error - DH-initiation-server-error - DHEX"
        



    def decrypt(self, data):
        """
        Entschluesselt ein Datenpaket mit dem Sessionkey, der zur Session-ID gehoert.

        @param data: Verschluesseltes Paket mit unverschluesselten Kopfinformationen
        @type data: str

        @return: str - Unverschluesseltes Paket ohne Kopfinformationen
        """

        try:
            tmp = split(";", data, 1)       # ";" Seperiert Nutz- und Kopfdaten
            sid = split(":", tmp[0], 2)     # Extrahiere Session-ID
            sid = int(sid[2])
            data = self.crypt.decrypt(self.sesskey[sid], self.ctr[sid], tmp[1])
            return data
        except IndexError:
            return None



    
    def encrypt(self, data):
        """
        Verschluesselt die Daten fuer ein Paket.

        @param data: Daten-String ohne Kopfinformationen
        @type data: str

        @return: Verschluesselt Datenpaket ohne Kopfinformationen
        """
        try:
            sid = self.header[2]
            #return self.crypt.encrypt(self.sesskey[sid], self.ctr[sid], data)
            return data
        except IndexError:
            return None

            
    def parse_header(self, data):
        """
        Verarbeitet Kopfinformationen und wandelt die Informationen in benoetigte Typen

        @param data: Kopfinformationen
        @type data: str

        @return: Array - Kopfinformationen
        """

        try:
            header = split(":", data, 2)
            if not header[0] == "dhex":
                header[2] = int(header[2])
            return header
        except IndexError:
            pass
        


    def build_pack(self, msg):
        """
        Erstellt die Kopfinformationen fuer ein Datenpaket und fuegt die Nachricht an.

        @param msg: Nachricht ohne Kopfinformationen
        @type msg: str

        @return: str - Nachrichtenpaket mit Kopfinformationen
        """

        try:
            package = "sresp" + ":" + str(self.header[2]) + ";"
            #enc_msg = self.encrypt(msg)
            #if enc_msg == None:
            #    return msg
            package += msg
            return package
        except IndexError:
            return msg



    def auth_user(self, data):
        """
        Prueft ob eine Nutzer-Passwort Kombination valid ist.

        @param data: Paket des Clients ohne Kopfinformationen
        @type data: str

        @return: str - Digest, der den Nutzer-ID-String enthaelt
        """
        cred = split(":", data, 1)
        if len(cred) < 2:
            return "error - not-enough-arguments - AUTH"
        try:
            if self.database.auth_user(cred[0], cred[1]) == True:

                # User-ID String erzeugen
                dig = self.crypt.get_hash(self.sesskey[self.header[2]] + str(cred[0])) 

                self.uidstrings[self.header[2]] = dig
                self.users[self.header[2]] = self.database.get_user_id(cred[0])

                return dig
            else:
                return "error - wrong-credentials - AUTH"
        except IndexError:
            return "error - invalid-header - AUTH"



    def check_uidstring(self, index, string):
        """
        Vergleicht einen Nutzer-ID-String mit dem, der zu dem Nutzer mit der Session-ID gehoert.

        @param index: Session-ID
        @type index: int

        @param string: Nutzer-ID-String
        @type string: str

        @return: Boolean - Ergebnis
        """

        try:
            if self.uidstrings[index] == string:
                return True
            return False
        except IndexError:
            return False


        
    def recv_msg(self, data):
        """
        Traegt eine Nachricht in die Datenbank ein.

        @param data: Datenpaket des Clients ohne Kopfinformationen
        @type data: str

        @return: str - Erfolgs-/Fehlermeldung
        """

        try:
            sid = self.header[2]
            tmp = split(":", data, 2)


            # Nicht alle Felder gegeben
            if len(tmp) != 3:
                return "error - not-long-enough - MSG"

            if self.check_uidstring(sid, tmp[0]):
                rcv_uid = self.database.get_user_id(tmp[1])
                snd_uid = self.users[self.header[2]]
                print "writing message:" + tmp[2]
                if not self.database.rcv_message(snd_uid, rcv_uid, tmp[2]):
                    return "error - server-database-error - MSG"
                return "success - MSG"
            else:
                return "error - wrong-uidstring - MSG"
        except IndexError:
            return "error - invalid-header - MSG"



    def get_msg(self, data):
        """
        Gibt dem Client die Nachrichten zurueck. 

        @param data: Letzte MID, die der Client an den Server gibt.
        @type data: str

        @return: Array - Nachrichten
        """

        data = split(":", data, 2)

        try:

            if not self.check_uidstring(self.header[2], data[0]):
              #  print "wrong uid string :" + data[0]
                return "error - wrong-credentials - GetMessage"

            messages = self.database.get_messages_by_last_mid(self.header[2], data[1])
            ret_msg = []

            for item in messages:
                username = self.database.get_user_by_id(item[0])

                if (username == None) or (item[0] == "False"):
                    username = "******"

                ret_msg.append((username, item[1]))

            return ret_msg
        except IndexError:
            return "error - internal-database-request-error - MSG"



    def get_gmsg(self, data):
        """
        Gibt dem Client die Gruppennachrichten zurueck.

        @param data: Letzte GID, die der Client an den Server gibt.
        @type data: str

        @return: Array - Nachrichten
        """

        data = split(":", data, 2)

        try:

            if not self.check_uidstring(self.header[2], data[0]):
                print "wrong uid string"
                return "error - wrong-credentials - GetGroupMessage"

            messages = self.database.get_messages_by_last_gid(self.header[2], data[1])
            ret_msg = []

            for item in messages:
                groupname = self.database.get_group_by_id(item[0])

                if groupname == None:
                    groupname = "Gruppenname unbekannt"

                ret_msg.append(item[1] + ":" + groupname + ":" + item[2])

            return ret_msg
        except IndexError:
            return "error - internal-database-request-error - GroupMessage"



    def recv_gmsg(self, data):
        """
        Traegt eine Broadcast-Nachricht in die Datenbank ein.

        @param data: Datenpaket des Clients ohne Kopfinformationen
        @type data: str

        @return: str - Erfolgs-/Fehlermeldung
        """

        try:
            sid = self.header[2]
            tmp = split(":", data, 2)

            # Nicht alle Felder gegeben
            if len(tmp) != 3:
                return "error - not-enough-arguments - GroupMessage"

            if self.check_uidstring(sid, tmp[0]):
                rcv_gid = self.database.get_group_id(tmp[1])
                snd_uid = self.users[self.header[2]]
                print "writing group message:" + tmp[2]
                if not self.database.rcv_brdc_message(snd_uid, rcv_gid, tmp[2]):
                    return "error - server-database-error - GroupMessage"
                return "success - GroupMessage"
            else:
                print "error in uidstring"
                return "error - wrong-uidstring - GroupMessage"
        except IndexError:
            return "error - invalid-header - GroupMessage"


    def request_file(self):
        """
        Gibt einen Dateistring fuer eine neue Datei zurueck, die ueber FTP hochgeladen werden kann

        @return: str - Dateistring
        """

        ret_value = self.generate_file_string()

        if ret_value == None:
            return "error - storage-full - REQFILE"
        else:
            self.database.add_file(ret_value)
            return ret_value



    def register_file(self, data):
        """
        Registriert eine Datei (Setzt den Besitzer zu einem Upload und gibt Dateinamen an)

        @param data: Datenpaket des Clients ohne Kopfinformationen
        @type data: str

        @return: str - Erfolgs-/Fehlermeldung
        """
        values = split(":", data, 2)
        print  values
    
        try: 
               

            filestring = values[0]
            global_name = values[1]
            del values


            if not self.database.check_filestring(filestring):
                return "error - wrong-filestring"

            if not self.database.register_file(self.users[self.header[2]], global_name, filestring):
                return "error - server-storage-error"
            else:
                return "success - FILE"
        except IndexError:
            return "error - invalid-header - FILE"


    def get_globalname(self, data):
        """
        Sucht eine Datei nach dem Dateinamen und gibt den filestring zuruekc

        @param data: Datenpaket des Clients ohne Kopfinformationen
        @type data: str

        @return: str - filestring / str - error
        """

        filestring = self.database.get_name_by_filestring(data)

        if not filestring:
            return "error - file-not-found - FILE"
        return filestring


    def generate_file_string(self):
        """
        Generiert einen Datei-String fuer eine neu empfangene Datei
        Prueft ausserdem, ob eine Datei mit diesem Namen in ./files vorhanden ist

        @return: str - Dateistring
        """
        for i in range(0, 14):
            filestring = ""
            for i in range(0, 10):
                filestring = filestring + choice(string.ascii_letters)

            if os.path.exists(self.file_storage + filestring):
                break
            else:
                return filestring

        return None



    def get_profile_pic(self, data):
        """
        Gibt dem Nutzer den String zum Profilfoto zurueck

        @param data: Datenpaket des Clients ohne Kopfinformationen
        @type data: str

        @return: str - Dateistring zum Profilbild
        """

        string = self.database.get_profile_pic(data)

        if not string:
            return "-"
        return string


    def add_user(self, data):
        """
        Fuegt einen neuen Benutzer hinzu

        @param data: Daten vom Client
        @type data: str

        @return: str - Nachricht an den Client
        """

        tmp = split(":", data, 2)

        if not len(tmp) == 2:
            return "error - not-enough-arguments - ADDUSER"        

        username = tmp[0]
        pwhash = tmp[1]

        if not self.database.check_user(username):
            return "error - already-present-username - ADDUSER"

        self.database.add_user(username, pwhash)
        return "success - ADDUSER"


    def get_address_book(self, data):
        """
        Gibt das Nutzer-Addressbuch zurueck

        @param data: uidstring
        @type data: str

        @return: Array - [int UID, str Name]
        """

        if not self.check_uidstring(int(self.header[2]), data):
            return "error - wrong-uidstring - GETADRBOOK"

        return self.database.get_address_book(self.users[int(self.header[2])])
示例#2
0
class DatabaseHandler:
    """
    Infolib.DatabaseHandler ist eine Klasse, die den Datenbankzugriff auf eine sqlite3-Datenbank fuer den Infobook-Server
    regelt.

    Eine Verwendung ausserhalb des Infobook-Projektes wird nicht empfohlen.
    """

    def __init__(self, database):
        """
        Initialisierung

        @param database: Pfad zur Datenbank
        @type database: str

        @return: None
        """
        self.db = sqlite3.connect(database)
        self.db.text_factory = str
        self.cursor = self.db.cursor()
        self.init_db()
        self.mid_Pool = Pool(0, self.get_start_mid())
        self.bid_Pool = Pool(0, self.get_start_brdc_mid())
        self.fid_Pool = Pool(0, self.get_start_fid())
        self.uid_Pool = Pool(0, self.get_start_uid())


    
    def init_db(self):
        """
        Initialisert die Datenbank

        @return: None
        """
        self.cursor.execute("CREATE TABLE IF NOT EXISTS users(uid INTEGER, username TEXT, password TEXT, profilepic TEXT)")
        self.cursor.execute("CREATE TABLE IF NOT EXISTS groups(gid INTEGER, member INTEGER, name Text)")
        self.cursor.execute("CREATE TABLE IF NOT EXISTS messages(mid INTEGER, uidsender INTEGER, uidreceiver INTEGER, content TEXT)")
        self.cursor.execute("CREATE TABLE IF NOT EXISTS groupmessages(bid INTEGER, uidsender INTEGER, gidreceiver INTEGER, content TEXT)")
        self.cursor.execute("CREATE TABLE IF NOT EXISTS files(fid INTEGER, localname Text, globalname Text, owner INTEGER)")
        self.cursor.execute("CREATE TABLE IF NOT EXISTS addressbook(uid INTEGER, addid INTEGER)")
        self.db.commit()

        self.cursor.execute("SELECT uid FROM users WHERE uid = 0")
        if self.cursor.fetchone() == None:
            self.cursor.execute("INSERT INTO users VALUES(0, 'initial', 'nohash', 'none')")

        self.cursor.execute("SELECT fid FROM files WHERE fid = 0")
        if self.cursor.fetchone() == None:
            self.cursor.execute("INSERT INTO files VALUES(0, 'initial', 'initial', 0)")

        self.cursor.execute("SELECT mid FROM messages WHERE mid = 0")
        if self.cursor.fetchone() == None:
            self.cursor.execute("INSERT INTO messages VALUES(0, 0, 0, 'initial')")

        self.cursor.execute("SELECT bid FROM groupmessages WHERE bid = 0")
        if self.cursor.fetchone() == None:
            self.cursor.execute("INSERT INTO groupmessages VALUES(0, 0, 0, 'initial')")

        self.cursor.execute("SELECT gid FROM groups WHERE gid = 0")
        if self.cursor.fetchone() == None:
            self.cursor.execute("INSERT INTO groups VALUES(0, 0, 'initial')")

        self.db.commit()

        
    def add_user(self, username, pwhash):
        """
        Fuegt einen Nutzer zur Datenbank hinzu

        @param username: Nutzername
        @type username: str

        @param pwhash: SHA256-Verschluesselter Passwort-Hash
        @type pwhash: str

        @return: None, False wenn Parameter nicht stimmen
        """

        self.cursor.execute("INSERT INTO users VALUES(?, ?, ?)", (self.uid_Pool.give_next(), username, pwhash))
        self.db.commit()


    def check_user(self, username):
        """
        Prueft ob Nutzer bereits vorhanden ist

        @param username: Nutzername
        @type username: str

        @return: Boolean Erfolg
        """

        self.cursor.execute("SELECT * FROM users WHERE username = ?", [username])
        if self.cursor.fetchone() != None:
            return False
        return True


        
    def auth_user(self, username, pwhash):
        """
        Prueft Nutzer-Passwort Kombination

        @param username: Nutzername
        @type username: str

        @param pwhash: SHA256-Verschluesselter Passwort-Hash
        @type pwhash: str

        @return: True, False wenn Parameter nicht stimmen oder Nutzer-Passwort Kombination falsch
        """ 

        self.cursor.execute("SELECT * FROM users WHERE username=? AND password=?", (str(username), str(pwhash)))
        if self.cursor.fetchone() != None:
            return True
        return False



    def get_user_id(self, username):
        """
        Gibt die Nutzer-ID eines Benutzers zurueck

        @param username: Nutzername
        @type username: str

        @return: int Nutzer-ID, False bei unbekanntem Nutzer
        """


        self.cursor.execute("SELECT uid FROM users WHERE username=?", [username])
        result = self.cursor.fetchone()
        if result == None:
            return False
        return int(result[0])



    def get_username_by_id(self, uid):
        """
        Gibt den Nutzernamen nach einer ID zurueck

        @param uid: Nutzer-ID
        @type uid: int

        @return: str - Name
        """

        self.cursor.execute("SELECT username FROM users WHERE uid = ?", [uid])
        result = self.cursor.fetchone()
        if result == None:
            return False
        return result[0]


    def get_group_id(self, name):
        """
        Gibt die Gruppen-ID einer Gruppe zurueck

        @param name: Gruppenname
        @type name: str

        @return: int Gruppen-ID, False bei unbekannter Gruppe
        """

        self.cursor.execute("SELECT gid FROM groups WHERE name=?", [name])
        result = self.cursor.fetchone()
        if result == None:
            return False
        return int(result[0])


    def get_user_by_id(self, id):
        """
        Gibt den Namen des Nutzers anhand der ID zurueck.

        @param id: Nutzer-ID
        @type id: int

        @return: str Name, None falls Name nicht gefunden
        """

        self.cursor.execute("SELECT username FROM users WHERE uid=?", str(id))
        return self.cursor.fetchone()



    def get_group_by_id(self, gid):
        """
        Gibt den Namen einer Gruppe anhand der ID zurueck.

        @param gid: Gruppen-ID
        @type gid: int

        @return: str Name - None falls Name nicht gefunden
        """

        self.cursor.execute("SELECT name FROM groups WHERE gid=?", gid)
        return self.cursor.fetchone()

        
    def rcv_message(self, uidSender, uidReceiver, data):
        """
        Traegt eine Nachricht in die Datenbank ein

        @param uidSender: Nutzer-ID des Senders
        @type uidSender: int

        @param uidReceiver: Nutzer-ID des Empfaengers
        @type uidReceiver: int

        @param data: Nachricht
        @type data: Nachricht

        @return: Boolean Erfolg
        """

        data = data.strip()

        if not isinstance(uidReceiver, list):
            self.cursor.execute("INSERT INTO messages VALUES(?, ?, ?, ?)", (self.mid_Pool.give_next(), uidSender, uidReceiver, data.encode("utf-8", "ignore")))
        else:
            for item in uidReceiver:
                self.cursor.execute("INSERT INTO messages VALUES(?, ?, ?, ?)", (self.mid_Pool.give_next(), uidSender, item, data.encode("utf-8", "ignore")))
        
        self.db.commit()
        return True



    def get_messages_by_last_mid(self, uidReceiver, last_mid):
        """
        Sendet dem Client die neuen Nachrichten.
        Alle Nachrichten sind neu, wenn sie eine groessere MID als die uebergebene hat.

        @param uidReceiver: Empfaenger der Nachrichten
        @type uidReceiver: str

        @param last_mid: Letzte bekannte MID
        @type last_mid: int

        @return Array - [Sender(str), Nachrichten(str)]
        """

        self.cursor.execute("SELECT uidSender, content FROM messages WHERE MID > ?", [last_mid])
        
        ret_value = []
        result = self.cursor.fetchone()
        while result != None:
            ret_value.append(result)
            result = self.cursor.fetchone()

        return ret_value




    def get_messages_by_last_group_id(self, uidReceiver, last_gid):
        """
        Sendet dem Client die neuen Gruppennachrichten.
        Alle Gruppennachrichten sind neu, wenn sie eine groessere GID als die uebergebene hat.

        @param uidReceiver: Empfaenger der Gruppennachrichten
        @type uidReceiver: str

        @param last_gid: Letzte bekannte GID
        @type last_gid: int

        @return Array - [Sender(str), Gruppennachrichten(str)]
        """

        self.cursor.execute("SELECT gidreceiver, uidsender, content FROM groupmessages WHERE bid > ?", last_gid)

        ret_value = []
        result = self.cursor.fetchone()
        while result != None:
            ret_value.append(result)
            result = self.cursor.fetchone()

        return ret_value



    def rcv_brdc_message(self, uidSender, gidReceiver, data):
            """
            Traegt eine Broadcast-Nachricht in die Datenbank ein

            @param uidSender: Nutzer-ID des Senders
            @type uidSender: int

            @param gidReceiver: Gruppen-ID des Empfaengers
            @type gidReceiver: int

            @param data: Nachricht
            @type data: Nachricht

            @return: Boolean Erfolg
            """
            self.cursor.execute("INSERT INTO groupmessages VALUES(?, ?, ?, ?)", (self.bid_Pool.give_next(), uidSender, gidReceiver, data))
            self.db.commit()
            return True



    def add_file(self, local_name):
        """
        Erzeugt einen neuen Dateieintrag

        @param local_name: Name der Datei auf dem Server
        @type local_name: str

        @return: Boolean Erfolg
        """

        self.cursor.execute("INSERT INTO files VALUES(?, ?, ?, ?)", (self.fid_Pool.give_next(), local_name, "", 0))
        self.db.commit()
        return True



    def register_file(self, owner, globalname, filestring):
        """
        Registriert eine Datei (Setzt Besitzer und Dateinamen)

        @param owner: Nutzer-ID des Besitzers
        @type owner: int

        @param globalname: Dateiname der Datei
        @type globalname: str

        @param filestring: Dateistring der Datei
        @type filestring: str

        @return: Boolean Erfolg
        """

        self.cursor.execute("UPDATE files SET owner=?, globalname=? WHERE localname=?", (owner, globalname, filestring))
        self.db.commit()
        return True



    def check_filestring(self, filestring):
        """
        Ueberprueft, ob ein Dateistring existiert

        @param filestring: Dateistring
        @type filestring: str

        @return Boolean Erfolg
        """

        self.cursor.execute("SELECT localname FROM files WHERE localname = ?", [filestring])
        if self.cursor.fetchone() != None:
            return True
        return False



    def get_name_by_filestring(self, name):
        """
        Sucht den Dateinamen anhand des Dateistrings 

        @param name: String der Datei
        @type name: str

        @return: str Dateiname
        """

        self.cursor.execute("SELECT globalname FROM files WHERE localname = ?", [name])
        result = self.cursor.fetchone()

        if result != None:
            try:
                return result[0]
            except IndexError:
                return result
        return False 



    def get_profile_pic(self, uid):
        """
        Gibt den Dateistring zu einem Nutzer zurueck

        @param uid: Nutzer ID
        @type uid: int

        @return: str - Filestring, False falls kein String bekannt
        """

        self.cursor.execute("SELECT profilepic FROM users WHERE uid=?", [uid])
        result = self.cursor.fetchone()
        if result == "None":
            return False
        return result


    
    def get_start_mid(self):
        """
        Gibt die erste freie Nachrichten-ID zurueck

        @return: int ID
        """
        self.cursor.execute("SELECT mid FROM messages ORDER BY mid DESC")
        result = self.cursor.fetchone()
        if result == None:
            return 0
        return (result[0] + 1)



    def get_start_brdc_mid(self):
        """
        Gibt die erste freie Broadcast-Nachrichten-ID zurueck

        @return: int ID
        """
        self.cursor.execute("SELECT bid FROM groupmessages ORDER BY bid DESC")
        result = self.cursor.fetchone()
        if result == None:
            return 0
        return (result[0] + 1)



    def get_start_fid(self):
        """
        Gibt die erste freie Datei-ID

        @return: int ID
        """
        self.cursor.execute("SELECT fid FROM files ORDER BY fid DESC")
        result = self.cursor.fetchone()
        if result == None:
            return 0
        return (result[0] + 1)


    def get_start_uid(self):
        """
        Gibt die erste freie UID zurueck

        @return: int ID
        """
        self.cursor.execute("SELECT uid FROM users ORDER BY uid DESC")
        result = self.cursor.fetchone()
        if result == None:
            return 0
        return (result[0] + 1)  



    def get_address_book(self, uid):
        """
        User-ID des Senders

        @param uid: Nutzer-ID
        @type uid: int

        @return: Array - [int UID, str Name]
        """

        self.cursor.execute("SELECT addid FROM addressbook WHERE uid = ?", [uid])

        ret_value = []
        result = self.cursor.fetchone()
        while result != None:
            ret_value.append((result[0], self.get_username_by_id(int(result[0]))))
            result = self.cursor.fetchone()

        return ret_value