Aktivieren des Displays am BananaPI Pro und Lubuntu

Benötigt wird ssh und git(hub).
Verbindung aufbauen mit dem pi.
PowerShell benötigt zusätzlich OpenSSH oder msys MinGW
ssh bananapi@ip_addr
Verzeichnis einbinden
sudo mount /dev/mmcblk0p1 /mnt
In ein Arbeitsverzeichnis wechseln zB. cd /Downloads
Die benötigten Dateien holen:
git clone https://github.com/LeMaker/fex_configuration
in das Verzeichnis wechseln
cd fex_configuration
die Datei kopieren
sudo cp bin/banana_pro_7lcd.bin /mnt/script.bin
Entbinden
sudo umount /mnt
und den PI neustarten, das Display sollte dann benutzt werden.

Einfacher Rechner (FX)

FX_Rechner

Einfacher Grundrechenarten-Taschenrechner mit JavaFX

Die .fxml wurde mit dem SceneBuilder erstellt/bearbeitet, die Hinweisbox wurde mittels AlertDialog umgesetzt. Hier wird nur die FXMLController.java abgebildet, die restlichen Dateien sind mit in dem Archiv.

 

/*FX Rechner
Copyright (C) 2015 Timo Wosnitza

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.*/

package de.wosnitza;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.Optional;
import javafx.application.Platform;
import javafx.event.ActionEvent;
import javafx.fxml.FXML;
import javafx.scene.control.Alert;
import javafx.scene.control.Alert.AlertType;
import javafx.scene.control.Button;
import javafx.scene.control.ButtonType;
import javafx.scene.control.Label;
import javafx.scene.control.RadioButton;
import javafx.scene.control.TextArea;
import javafx.scene.control.TextField;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.Priority;
import javafx.stage.Modality;
import javafx.stage.StageStyle;

