voku, Autor auf SUCKUP.de

C-Programm – Kommandozeilenparameter

In diesem Beispiel zeige ich, wie du Parameter in einem C-Programm einsetzen kannst…

/* 
read_args.c 

Achtung: 
        - bei Platzhaltern (*) !!! Wird hier noch nicht beruecksichtigt
        - die Hilfe ist nur per '-h' und nicht '--help' aufrufbar
        - Fehlermeldungen werden nicht ausgegeben
*/

#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[]) {
        int option, i;
        char *out_filename=NULL;

        /* argc -> Anzahl Kommandozeilenparameter + Programmnamen (1), somit ist der Wert min. 1 */

        /* argv -> ist ein Zeiger auf das Feld (Array) mit der in argc angegebene Anzahl von Elementen...
                   ... und die Elemente (z.B.: argc[0] sind Zeiger auf eine Zeichenkette...

                   arg[0] -> Programmname
                   arg[1] -> 1. Parameter 
                   arg[2] -> 2. Parameter
                   [...]
                   arg[n] -> letzter Parameter
                    0L    -> das letzte Element von argv[] einthaelt eine Null
        */

        /* 
           getopt() sortiert zunaechst das Feld argc[] 
           1. Optionen
           2. Argumente

           Rueckgabewert: erste in der Kommandozeile angegebene Option oder -1 wenn keine Option angegeben wurde...
                          ... beim naechen Durchlauf jeweills die naechste angegebene Option...
                          ... und zum Schluss -1

           x:  -> 'x' waehre hier eine Option
           x:: -> 'x' waehre hier eine optinale Option
           xy: -> 'x' und 'y' waehren hier die Optionen (Optionsliste)  
        */
        while((option = getopt(argc, argv, "ho:")) >= 0) {
                switch(option) {
                        case 'h':
                                printf("Usage: %s [-o output-file] [input-file ...]\n", argv[0]);
                                return(0);
                        case 'o':
                                out_filename = optarg;
                                break;
                        /* wenn ein unzulaessige Option angegeben wurde, gibt getopt() ein '?' aus */
                        case '?':
                                return(1); /* unbekannte Option ... Abbruch */
                }
                /* die globale Variable 'optind' gibt den Index des ersten Arguments dem Feld argv[] weiter */
                for (i=optind; i<argc; i++) {
                        printf("'%s'\n", argv[i]);
                }
                if (out_filename) {
                        printf("output is '%s'\n", out_filename);
                }
        }
        return(0);
}

/*
Ausgabe:
./read_args -o test1 1 2 3 4 5 
'1'
'2'
'3'
'4'
'5'
output is 'test1'
*/

C-Programm – Primzahlen & Makefiles

Das folgende Programm gibt alle Primzahlen von 1 bis 100 aus, dabei wurde die Berechnung in eine eigene Funktion ausgelager.

/*
primzahlen.c
*/

#include <stdio.h>
#include <math.h>

/*
gcc -Wall -lm primzahlen.c -o primzahlen -O3
*/

int ist_primzahl(int zahl) {
    int teiler=2;

    /* solange der 'teiler' kleiner/gleich der (²)Wurzel aus 'zahl' ist ...
    ...  denn Primzahlen haben -keinen- Teiler der kleienr als dessen Quadratwurzel ist */
    while (teiler <= sqrt(zahl)) {
    /* alternativ, dann ohne <math.h> */
    /* while (teiler*teiler <= zahl) { */
        /* wenn kein Rest, dann... */
        if (zahl % teiler == 0) {
            /* ... 'false' */
            return(0);  /* 'zahl' ist keine Primzahl */
        }
        /* teiler und einen erhoehen */
        teiler++;
    }
    /* ... ansonsten 'true' */
    return(1);          /* 'zahl' ist eine Primzahl */
}

int main() {
    int zahl;

    /* solange bis 1 nicht mehr kleiner/gleich 100 bis, 1 erhoehen */
    for (zahl=1; zahl<=100; zahl++) {
        /* wenn Funktion='true' dann ...*/
        if (ist_primzahl(zahl)) {
            /* ... Zahl ausgebn */
            printf("%d\n", zahl);
        }
    }
    return(0);
}

Bei großen Projekten kann es hilfreich sein, diese Funktionen in verschiedenen Dateien zu organisieren und später wieder zusammen zu fügen…

1.) Den Quellcode in einen beliebigen ASCII-Texteditor eintippen und abspeichern.

2.) Den Quellcode mit einem Compiler übersetzen, wodurch eine Objektdatei (*.pbj oder *.o) erzeugt wird.

3.) Die Objektdatei mit einem Linker binden, so dass eine ausführbare Datei erzeugt wird. Der Linker sucht außerdem alle benötigten Funktionen aus den Standard-Bibliotheken heraus und fügt diese anschließend dem fertigen Programm hinzu.

zu 2.)

gcc -c primz_haupt.c
gcc -c primz_math.c

zu 3.)

gcc primz_haupt.o primz_math.o -lm -O3 -Wall -o primzahl

/*
primz_haupt.c
*/

#include <stdio.h>
#include "primz_math.h"

int main() {
        int zahl;

        for(zahl=1; zahl<=100; zahl++) {
                if (ist_primzahl(zahl)) {
                        printf("%d\n", zahl);
                }
        }
        return(0);
}

/*
primz_math.c
*/

#include <math.h>

int ist_primzahl(int zahl) {
        int teiler=2;

        while(teiler <= sqrt(zahl)) {
                if(zahl % teiler == 0) {
                        return(0);
                }
                teiler++;
        }
        return(1);
}

Um die zuvor beschriebene Prozedur zu beschleunigen, gibt es die sogenannten Makefiles, welche alle Informationen zum kompilieren enthalten und den Prozess somit automatisch durchführen können.

Als erstes ein ausführliches Beispiel:

# Makefile
#

#4.) 'primz_haupt.o' + 'primz_math.o' zusammenfuehren
primzahl:       primz_haupt.o primz_math.o
                gcc primz_haupt.o primz_math.o -lm -o primzahl

#3.) 'primz_haupt.o' erzeugen + 'primz_math.h' einfuegen
# Info: 'primz_math.h' ist die Verknuepfung zu 'primz_math.c'
primz_haupt.o:  primz_haupt.c primz_math.h
                gcc -c primz_haupt.c

#2.) 'primz_math.o' erzeugen
primz_math.o:   primz_haupt.c
                gcc -c primz_math.c

#1.) aufraeumen
clean: 
                rm -f primz_haupt.o prinz_math.o

Und hier die komprimierte Version: :-)

# Makefile2
#

TARGET  = primzahl
OBJECTS = primz_haupt.o primz_math.o
HEADERS = primz_math.h
LIBS    = -lm

