C-Programm – Euro & Dollar Umrechnung

Und noch ein einfaches Beispiel für Funktionen… + verschiedenen Schleifen. (for, while, do-while)

// Euro & Dollar

#include <stdio.h>
#define WKURS 1.40331182

double euro2dollar( double euro) {
	return euro*WKURS;
}

double dollar2euro( double dollar) {
	return dollar/WKURS;
}

int main(void) {
	double anfangsbetrag;
	double endbetrag;
	int umrechnung;

	printf("Umrechnen von Dollar in Euro & von Euro in Dollar:\n\n");
	do {
		printf("Anfangsbetrag = "); scanf("%lf", &anfangsbetrag);
	} while ( anfangsbetrag <= 0 );
	do {
		printf("Endbetrag = "); scanf("%lf", &endbetrag);
	} while ( endbetrag <= 0 );

	do {
		printf("\n1 - von Euro in Dollar\n2 - von Dollar in Euro\nUmrechnung:"); scanf("%d", &umrechnung);
	} while ( (umrechnung < 1)  || (umrechnung > 2) );

	if (umrechnung == 1) {
		printf("\n  Euro  |  Dollar");
		printf("\n--------+--------");
		// for
		for (anfangsbetrag; anfangsbetrag <= endbetrag; anfangsbetrag=anfangsbetrag+10) {
			printf("\n %6.2lf | %6.2lf", anfangsbetrag, euro2dollar(anfangsbetrag) );
		}
		/* // while
		while (anfangsbetrag <= endbetrag) {
			printf("\n %6.2lf | %6.2lf", anfangsbetrag, euro2dollar(anfangsbetrag) );
			anfangsbetrag=anfangsbetrag+10;
		}
		*/
		/* // do-while
		do {
			printf("\n %6.2lf | %6.2lf", anfangsbetrag, euro2dollar(anfangsbetrag) );
			anfangsbetrag=anfangsbetrag+10;
		} while (anfangsbetrag <= endbetrag);
		*/
	} else {
		printf("\nDollar  |    Euro");
		printf("\n--------+--------");
		for (anfangsbetrag; anfangsbetrag <= endbetrag; anfangsbetrag=anfangsbetrag+10) {
			printf("\n %6.2lf | %6.2lf", anfangsbetrag, dollar2euro(anfangsbetrag) );
		}
		/* // while
		while (anfangsbetrag <= endbetrag) {
			printf("\n %6.2lf | %6.2lf", anfangsbetrag, dollar2euro(anfangsbetrag) );
			anfangsbetrag=anfangsbetrag+10;
		}
		*/
		/* // do-while
		do {
			printf("\n %6.2lf | %6.2lf", anfangsbetrag, dollar2euro(anfangsbetrag) );
			anfangsbetrag=anfangsbetrag+10;
		} while (anfangsbetrag <= endbetrag);
		*/
	}

	return 0;
}

C-Programm – eulersche Zahl

Hier noch ein Beipspiel für eine Funktion, in welcher die “eulersche Zahl” zu einem bestimmten Exponenten berechnet wird…

#include <stdio.h>

/* 

Die Exponentialfunktion e^x kann als eine unendliche Reihe geschrieben werden, um sich dem Ergebnis anzunaehern!!!

------
e^x = 1 + x + x²/2! + x³/3! + x⁴/4! + ... = 1 + x + 1/2*x² + 1/6*x³ + 1/24*x⁴ + ...  
------

i! ist hier die Fakultaet von i und ist definiert als

------
i! = 1*2*3* ... *(i-1)*i
------

- 1.) die Fakultaet ist fortlaufend mit den aufsteigenden ganzen Zahlen zu multiplizieren
- 2.) die Potenz ist fortlaufend mit Exponenten zu multiplizieren
- 3.) die Summanden koennen aus Fakultaet & Potenz berechnet werden
- 4.) die Summenbildung wird abgebrochen, wenn die Summanden kleiner als eine bestimmte Genauigkeit (Epsilon) werden

*/

double exp_fkt( double exponent) {
	int fakultaet=1; /* i! */
	double potenz=1.0; /* x^i */
	double resultat=1.0, summanden;
	int n=1;

	do {
		fakultaet *= n; // 1.)
		potenz *= exponent; // 2.)
		summanden = potenz/fakultaet; // 3.)
		resultat = resultat + summanden;
		printf("%3d %12d %12.6f %12.6f\n", n, fakultaet, summanden, resultat); // test - Ausgabe
		n++;
	} while (summanden >= 0.0001); // 4.)

	return resultat;
}

int main(void) {
	double exponent;

	printf("Berechnung von e^x\n\n");
	printf("Exponent = "); scanf("%lf", &exponent);

	printf("\nDurchlauf Fakultaet Summanden Resultat\n");
	printf("----------------------------------------\n");
	printf("\nexp(%.1lf) = %.16lf\n", exponent, exp_fkt(exponent));

	return 0;
} 

C-Programm – Funktionen

Dies kurze Beispiel zeigt das Prinzip von Funktionen… und wie man das Maximum von drei Zahlen ausgibt. ;-)

#include <stdio.h>

// Funktion_1: max_1 (Maximum) mit drei Eingaengen
int max_1 (int a, int b, int c) {
	if(a>b && a>c)
		return a;
	else if(b>a && b>c)
		return b;
	else
		return c;
}

// Funktion_2: max_2 (Maximum) mit zwei Eingaengen
int max_2 (int a, int b) {
	if(a>b)
		return a;
	else
		return b;
}