public class FXMLController {

/*
* Muessen leider alle einzeln angegeben werden, sonst erscheinen sie nicht
* als zuweisbar im SceneBuilder :(
*/
//Nodes - Attribute
@FXML
private TextField eingabeFeldWertEins;
@FXML
private TextField eingabeFeldWertZwei;
@FXML
private Label ergbnisAusgabe;
@FXML
private Button infoButton;
@FXML
private Button beendenButton;
@FXML
private RadioButton radioButtonAddition;
@FXML
private RadioButton radioButtonSubtraktion;
@FXML
private RadioButton radioButtonMultiplikation;
@FXML
private RadioButton radioButtonDivision;

/*
* Die Methoden werden mittels .fxml zugewiesen,
* ebenso die Gruppierung der RadioButton
*/

/*
* die beiden Methoden programmBeendenVorstufeMethode
* und programBeendenMethode arbeiten direkt zusammen.
* Mittels programmBeendenVorstufemethode wird die
* programmBeendenMethode aufgerufen und geprueft ob
* diese wahr ist, wenn sie wahr ist wird das Programm
* geschlossen.
*/

@FXML
private void programmBeendenVorstufeMethode(){
if (programmBeendenMethode()){
// System.out.println("Rueckgabewert angekommen!");
Platform.exit();
}
}
/*
* programmbeendenMethode wird durch die Vorstufenmethode auf-
* gerufen erzeugt einen AlertDialog der als Confirmation deklariert
* ist und in diesem Fall die geforderten zwei Mglichkeiten bietet.
* Ja oder Nein.
*/

//zu Aufgabe 2
private boolean programmBeendenMethode() {
//Rueckgabewert wird erstmal auf unwahr gesetzt
boolean dummy = false;
//Confirmation = wartet auf eine Besttigung,hat min 2 Auswahlmoeglichkeiten
Alert alert = new Alert(AlertType.CONFIRMATION);
//Titel
alert.setTitle("FX Rechner beenden?");
//"Ueberschrift"
alert.setHeaderText("Soll das Programm wirklich beendet werden?");
//Inhalt
alert.setContentText("Waehlen Sie zwischen Ja und Nein!");
//Die beiden zur Verfuegung stehenden Schaltflaechen
ButtonType buttonProgrammBeenden = new ButtonType("Ja");
ButtonType buttonAbbruch = new ButtonType("Nein");
//Schaltflaechen hinzufuegen
alert.getButtonTypes().setAll(buttonProgrammBeenden, buttonAbbruch);
//Anzeigen und warten
Optional result = alert.showAndWait();
//Abfrage wenn ... dann
if (result.get() == buttonProgrammBeenden) {
//wenn ja gewaehlt wurde
dummy = true;
} else if (result.get() == buttonAbbruch) {
//wurde nein gewaehlt dann ...
dummy = false;
//nein = abbruch und der AlertDialog wird wieder geschlossen
alert.close();
}
/*
* Rueckgabewert wird an den Aufrufer zurueckgegeben,
* interessant ist hier nur wenn es wahr ist, dann schliesst
* die Aufrufendemethode das Programm.
*/
return dummy;
}

/*
* In der berechnenMethode werden nicht nur
* die Werte anhand des Operators berechnet,
* es findet auch eine Ausnahmebehandlung statt.
*/
@FXML
private void berechnenMethode(ActionEvent event) {
// lokale Variablen fuer die Berechnung
double wertEins = 0, wertZwei = 0, ergebnis = 0;
//Meldung bei Division durch Null, klingt besser als nicht definiert ;)
final String ERROR = "Infinity!";
//Fehlerschalter, wichtig fuer die Ausgabe
boolean fehlerflag = false;
//Dummy fuer die Ausgabe
String temp;
// Werte vom TextField holen und zum double parsen
try {
wertEins = Double.parseDouble(eingabeFeldWertEins.getText());
} catch (NumberFormatException e) {
//Alert = Besttigungsdialog bei "Fehlern" hier
//fuer Ausnahmen
Alert alert = new Alert(AlertType.ERROR);
//Titel
alert.setTitle("Exception Dialog fuer Feld 1");
//"Ueberschrift"
alert.setHeaderText("Nice Try!");
//Inhalt
alert.setContentText("Except an Exception ;)");
//neue Ausnahme
Exception ex = new NumberFormatException("Exception");

/*
* hier werden mit den "writern" Daten der Ausnahme
* in dem Dialog zur Verfuegung gestellt.
*/
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
ex.printStackTrace(pw);
//als Text verwendbar machen
String exceptionText = sw.toString();
//Feld fuer die Ausgabe
Label label = new Label("The exception stacktrace was:");
//Textbereich fuer dei Ausnahme
TextArea textArea = new TextArea(exceptionText);
/*
* TextField ist bearbeitbar, dies ist hier nicht erwuenscht
* daher daektiviert und Textumbruch aktiviert.
*/
textArea.setEditable(false);
textArea.setWrapText(true);
//Masse fuer die Ausgabe
textArea.setMaxWidth(Double.MAX_VALUE);
textArea.setMaxHeight(Double.MAX_VALUE);
GridPane.setVgrow(textArea, Priority.ALWAYS);
GridPane.setHgrow(textArea, Priority.ALWAYS);
//erstellen und hinzufuegen
GridPane expContent = new GridPane();
expContent.setMaxWidth(Double.MAX_VALUE);
expContent.add(label, 0, 0);
expContent.add(textArea, 0, 1);
// ist "ausklappbar" erweiterbar (sichtbereich)
alert.getDialogPane().setExpandableContent(expContent);
//anzeigen und warten
alert.showAndWait();
}
/*
* Fuer das zweite Feld gelten die gleichen
* Kommentare wie Feld eins, Kode ist sinngemaess
* an Feld zwei angepasst.
*/
try {
wertZwei = Double.parseDouble(eingabeFeldWertZwei.getText());
} catch (NumberFormatException e) {
Alert alert = new Alert(AlertType.ERROR);
alert.setTitle("Exception Dialog fuer Feld 2");
alert.setHeaderText("Nice Try!");
alert.setContentText("Except an Exception ;)");
Exception ex = new NumberFormatException("Exception");
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
ex.printStackTrace(pw);
String exceptionText = sw.toString();
Label label = new Label("The exception stacktrace was:");
TextArea textArea = new TextArea(exceptionText);
textArea.setEditable(false);
textArea.setWrapText(true);
textArea.setMaxWidth(Double.MAX_VALUE);
textArea.setMaxHeight(Double.MAX_VALUE);
GridPane.setVgrow(textArea, Priority.ALWAYS);
GridPane.setHgrow(textArea, Priority.ALWAYS);
GridPane expContent = new GridPane();
expContent.setMaxWidth(Double.MAX_VALUE);
expContent.add(label, 0, 0);
expContent.add(textArea, 0, 1);
alert.getDialogPane().setExpandableContent(expContent);
alert.showAndWait();
}
/*
* Auswahl der Berechnung anhand des selektierten
* RadioButton. Bei Division wird Wert zwei erst auf 0
* geprft. Anhand des Fehlerschalters wird das berechnete
* Ergebnis oder Fehlertext ausgegeben.
*/
if (radioButtonAddition.isSelected())
ergebnis = wertEins + wertZwei;
if (radioButtonSubtraktion.isSelected())
ergebnis = wertEins - wertZwei;
if (radioButtonMultiplikation.isSelected())
ergebnis = wertEins * wertZwei;
if (radioButtonDivision.isSelected()) {
//wenn nicht null
if (wertZwei != 0)
ergebnis = wertEins / wertZwei;
else
//bei null
fehlerflag = true;
}
//wenn alles ok dann weiter
if (fehlerflag == false) {
temp = Double.toString(ergebnis);
ergbnisAusgabe.setText(temp);
} else
//Fehlertext anzeigen
ergbnisAusgabe.setText(ERROR);
}

/*
* infoAnzeigenMethode zeigt ein Dialogfenster
* mit dem Hinweis auf den Autor.
* Sie wird aufgerufen wenn der InfoButton
* gedrueckt wird.
*/
public void infoAnzeigenmethode() {
//Inforamtion = Hinweisfenster mit "Ein-Button-Bestaetigung"
Alert alert = new Alert(AlertType.INFORMATION);
alert.setTitle("Programminfo");
alert.setHeaderText("FX Rechner v1.3 final");
alert.setContentText("by Timo Wosnitza");
alert.showAndWait();
}

}