$(TARGET):      $(OBJECTS)
                gcc $^ $(LIBS) -o $@

primz_%.o:      primz_%.c $(HEADERS)
                gcc -c $&lt; -o $@

clean: 
                rm -f $(OBJECTS)

C-Programm – Größe von Variablen

Mit diesem kleinem Programm kannst du dir die minimale und maximale Größe von Variablen ausgeben lassen. :-)

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main(void) {
        printf("min. char-Wert          : %d\n", SCHAR_MIN);
        printf("max. char-Wert          : +%d\n", SCHAR_MAX);
        printf("min. unsigned-char      : 0\n");
        printf("max. unsigned-char      : %u\n\n", UCHAR_MAX);

        printf("min. short-Wert         : %d\n", SHRT_MIN);
        printf("max. short-Wert         : +%d\n", SHRT_MAX);
        printf("min. unsigned-short     : 0\n");
        printf("max. unsigned-short     : %u\n\n", USHRT_MAX);

        printf("min. int-Wert           : %d\n", INT_MIN);
        printf("max. int-Wert           : +%d\n", INT_MAX);
        printf("min. unsigned-int       : 0\n");
        printf("max. unsigned-int       : %u\n\n", UINT_MAX);

        printf("min. long-Wert          : %ld\n", LONG_MIN);
        printf("max. long-Wert          : +%ld\n", LONG_MAX);
        printf("min. unsigned-long      : 0\n");
        printf("max. unsigned-long      : %lu\n\n", ULONG_MAX);

        printf("min. long long-Wert     : %lld\n", LLONG_MIN);
        printf("max. long long-Wert     : +%lld\n", LLONG_MAX);
        printf("min. unsigned-llong     : 0\n");
        printf("max. unsigned-llong     : %llu\n\n", ULLONG_MAX);


        printf("min. float-Wert         : %f\n", FLT_MIN);
        printf("max. float-Wert         : +%f\n", FLT_MAX);
        printf("float Genauigkeit       : %d\n\n", FLT_DIG);

        printf("min. double-Wert        : %lf\n", DBL_MIN);
        printf("max. double-Wert        : +%lf\n", DBL_MAX);
        printf("double Genauigkeit      : %d\n\n", DBL_DIG);

        printf("min. long double        : %Lf\n", LDBL_MIN);
        printf("max. long double        : +%Lf\n", LDBL_MAX);
        printf("long double Genu.       : %d\n\n", LDBL_DIG);

        return 0;
}

Ausgabe:

min. char-Wert : -128
max. char-Wert : +127
min. unsigned-char : 0
max. unsigned-char : 255

min. short-Wert : -32768
max. short-Wert : +32767
min. unsigned-short : 0
max. unsigned-short : 65535

min. int-Wert : -2147483648
max. int-Wert : +2147483647
min. unsigned-int : 0
max. unsigned-int : 4294967295

min. long-Wert : -2147483648
max. long-Wert : +2147483647
min. unsigned-long : 0
max. unsigned-long : 4294967295

min. long long-Wert : -9223372036854775808
max. long long-Wert : +9223372036854775807
min. unsigned-llong : 0
max. unsigned-llong : 18446744073709551615

min. float-Wert : 0.000000
max. float-Wert : +340282346638528859811704183484516925440.000000
float Genauigkeit : 6

min. double-Wert : 0.000000
max. double-Wert : +179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889[…]

min. long double : 0.000000
max. long double : +1189731495357231765021263853030970205169063322294624200440323733891737005522970722616410290336528882853545697807495577314427443153670[…]

Wenn du das nächste C-Programm einmal kompiliert hast und es mehrere male nacheinander ausführst siehst du, dass die Variable ggf. an einer anderen Stelle im Speicher abgelegt wurde.

#include <stdio.h>

int main(void) {
        int var=0;
        printf("Die Adresse von var lautet: %p\n", &var);
        return 0;
}

C-Programm – letzte Ziffer anzeigen

Die letzte Ziffer einer Zahl ausgeben lassen…

#include <stdio.h>

void main(void) {
    int n,letzteZiffer;

    /* 
       
      n mod 10 
    = n % 10 
    = Rest, nach der Division durch 10
     
    "Die Division mit Rest (Modulo) wird in der Programmierung relativ häufig verwendet. 
    Die Syntax ist dabei die eines Operators. Mit mod kann geprüft werden, 
    ob eine Zahl gerade ist: if ( (x mod 2) == 0), dann ist x gerade. 
    Modulo kann man immer benutzen, wenn man alle X Schleifendurchläufe einen speziellen 
    Programmcode ausführen will. Auch bei vielen Berechnungen und Algorithmen ist er 
    sinnvoll einsetzbar. Allgemein kann man mit mod prüfen, 
    ob eine Zahl durch eine andere genau teilbar ist, dann ist der Modulo nämlich Null." - wiki

    */

    printf("Bitte eine Zahl eingeben: ");
    scanf("%d", &n);
    letzteZiffer = n % 10;
    printf("\nletzteZahl %d\n", letzteZiffer);
}

Wie interpretiert man DSL-Informationen

“Mit Asymmetric Digital Subscriber Line (ADSL, engl. „asymmetrischer, digitaler Teilnehmer-Anschluss“) wird die zur Zeit häufigste Anschlusstechnik von Breitbandanschlüssen für Konsumenten bezeichnet. Sie wurde auf Basis der DSL-Technik mit der Maßgabe entwickelt, über die vorhandene Telefonanschlussleitung zu funktionieren, ohne die Telefonie über den Festnetzanschluss zu beeinträchtigen, und gleichzeitig den meist asymmetrischen (ungleichen) Datenratenbedürfnissen der Privatkunden nach höherer Empfangs- als Sendedatenrate nachzukommen.” – wiki

ADSL ist im Gegensatz zu SDSL weiter verbreitet und um einiges günstiger, da man zwar hohe Downloadraten, jedoch nicht so hohe Uploadraten erzielt. Das Übertragungsverfahren für ADSL wird über die bestehende Telefonverkabelung realisiert, es handelt sich um ein asymmetrisches breitbandiges Datenübertagungsverfahren (SDSL = symmetrische), welches auf die herkömmliche Kupfer-Doppelader im Anschlussbereich geschaltet wird. Zur ADSL-Kommunikation muss auf beiden Seiten der Anschlussleitung ein ADSL-Modem installiert sein, sowohl in der Ortsvermittlungsstelle als auch beim Teilnehmer, daher hängt die max. Geschwindigkeit der Leitung auch maßgeblich von der Entfernung zur Hauptvermittlungsstelle (HVT) und die Qualität (dicke) des eingesetzten Kabels ab. Hier noch schnell ein Link, wo du die Vermittlungsstellen finden kannst -> “www.schmalbandatlas.de/atlas/“. Wenn du nun einige Kilometer von solche einer Stelle entfernt wohnst, ist dies noch nicht weiter schlimm, da du wahrscheinlich über einen von zirka 300.000 Kabelverzweigeren (KVZ) mit dem HVT verbunden bist.