int main (void){

	int a,b,c,max_3;

	printf("a");
	scanf("%d",&a);
	printf("b");
	scanf("%d",&b);
	printf("c");
	scanf("%d",&c);

	// Funktion_1
	printf ("%d", max_1(a,b,c));

	// Funktion_2 (wird 2-mal ineinander ausgefuehrt)
	printf ( "%d", max_2(max_2(a,b),c) );

	// alles in einer Zeile :-)
	max_3 = (a>b) ? ((a>c) ? a : c) : ((b>c) ? b : c);
	printf("%d", max_3);

	return (0);
}

Überblick: Google – Chrome

“Google Chrome ist ein Webbrowser, der von Google Inc. entwickelt wird und seit dem 2. September 2008 verfügbar ist. Am 11. Dezember 2008 erschien die erste finale Version. Zentrales Konzept ist die Aufteilung des Browsers in optisch und aufProzessebene getrennte Browser-Tabs.” – Wiki


1.) Versionsgeschichte von Google Chrome (Quelle: Wiki)

Legende: Alte Version Aktuelle Version Aktuelle Vorabversion Zukünftige Version
Webkit-
Version

JS-Version

(V8)

Version Veröffentlichung Anmerkungen und wichtige Änderungen
522 0.3 0.2 2. September 2008 erste Veröffentlichung als Beta-Version für Windows
0.3 29. Oktober 2008 Verbesserte Pluginstabilität
525 0.4 24. November 2008 Lesezeichenmanager mit Export und Import, Datenschutzabschnitt in den Optionen, Sicherheitsupdates
528 1.0 11. Dezember 2008 erste stabile Version.
530 0.4 2.0 24. Mai 2009 Vollbild (F11), 35% schnelleres JavaScript beim SunSpider Benchmark Test, Unterstützung vom Mausrad
532 1.2 3.0 15. September 2009 Neue „Neuer Tab“-Seite, bis zu 25% schnelleres JavaScript, Unterstützung des HTML5-video-und-audio-Tags, Themes.
532.5 1.3 4.0 25. Januar 2010 Erweiterungen, native Unterstützung für Greasemonkey-Scripte, Lesezeichensynchronisierung, verbesserte Entwicklerwerkzeuge, verbesserte HTML5-Unterstützung[20]
4.1 17. März 2010 Integration des Google-Übersetzers und erweiterte Content-Einstellungen[21]
533 2.1 5.0 25. Mai 2010 Erste offizielle Version für Linux und Mac; bis zu 30% schnelleres JavaScript, Zoom-Einstellungen werden pro Seite gespeichert; verbesserte Unterstützung von HTML 5; Lesezeichenmanager als Tab, Synchronisierung von Browser-Einstellungen[22] integriertes Flash-Plugin
534 2.2 6.0 2. September 2010 Überarbeitetes Design der Omnibox (Adresszeile), bis zu 15% schnelleres JavaScript, Integration der Autofill-Funktion, Synchronisierung von Erweiterungen und Autofill, Unterstützung für das WebM-Format[23]
534 2.3 7.0 19. Oktober 2010 Verbesserte Unterstützung von HTML5, schnelleres JavaScript, Unterstützung des File-API, Behebung hunderter Bugs, erleichtertes Blockieren von Cookies
534 2.4 8.0 Dezember 2010 Hardwarebeschleunigung durch Grafikkarte, Instant-Suche, verbesserte HTML5-Unterstützung, “about:flags” zum Aktivieren von Vorabfunktionen, integrierter PDF-Betrachter[24]
534 2.4 9.0 2010/2011 Print Preview (Vorabfunktion; ist standardmäßig deaktiviert)


2.) Tastenkombination:

Tastenkombination Funktion
Strg + T Tab öffnen
Strg + 1…8 Tab 1/…/8 aufrufen
Strg + Tab Durchschalten der Tabs
Strg + Umschalt + T Geschlossen Tab zurückholen
Strg + B Bookmarks ein-/ausblenden
Strg + H Verlauf anzeigen
Strg + J Downloadseite aufrufen
Umschalt + Esc Task-Manager aufrufen
Strg + F Suchen

weitere Tastenkombis für Chrome:

[stextbox id=”warning”]Unterscheidung: Win, MAC, Linux[/stextbox]

-> http://www.google.com/support/chrome/bin/static.py?page=guide.cs&guide=25799&topic=28650


3.) Design (Theme) für Chrome

Wer ein neues Design (Theme) für Chrome sucht wird hier fündig:

-> https://tools.google.com/chrome/intl/de/themes/index.html


4.) WebInspector – Webseiten live ändern

Mit dem standardmäßig installiertem WebInspector kann man den Quell-Code einer Webseite ändern und diese Änderung auch direkt ansehen. Einfach einen bestimmten -> Bereich markieren -> rechte Maustaste -> “Element untersuchen”

http://trac.webkit.org/wiki/WebInspector


5.) Erweiterungen nachinstallieren

-> http://code.google.com/chrome/extensions/


5.1.) Xmarks Bookmark and Password Sync: (Synchronisiert auch zwischen verschiedenen Browsern, ggf. danach wieder deinstallieren)

https://chrome.google.com/extensions/detail/ajpgkpeckebdhofmmjfgcjjiiejpodla

5.2.) Erweiterung “RSS-Abonnement” (von Google):

https://chrome.google.com/extensions/detail/nlbjncdgjeocebhnmkbbbdekmmmcbfjd

5.3.) HTML Validator:

https://chrome.google.com/extensions/detail/cgndfbhngibokieehnjhbjkkhbfmhojo

5.4.) Firebug Lite for Google Chrome:

https://chrome.google.com/extensions/detail/bmagokdooijbeehmkpknfglimnifench



6.) neue Funktionen freischalten

In der Vorherigen Tabelle findet man bereits einige Funktionen, (interner PDF-Betrachter (+ Sandbox), Hardwarebeschleunigung …) um diese nutzen zu können muss man jedoch folgende Schritte befolgen:


6.1.) Vorabversion verwenden:

Natürlich läuft eine Stable-Version ggf. stabiler und eine Dev-Version noch unstabiler wie eine Beta, jedoch hatte ich bisher keine Probleme mit der Dev-Version. :-)


Windows:

MAC:

Linux:


Quelle: dev.chromium.org/getting-involved/dev-channel


6.2.) ggf. Plugins deaktivieren

Ich habe nun andere PDF-Reader deaktiviert…

about:plugins


6.3.) ggf. experimentelle Funktionen freischalten

about:flags


6.4.) ggf. nachschauen mit welchen Parametern Chrome nun gestartet wurde

about:version


bley – gewichtetes Greylisting + Cache

Auf der openrheinruhr.de habe ich gestern einen sehr interessanten Vortrag über Greylisting von Evgeni Golov gehört.


Ich selber hatte bis vor einigen Stunden noch eine Kombination aus Black- & Greylisting + SpamAssassin + ClamAV. Das Problem welches einige kennen ist, dass E-Mails dadurch ggf. verloren gehen oder zumindest verzögert werden, wenn ein “guter” Absender auf einer Blacklist kommt.

Das gewichtetet Greylisting erweitert das normale Greylisting um eine selektive Komponente, somit wenden nur auffällige Sender (welche in einer DNSBL (Blackliste) ist, nicht RFC-konformes EHLO übergibt etc…) werden gegreylisted. Das heißt, dass dem Absender mitgeteilt wird, dass momentan die E-Mail nicht zugestellt werden kann und er es gleich noch einmal versuchen soll, alle anderen werden durchgelassen. Spamer kommen jedoch (noch) nicht noch-einmal, um die selbe E-Mail ein zweites Mal zuzustellen.

Normalerweise werden bei “normalem” Greylisting unbekannten Absender direkt temporär abgewiesen und dessen Reaktion abgewartet. Bei dem “gewichtetem” (intelligentem) Greylisting wird der erste Zustellversuch zunächst analysiert. Anhand dieser Analyse wird entschieden, ob die E-Mail sofort angenommen werden soll oder ob Greylisting zum Einsatz kommt und die E-Mail somit mit einem temporären Fehler abgelehnt wird.


die Analyse:
  1. Absender hat bereits eine E-Mail erfolgreich zugestellt -> E-Mail sofort annehmen
  2. Absender in einer bekannten Whitelist -> E-Mail sofort annehmen
  3. Absender in einer bekannten Blacklist -> Greylisting
  4. Absender verwendet einen nicht standardkonformen Namen im SMTP-HELO, Absender kommt aus einem DialUp-Netzwerk etc… -> Greylisting
  5. SPF-Check (Sender Policy Framework) schlägt fehl -> Greylisting
  6. ansonsten -> E-Mail annehmen
Golov2009a.pdf (docs.google.com) -> S.42


Bley verwendet die Policy-Daemon-Schnittstelle des SMTP-Servers Postfix und ist somit leicht in existierende Umgebungen integrierbar bzw. “policyd-weight” zu ersetzen.
Als Vergleich wurde “bley” & “policyd-weight” auf einem Server mit ca 20.000 E-Mails/Tag getestet, dabei filterte policyd-weight 97,5% der E-Mails als Spam, bley 97%, der Vorteil von bley ist jedoch, dass E-Mails ggf. nicht Verzögert und nicht verloren gehen.
Für den praktischen Einsatz wird die Kombination von bley mit einer inhaltsbasierten Spam-Erkennung (z.B. SpamAssassin) vorgeschlagen. Dadurch, dass bley bereits die meisten Spam-Mails mit minimalem Rechenaufwand auf Protokollebene abweisen kann, müssen rechenaufwändige inhaltsbasierte Verfahren (z.B. SpamAssassin) nur noch auf eine sehr viel geringere Zahl von E-Mails angewendet werden.


Es folgt noch ein kurzes How-To: ;-)


Software nachinstallieren:

aptitude install python-setuptools python-twisted-core python-twisted-names python-spf python-psycopg2 postgresql python-pgsql

bley herunterladen und entpacken:

cd /usr/src
mkdir bley && cd bley
wget http://bley.mx/download/bley-0.1.4.tar.gz
tar xzvf bley-0.1.4.tar.gz
cd bley-0.1.4/

Datenbank anlegen:

su postgres
createuser bley
Enter password for new role: ********
Enter it again: ********
Shall the new role be a superuser? (y/n) n
Shall the new role be allowed to create databases? (y/n) n
Shall the new role be allowed to create more new roles? (y/n) n

createdb --owner=bley bley

exit

bley installieren:

python setup.py build
python setup.py install

cp -vp build/scripts-2.6/bley /usr/bin/

Konfiguration anpassen (Datenbank -> Passwort):

vim /etc/bley/bley.conf

Autostart für bley anlegen:

vim /etc/init.d/bley
#! /bin/sh
### BEGIN INIT INFO
# Provides:          bley
# Required-Start:    $remote_fs $syslog
# Required-Stop:     $remote_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: bley initscript
# Description:       intelligent greylisting daemon for Postfix.
### END INIT INFO

# Author: Evgeni Golov <evgeni@debian.org>

# Do NOT "set -e"

# PATH should only include /usr/* if it runs after the mountnfs.sh script
PATH=/sbin:/usr/sbin:/bin:/usr/bin
DESC="intelligent greylisting daemon for Postfix"
NAME=bley
DAEMON=/usr/bin/$NAME
DAEMON_ARGS=""
DAEMON_USER=$NAME
PIDFILE=/var/run/$NAME/$NAME.pid
SCRIPTNAME=/etc/init.d/$NAME

# Exit if the package is not installed
[ -x "$DAEMON" ] || exit 0

