<\/p>\n
Wenn Sie Verknüpfungen auf die Tabellen oder Daten etwa einer SQL Server- oder MySQL-Datenbank anlegen, haben Sie zwei Möglichkeiten: Entweder Sie speichern die Verknüpfung ohne Kennwort und geben Sie diese beim ersten Zugriff einer Sitzung jeweils erneut ein. Oder Sie speichern die Benutzerdaten im Klartext in der Datenbank. Das eine ist aufwendig, das andere unsicher. Dieser Beitrag zeigt einen Weg auf, wie Sie komfortabel und sicher auf die Daten Ihrer Backend-Datenbank zugreifen. Voraussetzung ist, dass Sie das Frontend in eine .mde<\/b>– beziehungsweise .accde<\/b>-Anwendung umwandeln.<\/b><\/p>\n
In den beiden Beiträgen RDBMS-Tabellen manuell verknüpfen <\/b>(www.access-im-unternehmen.de\/973<\/b>) und RDBMS-Tabellen per VBA verknüpfen <\/b>(www.access-im-unternehmen.de\/974<\/b>) haben wir uns verschiedene Methoden angesehen, wie Sie die Tabellen einer Datenbank, die von einem relationalen Datenbankmanagementsystem verwaltet wird, in eine Access-Datenbank einbinden und so auf die enthaltenen Daten zugreifen können.<\/p>\n
Die dort vorgestellten Techniken haben allerdings den Nachteil, dass der Benutzer entweder für jede neue Sitzung die Benutzerdaten neu eingeben oder aber diese unverschlüsselt in der Systemtabelle MSys-Objects <\/b>speichern muss (dies gilt natürlich nicht für die Windows-Authentifizierung, die Sie allerdings nur mit dem Microsoft SQL Server nutzen können – für diesen Fall benötigen Sie die hier vorgestellten Techniken nicht).<\/p>\n
Grundsätzlich ist anzumerken, dass ein Frontend, das die Benutzerdaten für das RDBMS-Backend speichert, nur dann sicher ist, wenn sich der Benutzer immer vom Rechner, auf dem sich das Frontend befindet, abmeldet und diesen nicht unbeaufsichtigt lässt, wenn er eingeloggt ist.<\/p>\n
Außerdem muss natürlich sichergestellt sein, dass der Zugriff auf die entsprechende Access-Datei nur dann möglich ist, wenn der Benutzer sich an dem Rechner angemeldet hat.<\/p>\n
Konzept für ein sicheres Speichern der Benutzerdaten<\/b><\/p>\n
Wie aber wollen wir die Benutzerdaten überhaupt sicher in der Frontend-Datenbank speichern Dazu nutzen wir eine zweistufige Sicherung. Die erste besagt, dass die Datenbank als .mde<\/b>– oder .accde<\/b>-Datenbank gesichert sein muss.<\/p>\n
Die zweite legt fest, dass die zu sichernden Daten, in diesem Fall der Benutzername und insbesondere das Kennwort, in verschlüsselter Form gespeichert werden sollen.<\/p>\n
Das wäre grundsätzlich der Fall, wenn Benutzername und Kennwort im Quellcode fest codiert werden und die Datenbank als .mde <\/b>oder .accde <\/b>gesichert wird. Allerdings ist es wenig sinnvoll, Daten wie diese fest im Code zu verdrahten, da sich diese von Zeit zu Zeit ändern könnten.<\/p>\n
Wie also können wir solche Daten sicher in der Datenbank speichern und dem Benutzer dennoch die Möglichkeit geben, diese nach Wunsch zu ändern<\/p>\n
Das ist kein Problem: Wozu gibt es schließlich die Algorithmen zum Ver- und Entschlüsseln von Daten Also bauen wir einfach entsprechende Routinen in die Datenbank ein, die Benutzername und Kennwort nach der erstmaligen Eingabe beziehungsweise änderung verschlüsseln und so in einer Tabelle der Datenbank speichern. Bei der Anmeldung an das RDBMS soll die Anwendung die Daten dann wieder entschlüsseln und für die Anmeldung nutzen.<\/p>\n
Dabei darf man natürlich nicht außer Acht lassen, dass es durchaus Dienstleister im Internet gibt, die das Entschlüsseln von .mde<\/b>-Datenbanken anbieten.<\/p>\n
Alle Tabellen neu verknüpfen<\/b><\/p>\n
Die sichere Speicherung der Benutzerdaten erfordert, dass die Verknüpfung der Tabellen mit jeder neuen Sitzung neu erstellt werden muss. Sonst würden diese doch nicht unter Angabe der aktuellen Benutzerdaten geöffnet werden, oder<\/p>\n
Dies könnte man annehmen, aber es ist anders: Wenn Sie eine einzige Tabelle dieser Datenbank neu verknüpfen, dann sind auch alle anderen Tabellen, für welche die gleichen Verbindungsdaten (also Server, Datenbank und Port) angegeben sind und für die die gleichen Benutzerdaten gelten, verfügbar.<\/p>\n
Genau genommen brauchen Sie noch nicht einmal eine Tabelle der RDBMS-Datenbank zu öffnen. Es reicht aus, wenn Sie innerhalb der aktuellen Sitzung eine DAO-Verbindung zu dieser Datenbank aufbauen. Sie brauchen diese auch nicht in einer entsprechenden Variablen aufzubewahren!<\/p>\n
Also werden wir mit den nachfolgend beschriebenen Techniken schlicht und einfach einmalig eine Verbindung zur Quelldatenbank herstellen.<\/p>\n
Ein denkbarer Fall, bei dem dies nicht ausreichen könnte, liegt vor, wenn das Frontend mit Tabellen aus verschiedenen RDBMS verknüpft ist. Merkt sich Access dann tatsächlich die Verbindungen zu verschiedenen RDBMS oder nur die zuletzt hergestellte Verbindung<\/p>\n
Wie ein Text mit verknüpften Tabellen von verschiedenen Servern zeigt, ist Access hier durchaus flexibel: Wir haben die Verbindung zu beiden RDBMS aufgebaut und konnten die Tabellen, für die wir in einer vorherigen Sitzung entsprechende Verknüpfungen erstellt haben, ohne erneute Anforderung der Benutzerdaten öffnen.<\/p>\n
Im Rahmen des vorliegenden Beitrags wollen wir die Lösung jedoch nicht unnötig kompliziert machen, da die meisten Frontends ihre Daten wohl nur aus einem einzigen RDBMS beziehen dürften.<\/p>\n
Ablauf<\/b><\/p>\n
Sobald die Benutzerdaten einmal in der dafür vorgesehenen Tabelle gespeichert sind, soll die Datenbankanwendung beim öffnen einmalig die Verbindung zur angegebenen Tabelle herstellen.<\/p>\n
Gelingt diese Verbindung nicht, soll ein Formular zur Eingabe der Benutzerdaten geöffnet werden. Mit diesem kann der Benutzer dann Benutzername und Kennwort eingeben. Nach der Eingabe entscheidet er dann, ob die Daten nur in der dafür vorgesehenen Tabelle gespeichert werden sollen oder ob die Verbindung auch neu hergestellt werden soll.<\/p>\n
Formular zur Eingabe der Benutzerdaten<\/b><\/p>\n
Das Formular zur Eingabe der Benutzerdaten soll frmBenutzerdaten <\/b>heißen. Es enthält zwei Textfelder und drei Schaltflächen.<\/p>\n
Die beiden Textfelder statten Sie mit den Namen txtBenutzername <\/b>und txtKennwort <\/b>aus. Die drei Schaltflächen sollen cmdSpeichern<\/b>, cmdSpeichernUndVerknuepfen <\/b>und cmdSchliessen <\/b>heißen. Die Steuerelemente ordnen Sie etwa wie in Bild 1 an.<\/p>\n
![\"Formular](\"..\/fileadmin\/_temp_\/2015_02\/pic_975_001.png\")
<\/p>\n
Bild 1: Formular zur Eingabe der Benutzerdaten<\/span><\/b><\/p>\n Damit das Formular wie ein reiner Dialog aussieht, stellen Sie die Eigenschaften Navigationsschaltflächen<\/b>, Datensatzmarkierer<\/b>, Trennlinien <\/b>und Bildlaufleisten <\/b>auf den Wert Nein <\/b>ein. Außerdem soll das Formular in der Mitte des Access-Fensters erscheinen, daher stellen Sie die Eigenschaft Automatisch zentrieren <\/b>auf den Wert Ja <\/b>ein.<\/p>\n Damit andere Personen das Kennwort bei der Eingabe nicht ablesen können, passen wir das Textfeld txtKennwort <\/b>noch so an, dass es statt des eingegebenen Textes ausschließlich das Sternchen-Zeichen anzeigt (*<\/b>).<\/p>\n Dazu klicken Sie einmalig in die Eigenschaft Daten|Eingabeformat <\/b>des Eigenschaftsfensters und dann auf die nun erscheinende Schaltfläche mit den drei Punkten rechts neben der Eigenschaft.<\/p>\n Dies öffnet den Dialog aus Bild 2.<\/p>\n Bild 2: Aktivieren der sicheren Kennwort-Eingabe<\/span><\/b><\/p>\n Nachdem Sie hier den Eintrag Kennwort <\/b>ausgewählt haben, können Sie direkt auf die Schaltfläche Fertigstellen <\/b>klicken. Beim öffnen des Formulars frmBenutzerdaten <\/b>ersetzt dieses eingegebene Zeichen für das Kennwort durch das Sternchen (s. Bild 3).<\/p>\n Bild 3: Verdeckte Eingabe des Kennworts<\/span><\/b><\/p>\n Nun schauen wir uns die Prozeduren an, die durch die verschiedenen Schaltflächen ausgelöst werden.<\/p>\n Die einfachste schließt einfach das Formular:<\/p>\n Interessanter ist schon die Schaltfläche, mit der wir die Benutzerdaten in der Tabelle tblBenutzerdaten <\/b>speichern wollen.<\/p>\n Diese enthält nur eine einzige Anweisung, die aber eine weitere Routine namens BenutzerdatenSpeichern <\/b>aufruft und dabei den Benutzernamen und das Kennwort aus den beiden Textfeldern übergibt:<\/p>\n <\/p>\n Die letzte Prozedur des Formulars speichert zuerst die Benutzerdaten und aktualisiert dann mit einem Aufruf der Routine VerknuepfungenAktualisierenVerschluesselt <\/b>die Verbindung:<\/p>\n Tabelle zum Speichern der Benutzerdaten<\/b><\/p>\n Die Tabelle zum Speichern der Benutzerdaten heißt tblBenutzerdaten <\/b>und enthält nur zwei Felder – ein Primärschlüsselfeld namens BenutzerdatenID<\/b> sowie das Feld Benutzerdaten zum Speichern des verschlüsselten Textes mit dem Benutzernamen und dem Kennwort (s. Bild 4).<\/p>\n Bild 4: Tabelle zum Speichern der Benutzerdaten in der Entwurfsansicht<\/span><\/b><\/p>\n Benutzerdaten speichern<\/b><\/p>\n Klickt der Benutzer auf eine der beiden Schaltflächen cmdSpeichern <\/b>oder cmdVerknuepfen<\/b>, löst dies die Prozedur BenutzerdatenSpeichern<\/b> aus Listing 1 aus.<\/p>\n Listing 1: Prozedur zum Speichern der Benutzerdaten<\/span><\/b><\/p>\n Die Prozedur erwartet den zu kodierenden Benutzernamen und das Kennwort als Parameter. Da das Pipe-Zeichen (|<\/b>) als Trennzeichen zwischen den beiden Ausdrücken eingesetzt werden soll, dürfen diese natürlich kein Pipe-Zeichen enthalten. Dies prüft die Prozedur gleich mit der If…Then<\/b>-Bedingung zu Beginn.<\/p>\n Dann stellt sie den zu verschlüsselnden Ausdruck zusammen, indem Sie den Wert aus strBenutzername<\/b>, das Pipe-Zeichen und den Wert aus strKennwort <\/b>mit & <\/b>verknüpft. Der Ausdruck lautet dann beispielsweise MeinBenutzername|MeinKennwort<\/b>.<\/p>\n Diesen Ausdruck übergibt sie dann zusammen mit einer weiteren Zeichenkette als Schlüssel für die Kodierung an die Funktion DecryptString<\/b>.<\/p>\n Das Ergebnis dieser Funktion landet dann in der Variablen strVerschluesselt<\/b>. Anschließend löscht die Prozedur alle Datensätze der Tabelle tblBenutzerdaten <\/b>und fügt einen neuen Datensatz hinzu, dessen Feld Benutzerdaten <\/b>den verschlüsselten Ausdruck als Wert erhält.<\/p>\n Sollte einer der beiden Parameter strBenutzername<\/b> oder strKennwort <\/b>das Pipe-Zeichen enthalten, weist die Prozedur den Benutzer mit einer entsprechenden Meldung darauf hin. Wenn die Benutzerdaten erfolgreich gespeichert wurden, zeigt die Tabelle diese wie in Bild 5 an.<\/p>\n Bild 5: Die verschlüsselten Benutzerdaten in der Tabelle tblBenutzerdaten<\/span><\/b><\/p>\n Ver- und entschlüsseln<\/b><\/p>\n Die Funktion DecryptString<\/b>, die wir in der obigen Prozedur zum Verschlüsseln der Zeichenkette verwenden, steckt im Modul mdlEncrypt <\/b>und erwartet zwei Parameter: die zu verschlüsselnde Zeichenkette sowie einen Schlüsselausdruck, der dafür sorgt, dass die gleiche zu verschlüsselnde Zeichenkette auf verschiedene Arten verschlüsselt werden kann.<\/p>\n Diese Funktion nutzt die Funktion Decrypt <\/b>der Klasse CCrypt<\/b>, die wir im Beitrag Datenverschlüsselung <\/b>(www.access-im-unternehmen.de\/438<\/b>) vorgestellt haben.<\/p>\n Zum Entschlüsseln des verschlüsselten Ausdrucks verwenden Sie die Funktion EncryptString<\/b>, welche den verschlüsselten Ausdruck sowie den Schlüssel als Parameter erwartet und den entschlüsselten Ausdruck zurückliefert.<\/p>\n Verknüpfung aktualisieren<\/b><\/p>\n Nun folgt die Funktion VerknuepfungenAktualisierenVerschluesselt<\/b>. Diese liefert einen Boolean<\/b>-Wert zurück, der angibt, ob die Verbindung erfolgreich aktualisiert werden konnte (s. Listing 2).<\/p>\n Listing 2: Funktion zum Aktualisieren der Verknüpfungen<\/span><\/b><\/p>\n Die Prozedur ermittelt zunächst per DLookup <\/b>den Wert des Feldes Benutzerdaten <\/b>aus der Tabelle tblBenutzerdaten<\/b> und speichert diesen in der Variablen strVerschluesselt<\/b>.<\/p>\n Sollte strVerschluesselt <\/b>leer sein, hat der Benutzer offensichtlich keine Benutzerdaten gespeichert. Die Prozedur öffnet dann das Formular frmBenutzerdaten<\/b>. Dieses enthält ja selbst wieder die Möglichkeit, die Funktion VerknuepfungenAktualisierenVerschluesselt <\/b>aufzurufen.<\/p>\n Ist strVerschluesselt <\/b>nicht leer, verwendet die Funktion die Routine DecryptString<\/b>, um den Inhalt zu entschlüsseln. Dabei übergibt sie logischerweise den gleichen Schlüssel-Ausdruck, der bereits bei Verschlüsseln verwendet wurde.<\/p>\n Das Ergebnis ist ein Ausdruck, der den Benutzernamen und das Kennwort getrennt durch das Pipe-Zeichen enthält.<\/p>\n Die beiden Elemente ermitteln wir mithilfe der Split<\/b>-Funktion, welche den Ausdruck an der Stelle des Pipe-Zeichens aufteilt, in ein Array schreibt und aus diesem das nullte und erste Element in die Variablen strBenutzername <\/b>und strKennwort <\/b>schreibt.<\/p>\n Nun fügt die Prozedur die Verbindungszeichenfolge zusammen, wobei einige Elemente fest im Code verankert sind – zum Beispiel der Treiber, der Server und der Name der Datenbank.<\/p>\n Für eine flexiblere Anwendung würden wir diese Werte natürlich auch noch in einer Tabelle verwalten, damit diese bei Bedarf geändert werden können, ohne direkt eine neue Version der Datenbank herausgeben zu müssen. Aus Gründen der übersichtlichkeit haben wir jedoch im Beispiel zu diesem Beitrag darauf verzichtet.<\/p>\n Außerdem fügen wir der Verbindungszeichenfolge in strConnection <\/b>noch folgenden Ausdruck hinzu:<\/p>\n Was es damit auf sich hat, klären wir später auf.<\/p>\n Der Benutzername und das Kennwort fügen wir ebenfalls in die Verbindungszeichenfolge ein.<\/p>\n Damit rufen wir nun die Funktion VerbindungTesten<\/b> auf, welche die folgenden drei Parameter erwartet:<\/p>\n Sollte die Funktion den Wert True <\/b>zurückliefern, stellen wir auch den Rückgabewert der Funktion VerknuepfungenAktualisierenVerschluesselt <\/b>auf den Wert True <\/b>ein.<\/p>\n Falls nicht, liefert die Funktion eine Meldung mit dem Hinweis, dass die Verbindung fehlgeschlagen, ist und fügt die Fehlernummer und die Fehlermeldung hinzu.<\/p>\n Außerdem fragt sie, ob der Benutzer die Benutzerdaten neu eingeben möchte. Klickt der Benutzer hier auf die Schaltfläche Ja<\/b>, soll wiederum das Formular zur Eingabe der Benutzerdaten erscheinen.<\/p>\n Testen der Verbindung<\/b><\/p>\n Die Funktion VerbindungTesten <\/b>testet genau genommen nicht nur die Verbindung, sondern durch die Herstellung einer solchen zum Zwecke der Prüfung kann diese auch für den Zugriff auf die bestehenden verknüpften Tabellen auf Basis dieser Verbindung genutzt werden (s. Listing 3).<\/p>\n Listing 3: Funktion zum Testen der Verbindung<\/span><\/b><\/p>\n Sie erledigt nichts anderes, als ein Database<\/b>-Objekt namens db <\/b>mit der OpenDatabase<\/b>-Methode zu füllen. Dabei verwendet sie unter anderem den Wert Test <\/b>als Name und die in strConnection <\/b>gespeicherte Verbindungszeichenfolge als Parameter.<\/p>\n Da hier ein Fehler auftritt, wenn der Verbindungsaufbau misslingt, deaktiviert die Prozedur die Fehlerbehandlung zuvor mit On Error Resume Next<\/b>. Ob ein Fehler aufgetreten ist, prüft die Prozedur dann in einer If…Then<\/b>-Bedingung, die den Wert von Err.Number <\/b>mit dem Wert 0 <\/b>abgleicht.<\/p>\n Ist dieser ungleich 0<\/b>, speichert die Funktion Err.Number <\/b>im Parameter lngError <\/b>und die Beschreibung aus Err.Description <\/b>in strError<\/b>. Danach wird die Funktion mit Exit Function <\/b>verlassen, ohne zuvor den Funktionswert auf den Wert True <\/b>einzustellen – was anderenfalls natürlich geschieht.<\/p>\n Sollte der Verbindungstest fehlschlagen, erscheint üblicherweise ein Dialog des jeweiligen ODBC-Treibers, der zur Eingabe der korrekten Verbindungsinformationen auffordert. Unter MySQL sieht dieser beispielsweise wie in Bild 6 aus.<\/p>\n Bild 6: Beim Fehlschlagen einer Verbindung zeigt der ODBC-Treiber eine Meldung wie diese an.<\/span><\/b><\/p>\n Einen solchen Dialog wollen wir dem Benutzer unserer Datenbankanwendung natürlich nicht zumuten. Deshalb haben wir weiter oben den Parameter NO_PROMPT=1; <\/b>zur Verbindungszeichenfolge hinzugefügt.<\/p>\n Auf diese Weise verhindern wir die Anzeige dieses Dialogs und können beim Scheitern des Verbindungsaufbaus eine eigene Fehlermeldung anbieten – und in der Folge das Formular frmBenutzerdaten<\/b>, damit der Benutzer die Zugangsdaten korrigieren kann.<\/p>\n Verbindung beim Start der Anwendung aufbauen<\/b><\/p>\n Nun fehlt noch ein kleiner Schritt: Wir müssen die Verbindung direkt beim Starten der Datenbank aufbauen, damit der Benutzer gleich auf die Daten des RDBMS zugreifen kann.<\/p>\n Das ist eine leichte Aufgabe: Dazu legen wir einfach ein Makro namens AutoExec <\/b>an, das ja automatisch beim Start der Anwendung ausgeführt wird.<\/p>\n Die einzige Makroaktion dieses Makros heißt AusführenCode<\/b> und löst die Funktion VerknuepfungenAktualisierenVerschluesselt <\/b>aus (s. Bild 7).<\/p>\n![\"Aktivieren](\"..\/fileadmin\/_temp_\/2015_02\/pic_975_002.png\")
<\/p>\n![\"Verdeckte](\"..\/fileadmin\/_temp_\/2015_02\/pic_975_003.png\")
<\/p>\nPrivate Sub <\/span>cmdSchliessen_Click()\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdSpeichern_Click()\r\n BenutzerdatenSpeichern Nz(Me!txtBenutzername), _\r\n Nz(Me!txtKennwort)\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdVerknuepfen_Click()\r\n BenutzerdatenSpeichern Nz(Me!txtBenutzername), _\r\n Nz(Me!txtKennwort)\r\n If <\/span>VerknuepfungenAktualisierenVerschluesselt Then<\/span>\r\n MsgBox<\/span> \"Verknüpfung erfolgreich.\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2015_02\/pic_975_004.png\")
<\/p>\nPublic Sub <\/span>BenutzerdatenSpeichern(strBenutzername As String<\/span>, strKennwort As String<\/span>)\r\n Dim <\/span>strVerschluesselt As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n If <\/span>InStr<\/span>(1, strBenutzername & strKennwort, \"|\") = 0 Then<\/span>\r\n strVerschluesselt = DecryptString(strBenutzername & \"|\" & strKennwort, \"aiu2015\")\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblBenutzerdaten\", dbFailOnError\r\n db.Execute \"INSERT INTO tblBenutzerdaten(Benutzerdaten) VALUES(''\" & Replace<\/span>(strVerschluesselt, \"''\", \"''''\") _\r\n & \"'')\", dbFailOnError\r\n Else<\/span>\r\n MsgBox<\/span> \"Benutzername und Kennwort dürfen nicht das Zeichen ''|'' enthalten.\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2015_02\/pic_975_005.png\")
<\/p>\nPublic Function <\/span>VerknuepfungenAktualisierenVerschluesselt() As Boolean<\/span>\r\n Dim <\/span>strConnection As String<\/span>\r\n Dim <\/span>strBenutzername As String<\/span>\r\n Dim <\/span>strKennwort As String<\/span>\r\n Dim <\/span>strVerschluesselt As String<\/span>\r\n Dim <\/span>strEntschluesselt As String<\/span>\r\n Dim <\/span>lngError As Long<\/span>\r\n Dim <\/span>strError As String<\/span>\r\n strVerschluesselt = Nz(DLookup(\"Benutzerdaten\", \"tblBenutzerdaten\"))\r\n If <\/span>Len<\/span>(strVerschluesselt) = 0 Then<\/span>\r\n MsgBox<\/span> \"Es liegen keine Benutzerdaten vor. Bitte geben Sie diese im folgenden Formular ein.\"\r\n DoCmd.OpenForm \"frmBenutzerdaten\", windowMode:=acDialog\r\n Else<\/span>\r\n strEntschluesselt = DecryptString(strVerschluesselt, \"aiu2015\")\r\n strBenutzername = Split<\/span>(strEntschluesselt, \"|\")(0)\r\n strKennwort = Split<\/span>(strEntschluesselt, \"|\")(1)\r\n strConnection = strConnection & \"ODBC;\"\r\n strConnection = strConnection & \"DRIVER={MySQL ODBC 5.2 ANSI Driver};\"\r\n strConnection = strConnection & \"SERVER=85.214.142.26;\"\r\n strConnection = strConnection & \"DATABASE=amvshop_sw;\"\r\n strConnection = strConnection & \"NO_PROMPT=1;\"\r\n strConnection = strConnection & \"UID=\" & strBenutzername & \";\"\r\n strConnection = strConnection & \"PWD=\" & strKennwort & \";\"\r\n If <\/span>VerbindungTesten(strConnection, lngError, strError) Then<\/span>\r\n VerknuepfungenAktualisierenVerschluesselt = True<\/span>\r\n Application.RefreshDatabaseWindow\r\n Else<\/span>\r\n If MsgBox<\/span>(\"Verbindung fehlgeschlagen:\" & vbCrLf<\/span> & \"Fehler: \" & Err.Number & vbCrLf<\/span> & \"Beschreibung: \" _\r\n & vbCrLf<\/span> & strError & vbCrLf<\/span> & vbCrLf<\/span> & \"Benutzerdaten neu eingeben\", vbYesNo) = vbYes Then\r\n DoCmd.OpenForm \"frmBenutzerdaten\", windowMode:=acDialog\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nNO_PROMPT=1;<\/pre>\n
\n
Public Function <\/span>VerbindungTesten(strConnection As String<\/span>, Optional<\/span> lngError As Long<\/span>, _\r\n Optional<\/span> strError As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n On Error Resume Next<\/span>\r\n Set<\/span> db = DBEngine.OpenDatabase(\"Test\", dbDriverNoPrompt, False, strConnection)\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n lngError = Err.Number\r\n strError = Err.Description\r\n Exit Function<\/span>\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n VerbindungTesten = True<\/span>\r\nEnd Function<\/span><\/pre>\n![\"Beim](\"..\/fileadmin\/_temp_\/2015_02\/pic_975_006.png\")
<\/p>\n![\"Makro](\"..\/fileadmin\/_temp_\/2015_02\/pic_975_007.png\")
<\/p>\n