DSL-Leitungs-Informationen kann man in jedem handelsüblichen DSL-Modem finden, diese Werte können nützliche sein um z.B. Probleme von ADSL einzugrenzen oder Leitungsfehler festzustellen. Die Werte können außerdem als grober Richtwert dafür verwendet werden, ob eine Leitung mit höheren Geschwindigkeiten laufen könnte oder eben nicht!

Welche Zahlen musst du dir anschauen?

Verschiedene Router bezeichnen diese Zahlen unterschiedlich, aber die wichtigsten Werte (Zahlen), sollten in etwa folgende Bezeichnung haben: (ADSL-Status / Statusübersicht)

Connection-, Sync-Speed oder Rate
Attenuation / Dämpfung oder Atten oder Loop loss
SNR Margin oder Noise Margin oder Noise oder Margin
Einzelheiten über etwaige CRC / HEC / RS / FEC Fehler und fehlerbehaftete Sekunden können ebenfalls hilfreich sein.

Es gibt natürlich auch Router / Modems welche noch weitere Zahlen & Fakten welche eventuell helfen können die Leitung zu analysieren, anzeigen. Jedoch sollten die meisten Geräte die soeben genannten Dinge anzeigen können.

Was ist “Sync Speed”?

Die Geschwindigkeit, mit der der Router synchronisiert (verbindet), dies wird vom Provider entweder “fest” eingetragen oder wird “dynamisch” mit der Gegenstelle ausgehandelt, so dass deine Leitung ggf. mit weniger Bandbreite synchronisiert, wenn z.B. die Qualität der Leitung schlechter wird. (die Leitung kann z.B. schlechter werden, wenn plötzlich alle deine Nachbarn einen DSL-Anschluss haben und somit sich diese Leitungen in der Vermittlungsstelle gegenseitig stören.

Daher ist es auch nicht ungewöhnlich, wenn du nach einem Reboot deines Routers eine andere Geschwindigkeit angezeigt bekommst.

Es ist wichtig zu bedenken, dass der “Sync Speed” nicht deine “wahre Geschwindigkeit” ist, mit welcher du downloaden kannst. Solche Dinge wie der “TCP/IP Overhead” führen dazu, dass eine Leitung welche mit z.B. 8128 kbps synchronisiert ist, einen maximalen Durchsatz-Geschwindigkeit von rund 7,1 MB hat (ca. 13% weniger).

Was ist Dämpfung?

Leitungsdämpfung steht im Zusammenhang mit “loop lose”, je niedriger dieser Wert ist desto besser und desto bessere sind deine Chancen immer eine hohe Geschwindigkeiten zu haben.

Der Begriff Dämpfung wird verwendet, um die Reduktion der ADSL-Signalstärke, die auf dem Kupferkabel über größere Entfernungen auftritt zu beschreiben. Die Dämpfung wird in dB (Dezibel) gemessen und je weiter du vom der Vermittlungsstelle entfernt bist, desto höher steigen die Dämpfungswerte bzw. mit desto mehr Signal-Verluste treten auf.

Dämpfung ist exponentiell, somit halbiert jeweils 3dB Dämpfung die Stärke des Signals. Erhält man daher mit 30dB Dämpfung nur 1/1.000 der Signalstärke, so erhält man mit 60dB nur noch 1/1.000.000 der Signalstärke.

Die wahre Leitungsdämpfung kann nur am DSLAM, in der Vermittlungsstelle gemessen werden (DSLAM = DSL Adress Multiplexer) – hier werden die Daten vieler DSL Nutzer (Adressaten) zusammenfasst (Multiplex) und in das schnelle ATM Netz einspeist) Jedoch kann unser Router uns bereits einen Richtwert anzeigen.

Wenn man höhere Frequenzen / Geschwindigkeiten auf einer Leitung fährt (500kb zu 2Mb) ist es sehr wahrscheinlich, dass die Dämpfungswerte nach oben gehen, da höhere Frequenzen, wie sie verwendet werden, um höhere Geschwindigkeiten zu übertragen eher gedämpft werden (höhere Frequenzen = höhere Dämpfung).

ADSL2+ hat eine erhöhte Frequenz-Spektrum, also eine erhöhte Dämpfung von ca. 3-4dB. Als sehr grobe Orientierung:

Eine Geschwindigkeitssteigerung von 4MB bewirkt ~1dB Erhöhung der Dämpfung.

Da unterschiedliche Router verschieden mit den Frequenzen zurechtkommen, kann es sein, dass Router nicht auf 1Mb bei einer weiten Entfernung zur Vermittlungsstelle synchronisieren andere Modelle hingegen schon. Sehr gute Erfahrungen hab ich hier mit SpeedTouch-Geräten gemacht. :-)

Was ist SNR?

SNR Signal to Noise Ratio – in anderen Worten: eine Messung in Dezibel der Signalstärke auf der Leitung. Um die Information sicher aus dem Signal extrahieren zu können, muss sich das Nutzsignal deutlich vom Hintergrundrauschen abheben, das SNR muss also ausreichend groß sein. Fällt das SNR, steigt die Fehlerrate. Dem SNR entspricht bei der Digitalübertragung die Bitfehlerrate und je höher dein SNR-Wert ist, desto besser, da es weniger Nebengeräusche gibt. :-)

SNR schwankt auf allen Leitungen im Laufe des Tages durch verschiedene Faktoren. Die Signalstärke ist in der Regel am Morgen besser als am Abend, da am Abende mehr “Lärm” auftritt, da mehr Menschen zu Hause sind und somit elektromagnetisches Rauschen verursachen. Die Liste der Stör-Quellen ist lang… es können Fernseher, PCs, Beleuchtung, Heizung, Pumpen etc. sein.

Eine einfache bildliche Beschreibung von SNR:

“Du” bist der DSLAM in der Vermittlungsstelle (links)
“Ihre Stimme” ist das DSL-Signal. (blaue Linie)
“Dein Freund” ist der Router bei dir @ home (rechts)
Die “Musik” sind generelle Hintergrundgeräusche aus verschiedenen elektromagnetischen Quellen (unten)
Die “andern Gespräch” sind alle anderen DSL-Anschlüsse in deiner Nähe (oben)