# Read configuration variable file if it is present
[ -r /etc/default/$NAME ] && . /etc/default/$NAME

# Load the VERBOSE setting and other rcS variables
. /lib/init/vars.sh

# Define LSB log_* functions.
# Depend on lsb-base (>= 3.0-6) to ensure that this file is present.
. /lib/lsb/init-functions

# Add pidfile to DAEMON_ARGS
DAEMON_ARGS="-p $PIDFILE $DAEMON_ARGS"

#
# Function that starts the daemon/service
#
do_start()
{
	# Return
	#   0 if daemon has been started
	#   1 if daemon was already running
	#   2 if daemon could not be started

	# prepare /var/run/bley which can be gone if /var/run is cleaned on reboot
	if [ ! -d /var/run/bley ]; then
		mkdir /var/run/bley
		chown bley:bley /var/run/bley
	fi

	# start bley
	start-stop-daemon --start --quiet --pidfile $PIDFILE --startas $DAEMON --test > /dev/null \
		|| return 1
	start-stop-daemon --start --quiet --pidfile $PIDFILE --chuid $DAEMON_USER --startas $DAEMON -- \
		$DAEMON_ARGS \
		|| return 2
	# Add code here, if necessary, that waits for the process to be ready
	# to handle requests from services started subsequently which depend
	# on this one.  As a last resort, sleep for some time.
}

#
# Function that stops the daemon/service
#
do_stop()
{
	# Return
	#   0 if daemon has been stopped
	#   1 if daemon was already stopped
	#   2 if daemon could not be stopped
	#   other if a failure occurred
	start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --pidfile $PIDFILE --name $NAME
	RETVAL="$?"
	[ "$RETVAL" = 2 ] && return 2
	# Wait for children to finish too if this is a daemon that forks
	# and if the daemon is only ever run from this initscript.
	# If the above conditions are not satisfied then add some other code
	# that waits for the process to drop all resources that could be
	# needed by services started subsequently.  A last resort is to
	# sleep for some time.
	start-stop-daemon --stop --quiet --oknodo --retry=0/30/KILL/5 --exec $DAEMON
	[ "$?" = 2 ] && return 2
	# Many daemons don't delete their pidfiles when they exit.
	rm -f $PIDFILE
	return "$RETVAL"
}

case "$1" in
  start)
	[ "$VERBOSE" != no ] && log_daemon_msg "Starting $DESC" "$NAME"
	do_start
	case "$?" in
		0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
		2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
	esac
	;;
  stop)
	[ "$VERBOSE" != no ] && log_daemon_msg "Stopping $DESC" "$NAME"
	do_stop
	case "$?" in
		0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;;
		2) [ "$VERBOSE" != no ] && log_end_msg 1 ;;
	esac
	;;
  status)
       status_of_proc "$DAEMON" "$NAME" && exit 0 || exit $?
       ;;
  restart|force-reload)
	log_daemon_msg "Restarting $DESC" "$NAME"
	do_stop
	case "$?" in
	  0|1)
		do_start
		case "$?" in
			0) log_end_msg 0 ;;
			1) log_end_msg 1 ;; # Old process is still running
			*) log_end_msg 1 ;; # Failed to start
		esac
		;;
	  *)
	  	# Failed to stop
		log_end_msg 1
		;;
	esac
	;;
  *)
	echo "Usage: $SCRIPTNAME {start|stop|status|restart|force-reload}" >&2
	exit 3
	;;
esac

:
chmod +x bley

update-rc.d bley defaults

User anlegen & Rechte setzen:

adduser --system --quiet --disabled-password --no-create-home --home "/var/run/bley" --gecos "intelligent greylisting daemon for Postfix" --group bley
chown root:bley /etc/bley
chmod 750 /etc/bley
chown bley:bley /etc/bley/bley.conf
chmod 600 /etc/bley/bley.conf
vim /etc/bley/bley.conf

log_file = /var/log/bley/bley.log

cd /var/log
mkdir bley
chown bley:bley bley/
mkdir /var/run/bley
chown bley:bley /var/run/bley
/etc/init.d/bley start

Postfix anpassen:

vim /etc/postfix/main.cf
smtpd_recipient_restrictions =
        permit_mynetworks,
        permit_sasl_authenticated,
        #reject_invalid_hostname,
        #reject_unknown_recipient_domain,
        #reject_unauth_pipelining,
        reject_unauth_destination,
        #reject_non_fqdn_hostname,
        #reject_non_fqdn_sender,
        #reject_non_fqdn_recipient,
        #reject_unknown_sender_domain,
        #reject_unknown_recipient_domain,
        #reject_unauth_pipelining,
        #reject_unauth_destination,
        #check_client_access hash:/etc/postfix/rbl_override,
        check_policy_service inet:127.0.0.1:1337,
        ##check_policy_service inet:127.0.0.1:12525,
        #reject_rbl_client multi.uribl.com,
        #reject_rbl_client dsn.rfc-ignorant.org,
        ##reject_rbl_client dul.dnsbl.sorbs.net,
        #reject_rbl_client list.dsbl.org,
        #reject_rbl_client sbl-xbl.spamhaus.org,
        #reject_rbl_client bl.spamcop.net,
        ##reject_rbl_client dnsbl.sorbs.net,
        #reject_rbl_client cbl.abuseat.org,
        ##reject_rbl_client ix.dnsbl.manitu.net,
        #reject_rbl_client combined.rbl.msrbl.net,
        #reject_rbl_client rabl.nuclearelephant.com,
        permit

Linux-Server analysieren

Dieser Blog-Post ist als Antwort auf die Frage “Nun würde mich mal interessieren, welche Tools euch zum Administrieren eines Linux Servers helfen und speziell auch welchen Taskmanager ihr verwendet.”, aus dem folgendem Blog gedacht. -> infoblog.li/besserer-taskmanager-fuer-den-linux-server-htop/

 