Java JComboBox mit ItemStateChanged

Wird ein Eintrag eines Kombofeldes (JComboBox) ausgewählt, werden ohne weitere Angaben zwei Werte übergeben. Der de-selektierte und der selektierte Wert.

Dies kann dazu führen das Ergebnisse (Maßnahmen) doppelt ausgeführt oder angezeigt werden. Um dies zu verhindern kann gezielt angegeben werden, dass auf den de- oder selektierten Wert reagiert werden soll.

@Override
public void itemStateChanged(ItemEvent e) {
// wenn der Ausloeser von der JComboBox kommt
if (e.getSource() instanceof JComboBox) {
/*
* die folgende if Anweisung verhindert die doppelte
* Wertuebergabe. Ohne diese Anweisung wuerde
* deselected & selected uebergeben werden
*/
if (e.getStateChange() == ItemEvent.SELECTED) {
// ausgewaehlten Index speichern
indexDummy = auswahlMenue.getSelectedIndex();
System.out.println(e.getItem());
// berechnen () gibt Wert an Aufrufer zurueck
// diesen Wert ausgeben
ausgabe.setText(berechnen(indexDummy));
}
}
}

FensterSchubser

Der FensterSchubser ermittelt die Bildschirmgröße, positioniert sich mittig auf dem Startbildschirm und lässt sich dann mittels Schaltflächen bewegen. Das Fenster wird je 10px in die gewünscht Richtung bewegt, bis die Bildschirmgrenze erreicht ist.

Die Bildschirmmitte wird mit zwei unterschiedlichen Methoden ermittelt, einmal für den Hinweis beim Programmstart und für das Programm selbst.

Weiter wird die Taskleiste (sofern auf dem Startbildschirm vorhanden) berücksichtigt.

 


/*fensterSchubser
Copyright (C) 2015 Timo Wosnitza

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.*/

/**
* Dieses Programm erstellt ein Fenster mit vier Button. Ueber diese
* Button laesst sich das Fenster in die entsprechende Richtung bewegen.
* Vor dem eigentlichen Programm wird ein kleines Hinweisfenster zur
* Bedienung gezeigt.
* Fuer die Positionierung des Hinweis- und Programmfesnters wurden zwei
* Unterschiedliche Methoden benutzt.
*/

package einsendeaufgabe;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Insets;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JOptionPane;

