import java.io.*; // I/O package
import java.net.*; // internet
import java.awt.*; //AWT basic classes
import java.awt.event.*; //AWT event classes
import com.sun.java.swing.*; //SWING basic classes
import com.sun.java.swing.text.*; //SWING text classes
import com.sun.java.swing.border.*; //SWING border classes
public class HostPwd
extends JFrame
implements Runnable // interface to run thread
{ //start of class HostPwd
JTextField hostBox;
JTextField benutzer;
JPasswordField altesPasswort;
JPasswordField neuesPasswort;
JButton check;
JButton change;
JButton cancel;
JTextField statusBox;
String hostName = " "; // host name
int hostPort = 0; // port of Password server
Socket hostSocket = null;
String urspruenglichesPasswort = ""; // zuerst eingetipptes neue Passwort
Thread hostThread = null;
String hostRequest = ""; // request message to Host
String hostReply = ""; // reply message from Host
Cursor cursorWarten = Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR);
Cursor cursorText = Cursor.getPredefinedCursor(Cursor.TEXT_CURSOR);
Cursor cursorHand = Cursor.getPredefinedCursor(Cursor.HAND_CURSOR);
Cursor cursorNormal = Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR);
//***************************************************************
// MAIN method
//...............................................................
//
public static void main (String[] args)
{ // start of MAIN method
// System.out.println("MAIN start");
// get first argument (host name)
String arg1 = "S51.winterthur.ch"; // default host name
if (args.length >= 1)
{
arg1 = args[0];
}
// get second argument (port number)
String arg2 = "11111"; // default port number
if (args.length >= 2)
{
arg2 = args[1];
}
// instantiate a new object of class HostPwd
// passing host name (arg1) and Port number (arg2)
new HostPwd(arg1,arg2);
// System.out.println("MAIN end");
} //end of MAIN method
//
//***************************************************************
//***************************************************************
// CONSTRUCTOR method
//...............................................................
//
HostPwd (String arg1, String arg2)
{ // method HostPwd (constructor)
// get host name (arg1)
// System.out.println(arg1);
hostName = arg1;
// System.out.println("hostName=" + hostName);
// get port number (arg2)
// careful: arg2 must be converted from String to int
System.out.println(arg2);
hostPort = Integer.valueOf(arg2).intValue();
// System.out.println("hostPort=" + hostPort);
setTitle("HostPwd Version 1.0 (beta 4) - HostPasswortpflege");
setSize(650,400);
setResizable(false);
addWindowListener(new Fenster()); //class Fenster (window events)
//
//------------------------------------------------------------------------
//
// make textfield "Host"
//
hostBox = new JTextField(64);
hostBox.setFont(new Font("Monospaced",Font.BOLD,16));
hostBox.setText(hostName);
hostBox.setToolTipText("Eingabefeld für Hostname oder IP-adresse");
hostBox.setCursor(cursorText);
//
//------------------------------------------------------------------------
//
// make textfield "Benutzer-ID"
//
benutzer = new JTextField(32);
benutzer.setFont(new Font("Monospaced",Font.BOLD,16));
benutzer.setToolTipText("Eingabefeld für Ihr Benutzer-ID");
benutzer.setCursor(cursorText);
//
//......................................................................
//
// make textfield "Passwort"
//
altesPasswort = new JPasswordField(32);
altesPasswort.setFont(new Font("Monospaced",Font.BOLD,16));
altesPasswort.setToolTipText("Eingabefeld für das momentan gültige Passwort");
altesPasswort.setCursor(cursorText);
//
//......................................................................
//
// make textfield "neues Passwort"
//
neuesPasswort = new JPasswordField(32);
neuesPasswort.setFont(new Font("Monospaced",Font.BOLD,16));
neuesPasswort.setToolTipText("Eingabefeld für das neue Passwort");
neuesPasswort.setCursor(cursorText);
//
//......................................................................
//
// make "check" button
//
check = new JButton("prüfen");
check.setMnemonic('p');
check.setToolTipText("prüfen des momentan gültigen Passwortes");
check.addActionListener(new Pruefen());
check.setCursor(cursorHand);
//
//......................................................................
//
// make "change" button
//
change = new JButton("ändern");
change.setMnemonic('ä');
change.setToolTipText("ändern des momentan gültigen Passwortes in das neue Passwort");
change.addActionListener(new Aendern());
change.setCursor(cursorHand);
//
//......................................................................
//
// make "cancel" button
//
cancel = new JButton("abbrechen");
cancel.setMnemonic('a');
cancel.setToolTipText("Verbindung mit Host abbrechen");
cancel.addActionListener(new Abbrechen());
cancel.setCursor(cursorHand);
cancel.setEnabled(false); // disable Taste "abbrechen"
//
//------------------------------------------------------------------------
//
// make textfield "Status"
//
statusBox = new JTextField("bereit");
statusBox.setToolTipText("Statusmeldung vom Programm");
statusBox.setEditable(false);
//------------------------------------------------------------------------
//
// make "hostPanel"
//
//......................................................................
//
JPanel hostBoxPanel = new JPanel(new BorderLayout());
hostBoxPanel.setMinimumSize(new Dimension(175,50));
hostBoxPanel.setMaximumSize(new Dimension(350,50));
hostBoxPanel.setPreferredSize(new Dimension(350,50));
hostBoxPanel.setBorder(new TitledBorder(new EtchedBorder(),"Host"));
hostBoxPanel.add(hostBox);
//
//......................................................................
//
JPanel hostPanel = new JPanel(new FlowLayout(FlowLayout.CENTER,20,20));
hostPanel.add(hostBoxPanel);
//
//------------------------------------------------------------------------
//
// make "eingabePanel" ("Benutzer-ID", "Passwort", "neues Passwort")
//
//......................................................................
//
JPanel benutzerPanel = new JPanel(new BorderLayout());
benutzerPanel.setMaximumSize(new Dimension(175,50));
benutzerPanel.setPreferredSize(new Dimension(175,50));
benutzerPanel.setBorder(new TitledBorder(new EtchedBorder(),"Benutzer-ID"));
benutzerPanel.add(benutzer);
//
//......................................................................
//
JPanel altesPasswortPanel = new JPanel(new BorderLayout());
altesPasswortPanel.setMaximumSize(new Dimension(175,50));
altesPasswortPanel.setPreferredSize(new Dimension(175,50));
altesPasswortPanel.setBorder(new TitledBorder(new EtchedBorder(),"Passwort"));
altesPasswortPanel.add(altesPasswort);
//
//......................................................................
//
JPanel neuesPasswortPanel = new JPanel(new BorderLayout());
neuesPasswortPanel.setMaximumSize(new Dimension(175,50));
neuesPasswortPanel.setPreferredSize(new Dimension(175,50));
neuesPasswortPanel.setBorder(new TitledBorder(new EtchedBorder(),"neues Passwort"));
neuesPasswortPanel.add(neuesPasswort);
//
//......................................................................
//
JPanel eingabePanel = new JPanel(new FlowLayout(FlowLayout.CENTER,20,20));
eingabePanel.add(benutzerPanel);
eingabePanel.add(altesPasswortPanel);
eingabePanel.add(neuesPasswortPanel);
//
//------------------------------------------------------------------------
//
// make "tastenPanel" ("pruefen", "aendern", "Abbrechen")
//
//......................................................................
//
// dimensions for button "Passwort pruefen"
check.setMaximumSize(new Dimension(175,25));
check.setPreferredSize(new Dimension(150,25));
//
//......................................................................
//
// dimensions for button "Passwort aendern"
change.setMaximumSize(new Dimension(175,25));
change.setPreferredSize(new Dimension(150,25));
//
//......................................................................
//
// dimensions for button "Abbrechen"
cancel.setMaximumSize(new Dimension(175,25));
cancel.setPreferredSize(new Dimension(150,25));
//
//......................................................................
//
JPanel tastenPanel = new JPanel(new FlowLayout(FlowLayout.CENTER,20,20));
tastenPanel.add(check);
tastenPanel.add(change);
tastenPanel.add(cancel);
//
//------------------------------------------------------------------------
//
// make "Status" panel
//
//......................................................................
//
JPanel statusBoxPanel = new JPanel(new BorderLayout());
statusBoxPanel.setMinimumSize(new Dimension(200,50));
statusBoxPanel.setMaximumSize(new Dimension(500,50));
statusBoxPanel.setPreferredSize(new Dimension(500,50));
statusBoxPanel.setBorder(new TitledBorder(new EtchedBorder(),"Status"));
statusBoxPanel.add(statusBox);
//
//......................................................................
//
JPanel statusPanel = new JPanel(new FlowLayout(FlowLayout.CENTER,20,20));
statusPanel.add(statusBoxPanel);
//
//------------------------------------------------------------------------
//
// make "combiPanel"
//
Box combiPanel = new Box(BoxLayout.Y_AXIS);
combiPanel.add(hostPanel);
combiPanel.add(eingabePanel);
combiPanel.add(tastenPanel);
combiPanel.add(statusPanel);
//
//------------------------------------------------------------------------
//
// put "combiPanel" into main content pane
getContentPane().add(combiPanel);
// getRootPane().setDefaultButton(cancel);
//
//------------------------------------------------------------------------
//
setVisible(true); //make window visible
benutzer.requestFocus(); //Eingabe Benutzer-ID
getContentPane().setCursor(cursorNormal);
//
//------------------------------------------------------------------------
//
} // method "HostPwd" (constructor)
//
//***************************************************************
//***************************************************************
// Methode "HostRuf"
//
// Diese Methode ("HostRuf") wird aufgerufen von
// 1.- ActionListener "Pruefen" (method actionPerformed)
// 2.- ActionListener "Aendern" (method actionPerformed)
//
// Diese Methode ("HostRuf") ruft dem Host indem sie ein hostThread
// erzeugt und dann hostThread.start aufruft.
// Dies bewirkt dass die "run" Methode anlauft.
//
//
//...............................................................
//
public void HostRuf(String hostRequest)
{ // method "HostRuf"
//
//------------------------------------------------------------------------
//
// Kontrollieren ob "Host" eingegeben wurde
//
hostName = hostBox.getText(); //get host name
//
if (hostName.length() == 0)
{
JOptionPane meldung01 = new JOptionPane();
meldung01.showMessageDialog (hostBox,
"Hostname fehlt",
"HostPwd",
JOptionPane.WARNING_MESSAGE);
hostBox.requestFocus();
return; // benutzer soll Hostnamen eingeben
}
//
//----------------------------------------------------------------
//
// Die Tasten "pruefen" und "aendern" dürfen jetzt nicht mehr gedruckt werden.
// Diese Tasten werden in Method "run" wieder enabled
// (nachdem das Antwort vom Host empfangen wurde)
//
// Disable Tasten:
check.setEnabled(false); // disable Taste "prüfen"
change.setEnabled(false); // disable Taste "ändern"
//
getContentPane().setCursor(cursorWarten); //warten Cursor
//
//................................................................
//
// make a new host thread.
hostThread = new Thread(this,"Host");
//
//................................................................
//
// start host thread (method "run" will be executed)
//
hostThread.start();
//
// Der Host-Thread wurde gestartet aber wir warten nicht auf Antwort.
// Der Benutzer kann auf Antwort vom Host warten oder auf der Taste
// "abbrechen" drucken (falls kein Antwort kommt).
//
//------------------------------------------------------------------------
//
// Rücksprung nach ActionListener "Pruefen" oder "Aendern"
//
//------------------------------------------------------------------------
//
} // method "HostRuf"
//
//***************************************************************
//***************************************************************
// Methode "run"
//
// Diese Methode ("run") wird gestartet von Methode "HostRuf"
// in dem sie ein hostThread erzeugt und dann hostThread.start aufruft.
//
// Diese Methode ("run") ruft "Host" auf, welche String "hostRequest" an
// den Host sendet, und das Antwort in String "hostReply" kopiert.
// Nach dem Rücksprung von "Host" wird String "hostReply" in ein Message
// box angezeigt.
// Der Thread stirbt dann eines natürlichen Todes.
//
//...............................................................
//
public void run()
{ // method "run"
//
//------------------------------------------------------------------------
//
try
{ // anfang try block
//
//------------------------------------------------------------------------
//
// Methode "Host aufrufen:
// Diese Methode macht folgendes:
// 1.- String "hostRequest" an Host senden
// 2.- String "hostReply" vom Host empfangen.
//
hostReply = Host(hostRequest);
//
//------------------------------------------------------------------------
//
// Falls hostReply tatsächlich vom Host kommt dann wird
// dies aus eine der folgenden Nummern bestehen.
//
// Messages 10-19 kommen von Passwortserver auf Host:
// "11" Benutzer-id fehlt oder zu kurz
// "12" Benutzer-id zu lange
// "13" Passwort fehlt oder zu kurz
// "14" Passwort zu lange
// "15" neues Passwort zu lange
//
// Messages 20-29 kommen von RACF auf Host:
// "21" Passwort wurde geprueft und fuer gültig befunden
// "22" Passwort wurde geprueft und in das neue geändert
// "23" Benutzer ist unbekannt
// "24" Benutzer ist bekannt aber wurde gesperrt
// "25" Passwort ist ungültig
// "26" Passwort ist abgelaufen
// "27" neues Passwort ist ungültig
// "29" unerwartete Fehlermeldung von RACF
//
if (hostReply.equals("11")) hostReply = "Achtung! Benutzer-id zu kurz";
if (hostReply.equals("12")) hostReply = "Achtung! Benutzer-id zu lange";
if (hostReply.equals("13")) hostReply = "Achtung! Passwort zu kurz";
if (hostReply.equals("14")) hostReply = "Achtung! Passwort zu lange";
if (hostReply.equals("15")) hostReply = "Achtung! neues Passwort zu lange";
if (hostReply.equals("21")) hostReply = "OK, Passwort ist gültig";
if (hostReply.equals("22")) hostReply = "OK, Passwort wurde geändert";
if (hostReply.equals("23")) hostReply = "Achtung! Benutzer unbekannt";
if (hostReply.equals("24")) hostReply = "Achtung! Benutzer ist gesperrt";
if (hostReply.equals("25")) hostReply = "Achtung! Passwort ist ungültig";
if (hostReply.equals("26")) hostReply = "Achtung! Passwort ist abgelaufen";
if (hostReply.equals("27")) hostReply = "Achtung! neues Passwort ist ungültig";
if (hostReply.equals("29")) hostReply = "Achtung! unbekannter Fehler im RACF";
//
//------------------------------------------------------------------------
//
// Vom Host empfangener String "hostReply" an Benutzer zeigen
//
JOptionPane meldung02 = new JOptionPane();
meldung02.showMessageDialog (hostBox,
hostReply,
"Antwort von Host:",
JOptionPane.PLAIN_MESSAGE);
//
//------------------------------------------------------------------------
//
// die Tasten "prüfen" und "ändern" können jetzt wieder enabled werden.
// Sie wurden vom ActionListener disabled.
//
check.setEnabled(true); // enable Taste "prüfen"
change.setEnabled(true); // enable Taste "ändern"
getContentPane().setCursor(cursorNormal); //normaler Cursor
//
//------------------------------------------------------------------------
// Status:
statusBox.setText("Bereit");
//
//------------------------------------------------------------------------
//
} // ende try block
finally
{
hostThread = null;
//System.out.println("host thread = null");
}
//
//------------------------------------------------------------------------
//
} // method "run"
//
//***************************************************************
//***************************************************************
// Methode "Host"
//
// Diese Methode wird aufgerufen von Methode "run", welche wiederum
// von hostThread.start aufgerufen wurde.
// Diese Methode ist also ein Thread.
//
// Methode "run" übergibt einen String names "hostRequest" und
// erwartet einen Return-String names "hostReply".
//
// Diese Methode ("Host") stellt eine TCP-Verbindung met dem Host her
// und sendet String "hostRequest" an den Host.
// Das Antwort vom Host wird im Return-String "hostReply" kopiert und an
// die rufende Methode "run" zurückgegeben.
//
// Der Return-String "hostReply" wird normalerweise vom Host empfangen.
// Jedoch, wenn ein Exception auftritt, kann er auch selbst erzeugt werden.
// In diesem Falle ist "hostReply" als Fehlermeldung zu betrachten.
//
//...............................................................
//
public String Host (String hostRequest)
{ // method "Host"
//
//------------------------------------------------------------------------
//
// Verbindung zum Host herstellen:
//
InetAddress hostIP = null;
boolean fehler = false;
//
//------------------------------------------------------------------------
//
// get hostname from text field "Host"
hostName = hostBox.getText();
//
//------------------------------------------------------------------------
//
// make IP address:
//
statusBox.setText("suche Host " + hostName);
try
{
hostIP = InetAddress.getByName(hostName);
}
catch (UnknownHostException ex)
{
statusBox.setText(ex.toString());
hostReply = "kein Antwort (Hostname wahrscheinlich falsch)";
hostIP = null;
}
catch (SecurityException ex)
{
statusBox.setText(ex.toString());
hostReply = "kein Antwort (komme nicht durch Sicherheits-Sperre)";
hostIP = null;
}
if (hostIP == null) return(hostReply);
//
//................................................................
//
statusBox.setText("Öffne Verbindung mit " + hostIP + " an Port " + hostPort);
//
//................................................................
//
// make Socket:
//
try
{
hostSocket = new Socket (hostIP,hostPort);
}
catch (IOException ex) // hat nicht funktioniert
{
statusBox.setText(ex.toString());
hostReply = "Passwortserver läuft nicht auf "
+ hostName;
hostSocket = null;
}
//
if (hostSocket == null) return(hostReply);
//
//................................................................
//
// wir haben jetzt eine Verbindung mit dem Passwortserver auf dem Host
cancel.setEnabled(true); // enable Taste "abbrechen"
statusBox.setText("Verbunden mit Passwortserver auf " + hostName);
//
//................................................................
//
// make input and output streams:
//
OutputStream rawOutput = null;
BufferedOutputStream outputBuffer = null;
DataOutputStream output = null;
InputStream rawInput = null;
BufferedInputStream inputBuffer = null;
DataInputStream input = null;
try
{
// make output buffer
rawOutput = hostSocket.getOutputStream();
outputBuffer = new BufferedOutputStream (rawOutput);
output = new DataOutputStream (outputBuffer);
//
// make input buffer
rawInput = hostSocket.getInputStream();
inputBuffer = new BufferedInputStream (rawInput);
input = new DataInputStream (inputBuffer);
//
// send request message
statusBox.setText("Sende Daten an Passwortserver");
output.writeBytes(hostRequest + "\r\n"); //append end-of-line
output.flush();
//
// receive reply message
statusBox.setText("Warte auf Antwort von Passwortserver");
hostReply = input.readLine();
//
}
catch (IOException ex)
{
statusBox.setText(ex.toString());
hostReply = "Übertragungsfehler aufgetreten";
fehler = true;
}
//
if (fehler == false)
{
statusBox.setText("Antwort von Passwortserver erhalten");
}
//
//................................................................
//
// disable Taste "abbrechen"
cancel.setEnabled(false);
//
// Wurde Verbindung durch Taste "abbrechen" geschlossen?
if (hostSocket == null)
{
hostReply = "Verbindung abgebrochen";
return(hostReply);
}
//
//................................................................
//
// close TCP verbindung
//
try
{
hostSocket.close();
}
catch (IOException ex) // hat nicht funktioniert
{
statusBox.setText(ex.toString());
fehler = true;
hostSocket = null;
}
//
//------------------------------------------------------------------------
//
return(hostReply);
//
//------------------------------------------------------------------------
//
} // method "Host"
//
//***************************************************************
//***************************************************************
//
// inner class "Fenster"
//
// This class is the Window Listener:
// it's only method "windowClosing" is called when the close box
// of the window is pressed.
//
//...............................................................
//
class Fenster extends WindowAdapter
{ // start of inner class "Fenster"
public void windowClosing (WindowEvent e)
{ // start of windowClosing
System.exit(0);
} // end of windowClosing
} // end of inner class "Fenster"
//
//***************************************************************
//***************************************************************
//
// class "Abbrechen"
//
// This class is the actionListener of the cancel button.
// it's only method "actionPerformed" is called when the user
// has pressed the cancel button.
//
// The cancel button is enabled when there is a TCP connection
// and disabled when the TCP connection is closed.
//
//...............................................................
//
class Abbrechen implements ActionListener
{ // start of class Abbrechen
//
public void actionPerformed(ActionEvent e)
{ // start of method actionPerformed
// System.out.println("abbrechen");
// This method closes the TCP connection
//...............................................................
//
// if there is no TCP connection then do nothing
if (hostSocket == null) return;
//
//...............................................................
//
// close TCP connection
//
boolean fehler = false;
try
{
hostSocket.close();
}
catch (IOException ex) // hat nicht funktioniert
{
statusBox.setText(ex.toString());
fehler = true;
hostSocket = null;
}
//
if (fehler == false)
{
statusBox.setText("Verbindung abgebrochen");
}
//
//...............................................................
//
} // end of method actionPerformed
//
} // end of class Abbrechen
//
//***************************************************************
//***************************************************************
//
// class "Pruefen"
//
// This class is the actionListener of button "prüfen".
// it's only method "actionPerformed" is called when the user
// has pressed the button.
//
//...............................................................
//
class Pruefen implements ActionListener
{ // start of class Pruefen
//
public void actionPerformed(ActionEvent e)
{ //start of method actionPerformed
String user = benutzer.getText();
String oldPassword = altesPasswort.getText();
//
//................................................................
//
if (user.length() == 0)
{
JOptionPane meldung03 = new JOptionPane();
meldung03.showMessageDialog (benutzer,
"Benutzer-ID fehlt",
"HostPwd",
JOptionPane.WARNING_MESSAGE);
benutzer.requestFocus();
return; // benutzer soll sein ID eingeben
}
//
//................................................................
//
if (oldPassword.length() == 0)
{
JOptionPane meldung04 = new JOptionPane();
meldung04.showMessageDialog (altesPasswort,
"Passwort fehlt",
"HostPwd",
JOptionPane.WARNING_MESSAGE);
altesPasswort.requestFocus();
return; // benutzer soll das alte Passwort eingeben
}
//
//----------------------------------------------------------------
//
// Das Passwort kann jetzt auf dem Host geprüft werden.
//
//----------------------------------------------------------------
//
// String "hostRequest" erstellen.
// (dies ist die Nachricht die an Host gesendet wird)
//
hostRequest = "VERIFY " + user
+ " "
+ oldPassword;
//
//................................................................
//
// String "hostRequest" and Host senden:
//
HostRuf(hostRequest);
//
//
//----------------------------------------------------------------
//
} // end of method actionPerformed
//
} // end of class Pruefen
//
//***************************************************************
//***************************************************************
//
// class "Aendern"
//
// This class is the actionListener of button "ändern".
// it's only method "actionPerformed" is called when the user
// has pressed the button.
//
//...............................................................
//
class Aendern implements ActionListener
{ // start of class Aendern
//
public void actionPerformed(ActionEvent e)
{ // start of method actionPerformed
String user = benutzer.getText();
String oldPassword = altesPasswort.getText();
String newPassword = neuesPasswort.getText();
boolean bestaetigt = false;
//
//................................................................
//
if (user.length() == 0)
{
JOptionPane meldung03 = new JOptionPane();
meldung03.showMessageDialog (benutzer,
"Benutzer-ID fehlt",
"HostPwd",
JOptionPane.WARNING_MESSAGE);
benutzer.requestFocus();
return; // benutzer soll sein ID eingeben
}
//
//................................................................
//
if (oldPassword.length() == 0)
{
JOptionPane meldung04 = new JOptionPane();
meldung04.showMessageDialog (altesPasswort,
"Passwort fehlt",
"HostPwd",
JOptionPane.WARNING_MESSAGE);
altesPasswort.requestFocus();
return; // benutzer soll das alte Passwort eingeben
}
//
//................................................................
//
if (newPassword.length() == 0)
{
JOptionPane meldung05 = new JOptionPane();
meldung05.showMessageDialog (neuesPasswort,
"neues Passwort fehlt",
"HostPwd",
JOptionPane.WARNING_MESSAGE);
neuesPasswort.requestFocus();
return; // benutzer soll das neue Passwort eingeben
}
//
//................................................................
//
// if dies ist das erste mal dass das neue Passwort eingeben wurde...
//
if (urspruenglichesPasswort.length() == 0)
{
JOptionPane meldung06 = new JOptionPane();
meldung06.showMessageDialog (neuesPasswort,
"Geben Sie das neue Passwort noch einmal ein.",
"HostPwd",
JOptionPane.PLAIN_MESSAGE);
urspruenglichesPasswort = neuesPasswort.getText(); // sichern neues Passwort
neuesPasswort.setText(""); // neues Passwort löschen
neuesPasswort.requestFocus();
return; // benutzer soll das neue Passwort noch einmal eingeben
}
//
//................................................................
//
// dies ist das zweite mal dass das neue Passwort eingeben wurde
//
// prüfen ob das neue Passwort zweimal nacheinander richtig eingegeben wurde
bestaetigt = newPassword.equals(urspruenglichesPasswort);
//
//................................................................
//
if (bestaetigt == false)
{
// das neue Passwort wurde nicht zweimal nacheinander richtig eingegeben:
JOptionPane meldung07 = new JOptionPane();
meldung07.showMessageDialog (neuesPasswort,
"Bestätigung falsch: Bitte, geben Sie das neue Passwort ein.",
"HostPwd",
JOptionPane.PLAIN_MESSAGE);
urspruenglichesPasswort = ""; // ursprüngliches Passwort löschen
neuesPasswort.setText(""); // neues Passwort löschen
neuesPasswort.requestFocus();
return; // Benutzer soll es nochmals versuchen
}
//
//................................................................
//
// Das "neue Passwort" wurde zweimal nacheinander richtig eingegeben
//
urspruenglichesPasswort = ""; // ursprüngliches Passwort löschen
//
//----------------------------------------------------------------
//
// Das Passwort kann jetzt auf dem Host geändert werden.
//
//----------------------------------------------------------------
//
// String "hostRequest" erstellen.
// (dies ist die Nachricht die an Host gesendet wird)
//
hostRequest = "VERIFY " + user
+ " "
+ oldPassword
+ " "
+ newPassword;
// System.out.println("hostRequest: " + hostRequest);
//
//................................................................
//
// String "hostRequest" and Host senden:
//
HostRuf(hostRequest);
//
//----------------------------------------------------------------
//
} // end of method actionPerformed
//
} // end of class Aendern
//
//***************************************************************
} // class HostPwd