Dein Freund kann dich besser verstehen, wenn du näher bei Ihm bist, als wenn er auf der anderen Seite des Raumes ist, dies entspricht dem Abstand zwischen deiner Wohnung und der Vermittlungsstelle – je weiter man von der Vermittlungsstelle weg wohnen, desto schlechter die Signale und so anfälliger ist die Leitung für Störsignale (Lärm).

Jede Leitung muss eine bestimmte Menge an SNR haben, um bei einer bestimmten Geschwindigkeit zu funktionieren. Sehr grob kann man sagen, dass 1dB (SNR) entspricht 450 kbps der Geschwindigkeit, aber auch andere Faktoren wie die Dämpfung und Leistung müssen im Auge behalten werden.

Was ist SNR Margin?

SNR Margin resultiert aus SNR, ist aber nicht das Gleiche. SNR Margin könnte als “Pufferzone” bezeichnet werden, die es gibt, um Verbindung gegen normale SNR-Schwankungen, welche täglich auftauchen zu schützen.

Die meistern Standard-Router zeigen in der Regel die “SNR Margin” und nicht der “SNR-Wert” an, unabhängig von der angezeigten Bezeichnung. Je nach Hersteller kann dies “Receive Margin”, “SNR”, “Noise” oder jede Variation davon sein oder es kann auch zu SNRM oder Noise Margin abgekürzt werden.

SNR Margin ist die Differenz zwischen dem tatsächlichen und dem SNR und dem benötigtem SNR, um bei einer bestimmten Geschwindigkeit stabil zu laufen. Zum Beispiel, wenn Ihre Leitung 35dB SNR haben muss, um auf 8Mbps zu laufen, und die aktuelle Leitung einen SNR von 41dB hat, dann ist die SNR Margin 6dB.

Wenn somit dein “SNR Margin”-Wert zu niedrig ist, kann die Leitung zusammen brechen, welche auch zwischen-zeitig auftreten können, somit ist ein Blick auf deinen “SNR Margin”-Wert oft eine nützliches Mittel ADSL-Fehler festzustellen. Dämpfung und SNR Margin sind unabhängige voneinander, so kannst du eine gute Dämpfung haben, aber einen schlechten (niedrigen) SNRM – oder umgekehrt.

Was ist Target SNR Margin?

Wenn der Sync-Speed automatisch ausgehandelt wird, muss man jedoch noch einen gewissen Rahmen angeben, so teilt man seinem Modem mit, dass man einen Target SNR Margin von z.B. 10dB wünscht und es die Verbindung so herstellen soll. (Dies kann jedoch auch nicht bei allen Routern angegeben werden.) Wenn du z.B. eine Fritzbox im Einsatz hast und Verbindungsabbrüche feststellst, dir dann deine “SNR Margin” anschaust und diese sehr niedrig ist, solltest du einmal ein anderes Gerät an deinem Anschluss ausprobieren, da die Fritzbox besonders schnelle Verbindungen aufzubauen versucht und den “Target SNR Margin”-Wert zu niedrig ansetze. Warum AVM das macht? Es könnte daran liegen, dass man anderen (besseren) Modems in punkto Geschwindigkeit nicht nachstehen möchte.

Somit spielt die Target SNR Margin eine wichtige Rolle bei der Synchronisierung zwischen deinem Router und dem DSLAM in der Vermittlungsstelle. Target SNRM beeinflusst die Geschwindigkeit, mit der wir Synchronisieren und legt die anfängliche SNR Margin (Pufferzone) fest und ist somit die (grobe) Voreinstellung der SNR Margin unmittelbar nach einer Resynchronisation.

Meist werden 6dB, 9dB, 12dB oder 15dB als Profile verwendet, wobei 6dB der Standardwert ist. Längere Strecken sind anfälliger für Störungen (Lärm) und benötigen daher oft eine höheren Wert als kürzere Leitungen.

Es ist wichtig zu beachten, dass auf sehr guten Leitungen, die in der Lage sind mit über 8 MB zu synchronisieren und die derzeit mit 8128 oder 7616 Synchronisiert sind, der SNR Margin-Wert als höher eingestuft ist, da die “output power” ggf. reduziert wurde, um Störungen von anderen Leitungen zu minimieren und somit wäre der SNRM-Wert “verfälscht”.

Wie schnell sollte meine Verbindung sein?

Dies hängt ganz von der Entfernung von der Vermittlungsstelle und den Zustand Ihrer Telefonleitung ab.

Du kannst einen groben Wert aus deiner Leitungsdämpfung und deiner Leitungslänge berechnen lassen, jedoch spielen hier noch Unmengen andere Stör-Quellen eine Rolle, wodurch deine Geschwindigkeit in der Realität stark von deinem Ergebnis abweichen kann.

-> www.kitz.co.uk/adsl/max_speed_calc.php

Was sind BT Fixed Rate Grenzen?

Idealerweise sollte deine Leitungslänge unterhalb von 3,5 km sein, um eine 2Mb Verbindung zu bekommen und 6km, für eine 1Mb Verbindung nicht überschreiten.

Auf einigen Leitungen kann man ein festes Profil einstellen, dies kann hilfreich sein, wenn man z.B. große Schwankungen von SNR hat, welche in guten Zeiten mit hohen Geschwindigkeiten synchronisieren und dann öfter zusammenbrechen.

Dämpfung	Geschwindigkeit	Sync Down	Sync Up	Profil
> 60dB	512 kbps	576	64-288	Profil 500
43 bis 60 dB	1 Mbps	1152	288	Profil 1000
<= 42 dB	2 Mbps	2272	288	Profil 2000

63.5 dB Dämpfung?

Der Grund dafür, dass einige Router / Modems eine maximale Dämpfung von 63.5 dB anzeigen, ist das im G.992.1-Standard folgendes steht, -> “Die Dämpfung reicht von 0 bis 63,5 dB mit 0,5 dB-Schritten.” Daher haben viele Firmware-Versionen diese als Grundlage und sind daher buchstäblich nur bis 63.5dB ausgelegt. Wenn dein Router 63.5dB anzeigt, dann kann es sein, dass die Dämpfung in Wirklichkeit höher ist.

Quelle:

http://www.kitz.co.uk/adsl/linestats.htm

Nginx + Varnish auf Debian/Ubuntu

Zurück zur “Webseiten beschleunigen” – Übersicht

5.4) Nginx mit Varnish

“Varnish ist ein Web-Beschleuniger für dynamische Web-Seiten mit viel Inhalt. Im Gegensatz zu anderen Web-Beschleunigern, die häufig aus clientseitigen Proxies oder aus Servern entstanden, wurde Varnish von Grund auf als Web-Beschleuniger konzipiert.” – Wiki