1.) Überblick verschaffen

Wenn man nicht genau weiß, wo das Problem liegt, muss man sich erst-einmal einen groben Überblick über die Situation verschaffen, dabei helfen die folgenden Befehle:

 

1.1) top – CPU- und Arbeitsspeicher-Auslastung analysieren

top

Es folgen einige wichtige Tastenkürzel:

1 -> zeigt die Auslastung der einzelnen CPUs an
b / B -> hebt die aktiven Prozesse hervor
z -> wie “b oder B” nur mit Farbe ;-)
i -> zeigt nur aktive Prozesse an
M -> zeigt die Prozesse sortiert nach dem Speicherverbrauch an
P -> zeigt die Prozesse sortiert nach der CPU-Last an
d -> gibt die Aktualisierungszeit an
k -> kill – tötet einen Prozess

(alternativ kann man sich auch mal “htop” anschauen)

 

1.2) df / du – Festplattenverbrauch analysieren

df -h

-h -> auch für Menschen lesbar (–human-readable)

df -h
df -h

 

Wenn wir den Speicherverbrauch nun weiter analysieren müssen, weil z.B. ein Verzeichnis unter /var zu groß ist, können wir dies mit “du” machen.

du -h | grep "^[0-9,]*[MG]" | sort -hr | less

 

Erklärung: “du” gibt die Größe von Dateien und Verzeichnissen aus “-h” zeigt dies leserlich an, “|” der Pipe leitet die Ausgabe weiter, “grep” ist universal einsetzbar, um etwas (Dateien / Ausgaben…) zu durchsuchen und wir suchen alle Zeilen, in denen “^” am Anfang eine Zahl  “0 1 2 3 4 5 6 7 8 9” oder / und “,” in beliebiger Häufigkeit “*” gefolgt von einem großen “M” oder einem “G”. Diese Ausgabe wird per Pipe “|” an “sort” weitergegeben, wo diese Ausgabe nach sortiert wird und “|” schließlich mit “less” angezeigt wird. (mit q kann man less wieder beenden) Wer mehr über Reguläre Ausdrücken lernen möchte, kann sich dies hier antun ;-) -> http://linuxwiki.de/

Wer will kann dich solche “Funktionen” einfach in die .bashrc eintragen…

alias du_suckup='du -h | grep "^[0-9,]*[MG]" | sort -hr | less'

 

1.3) iotop – Festplattenauslastung  analysieren

iotop

Der Befehl “iotop” kann die aktuellen I/O Transferraten für die laufenden Prozesse/Threads anzeigen und greift dazu direkt auf die Informationen vom Kernel zu ( >= v2.6.20 ).

Es folgen wieder einige wichtige Tastenkürzel:

Pfeiltasten – link & rechte -> ändern die Sortierung der Ausgabe, je nach Kategorie
r -> dreht die Sortierung um (reverse)
o -> Zeigt nur noch Prozesse/Threads an, welche auch I/O-Last produzieren
p-> zeigt nur noch Prozesse an (keine Threads )
a -> zeigt nicht mehr die Last in Sekunden an, sondern addiert die I/O fortlaufen (solange iotop läuft)

1.4) lsof – Beziehung zwischen Dateien & Prozessen analysieren

Der Befehl “lsof” kann eingesetzt werden, um z.B. zu analysieren, welcher Prozess oder Anwender momentan eine bestimmte Datei verwendet oder auch welcher User, welchen Port offen hält + die dazugehörige PID (ProzessID)…

lsof -a -i -u www-data

 

lsof - Beispiel
lsof – Beispiel

 

Wer mehr zu dem Thema erfahren möchte, kann in einen alten Blog-Beitrag weiter lesen -> suckup.de/blog/2010/02/22/lsof-list-open-files


2.) Prozesse analysieren

Hier verweise ich einfach mal auf zwei alte Blog-Beiträge.:

2.1) der Befehl “ps”, um bestimmte Prozesse aufzuspüren -> suckup.de/blog/2010/09/14/shell-ps-prozessstatus

2.2) und noch einige Programm, um den verbrauchten Arbeitsspeicher zu analysieren -> suckup.de/blog/2010/02/08/speicherverbrauch-anzeigen-lassen

 

3.) Hardware analysieren

Auch hier verweise ich auf einen alten Beitrag.:

3.1) hier noch eine Sammlung von Befehlen mit denen man z.B. die Festplatte auf Fehler prüfen kann ->  http://suckup.de/blog/2010/02/08/systeminfos-anzeigen-lassen/

 

4.) Netzwerk analysieren

Und auch hier verweise ich auf ein paar alte Beiträge.:

4.1) mit “TCPdump” kannst du den Netztraffik analysieren (sniffen) ähnlich wie Wireshark, nur auf der Konsole. :-) -> suckup.de/blog/2010/08/02/tcpdump-howto

4.2) offene Ports analysieren mit “nmap” + “fuser” -> suckup.de/blog/2010/03/28/offene-ports-analysieren

 

weitere Schritte

Mit Hilfe dieser Befehl sollte man einige Problem bereits eingrenzen können, ich würde parallel unter /var/log/ nachschauen, ob irgendetwas auffälliges in den Logfiles steht …

ls -altr /var/log/

-> Dateien rekursiv nach ihrer letzten Änderung anzeigen (neuste Datei steht nun unten)

tail -f test.log

-> das Logfile wird nun kontinuierlich mit-gelesen, so dass man neu auftretende Fehler bemerkt

Chrome-Cache zum RAM


Endlich mal wieder ein Post über Windows. Heute wollte ich kurz zeigen, dass man den Browser-Cache von Chrome nicht nur unter Ubuntu in den Arbeitsspeicher auslagern kann. ;-)