public class FensterGUI extends JFrame {

private static final long serialVersionUID = 1L;

// Attribute
protected JButton oben, rechts, unten, links;
protected final int X = 10;
protected final int SCHRIFTGROESSE = 10;
protected final String BEREICHVERLASSENTEXT = "Sie versuchen den erlaubten Bereich zu verlassen\n"
+ "Das schubsen ist nur auf dem primären Bildschirm erlaubt ;)";

// Fensterpositionierung
protected Toolkit tk = Toolkit.getDefaultToolkit();
protected Dimension bildschirmGroesse = tk.getScreenSize();
// minus "Wert" da die Haelfte des Fensters beruecksichtig werden muss
// sonst wird nur die Ecke oben Links zentriert
protected int width = ((bildschirmGroesse.width - getSize().width) / 2) - 100;
protected int height = ((bildschirmGroesse.height - getSize().height) / 2) - 100;

//height of the task bar
protected Insets scnMax = Toolkit.getDefaultToolkit().getScreenInsets(getGraphicsConfiguration());
protected int taskBarSize = scnMax.bottom;

// Max Werte fuer Bildschirm, hier gibt es Unterschiede zwischen Windows und
// Linux (bei mehreren Bildschirmen)
protected final int WIDHTMAX = (int) bildschirmGroesse.getWidth() -210;//-10 Fensterrahmen links und rechts je 5px
protected final int HEIGHTMAX = (int) ((bildschirmGroesse.getHeight() -205) - taskBarSize);//Fensterrahmen unten 5px

// Konstruktor
public FensterGUI(String titel) {
super(titel);
System.out.println("Ermittelte Bildschirmgroesse: " + bildschirmGroesse.getWidth() + " " + bildschirmGroesse.getHeight());
System.out.println("davon benutzbar: " + bildschirmGroesse.getWidth() + " " + (bildschirmGroesse.getHeight()-taskBarSize));
System.out.println("Hoehe der Taskleiste: " + taskBarSize);
System.out.println("aktuell gesetzte Grenzen " + WIDHTMAX + " " + HEIGHTMAX + " beruecksichtig die Taskleiste und den Nullpunkt des Fensters (oben links)");
System.out.println("Startposition des Hauptfensters " + width + " " + height);
setLayout(new BorderLayout(25, 25));
// der Uebersicht wegen wurden Methoden erstellt
komponentenHinzufuegen();
layoutErstellen();
}// Konstruktor Ende

// Methode fuer die Komponenten
public void komponentenHinzufuegen() {

// Listener
InnererListener listener = new InnererListener();
// "Button" erzeugen
oben = new JButton("nach oben");
rechts = new JButton("nach rechts");
unten = new JButton("nach unten");
links = new JButton("nach links");

/*
* unter Linux sind die JButton zu gross da die Schriftgroesse nicht
* passt, daher werden die Button auf eine feste groesse gesetzt und im
* Konstruktor die Groesse der Schrift festgelegt
*/
oben.setPreferredSize(new Dimension(35, 35));// Weite wird ignoriert
rechts.setPreferredSize(new Dimension(90, 35));
unten.setPreferredSize(new Dimension(35, 35));// Weite wird ignoriert
links.setPreferredSize(new Dimension(90, 35));

// Schrift anpassen
oben.setFont(new Font("Arial", Font.PLAIN, SCHRIFTGROESSE));
rechts.setFont(new Font("Arial", Font.PLAIN, SCHRIFTGROESSE));
unten.setFont(new Font("Arial", Font.PLAIN, SCHRIFTGROESSE));
links.setFont(new Font("Arial", Font.PLAIN, SCHRIFTGROESSE));

// zuweisen actionCommand
oben.setActionCommand("nach oben");
rechts.setActionCommand("nach rechts");
unten.setActionCommand("nach unten");
links.setActionCommand("nach links");

// listener verbinden
oben.addActionListener(listener);
rechts.addActionListener(listener);
unten.addActionListener(listener);
links.addActionListener(listener);

}// Ende komponentenHunzufuegen

// Methode fuer das Layout
public void layoutErstellen() {

// Groesse des Fesnters setzen
setSize(200, 200);
/*
* nach max. des Fensters koennte dies nicht mehr "geschoben" werden, da
* die max Koordinaten erreicht waeren, daher wird das Aendern der
* Fenstergroesse deaktiviert.
*/
setResizable(false);

// Position des Fensters setzen
setLocation(width, height);

// Buttons anordnen/zuweisen, center soll frei bleiben
// this.add(oben, BorderLayout.NORTH);
this.add(oben, BorderLayout.PAGE_START);// north
this.add(rechts, BorderLayout.LINE_END);// east
this.add(unten, BorderLayout.PAGE_END);// south
this.add(links, BorderLayout.LINE_START);// west
// Listener damit das Hinweisfenster bei Programmstart angezeigt wird
addWindowListener(new InnererListener());

// Programm beenden wenn Fenster geschlossen wird
setDefaultCloseOperation(EXIT_ON_CLOSE);

// Fenster sichtbar machen
setVisible(true);

}// Ende layoutErstellen

// Innere Klasse fuer Listener
class InnererListener extends WindowAdapter implements ActionListener, WindowListener {

// wenn Prgramm gestartet wird (Hinweisfenster)
@Override
public void windowOpened(WindowEvent ee) {
System.out.println("Programm wurde gestartet");
JOptionPane pane = new JOptionPane(
"Zum Schubsen auf den Button für die " + "entsprechende Richtung drücken.");
JDialog d = pane.createDialog((JFrame) null, "Willkommen beim Fensterschubser!");
// Fenster zentrieren
d.setLocationRelativeTo(null);
d.setVisible(true);
}

// fuer die vier Button
@Override
public void actionPerformed(ActionEvent e) {

String weiche = e.getActionCommand();

if (weiche.equals("nach oben"))
// move window up
setFensterBewegerMethodeOben(X);
;
if (weiche.equals("nach rechts"))
// move window right
setFensterBewegerMethodeRechts(X);
;
if (weiche.equals("nach unten"))
// move window down
setFensterBewegerMethodeUnten(X);
;
if (weiche.equals("nach links"))
// move window left
setFensterBewegerMethodeLinks(X);
;

}

}

/*
* Methode um das Fenster nach oben zu bewegen
*/

public void setFensterBewegerMethodeOben(int X) {
if (height > 0) {
height -= X;
setLocation(width, height);
System.out.println(getX() + " - " + getY());
} else {
JOptionPane.showMessageDialog(null, BEREICHVERLASSENTEXT);
}
}

// Methode um das Fenster nach rechts zu bewegen
public void setFensterBewegerMethodeRechts(int X) {
if (width <= WIDHTMAX) {
width += X;
setLocation(width, height);
System.out.println(getLocation());
//weitere Möglihckeit fuer Koordinatenausgabe
System.out.println("X Koord " + getX() + " - " + " Y Koord " + getY());
} else {
JOptionPane.showMessageDialog(null, BEREICHVERLASSENTEXT);
}
}

// Methode um das Fenster nach unten zu bewegen
public void setFensterBewegerMethodeUnten(int X) {
if (height <= HEIGHTMAX) { height += X; this.setLocation(width, height); System.out.println(getX() + " - " + getY()); } else { JOptionPane.showMessageDialog(null, BEREICHVERLASSENTEXT); } } // Methode um das Fenster nach links zu bewegen public void setFensterBewegerMethodeLinks(int X) { if (width > 0) {
width -= X;
this.setLocation(width, height);
System.out.println(getX() + " - " + getY());
} else {
JOptionPane.showMessageDialog(null, BEREICHVERLASSENTEXT);
}
}

}