Als erstes erweitern wir unsere sources.list, so dass wir die Varnish-Software einfach installieren / updaten können:

Ubuntu:

echo "http://repo.varnish-cache.org/ubuntu/ lucid varnish-2.1" >> /etc/apt/sources.list

Debian:

echo "deb http://repo.varnish-cache.org/debian/ lenny varnish-2.1" >> /etc/apt/sources.list

Nun installieren wir Varnish…

curl http://repo.varnish-cache.org/debian/GPG-key.txt | apt-key add -
aptitude install varnish

Nun müssen wir einige Eistellungen an Varnish vornehmen, so dass dieser als erstes angesprochen wird…

vim /etc/default/varnish

# Configuration file for varnish
#
# /etc/init.d/varnish expects the variables $DAEMON_OPTS, $NFILES and $MEMLOCK
# to be set from this shell script fragment.
#

# Should we start varnishd at boot?  Set to "yes" to enable.
START=yes

# Maximum number of open files (for ulimit -n)
NFILES=131072

# Maximum locked memory size (for ulimit -l)
# Used for locking the shared memory log in memory.  If you increase log size,
# you need to increase this number as well
MEMLOCK=82000

# Default varnish instance name is the local nodename.  Can be overridden with
# the -n switch, to have more instances on a single server.
INSTANCE=$(uname -n)

## Configuration with VCL
#
DAEMON_OPTS="-a :80 \
             -T localhost:6082 \
             -f /etc/varnish/default.vcl \
             -S /etc/varnish/secret \
             -s file,/var/lib/varnish/$INSTANCE/varnish_storage.bin,1G"

## TEST
#
#DAEMON_OPTS="-a :80 \
#             -T localhost:6082 \
#             -f /etc/varnish/default.vcl \
#             -s malloc,512M \
#             -p lru_interval=3600 \
#             -p thread_pool_max=2000 \
#             -p listen_depth=2048 \
#             -p 'cc_command=exec cc -fpic -shared -Wl,-x -L/usr/include/libmemcached/memcached.h -lmemcached -o %o %s' \
#             -h classic,500009 \
#             -t 0"

## Alternative 3, Advanced configuration
#
# See varnishd(1) for more information.
#
# # Main configuration file. You probably want to change it :)
# VARNISH_VCL_CONF=/etc/varnish/default.vcl
#
# # Default address and port to bind to
# # Blank address means all IPv4 and IPv6 interfaces, otherwise specify
# # a host name, an IPv4 dotted quad, or an IPv6 address in brackets.
# VARNISH_LISTEN_ADDRESS=
# VARNISH_LISTEN_PORT=6081

#
# # Telnet admin interface listen address and port
# VARNISH_ADMIN_LISTEN_ADDRESS=127.0.0.1
# VARNISH_ADMIN_LISTEN_PORT=6082
#
# # The minimum number of worker threads to start
# VARNISH_MIN_THREADS=1
#
# # The Maximum number of worker threads to start
# VARNISH_MAX_THREADS=1000
#
# # Idle timeout for worker threads
# VARNISH_THREAD_TIMEOUT=120
#
# # Cache file location
# VARNISH_STORAGE_FILE=/var/lib/varnish/$INSTANCE/varnish_storage.bin
#
# # Cache file size: in bytes, optionally using k / M / G / T suffix,
# # or in percentage of available disk space using the % suffix.
# VARNISH_STORAGE_SIZE=1G
#
# # File containing administration secret
# VARNISH_SECRET_FILE=/etc/varnish/secret
#
# # Backend storage specification
# VARNISH_STORAGE="file,${VARNISH_STORAGE_FILE},${VARNISH_STORAGE_SIZE}"
#
# # Default TTL used when the backend does not specify one
# VARNISH_TTL=120
#
# # DAEMON_OPTS is used by the init script.  If you add or remove options, make
# # sure you update this section, too.
# DAEMON_OPTS="-a ${VARNISH_LISTEN_ADDRESS}:${VARNISH_LISTEN_PORT} \
#              -f ${VARNISH_VCL_CONF} \
#              -T ${VARNISH_ADMIN_LISTEN_ADDRESS}:${VARNISH_ADMIN_LISTEN_PORT} \
#              -t ${VARNISH_TTL} \
#              -w ${VARNISH_MIN_THREADS},${VARNISH_MAX_THREADS},${VARNISH_THREAD_TIMEOUT} \
#              -S ${VARNISH_SECRET_FILE} \
#              -s ${VARNISH_STORAGE}"
#

Nun muss du die Konfig anpassen, ich zeige hier ein Beispiel für meinen WordPress Blog… ggf. musst du für deine Webseiten jedoch noch weitere Einstellungen ändern.

vim /etc/varnish/default.vcl

backend default {
        .host = "127.0.0.1";
        .port = "8080";
}

acl purge {
        "localhost";
}

sub vcl_fetch {
        set beresp.ttl = 12h;
        set req.grace = 24h;
        if (req.url ~ "wp-(login|admin)") {
                return (pass);
        }
        if (req.url ~ "feed") {
                return (pass);
        }
        return (deliver);
        unset beresp.http.set-cookie;
        if (req.url ~ "\.(jpeg|jpg|png|gif|ico|swf|js|css|txt|gz|zip|rar|bz2|tgz|tbz|html|htm|pdf|pls|torrent)$") {
                set beresp.ttl = 48h;
        }

        remove req.http.X-Forwarded-For;
        set    req.http.X-Forwarded-For = req.http.rlnclientipaddr;
        if (req.url ~ "^/w00tw00t") {
                error 403 "Not permitted";
        }
        return(deliver);
}

sub vcl_deliver {
        if (obj.hits > 0) {
                set resp.http.X-Cache = "HIT";
                set resp.http.X-Cache-Hits = obj.hits;
        } else {
                set resp.http.X-Cache = "MISS";
        }
        remove resp.http.X-Varnish;
        remove resp.http.Via;
        remove resp.http.Age;
        remove resp.http.X-Powered-By;
}