1.) RAM-Disk erstellen (getestet unter Win7 64-Bit)

Als erstes müssen wir Arbeitsspeicher frei haben, welchen wir gleich als Festplatte einbinden können. (Unter Linux würde man anstatt einer RAM-Disk -> tmpfs verwenden.)


1.1.) Download / Installation von “Dataram_RAMDisk”

http://memory.dataram.com/products-and-services/software/ramdisk


1.2) RAM-Disk anlegen

RAMDisk
RAMDisk
RAMDisk2
RAMDisk2


[stextbox id=”info”]Wer mehr Arbeitsspeicher übrig hat, kann natürlich auch mehr angeben.[/stextbox]


1.3) RAM-Disk formatieren

Start -> Systemsteuerung -> System und Sicherheit -> Verwaltung -> Computerverwaltung -> Datenträgerverwaltung


Nun wirst du direkt darüber benachrichtigt, dass eine neue Festplatte gefunden wurde und wird nun in der Datenträgerverwaltung angezeigt, schnell noch die neue Festplatte formatieren (NTFS) und schon lässt diese sich im Dateimanager finden. Und du kannst bereits ein Verzeichnis mit dem Namen “ChromeCache” anlegen.


[stextbox id=”info”]Du kannst auch andere Caches z.B. vom Firefox etc. hierher verschieben. :-)[/stextbox]


Am besten führen wir nun einen Neu-Start durch und schauen, ob diese nun Reboot-fest ist.


[stextbox id=”warning”]Info: Das Herunterfahren dürfte nun ein-wenig länger dauern, da der Speicher auf die Festplatte geschrieben wird.[/stextbox]


2) Link anlegen

Unter Linux würden wir nun einfach einen symbolischen Link anlegen und genau das selbe machen wir nun auch unter Windows. ;-)


2.1) Download / Installation von “Junction”


Entpacke “junction.exe” und speicher die Datei auf deinem Desktop.


2.2) Junction verwenden


Bevor wir weiter machen können, müssen wir unter …
C:\Users\<USER>\AppData\Local\Google\Chrome\User Data\Default\
… das Verzeichnis Cache umbenenne / löschen / verschieben wie auch immer, zumindest darf es nicht mehr vorhanden sein!


Start -> “Programme/Dateien durchsuchen -> “cmd” eintippen -> rechte Maustaste -> “Als Administrator ausführen”
cd \Users\<USER>\Desktop
z.B.: cd \Users\Lars\Desktop


junction "C:\Users\<USER>\AppData\Local\Google\Chrome\User Data\Default\Cache" E:\ChromeCache

Dies ist natürlich nur ein Beispiel, deine RAM-Disk kann auch einen anderen Buchstaben haben (!E).


chrome-cache
chrome-cache

Fertig…

C-Programm – Umrechnung von Zahlensystemen

Das Programm kann dezimale Zahlen in andere Zahlensysteme umrechnen… sowohl Vorkomma- als auch Nachkommastellen.

#include <stdio.h>