fensterSchubser.jar

Viel Spaß beim experimentieren, die Klasse mit der main() ist hier nicht aufgeführt da sie nur die oben abgebildete Klasse startet.

Java 8

Zentyal: Erlaube recursive DNS Abfragen durch OpenVPN Tunnel

Ich habe es gern wenn ich den DNS Server auch durch die OpenVPN Tunnel abfragen kann, so dass ich auch von außerhalb, ganz normal auf die Dienste in meinem Netzwerk zugreifen kann.

Das ging bis jetzt nicht mit meinem Zentyal 4.1 OpenVPN Server.

Obwohl ich den Zentyal OpenVPN entsprechend konfiguriert hatte konnte ich von extern, keine Namen in meiner internen Domain „gaswarnanlagen.lan“ auflösen.

 

Die named Logs brauchten mich nun heute dazu mir das mal näher anzuschauen. Hier ist ein Auszug der Logs die mich letztlich auf die Spur brachten:

Zentyals DNS Log
Zentyal’s DNS Log
May 13 16:10:26 domain01 named[2039]: client 192.168.160.6#50862 (apps.facebook.com): query (cache) 'apps.facebook.com/A/IN' denied
May 13 16:10:26 domain01 named[2039]: client 192.168.160.6#63933 (wa.ui-portal.de): query (cache) 'wa.ui-portal.de/A/IN' denied
May 13 16:10:27 domain01 named[2039]: client 192.168.160.6#61863 (apps.facebook.com): query (cache) 'apps.facebook.com/A/IN' denied
May 13 16:10:29 domain01 named[2039]: client 192.168.160.6#64116 (uas.web.de): query (cache) 'uas.web.de/A/IN' denied
May 13 16:10:29 domain01 named[2039]: client 192.168.160.6#59933 (uas.web.de): query (cache) 'uas.web.de/A/IN' denied
May 13 16:10:30 domain01 named[2039]: client 192.168.160.6#56331 (millionenklick.web.de): query (cache) 'millionenklick.web.de/A/IN' denied
May 13 16:10:31 domain01 named[2039]: client 192.168.160.6#51609 (uim.tifbs.net): query (cache) 'uim.tifbs.net/A/IN' denied
May 13 16:10:31 domain01 named[2039]: client 192.168.160.6#64653 (uim.tifbs.net): query (cache) 'uim.tifbs.net/A/IN' denied