sub vcl_recv {
        set req.grace = 6h;
        if (req.request == "PURGE") {
                if(!client.ip ~ purge) {
                        error 405 "Not allowed.";
                }
                purge("req.url ~ ^" req.url "$ && req.http.host == "req.http.host);
        }
        if (req.url ~ "\.(jpg|png|gif|gz|tgz|bz2|lzma|tbz)(\?.*|)$") {
                remove req.http.Accept-Encoding;
        } elsif (req.http.Accept-Encoding ~ "gzip") {
                set req.http.Accept-Encoding = "gzip";
        } elsif (req.http.Accept-Encoding ~ "deflate") {
                set req.http.Accept-Encoding = "deflate";
        } else {
                remove req.http.Accept-Encoding;
        }
        if( req.url ~ "^/wp-(login|admin)" || req.http.Cookie ~ "wordpress_logged_in_" ) {
                return (pass);
        }
        if (!(req.url ~ "wp-(login|admin)")) {
                unset req.http.cookie;
        }
        if (req.request != "GET" &&
                req.request != "HEAD" &&
                req.request != "PUT" &&
                req.request != "POST" &&
                req.request != "TRACE" &&
                req.request != "OPTIONS" &&
                req.request != "DELETE") {
                return (pipe);
        }
        if (req.request != "GET" && req.request != "HEAD") {
                return (pass);
        }
        if (req.http.Authorization || req.http.Cookie) {
                return (pass);
        }
        if (req.url ~ "\.(jpeg|jpg|png|gif|ico|swf|js|css|txt|gz|zip|rar|bz2|tgz|tbz|html|htm|pdf|pls|torrent)(\?.*|)$") {
                unset req.http.Authenticate;
                unset req.http.POSTDATA;
                set req.request = "GET";
                set req.url = regsub(req.url, "\?.*$", "");
                return (lookup);
        }
        unset req.http.cookie;
        return (lookup);
}

sub vcl_pipe {
        set bereq.http.connection = "close";
        if (req.http.X-Forwarded-For) {
                set bereq.http.X-Forwarded-For = req.http.X-Forwarded-For;
        } else {
                set bereq.http.X-Forwarded-For = regsub(client.ip, ":.*", "");
        }
}

sub vcl_pass {
        set bereq.http.connection = "close";
        if (req.http.X-Forwarded-For) {
                set bereq.http.X-Forwarded-For = req.http.X-Forwarded-For;
        } else {
                set bereq.http.X-Forwarded-For = regsub(client.ip, ":.*", "");
        }
}

Parallel müssen wir nun unseren Webserver, egal ob Apache oder in diesem Fall Nginx, auf den Port 8080 lauschen lassen. Beim Nginx ist dies relativ simpel, du muss nur “listen 80” -> “listen 8080” ändern. Ich zeige an dieser Stelle jedoch einmal meine Nginx-Konfiguration für meinen WordPress Blog.

[stextbox id=”warning”]Wie immer gilt, erst verstehen, dann kopieren… :-)[/stextbox]