int main(void) {
	float kommazahl, kommazahl_darstellung;
	float array_kommazahl[32], array_kommazahl_ergebnis[32];
	char array_rest[32];
	int y=0, zahl, rest, ergebnis;
	int i=0, j=0, loop=0, basis, genauigkeit=30;

	/* mache etwas (min. 1-mal) ... */
	do { 
		printf("Bitte eine positive Kommazahl eingeben:");
		scanf("%f", &kommazahl);
	/* ... solange die Eingabe kleiner 0 */
	} while (kommazahl < 0);

	/* mache etwas (min 1-mal) ... */
	do {
		printf("Bitte eine Basis >=2 ein:");
		scanf("%d", &basis);
	/* ... solange die Eingabe kleiner 2 */ 
	} while (basis < 2 );

/*
	z.B.: die Dezimalzahl 8 soll ins 2er-System umgewandelt werden

	Verfahren:
	(1) Teile die Zahl mit Rest durch 2.
	(2) Der Divisionsrest ist die naechste Ziffer (von rechts nach links).
	(3) Falls der (ganzzahlige) Quotient = 0 ist, bist du fertig,
		andernfalls nimm den (ganzzahligen) Quotienten als neue Zahl 
		und wiederhole ab (1).

	8 : 2 = 4  Rest: 0
	4 : 2 = 2  Rest: 0
	2 : 2 = 1  Rest: 0
	1 : 2 = 0  Rest: 1

	-> Resultat: 1000
*/

	printf ("\nV O R K O M M A S T E L L E N:\n\n");

	/* nur die Vorkommastellen (Integer = ganze Zahl) in die Variable 'zahl' schreiben */
    zahl = (int) kommazahl;

	while (zahl > 0) { // (3)
		rest = zahl % basis; // (1)
		array_rest[y++] = rest; // Array fuer die umgekehrte Reihenfolge der Ausgabe
		ergebnis = zahl / basis;
		printf("%d : %d = %d  Rest: %d\n", zahl, basis, ergebnis, rest); // Ausgabe 
		zahl = zahl / basis; // (2)
	}

	printf("\n-> Resultat: ");
	while (--y >= 0) { // umgekehrte Reihenfolge der Ausgabe
 		printf("%d", array_rest[y]);
	}


/* 
	z.B: der Dezimalbruch  0,8  soll ins 2er System umgewandelt werden

	Verfahren fuer Nachkommaziffern:
	(1) Multipliziere die Zahl mit der Basis 2
	(2) Die Zahl vor dem Komma ist die naechste Ziffer des Ergebnisses
	(3) Schneide die Zahl vor dem Komma weg.
	(4) Wiederhole ab (1), bis der Rest 0 ist, sich ein Rest wiederholt
		oder die gewuenschte Genauigkeit erreicht ist.

	2 · 0,8 = 1,6    --> Ziffer: 1
	2 · 0,6 = 1,2    --> Ziffer: 1
	2 · 0,2 = 0,4    --> Ziffer: 0
	2 · 0,4 = 0,8    --> Ziffer: 0
	2 · 0,8 = 1,6    --> Ziffer: 1

	Der "Rest" 1,6 trat im 1. Schritt bereits auf.
	Ab dort wiederholen sich die Nachkommaziffern periodisch.

	-> Resultat: 0,1100110011001100110011001100110011001100110011001100...
*/

	printf ("\n\n\nN A C H K O M M A S T E L L E N:\n\n");

	kommazahl = kommazahl - (int) kommazahl; // z.B. kommazahl = 2,5 - 2 = 0,5
	kommazahl_darstellung = kommazahl; // nur zur Veranschaulichung in der Ausgabe

	do {
		kommazahl *= basis; // (1)
		kommazahl = ( (int) (kommazahl * 1000.0 + 0.5)) / 1000.0; // Runden auf 4 Nachkommastellen
		array_kommazahl[j] = kommazahl; // Restwert in ein Array schreiben

		for ( j=0; j < i; j++ ) { 
			// printf("\ntest - [%d][%d] - %f\n", i, j, array_kommazahl[j]); // test - Ausgabe
			if ( array_kommazahl[j] == kommazahl ) { // (4) - Wiederholung feststellen
				loop = j;
			}
		}

		if ( (int) kommazahl == 0 && loop == 0) { // (2)
			printf ("%d * %.1f = %.1f  --> Ziffer: %d\n", basis, kommazahl_darstellung, kommazahl, (int) kommazahl); // Ausgabe
			array_kommazahl_ergebnis[j] = (int) kommazahl;
		} else if ( (int) kommazahl != 0 && loop == 0) { // (2) 
			printf ("%d * %.1f = %.1f  --> Ziffer: %d\n", basis, kommazahl_darstellung, kommazahl, (int) kommazahl); // Ausgabe
			array_kommazahl_ergebnis[j] = (int) kommazahl;
			kommazahl -= (int) kommazahl; // (3)
		}

		if ( loop >= 1 ) {
			printf ("\nDer \"Rest\" von %f trat im %d. Schritt bereits auf.\nAb dort wiederholen sich die Nachkommaziffern periodisch.\n", array_kommazahl[j-1], loop); 
			printf ("\n-> Resultat: 0,");
			for ( j=0; j < i; j++ ) {
				printf ("%d", (int) array_kommazahl_ergebnis[j]);
			}
			printf ("\n");
		}

		if ( kommazahl == 0.0 ) {
			printf ("\nEs ist kein Rest mehr uebrig... :-)");
			printf ("\n-> Resultat: 0,");
			for ( j=0; j < i; j++ ) {
				printf ("%d", (int) array_kommazahl_ergebnis[j]);
			}
			printf ("\n");
		}

		if ( i >= genauigkeit ) {
			printf ("\nDie Genauigkeit sollte nun ausreichen... (%d Bit)", genauigkeit);
			printf ("\n-> Resultat: 0,");
			for ( j=0; j < i; j++ ) {
				printf ("%d", (int) array_kommazahl_ergebnis[j]);
			}
			printf ("\n");
			break;
		}

		kommazahl_darstellung *= basis; // nur zur Veranschaulichung in der Ausgabe
		kommazahl_darstellung = ( (int) (kommazahl_darstellung * 1000.0 + 0.5)) / 1000.0; // nur zur Veranschaulichung in der Ausgabe
		kommazahl_darstellung -= (int) kommazahl_darstellung; // nur zur Veranschaulichung in der Ausgabe

		i++;
		j++;
//	} while ( ( i < genauigkeit ) || !(!(loop == 0 && kommazahl != 0.0 ) && !(loop == 0 && kommazahl != 0.0 )) ); // (4) + Logisches XOR
	} while ( !(!(loop == 0 && kommazahl != 0.0 ) && !(loop == 0 && kommazahl != 0.0 )) ); // (4) + Logisches XOR

	return(0);
}

Backup to USB-Stick per udev


Udev-tux“udev überwacht und wertet hotplug-Ereignisse aus. Finden sich dort Informationen über ein neu angeschlossenes Gerät, werden zusätzliche zu diesem Gerät vorhandene Informationen dem sysfs-Dateisystem entnommen und eine neue Gerätedatei im /dev-Verzeichnis erzeugt. Dabei ist der für die spezielle Datei verwendete Name und die Zugriffsberechtigung frei durch Regeln konfigurierbar.” – wiki


Wir möchten ein Backup auf unseren USB-Stick durchführen, sobald wir diesen mit dem PC verbinden! Dafür müssen wir als erstes einige Infos sammeln, somit schauen wir uns folgnde Datei zeitgleich zum einstecken des USB-Speichers an.


tail -f /var/log/messages

Ausgabe:

Nov  2 22:10:30 suckup-netbook kernel: [13570.309562] scsi 5:0:0:0: Direct-Access     USB 2.0  Flash Drive      8.07 PQ: 0 ANSI: 2

Nov  2 22:10:30 suckup-netbook kernel: [13570.320160] sd 5:0:0:0: Attached scsi generic sg2 type 0

Nov  2 22:10:30 suckup-netbook kernel: [13570.338740] sd 5:0:0:0: [sdc] 3938304 512-byte logical blocks: (2.01 GB/1.87 GiB)

Nov  2 22:10:30 suckup-netbook kernel: [13570.339345] sd 5:0:0:0: [sdc] Write Protect is off

Nov  2 22:10:31 suckup-netbook kernel: [13570.342397]  sdc:

Nov  2 22:10:31 suckup-netbook kernel: [13570.778378] sd 5:0:0:0: [sdc] Attached SCSI removable disk

Somit wissen wir schon einmal, wo sich der Speicher befindet… mit dem folgendem Befehl können wir uns nun alle Partitionen anschauen….
cat /proc/partitions

… und ggf. mit dem nächsten Befehl eine neue Partition anlegen.

fdisk /dev/sda


Als nächstes wollen wir nun die spezifischen Infos vom USB-Stick abfragen:

udevadm info -a -p $(udevadm info -q path -n /dev/sdc)

Ausgabe:

looking at parent device ‘/devices/pci0000:00/0000:00:1d.7/usb1/1-3’:

KERNELS==”1-3″

SUBSYSTEMS==”usb”

DRIVERS==”usb”

[…]

ATTRS{idVendor}==”058f”

ATTRS{idProduct}==”6387″

[…]

ATTRS{manufacturer}==”Generic”

ATTRS{product}==”Mass Storage”

ATTRS{serial}==”9D853A1BCAC440404FEF”

Um das Gerät (USB-Stick) eindeutig zu identifizieren benötigen wir nun die folgenden Angaben: “idVendor”, “idProduct” und “serial”


sudo vim /etc/udev/rules.d/80-backup-stick.rules

KERNEL==”sd?”, ATTRS{idVendor}==”058f“, ATTRS{idProduct}==”6387“, ATTRS{serial}==”9D853A1BCAC440404FEF“, SYMLINK+=”backup-stick“, RUN+=”/home/lars/bin/bash/backup-stick.shBackup‘ ‘to_Stick'”

  • ggf. Partition mit angeben: sd?1
  • RUN+= -> muss der Pfad zu deinem Skript sein
  • idProdukt u.s.w. muss natürlich noch mit den Werten von deinem Stick angepasst werden
sudo /etc/init.d/udev restart


Als nächstes müssen wir ein Skript erstellen, welches auf einem User-Desktop per root eine Pop-Up erzeugen kann…

sudo vim /usr/local/bin/root-notify-send
#!/bin/sh
user=`whoami`
pids=`pgrep -u $user gnome-panel`
title=$1
text=$2
timeout=$3
icon=$4

if [ -z "$title" ]; then
 echo You need to give me a title >&2
 exit 1
fi
if [ -z "$text" ]; then
 text=$title
fi
if [ -z "$timeout" ]; then
 timeout=60000
fi

for pid in $pids; do
 DBUS_SESSION_BUS_ADDRESS=`grep -z DBUS_SESSION_BUS_ADDRESS \
 /proc/$pid/environ | sed -e 's/DBUS_SESSION_BUS_ADDRESS=//'`

 if [ -z $icon ]; then
 DBUS_SESSION_BUS_ADDRESS=$DBUS_SESSION_BUS_ADDRESS \
 notify-send -u low -t $timeout "$title" "$text"
 else
 DBUS_SESSION_BUS_ADDRESS=$DBUS_SESSION_BUS_ADDRESS \
 notify-send -u low -t $timeout -i "$icon" "$title" "$text"
 fi
done
sudo chmod +x /usr/local/bin/root-notify-send


vim ~/bin/bash/backup-stick.sh
#!/bin/bash

su lars -c "/bin/bash root-notify-send "$1" "$2" 6000 "/home/lars/Bilder/backup.png""
mount /dev/backupstick /media/backupstick
su lars -c "/usr/bin/rsync -rlptgzu --delete-after  /home/lars/bin/ /media/backupstick"
umount /media/backupstick

An dieser Stelle macht sich natürlich ein Bild vom Stick besondes gut. ;-) Dann noch schnell ggf. einige Programme nach-installieren, ein Verzeichnis anlegen und Rechte ändern, fertig!

chmod +x ~/bin/bash/backup-stick.sh
sudo aptitude install libnotify-bin rsync
sudo mkdir /media/backupstick




Backup to Stick
Backup to Stick


C-Programm – doppelte Schleife

In diesem Beispiel zeige ich, wie sich eine doppelte Schleife auswirkt…

#include 

main() {
    /* Integer (ganze Zahl) */
    int x,y;

    /* die erste Schleife wird 10-mal durchlaufen */
    for(x=1; x< =10; x=x+1) {
        /* als erstes wird ein Zeillenumbruch (\n) dargestellt */
        printf("\n");

        /* die zweite Schleife befindet sich in der ersten,
           so dass diese jeweills 10*20-mal durchlaufen wird */
        for(y=1; y<=20; y=y+1) {
            /* Feldbreite von 4-Stellen (1234,  34,   4),
               nun wird 1*1, 1*2 [20-mal],
               dann     2*1, 2*2 [20-mal] gerechnet */
            printf("%4i", x*y);
        }
    }
}

/*
   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20
   2   4   6   8  10  12  14  16  18  20  22  24  26  28  30  32  34  36  38  40
   3   6   9  12  15  18  21  24  27  30  33  36  39  42  45  48  51  54  57  60
   4   8  12  16  20  24  28  32  36  40  44  48  52  56  60  64  68  72  76  80
   5  10  15  20  25  30  35  40  45  50  55  60  65  70  75  80  85  90  95 100
   6  12  18  24  30  36  42  48  54  60  66  72  78  84  90  96 102 108 114 120
   7  14  21  28  35  42  49  56  63  70  77  84  91  98 105 112 119 126 133 140
   8  16  24  32  40  48  56  64  72  80  88  96 104 112 120 128 136 144 152 160
   9  18  27  36  45  54  63  72  81  90  99 108 117 126 135 144 153 162 171 180
  10  20  30  40  50  60  70  80  90 100 110 120 130 140 150 160 170 180 190 200
*/