Der named erlaubt also keine rekursiven DNS Anfragen für mein OpenVPN Netzwerk 192.168.160.0/24. Mein einziges internes Netzwerk hat die Adresse 192.168.89.0/24 und gehört somit definitiv nicht dazu.
Der named Server in der Zentyal Installation erlaubt für alle „intern“ markierten Netzwerke automatisch rekursive DNS Abfragen. Leider zählen die OpenVPN Netzwerke nicht zu den internen Netzen dazu. Außerdem gibt es keine Möglichkeit diese „erlaubten“, internen Netzwerke über die WebGUI zu konfigurieren.

Nach etwas Recherche bin ich auf die, schon recht alte Zentyal 2(!) Dokumentation gestoßen. Hier wird die Datei /etc/zentyal/dns.conf genannt. Unter dem Parameter …

intnets =

… können unter anderem die IP Adressen der internen Netzwerke von Hand gepflegt werden. Also einfach die IP Adresse des OpenVPN Netzwerks zum Parameter intnets hinzufügen.

sudo vim /etc/zentyal/dns.conf
# /etc/zentyal/dns.conf
...
intnets = 192.168.160.0/24
...

Hinweis: Die eigentlichen internen Netzwerke (192.168.89.0/24 in meinem Fall) müssen nicht extra noch eingetragen werden, es reicht einfach das OpenVPN Netz einzutragen.

Danach muss der Zentyal DNS Server neu gestartet werden, so das die neue Konfiguration eingelesen wird.

sudo service zentyal dns restart

Jetzt verschwinden die named Fehler in den Logs und die OpenVPN Clients können, wie im lokalen Netzwerk auf die DNS Einträge zugreifen.

P.S. Die Datei /etc/zentyal/dns.conf ist auch in der aktuellen Zentyal Version 4 gültig, diese Konfiguration somit vollkommen valide und sicher!

IPFIRE Fehlermeldung beim updaten der Snort Regeln (IPFire 2.17 (i586) – Core Update 87)

Beim aktualisieren der Regeln für IPFire 2.17 (i586) – Core Update 87 erhielt ich folgende Fehlermeldung.

--2015-03-09 14:11:11-- https://www.snort.org/rules/snortrules-snapshot-2961.tar.gz?oinkcode=XXX
Resolving www.snort.org (www.snort.org)... 104.20.20.171, 104.20.18.171, 104.20.21.171, ...
Connecting to www.snort.org (www.snort.org)|104.20.20.171|:443... connected.
WARNING: cannot verify www.snort.org's certificate, issued by '/C=BE/O=GlobalSign nv-sa/CN=GlobalSign Organization Validation CA - G2':
Unable to locally verify the issuer's authority.
HTTP request sent, awaiting response... 422 Unprocessable Entity
2015-03-09 14:11:12 ERROR 422: Unprocessable Entity.

Der Fehler konnte behoben werden in dem die Versionsnummer der Snort Regeln in der Datei ids.cgi angepasst wurde.

Ersetzt werden musste 2961 mit 2970 in den folgenden beiden Zeilen.

$url=" https://www.snort.org/rules/snortrules-snapshot-2970.tar.gz?oinkcode=$snortsettings{'OINKCODE'}";

und

$url=" https://www.snort.org/rules/snortrules-snapshot-2970.tar.gz?oinkcode=$snortsettings{'OINKCODE'}";

Danach wurde die Aktualisierung der Regeln erfolgreich ausgeführt.