server {
        listen 8080;
        server_name suckup.de www.suckup.de blog.voku-online.de linux.voku-online.de windows.voku-online.de ubuntu.voku-online.de allgemein.voku-online.de cdn1.voku-online.de cdn2.voku-online.de cdn3.voku-online.de cdn4.voku-online.de cdn5.voku-online.de *.suckup.de;
        root /var/www/www.suckup.de/web/;
        index index.php;
        access_log /var/log/nginx/suckup.access.log main;
        error_log /var/log/nginx/suckup.error.log;
        log_not_found on;

        ## Cache - testen
        open_file_cache max=2500 inactive=24h;
        open_file_cache_valid    24h;
        open_file_cache_min_uses 2;
        open_file_cache_errors   on;

        location ~* ^.+.(htm|html|jpg|jpeg|gif|png|ico|css|zip|tgz|gz|rar|bz2|doc|xls|exe|pdf|ppt|txt|tar|mid|midi|wav|bmp|rtf|js)(\?[0-9]+)?$ {
                root /var/www/www.suckup.de/web/;
                access_log off;
                expires max;
                break;
        }

        ## Optimierung - "(css/js).php" to "(css/js)"
        location /wp-content/plugins/wp-special-textboxes/css/ {
                location ~* \.(css.php)$ {
                        if ($args ~* ver=(.*)$) {
                                rewrite ^ $scheme://$host/wp-content/cache/wp-special-textboxes.css? permanent;
                        }
                }
        }
        location /wp-content/plugins/wp-special-textboxes/js/ {
                location ~* \.(js.php)$ {
                        if ($args ~* ver=(.*)$) {
                                rewrite ^ $scheme://$host/wp-content/cache/wstb.js? permanent;
                        }
                }
        }
        if ($args ~* ver=3.0.1$) {
                rewrite ^ $scheme://$host/wp-content/cache/wp-special-textboxes.css? permanent;
        }

        if (-f $request_filename) {
                break;
        }
        if (!-e $request_filename) {
                rewrite ^(.+)$ /index.php?q=$1 last;
        }

        # -----------------------------------------
        # http://wiki.nginx.org/Wordpress

        ## remove any multislashes //
        if ($request_uri ~* "\/\/") {
                rewrite ^/(.*) $scheme://$host/$1 permanent;
        }

        ## Slash am Ende anfuegen ?!?
        #if ($request_uri ~* "^[\w\-\/]+[^\/?]$") {
                #rewrite ^(.*)$ $scheme://$host$1/ permanent;
        #}

        ## www eifuegen
        #if ($host !~* ^(www|subdomain)) {
                #rewrite ^/(.*)$ $scheme://www.$host/$1 permanent;
        #}

        ## www vorne entfernen
        if ($host ~* ^www\.(.*)) {
                set $host_without_www $1;
                rewrite ^(.*)$ http://$host_without_www$1 permanent;
        }

        ## immer SSL verwenden
        #rewrite ^(.*) https://$server_name$1 permanent;

        ## immer HTTP verwenden
        #rewrite ^(.*) http://$server_name$1 permanent;

        ## Feedburner
        rewrite ^/e107_plugins/rss_menu/rss.php?(.*)$ http://suckup.de/feed/ last;
        if ($http_user_agent !~ (FeedBurner|Googlebot)) {
                rewrite ^/feed/?$ http://feeds.feedburner.com/suckup last;
                break;
        }

        ## WordPress3
        #if (!-e $request_filename) {
                #rewrite ^(.+)$ /index.php?q=$1 last;
                #break;
        #}

        ## WordPress3 MU
        #if (!-e $request_filename) {
                #rewrite ^.+/?(/wp-.*) $1 last;
                #rewrite ^.+/?(/.*\.php)$ $1 last;
                #rewrite ^(.+)$ /index.php?q=$1 last;
                #break;
        #}

        ## WordPress3 Multi-Domain
        rewrite ^.*/files/(.*)$ /wp-includes/ms-files.php?file=$1 last;
        if (!-e $request_filename) {
                rewrite ^.+/?(/ms-.*) $1 last;
                rewrite ^/files/(.+) /wp-includes/ms-files.php?file=$1 last;
                rewrite ^.+/?(/wp-.*) $1 last;
                rewrite ^.+/?(/.*.php)$ $1 last;
                rewrite ^(.+)$ /index.php?q=$1 last;
                break;
        }
        location ~* ^.+.(htm|html|jpg|jpeg|gif|png|ico|css|zip|tgz|gz|rar|bz2|doc|xls|exe|pdf|ppt|txt|tar|mid|midi|wav|bmp|rtf|js)(\?[0-9]+)?$ {
                access_log off;
                expires max;
                root /var/www/www.suckup.de/web/;
                rewrite ^/.(/wp-.*/.*.(html|jpg|jpeg|gif|png|ico|css|zip|tgz|gz|rar|bz2|doc|xls|exe|pdf|ppt|txt|tar|mid|midi|wav|bmp|rtf|js))(\?[0-9]+)?$ $1 last;
                break;
                rewrite ^.*/files/(.*(html|jpg|jpeg|gif|png|ico|css|zip|tgz|gz|rar|bz2|doc|xls|exe|pdf|ppt|txt|tar|mid|midi|wav|bmp|rtf|js))(\?[0-9]+)?$ /wp-includes/ms-files.php?file=$1 last;
                break;
                if (!-e $request_filename) {
                        rewrite ^.+/?(/wp-.*) $1 last;
                        rewrite ^.+/?(/.*.php)$ $1 last;
                        rewrite ^(.+)$ /index.php?q=$1 last;
                        break;
                }
        }

        ## WordPress-Forum
        if (!-e $request_filename) {
                rewrite ^/forums/topic/(.*)$ /forums/topic.php?q=$1 last;
                rewrite ^/forums/forum/(.*)$ /forums/forum.php?q=$1 last;
                rewrite ^/forums/profile/(.*)$ /forums/profile.php?q=$1 last;
                rewrite ^/forums/view/(.*)$ /forums/view.php?q=$1 last;
                rewrite ^/forums/tags/(.*)$ /forums/tags.php?q=$1 last;
                rewrite ^/forums/rss/(.*)$ /forums/rss.php?q=$1 last;
                rewrite ^/forums/bb-admin/ /forums/bb-admin/index.php last;
                rewrite ^/forums/ /forums/index.php last;
                break;
        }

        ## WordPress W3 Total Cache
        set $totalcache_file '';
        set $totalcache_uri $request_uri;
        if ($request_method = POST) {
                set $totalcache_uri '';
        }
        if ($query_string) {
                set $totalcache_uri '';
        }
        if ($http_cookie ~* "comment_author_|wordpress|wp-postpass_" ) {
                set $totalcache_uri '';
        }
        if ($totalcache_uri ~ ^(.+)$) {
                set $totalcache_file /wp-content/w3tc-suckup.de/pgcache/$1/_default_.html.gzip;
        }
        if (-f $document_root$totalcache_file) {
                rewrite ^(.*)$ $totalcache_file break;
        }

        ## WordPress SuperCache
        #set $supercache_file '';
        #set $supercache_uri $request_uri;
        #if ($request_method = POST) {
                #set $supercache_uri '';
        #}
        #if ($query_string) {
                #set $supercache_uri '';
        #}
        #if ($http_cookie ~* "comment_author_|wordpress|wp-postpass_" ) {
                #set $supercache_uri '';
        #}
        #if ($supercache_uri ~ ^(.+)$) {
                #set $supercache_file /wp-content/cache/supercache/$http_host/$1index.html;
        #}
        #if (-f $document_root$supercache_file) {
                #rewrite ^(.*)$ $supercache_file break;
        #}

        #if (!-e $request_filename) {
                #rewrite . /index.php last;
        #}

        # -----------------------------------------

        ## memchached test
        #location / {
                #default_type text/html;
                #add_header "Content" "text/html; charset=utf8";
                #charset utf-8;
                #set $memcached_key $uri;
                #memcached_pass 127.0.0.1:11211;
                #error_page 500 404 405 = @fallback;
        #}
        #location @fallback {
                #try_files $uri $uri/ @suckup;
        #}

        location / {
                try_files $uri $uri/ @suckup;
                sub_filter suckup.de:8080
                'suckup.de:80';
                sub_filter_once on;
        }

        location @suckup {
                include /etc/nginx/fastcgi_params;
                fastcgi_param SCRIPT_FILENAME $document_root/index.php;
                fastcgi_param QUERY_STRING q=$uri&$args;
                fastcgi_param SCRIPT_NAME /index.php;
                fastcgi_pass 127.0.0.1:11000;
        }

        location ~ \.php$ {
                try_files $uri @suckup;
                ## memchached test
                #set $memcached_key $uri;
                #memcached_pass  127.0.0.1:11211;
                fastcgi_index index.php;
                fastcgi_pass 127.0.0.1:11000;
                fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
                include /etc/nginx/fastcgi_params;
        }

        ## .htaccess & .htpassword sperren
        location ~ /\.ht {
                deny  all;
        }
}

C-Programm – Steuerzeichen

“Als Steuerzeichen bezeichnet man die Zeichen eines Zeichensatzes, die keine darstellbaren Zeichen repräsentieren. (Darstellbare Zeichen sind z. B. Buchstaben, Ziffern und Satzzeichen). Ursprünglich wurden sie zur Ansteuerung von Textausgabegeräten wie Textdruckern, Telegrammgeräten oder Fernschreibern verwendet. Durch Steuerzeichen ist es möglich, Steuerungsbefehle für die Ausgabegeräte innerhalb des Zeichensatzes zu übertragen, anstatt die Steuerungsinformationen über ein anderes Protokoll zu übertragen.” – Wiki

(Einige dieser Steuerzeichen habe ich bereits in meiner .bashrc eingetragen, um den Bash-Prompt Farbe zu verleihen.)

Steuerzeichen	Bedeutung
\a	BEL (bell) – akkustisches Warnsignal
\b	BS (backspace) – setzt Cursor um eine Position nach links
\f	FF(formfeed) – ein Seitenvorschub wird ausgelöst.
\n	NL (newline) – Cursor geht zum Anfang der nächsten Zeile
\r	CR (carriage return) – Cursor springt zum Anfang der aktuellen Zeile
\t	HT (horizontal tab) – Zeilenvorschub zur nächsten horizontalen Tabulatorposition (meistens acht Leerzeichen weiter)
\v	VT (vertical tab) – Cursor springt zur nächsten vertikalen Tabulatorposition
\"	” wird ausgegeben
\'	‘ wird ausgegeben
\?	? wird ausgegeben
\\	\ wird ausgegeben
\0	NULL (ist die Endmarkierung eines Strings)
\nnn	Ausgabe eines Oktalwerts (z.B. \033 = ESCAPE-Zeichen)
\xhh	Ausgabe eines Hexdezimalwerts
\033[0m	normaler Text
\033[1m	Fettschrift
\033[4m	unterstrichen
\033[30m	Schriftfarbe Schwarz
\033[31m	Schriftfarbe Rot
\033[32m	Schriftfarbe Grün
\033[33m	Schriftfarbe Gelb
\033[34m	Schriftfarbe Blau
\033[35m	Schriftfarbe Violett
\033[36m	Schriftfarbe Türkis
\033[40m	Hintergrundfarbe Schwarz
\033[41m	Hintergrundfarbe Rot
\033[42m	Hintergrundfarbe Grün
\033[43m	Hintergrundfarbe Gelb
\033[44m	Hintergrundfarbe Blau
\033[45m	Hintergrundfarbe Violett
\033[46m	Hintergrundfarbe Türkis

Es folge Beispiele, wo dies angewendet wurde…

#include <stdio.h>

main() {
    printf("\033[1m\033[31mDieser Text ist fett und rot.\033[0m\n");
    return(0);
}

#include <stdio.h>

int main() {
        printf("Dies ist ein Test und es folgt ein Zeilenumbruch\n");
        printf("\tTab einfügen und noch ein Zeilenumbruch\n");
        printf("Dieser Text wird überschrieben\r");
        printf("Das Leer \bzeichen wird entfernt");
        printf("\n\n\n");
        printf("\tJ\n");
        printf("\tu\n");
        printf("\ts\n");
        printf("\tt for\tF\n");
        printf("\t\tu\n");
        printf("\t\tn");
        return 0;
}

/* Ausgabe:

Dies ist ein Test und es folgt ein Zeilenumbruch
        Tab einfügen und noch ein Zeilenumbruch
Das Leerzeichen wird entfernt%

        J
        u
        s
        t for   F
                u
                n
*/

C-Programm – Schaltjahr Berechnung

ALGORITHMUS Schaltjahr

Beschreibung:

das Programm soll testen, ob eine Folge von Jahren jeweills ein Schaltjahr ist
wenn das Jahr größer 1582 ist
wenn das Jahr durch 4, aber nicht durch 100 teilbar ist, handelt es sich um ein Schaltjahr
ist das Jahr durch 400 teilbar, handelt es sich ebenfalls um ein Schaltjahr

Daten:

Jahr (Startwert)
Jahr (Endwert)
Schrittweite

Kern-(Algorithmus):

Einlesen von "Startwert" + "Endwert" + "Schrittweite"
WENN "Startwert" < 1582 ODER "Startwert" >= "Endwert" ODER Schrittweite <= 0
	DANN Fehler-Meldung
ANSONSTEN
	FÜR "Startwert" BIS "Endwert"
		WENN ("Startwert" / 4 ohne Rest UND "Startwert / 100 mit Rest) ODER ("Startwert" / 400 ohne Rest)
			DANN Ausgabe: "Ja"
		ANSONSTEN
			Ausgabe: "Nein"
		ENDE WENN
	ENDE FÜR
ENDE WENN

C-Programm:

#include "stdio.h"

int main(void) {
	int jahr_startwert,jahr_endwert,schrittweite;

	printf("\n\tK a l e n d e r\n");

	printf("\nBitte den Startwert (Jahrszahl) eingeben: ");
	scanf("%d", &jahr_startwert);

	printf("Bitte den Endwert (Jahreszahl) eingeben: ");
	scanf("%d", &jahr_endwert);

	printf("Bitte die Schrittweite (Jahre) eingeben: ");
	scanf("%d", &schrittweite);

	/* Beginn des gregorianischen Kalerndes - 1582*/
	if (jahr_startwert < 1582 || jahr_startwert >= jahr_endwert || schrittweite <= 0) {
		printf("\nFalsche Angabe!");
	} else {
		printf("\nJahr | Schaltjahr?");
		printf("\n------------------");

		for (jahr_startwert; jahr_startwert <= jahr_endwert; jahr_startwert=jahr_startwert+schrittweite) {
			if ((jahr_startwert % 4 == 0) && (jahr_startwert % 100 != 0) || (jahr_startwert % 400 == 0)) {
				printf("\n%d | Ja",jahr_startwert);
			}
			else {
				printf("\n%d | Nein",jahr_startwert);
			}
		}
	printf("\n\n");
	}
	return (0);
}

WordPress Editor TinyMCE optimieren

In diesem Blog-Post beschreibe ich, wie du den Editor von WordPress verbessern kannst und somit auch deine Beiträge interessanter & übersichtlicher gestalten kannst.

1.) TinyMCE Advanced

Als erstes installieren wir “TinyMCE Advanced“, dieses Plugin erweitert den Funktionsumfang des WordPress-Editors.

Advanced hr
Advanced Image
Advanced Link
Kontextmenü
Emotionen (Smilies)
Datum und Uhrzeit
IESpell
Layer
Nonbreaking
Drucken
“Suchen und Ersetzen”
Tabellen
Visual Charaktere
XHTML Extras
[…]

Diese Funktionen kannst du nun per “drag and drop” in der TinyMCE-Symbolleisten organisieren, indem du im Admin-Bereich unter “Einstellungen” -> “TinyMCE Advanced” folgende Optionen findest.

Des-weitern hat das Organisieren der Symbole noch den Vorteil, dass man den Editor auch auf kleinen Auslösungen (z.B. mit Netbook) verwenden kann, dazu wird passend zu deiner Auflösung angezeigt, wie viele Symbole du in einer Zeile einstellen kannst. (alternativ kann man auch im “Vollbildschirmmodus” einen Blog-Post erstellen)

Im linken Bild siehst du, was ich zuvor beschrieben habe (Optionen – 1), unter diesen Optionen findet man auch noch das rechte Bild (Optionen – 2). Dort kannst du “Advanced Image”, “Advanced Link” und das “Kontextmenü” aktivieren, außerdem kannst du eigene CSS-Klassen (Styles) erstellen, welche dann im Editor verwendet werden können. Zu guter letzt kann man dem Editor noch beibringen “p-” / “br”-Tags nicht einfach zu entfernen. ;-)

2.) Special Text Boxes

Als nächstes installieren wir “Special Text Boxes“, mit diesem Plugin können wir nun schöne “Warnungen”, “Hinweise” etc. in unseren Blog-Posts einfügen.

3.) WP-Syntax & WP-Syntax Button

Als nächstes installieren wir diese beiden Plugin (WP-Syntax & WP-Syntax Button), so dass wir Quelltexte besser darstellen können.

Tipp: Wenn du Probleme beim Einfügen von Quelltexten hast, da WordPress den ganze Code zusammenfasst und die Einrückungen dann weg sind, wechsel einfach in den HTML-Modus und füge dort den Quelltext ein und verwende dort den Button “pre (WP-Syntax)”, um das highliting zu aktivieren.