merging and cleaning up

Linux/BASH Basics/BASH Basics.md

@@ -0,0 +1,40 @@
+# BASH Basics - Übersicht
+
+Sammlung wichtiger BASH-Befehle und Konzepte für die Linux-Konsole.
+
+## Grundlegende Konzepte
+
+- [[BASH Funktionen]] - Wiederverwendbare Funktionen erstellen
+
+## Dateiverwaltung
+
+- [[ls]] - Dateien auflisten und Größen anzeigen
+- [[find]] - Dateien suchen, filtern und verarbeiten (inkl. Datum, Löschen)
+- [[Symlinks]] - Symbolische Links erstellen und verwalten
+
+## Textverarbeitung
+
+- [[grep]] - Textsuche in Dateien
+- [[sed]] - Stream-Editor für Textmanipulation
+- [[awk]] - Datenextraktion und Spaltenverarbeitung
+
+## Berechtigungen
+
+- [[Dateiberechtigungen]] - chmod und chown (Rechte, Eigentümer, Gruppen)
+
+## Archive und Backup
+
+- [[tar]] - Archive erstellen/entpacken und Software installieren
+- [[rsync]] - Dateien synchronisieren
+
+## System
+
+- [[lsblk]] - Block-Geräte anzeigen
+- [[fstab Credentials]] - Zugangsdaten sicher in fstab speichern
+
+## Verwandte Themen
+
+Weitere Linux-Themen im übergeordneten Verzeichnis:
+- [[Linux]] - Allgemeine Linux-Dokumentation
+- [[SSH Verbindung in Linux]] - SSH-Verbindungen
+- [[Navidrome]] - Musik-Server

Linux/BASH Basics/BASH Funktionen.md

@@ -0,0 +1,693 @@
+# BASH Funktionen# BASH FunktionenIn **[[Bash]]** kannst du wiederverwendbare **Funktionen** definieren, um Code übersichtlicher und modularer zu gestalten.  
+
+
+
+In BASH kannst du wiederverwendbare Funktionen definieren, um Code übersichtlicher und modularer zu gestalten.Hier ist eine kurze Einführung mit Beispielen 👇
+
+
+
+## GrundsyntaxIn BASH kannst du wiederverwendbare Funktionen definieren, um Code übersichtlicher und modularer zu gestalten.
+
+
+
+```bash---
+
+meine_funktion() {
+
+    echo "Das ist eine wiederverwendbare Funktion!"## Grundsyntax
+
+}
+
+```### 🔹 **Grundsyntax einer Funktion**
+
+
+
+Alternative Syntax (weniger üblich):```bash
+
+
+
+```bashmeine_funktion() {```bash
+
+function meine_funktion {
+
+    echo "Das ist eine wiederverwendbare Funktion!"    echo "Das ist eine wiederverwendbare Funktion!"meine_funktion() {
+
+}
+
+```}    echo "Das ist eine wiederverwendbare Funktion!"
+
+
+
+## Funktion mit Parametern```}
+
+
+
+In BASH werden Argumente positional übergeben: `$1`, `$2`, usw.```
+
+
+
+```bashAlternative Syntax (weniger üblich):
+
+begruesse() {
+
+    echo "Hallo $1!"Oder alternativ (weniger üblich, aber erlaubt):
+
+}
+
+```bash
+
+begruesse "Anna"
+
+# Ausgabe: Hallo Anna!function meine_funktion {```bash
+
+```
+
+    echo "Das ist eine wiederverwendbare Funktion!"function meine_funktion {
+
+## Rückgabewerte
+
+}    echo "Das ist eine wiederverwendbare Funktion!"
+
+### Numerischer Exit-Code
+
+```}
+
+Eine Funktion kann mit `return` einen numerischen Exit-Code (0–255) zurückgeben:
+
+```
+
+```bash
+
+teste_zahl() {## Funktion mit Parametern
+
+    if (( $1 > 10 )); then
+
+        return 0  # Erfolg---
+
+    else
+
+        return 1  # FehlerIn BASH werden Argumente positional übergeben: `$1`, `$2`, usw.
+
+    fi
+
+}### 🔹 **Funktion mit Parametern**
+
+
+
+if teste_zahl 15; then```bash
+
+    echo "Größer als 10"
+
+elsebegruesse() {In Bash werden Argumente **positional** übergeben — also `$1`, `$2`, usw.
+
+    echo "Nicht größer als 10"
+
+fi    echo "Hallo $1!"
+
+```
+
+}```bash
+
+### Text zurückgeben
+
+begruesse() {
+
+Um Text zurückzugeben, verwende `echo` oder `printf` und Command Substitution:
+
+begruesse "Anna"    echo "Hallo $1!"
+
+```bash
+
+addiere() {# Ausgabe: Hallo Anna!}
+
+    echo $(( $1 + $2 ))
+
+}```
+
+
+
+summe=$(addiere 3 5)begruesse "Anna"
+
+echo "Summe: $summe"  # Ausgabe: Summe: 8
+
+```## Rückgabewerte# Ausgabe: Hallo Anna!
+
+
+
+## Funktionen wiederverwendbar machen```
+
+
+
+Speichere Funktionen in einer separaten Datei und lade sie mit `source`:### Numerischer Exit-Code
+
+
+
+**funktionen.sh:**---
+
+```bash
+
+#!/bin/bashEine Funktion kann mit `return` einen numerischen Exit-Code (0–255) zurückgeben:
+
+begruesse() {
+
+    echo "Hallo $1!"### 🔹 **Rückgabewerte**
+
+}
+
+``````bash
+
+
+
+**hauptskript.sh:**teste_zahl() {- Eine Funktion kann mit `return` einen **numerischen Exit-Code** (0–255) zurückgeben.
+
+```bash
+
+#!/bin/bash    if (( $1 > 10 )); then    
+
+source ./funktionen.sh
+
+        return 0  # Erfolg- Um Text zurückzugeben, verwendest du **`echo`** oder **`printf`** und fängst den Wert mit **Command Substitution** ein.
+
+begruesse "Welt"
+
+```    else    
+
+
+
+Alternative: `. ./funktionen.sh`        return 1  # Fehler
+
+
+
+## Lokale Variablen    fi```bash
+
+
+
+Verwende `local`, um Variablen nur innerhalb der Funktion sichtbar zu machen:}# numerischer Rückgabewert
+
+
+
+```bashteste_zahl() {
+
+addiere() {
+
+    local summe=$(( $1 + $2 ))if teste_zahl 15; then    if (( $1 > 10 )); then
+
+    echo "$summe"
+
+}    echo "Größer als 10"        return 0  # Erfolg
+
+```
+
+else    else
+
+## Default-Werte für Parameter
+
+    echo "Nicht größer als 10"        return 1  # Fehler
+
+```bash
+
+mein_script() {fi    fi
+
+    local name="${1:-Welt}"       # Standardwert 'Welt'
+
+    local sprache="${2:-de}"      # Standardwert 'de'```}
+
+
+
+    echo "Name: $name, Sprache: $sprache"
+
+}
+
+### Text zurückgebenif teste_zahl 15; then
+
+mein_script "Anna" "en"  # Name: Anna, Sprache: en
+
+mein_script "Bob"        # Name: Bob, Sprache: de    echo "Größer als 10"
+
+```
+
+Um Text zurückzugeben, verwende `echo` oder `printf` und Command Substitution:else
+
+## Benannte Argumente simulieren
+
+    echo "Nicht größer als 10"
+
+### Mit case und Schleife
+
+```bashfi
+
+```bash
+
+begruesse() {addiere() {```
+
+    local name="Welt"
+
+    local sprache="de"    echo $(( $1 + $2 ))
+
+
+
+    for arg in "$@"; do}```bash
+
+        case $arg in
+
+            --name=*)# Text zurückgeben
+
+                name="${arg#*=}"
+
+                ;;summe=$(addiere 3 5)addiere() {
+
+            --sprache=*|--lang=*)
+
+                sprache="${arg#*=}"echo "Summe: $summe"  # Ausgabe: Summe: 8    echo $(( $1 + $2 ))
+
+                ;;
+
+            *)```}
+
+                echo "Unbekannte Option: $arg" >&2
+
+                ;;
+
+        esac
+
+    done## Funktionen wiederverwendbar machensumme=$(addiere 3 5)
+
+
+
+    echo "Hallo $name! (Sprache: $sprache)"echo "Summe: $summe"
+
+}
+
+Speichere Funktionen in einer separaten Datei und lade sie mit `source`:# Ausgabe: Summe: 8
+
+begruesse --name=Anna --sprache=en
+
+``````
+
+
+
+**Vorteile:****funktionen.sh:**
+
+- Reihenfolge der Argumente ist egal
+
+- Default-Werte bleiben bestehen```bash---
+
+- Sehr gut lesbar
+
+#!/bin/bash
+
+### Mit assoziativem Array
+
+begruesse() {### 🔹 **Wiederverwendbar machen**
+
+```bash
+
+begruesse() {    echo "Hallo $1!"
+
+    declare -A args=(
+
+        [name]="Welt"}Speichere deine Funktionen in einer separaten Datei, z. B. `funktionen.sh`, und **sourcen** sie in anderen Skripten:
+
+        [sprache]="de"
+
+    )```
+
+
+
+    for arg in "$@"; do**funktionen.sh**
+
+        [[ $arg == *=* ]] || continue
+
+        key="${arg%%=*}"**hauptskript.sh:**
+
+        val="${arg#*=}"
+
+        args[$key]="$val"```bash```bash
+
+    done
+
+#!/bin/bash#!/bin/bash
+
+    echo "Hallo ${args[name]}! (Sprache: ${args[sprache]})"
+
+}source ./funktionen.shbegruesse() {
+
+
+
+begruesse name=Anna sprache=en    echo "Hallo $1!"
+
+```
+
+begruesse "Welt"}
+
+## Praktische Beispiele
+
+``````
+
+### Backup-Funktion
+
+
+
+```bash
+
+backup_datei() {Alternative: `. ./funktionen.sh`**hauptskript.sh**
+
+    local datei="$1"
+
+    local backup="${datei}.backup-$(date +%Y%m%d)"
+
+    
+
+    if [[ -f "$datei" ]]; then## Lokale Variablen```bash
+
+        cp "$datei" "$backup"
+
+        echo "Backup erstellt: $backup"#!/bin/bash
+
+    else
+
+        echo "Fehler: $datei nicht gefunden" >&2Verwende `local`, um Variablen nur innerhalb der Funktion sichtbar zu machen:source ./funktionen.sh
+
+        return 1
+
+    fi
+
+}
+
+```bashbegruesse "Welt"
+
+backup_datei wichtig.txt
+
+```addiere() {```
+
+
+
+### Fehlerbehandlung    local summe=$(( $1 + $2 ))
+
+
+
+```bash    echo "$summe"Oder mit:
+
+sicheres_loeschen() {
+
+    local datei="$1"}
+
+    
+
+    if [[ ! -f "$datei" ]]; then``````bash
+
+        echo "Fehler: $datei existiert nicht" >&2
+
+        return 1. ./funktionen.sh
+
+    fi
+
+    ## Default-Werte für Parameter```
+
+    read -p "Wirklich $datei löschen? (j/n) " antwort
+
+    if [[ "$antwort" == "j" ]]; then
+
+        rm "$datei"
+
+        echo "$datei gelöscht"```bash---
+
+    else
+
+        echo "Abgebrochen"mein_script() {
+
+    fi
+
+}    local name="${1:-Welt}"       # Standardwert 'Welt'### 🔹 **Bonus: Funktionen mit lokaler Variable**
+
+```
+
+    local sprache="${2:-de}"      # Standardwert 'de'
+
+### Mehrere Rückgabewerte
+
+Verwende `local`, um Variablen nur innerhalb der Funktion sichtbar zu machen:
+
+```bash
+
+datei_info() {    echo "Name: $name, Sprache: $sprache"
+
+    local datei="$1"
+
+    }```bash
+
+    if [[ -f "$datei" ]]; then
+
+        echo "$(wc -l < "$datei")"     # Zeilenaddiere() {
+
+        echo "$(wc -w < "$datei")"     # Wörter
+
+        echo "$(stat -c%s "$datei")"   # Größemein_script "Anna" "en"  # Name: Anna, Sprache: en    local summe=$(( $1 + $2 ))
+
+    fi
+
+}mein_script "Bob"        # Name: Bob, Sprache: de    echo "$summe"
+
+
+
+# Verwendung```}
+
+read zeilen woerter groesse <<< $(datei_info text.txt)
+
+echo "Zeilen: $zeilen, Wörter: $woerter, Größe: $groesse"```
+
+```
+
+## Benannte Argumente simulieren
+
+## Best Practices
+
+---
+
+### Eingabevalidierung
+
+### Mit case und Schleife
+
+```bash
+
+verarbeite_zahl() {## 🧩 Beispiel 1: Named Arguments via `local` + Parameter Expansion
+
+    local zahl="$1"
+
+    ```bash
+
+    if ! [[ "$zahl" =~ ^[0-9]+$ ]]; then
+
+        echo "Fehler: Keine gültige Zahl" >&2begruesse() {```bash
+
+        return 1
+
+    fi    local name="Welt"mein_script() {
+
+    
+
+    echo "Ergebnis: $((zahl * 2))"    local sprache="de"    local name="${1:-Welt}"         # Standardwert 'Welt'
+
+}
+
+```    local sprache="${2:-de}"        # Standardwert 'de'
+
+
+
+### Dokumentation    for arg in "$@"; do
+
+
+
+```bash        case $arg in    echo "Name: $name"
+
+# Berechnet die Summe zweier Zahlen
+
+# Parameter:            --name=*)    echo "Sprache: $sprache"
+
+#   $1 - erste Zahl
+
+#   $2 - zweite Zahl                name="${arg#*=}"}
+
+# Rückgabe:
+
+#   Summe der beiden Zahlen                ;;
+
+addiere() {
+
+    echo $(( $1 + $2 ))            --sprache=*|--lang=*)mein_script "Anna" "en"
+
+}
+
+```                sprache="${arg#*=}"mein_script "Bob"
+
+
+
+### Fehler propagieren                ;;```
+
+
+
+```bash            *)
+
+hauptfunktion() {
+
+    hilfsfunktion || return $?                echo "Unbekannte Option: $arg" >&2➡️ Ausgabe:
+
+    # Weiterer Code nur wenn hilfsfunktion erfolgreich
+
+}                ;;
+
+```
+
+        esac```
+
+## Siehe auch
+
+    doneName: Anna
+
+- [[grep]] - Textsuche in Scripten
+
+- [[sed]] - Textmanipulation in FunktionenSprache: en
+
+- [[find]] - Dateien in Funktionen verarbeiten
+
+    echo "Hallo $name! (Sprache: $sprache)"Name: Bob
+
+}Sprache: de
+
+```
+
+begruesse --name=Anna --sprache=en
+
+```Aber das sind **positionsbasierte Argumente**, keine echten "benannten".
+
+
+
+**Vorteile:**---
+
+- Reihenfolge der Argumente ist egal
+
+- Default-Werte bleiben bestehen## 🧩 Beispiel 2: Simulierte **benannte Argumente** mit `case` oder Schleife
+
+- Sehr gut lesbar
+
+Du kannst Argumente wie `--name=Anna` oder `--lang=en` verwenden:
+
+### Mit assoziativem Array
+
+```bash
+
+```bashbegruesse() {
+
+begruesse() {    local name="Welt"
+
+    declare -A args=(    local sprache="de"
+
+        [name]="Welt"
+
+        [sprache]="de"    for arg in "$@"; do
+
+    )        case $arg in
+
+            --name=*)
+
+    for arg in "$@"; do                name="${arg#*=}"
+
+        [[ $arg == *=* ]] || continue                ;;
+
+        key="${arg%%=*}"            --sprache=*|--lang=*)
+
+        val="${arg#*=}"                sprache="${arg#*=}"
+
+        args[$key]="$val"                ;;
+
+    done            *)
+
+                echo "Unbekannte Option: $arg" >&2
+
+    echo "Hallo ${args[name]}! (Sprache: ${args[sprache]})"                ;;
+
+}        esac
+
+    done
+
+begruesse name=Anna sprache=en
+
+```    echo "Hallo $name! (Sprache: $sprache)"
+
+}
+
+## Siehe auch
+
+begruesse --name=Anna --sprache=en
+
+- [[find]] - BASH-Befehl zum Suchen von Dateienbegruesse
+
+- [[grep]] - Textsuche in Dateien```
+
+
+➡️ Ausgabe:
+
+```
+Hallo Anna! (Sprache: en)
+Hallo Welt! (Sprache: de)
+```
+
+✅ Vorteil: Reihenfolge der Argumente ist egal  
+✅ Default-Werte bleiben bestehen  
+✅ Sehr gut lesbar
+
+---
+
+## 🧩 Beispiel 3: Named Args via **`declare -A` (assoziatives Array)**
+
+Etwas fortgeschrittener, aber elegant:
+
+```bash
+begruesse() {
+    declare -A args=(
+        [name]="Welt"
+        [sprache]="de"
+    )
+
+    for arg in "$@"; do
+        [[ $arg == *=* ]] || continue
+        key="${arg%%=*}"
+        val="${arg#*=}"
+        args[$key]="$val"
+    done
+
+    echo "Hallo ${args[name]}! (Sprache: ${args[sprache]})"
+}
+
+begruesse name=Anna sprache=en
+```
+
+---
+
+## 🧩 Beispiel 4: Default-Werte per `:`-Operator
+
+Falls du Parameter ohne Parsing willst, kannst du Default-Werte einfach so setzen:
+
+```bash
+begruesse() {
+    local name="${1:-Welt}"
+    local sprache="${2:-de}"
+
+    echo "Hallo $name in Sprache $sprache"
+}
+```
+
+---
+
+### 🔹 Empfehlung
+
+Wenn du Funktionen **häufig wiederverwenden** oder **CLI-ähnliche Aufrufe** unterstützen willst, ist **Variante 2 (mit `--option=wert`)** am besten:
+
+- Lesbar
+    
+- Robust
+    
+- Einfach erweiterbar
+    
+
+---

Linux/BASH Basics/Dateiberechtigungen.md

@@ -0,0 +1,365 @@
+# Dateiberechtigungen - chmod und chown
+
+Verwaltung von Zugriffsrechten, Eigentümern und Gruppen in Linux.
+
+## Rechte-System in Linux
+
+Jede Datei hat:
+- **Eigentümer (Owner)** - der Benutzer, dem die Datei gehört
+- **Gruppe (Group)** - eine Benutzergruppe
+- **Zugriffsrechte** für drei Bereiche:
+  - **u** (user) = Eigentümer
+  - **g** (group) = Gruppe
+  - **o** (others) = Andere
+
+Jeder Bereich hat drei Rechte:
+- **r** (read) = Lesen (4)
+- **w** (write) = Schreiben (2)
+- **x** (execute) = Ausführen (1)
+
+## Rechte anzeigen
+
+```bash
+ls -l datei.txt
+```
+
+Ausgabe:
+```
+-rw-r--r-- 1 alice developers 1234 Nov 7 10:00 datei.txt
+```
+
+- Position 1: Dateityp (`-` = Datei, `d` = Verzeichnis, `l` = Link)
+- Position 2-4: User-Rechte (`rw-`)
+- Position 5-7: Group-Rechte (`r--`)
+- Position 8-10: Other-Rechte (`r--`)
+- `alice` = Eigentümer
+- `developers` = Gruppe
+
+## chmod - Zugriffsrechte ändern
+
+### Symbolische Notation
+
+```bash
+chmod [ugoa][+-=][rwx] datei
+```
+
+**Rechte hinzufügen:**
+```bash
+chmod u+x script.sh         # Eigentümer: ausführbar
+chmod g+w datei.txt         # Gruppe: schreibbar
+chmod o+r datei.txt         # Andere: lesbar
+chmod a+x script.sh         # Alle: ausführbar
+```
+
+**Rechte entfernen:**
+```bash
+chmod u-x script.sh         # Eigentümer: nicht ausführbar
+chmod g-w datei.txt         # Gruppe: nicht schreibbar
+chmod o-r datei.txt         # Andere: nicht lesbar
+```
+
+**Rechte setzen (überschreiben):**
+```bash
+chmod u=rw,g=r,o= datei.txt    # User: rw, Group: r, Others: keine
+chmod a=r datei.txt            # Alle: nur lesen
+```
+
+### Numerische Notation (Oktal)
+
+Rechte als dreistellige Oktalzahl:
+
+| Wert | Rechte | Bedeutung |
+|------|--------|-----------|
+| 0 | `---` | Keine Rechte |
+| 1 | `--x` | Ausführen |
+| 2 | `-w-` | Schreiben |
+| 3 | `-wx` | Schreiben + Ausführen |
+| 4 | `r--` | Lesen |
+| 5 | `r-x` | Lesen + Ausführen |
+| 6 | `rw-` | Lesen + Schreiben |
+| 7 | `rwx` | Alle Rechte |
+
+**Häufige Kombinationen:**
+```bash
+chmod 644 datei.txt        # rw-r--r-- (Standard für Dateien)
+chmod 755 script.sh        # rwxr-xr-x (Standard für Scripts)
+chmod 700 privat.key       # rwx------ (Nur Eigentümer)
+chmod 600 ~/.ssh/id_rsa    # rw------- (SSH-Schlüssel)
+chmod 777 verzeichnis      # rwxrwxrwx (Alle Rechte - UNSICHER!)
+```
+
+Beispiel: `chmod 755` bedeutet:
+- User: 7 (rwx)
+- Group: 5 (r-x)
+- Others: 5 (r-x)
+
+### Rekursiv
+
+```bash
+chmod -R 755 /pfad/zum/verzeichnis
+```
+
+**Nur Verzeichnisse oder nur Dateien:**
+```bash
+find . -type d -exec chmod 755 {} +    # Alle Verzeichnisse
+find . -type f -exec chmod 644 {} +    # Alle Dateien
+```
+
+### Spezielle Rechte
+
+**Sticky Bit** (nur Eigentümer kann löschen):
+```bash
+chmod +t /tmp               # Symbolic
+chmod 1777 verzeichnis      # Numeric (rwxrwxrwt)
+```
+
+**SUID** (läuft mit Rechten des Eigentümers):
+```bash
+chmod u+s /usr/bin/passwd   # Symbolic
+chmod 4755 datei            # Numeric (rwsr-xr-x)
+```
+
+**SGID** (neue Dateien erben Gruppe):
+```bash
+chmod g+s verzeichnis       # Symbolic
+chmod 2755 verzeichnis      # Numeric (rwxr-sr-x)
+```
+
+### Praktische Beispiele
+
+**Script ausführbar machen:**
+```bash
+chmod +x meinscript.sh
+./meinscript.sh
+```
+
+**SSH-Verzeichnis absichern:**
+```bash
+chmod 700 ~/.ssh
+chmod 600 ~/.ssh/id_rsa
+chmod 644 ~/.ssh/id_rsa.pub
+chmod 600 ~/.ssh/authorized_keys
+```
+
+**Web-Verzeichnis:**
+```bash
+chmod -R 755 /var/www/html
+find /var/www/html -type f -exec chmod 644 {} +
+find /var/www/html -type d -exec chmod 755 {} +
+```
+
+**Projekt-Verzeichnis:**
+```bash
+chmod -R u+rwX,g+rX,o-rwx projektordner
+```
+
+(`X` = ausführbar nur für Verzeichnisse)
+
+## chown - Eigentümer und Gruppe ändern
+
+### Grundsyntax
+
+```bash
+chown [OPTIONEN] EIGENTÜMER[:GRUPPE] DATEI
+```
+
+### Eigentümer ändern
+
+```bash
+chown alice datei.txt
+```
+
+### Eigentümer und Gruppe ändern
+
+```bash
+chown alice:developers datei.txt
+```
+
+### Nur Gruppe ändern
+
+```bash
+chown :developers datei.txt
+```
+
+Oder mit `chgrp`:
+```bash
+chgrp developers datei.txt
+```
+
+### Rekursiv
+
+```bash
+chown -R alice:developers /pfad/zum/verzeichnis
+```
+
+### Von anderem Benutzer übernehmen
+
+```bash
+chown --reference=referenzdatei zieldatei
+```
+
+### Praktische Beispiele
+
+**Web-Server Verzeichnis:**
+```bash
+sudo chown -R www-data:www-data /var/www/html
+```
+
+**Home-Verzeichnis korrigieren:**
+```bash
+sudo chown -R alice:alice /home/alice
+```
+
+**Nach Copy von Root:**
+```bash
+sudo cp /root/datei.txt /home/alice/
+sudo chown alice:alice /home/alice/datei.txt
+```
+
+**Nur Dateien, nicht Verzeichnisse:**
+```bash
+find /pfad -type f -exec chown alice:developers {} +
+```
+
+**Nur bei Bedarf ändern:**
+```bash
+find /pfad ! -user alice -exec chown alice {} +
+find /pfad ! -group developers -exec chgrp developers {} +
+```
+
+### Symbolische Links
+
+Standardmäßig ändert `chown` das Ziel des Links:
+
+```bash
+chown alice symlink  # ändert Ziel
+chown -h alice symlink  # ändert nur den Link selbst
+```
+
+## Kombinierte Anwendung
+
+### Berechtigungen komplett setzen
+
+```bash
+sudo chown -R www-data:www-data /var/www/html
+sudo find /var/www/html -type d -exec chmod 755 {} +
+sudo find /var/www/html -type f -exec chmod 644 {} +
+```
+
+### Projekt-Setup
+
+```bash
+sudo chown -R alice:developers /opt/projekt
+chmod -R u+rwX,g+rwX,o-rwx /opt/projekt
+```
+
+### Backup wiederherstellen
+
+```bash
+sudo tar -xpf backup.tar.gz  # -p bewahrt Rechte
+sudo chown -R alice:alice /home/alice/restored/
+```
+
+## Berechtigungen prüfen
+
+```bash
+ls -l datei.txt              # Einfache Ansicht
+stat datei.txt               # Detaillierte Info
+getfacl datei.txt            # ACLs anzeigen (falls gesetzt)
+```
+
+## Eigentümer-ID statt Name
+
+```bash
+chown 1000:1000 datei.txt    # Verwendet UID und GID direkt
+```
+
+UIDs anzeigen:
+```bash
+id alice                     # UID und GIDs von alice
+```
+
+## Fehler vermeiden
+
+### Rekursive Änderungen testen
+
+```bash
+# Erst anzeigen
+find /pfad -ls
+
+# Dann ändern
+sudo chown -R alice:developers /pfad
+```
+
+### NIEMALS auf Root-Verzeichnis
+
+```bash
+# GEFÄHRLICH - bricht System
+sudo chown -R user:user /              # NIEMALS!
+sudo chmod -R 777 /                    # NIEMALS!
+
+# Nur eigene Verzeichnisse
+sudo chown -R user:user /home/user
+```
+
+### Zu permissive Rechte
+
+```bash
+# FALSCH - macht alles ausführbar
+chmod -R 777 verzeichnis    # NICHT verwenden!
+
+# RICHTIG - differenziert
+find verzeichnis -type d -exec chmod 755 {} +
+find verzeichnis -type f -exec chmod 644 {} +
+```
+
+### Systemdateien
+
+```bash
+# Wichtige Systemdateien sollten root gehören
+ls -l /etc/passwd /etc/shadow
+# -rw-r--r-- 1 root root ... /etc/passwd
+# -rw-r----- 1 root shadow ... /etc/shadow
+```
+
+## Mit sudo
+
+`chown` erfordert meist Root-Rechte:
+
+```bash
+sudo chown root:root /etc/wichtig.conf
+sudo chmod 644 /etc/wichtig.conf
+```
+
+Ohne sudo:
+```bash
+# Nur eigene Dateien
+chmod 644 meine_datei.txt
+
+# chown nur als root
+chown alice datei.txt  # Permission denied (außer eigene Datei)
+```
+
+## Zusammenfassung
+
+| Befehl | Zweck | Beispiel |
+|--------|-------|----------|
+| `chmod` | Rechte ändern | `chmod 755 script.sh` |
+| `chown` | Eigentümer ändern | `chown alice:developers file` |
+| `chgrp` | Nur Gruppe ändern | `chgrp developers file` |
+| `ls -l` | Rechte anzeigen | `ls -l file` |
+| `stat` | Details anzeigen | `stat file` |
+
+**Standard-Rechte:**
+- Dateien: `644` (rw-r--r--)
+- Scripts: `755` (rwxr-xr-x)
+- Verzeichnisse: `755` (rwxr-xr-x)
+- Private Dateien: `600` (rw-------)
+
+## Siehe auch
+
+- [[find]] - Dateien mit bestimmten Rechten/Eigentümern finden
+- [[ls]] - Rechte und Eigentümer anzeigen
+- [[Symlinks]] - Links bleiben bei chown erhalten
+- [[tar]] - Rechte in Archiven bewahren
+- [[rsync]] - Rechte bei Synchronisation

Linux/BASH Basics/PATH und Alias.md

@@ -0,0 +1,115 @@
+# Linux BASH: Permanente Verfügbarkeit von Dateien und Pfaden
+
+Es gibt mehrere Methoden, um Dateien oder Pfade in Linux BASH permanent verfügbar zu machen:
+
+## PATH-Variable erweitern
+
+### Temporär (aktuelle Session)
+```bash
+export PATH="$PATH:/pfad/zum/verzeichnis"
+```
+
+### Permanent für aktuellen Benutzer
+Füge folgende Zeile in `~/.bashrc` oder `~/.profile` ein:
+```bash
+export PATH="$PATH:/pfad/zum/verzeichnis"
+```
+
+### Permanent systemweit
+Bearbeite `/etc/environment`:
+```bash
+sudo nano /etc/environment
+```
+Erweitere die PATH-Zeile:
+```
+PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/dein/pfad"
+```
+
+## Symbolische Links erstellen
+
+### Link in systemweitem Bin-Verzeichnis
+```bash
+sudo ln -s /vollständiger/pfad/zur/datei /usr/local/bin/dateiname
+```
+
+### Link in persönlichem Bin-Verzeichnis
+```bash
+mkdir -p ~/bin
+ln -s /vollständiger/pfad/zur/datei ~/bin/dateiname
+# ~/bin zu PATH hinzufügen falls nicht vorhanden
+echo 'export PATH="$PATH:$HOME/bin"' >> ~/.bashrc
+```
+
+## Aliase verwenden
+
+### In ~/.bashrc hinzufügen
+```bash
+alias meinprogramm='/vollständiger/pfad/zur/datei'
+alias cdprojekt='cd /pfad/zum/projekt'
+```
+
+## Umgebungsvariablen für Pfade
+
+### In ~/.bashrc definieren
+```bash
+export MEIN_PROJEKT_PFAD="/pfad/zum/projekt"
+export MEIN_SCRIPT_PFAD="/pfad/zu/scripts"
+```
+
+Verwendung:
+```bash
+cd $MEIN_PROJEKT_PFAD
+$MEIN_SCRIPT_PFAD/meinscript.sh
+```
+
+## Anwendung der Änderungen
+
+Nach Bearbeitung der Konfigurationsdateien:
+```bash
+source ~/.bashrc
+# oder
+exec bash
+# oder Terminal neu starten
+```
+
+## Praxisbeispiele
+
+### Eigene Scripts verfügbar machen
+```bash
+# 1. Persönliches Scripts-Verzeichnis erstellen
+mkdir -p ~/scripts
+
+# 2. Script dort ablegen
+cp meinscript.sh ~/scripts/
+
+# 3. Ausführbar machen
+chmod +x ~/scripts/meinscript.sh
+
+# 4. PATH erweitern in ~/.bashrc
+echo 'export PATH="$PATH:$HOME/scripts"' >> ~/.bashrc
+
+# 5. Änderungen laden
+source ~/.bashrc
+```
+
+### Häufig verwendete Verzeichnisse
+```bash
+# In ~/.bashrc
+alias proj='cd /home/user/projekte'
+alias docs='cd /home/user/dokumente'
+export WORKSPACE="/home/user/workspace"
+```
+
+## Wichtige Hinweise
+
+- **Reihenfolge im PATH**: Erste Treffer werden verwendet
+- **Sicherheit**: Keine unsicheren Verzeichnisse in PATH aufnehmen
+- **Systemweite vs. Benutzer-spezifische** Änderungen beachten
+- **Backup**: Konfigurationsdateien vor Änderungen sichern
+
+---
+
+**Verwandte Themen:**
+- [[Linux Shell Konfiguration]]
+- [[BASH Umgebungsvariablen]]
+- [[Linux Dateisystem Navigation]]

Linux/BASH Basics/Symlinks.md

@@ -0,0 +1,107 @@
+# Symbolische Links (Symlinks)
+
+Ein symbolischer Link (Symlink) ist eine spezielle Datei, die auf eine andere Datei oder ein Verzeichnis verweist.
+
+## Symlink erstellen
+
+```bash
+ln -s /pfad/zum/ziel /pfad/zum/link
+```
+
+Optionen:
+- `-s` → Symlink erstellen (statt Hardlink)
+- `-f` → vorhandenen Link überschreiben
+- `-n` → falls Link auf Verzeichnis verweist, Link selbst überschreiben
+
+Beispiel:
+
+```bash
+ln -s /opt/programm/binary /usr/local/bin/programm
+```
+
+## Ziel eines Symlinks anzeigen
+
+```bash
+readlink meinlink
+```
+
+Mit absolutem Pfad (löst verschachtelte Links auf):
+
+```bash
+readlink -f meinlink
+```
+
+Beispiel:
+
+```bash
+$ readlink mysoftlink
+../zielordner/datei.txt
+
+$ readlink -f mysoftlink
+/home/user/zielordner/datei.txt
+```
+
+## Symlink aktualisieren
+
+Einen Symlink kann man nicht direkt ändern, sondern muss ihn neu erstellen:
+
+```bash
+ln -sfn /neues/ziel meinlink
+```
+
+Beispiel:
+
+```bash
+#!/bin/bash
+link="meinlink"
+
+# Aktuelles Ziel auslesen
+altes_ziel=$(readlink "$link")
+echo "Aktuelles Ziel: $altes_ziel"
+
+# Neues Ziel setzen
+neues_ziel="/pfad/zum/neuen/ziel"
+ln -sfn "$neues_ziel" "$link"
+
+echo "Neues Ziel: $(readlink $link)"
+```
+
+## Symlinks vs. Hardlinks
+
+**Symlinks:**
+- Verweisen auf Pfad (nicht auf Inode)
+- Können auf Dateien und Verzeichnisse verweisen
+- Funktionieren über Dateisystemgrenzen hinweg
+- Brechen, wenn Ziel gelöscht wird
+
+**Hardlinks:**
+- Verweisen direkt auf Inode
+- Nur für Dateien (nicht für Verzeichnisse)
+- Müssen im gleichen Dateisystem liegen
+- Bleiben gültig, auch wenn Originaldatei gelöscht wird
+
+## Desktop-Verknüpfungen erstellen
+
+Für Desktop-Umgebungen (GNOME, KDE, XFCE) verwendet man `.desktop`-Dateien:
+
+**weblink.desktop:**
+```ini
+[Desktop Entry]
+Name=Open ChatGPT
+Type=Link
+URL=https://chat.openai.com/
+Icon=web-browser
+```
+
+Ausführbar machen:
+
+```bash
+chmod +x weblink.desktop
+```
+
+## Siehe auch
+
+- [[find]] - Dateien suchen (z.B. nach Symlinks mit `-type l`)
+- [[ls]] - Symlinks in Verzeichnissen anzeigen
+- [[Dateiberechtigungen]] - Rechte von Links und Zielen
+- [[lsblk]] - Block-Geräte anzeigen

Linux/BASH Basics/awk.md

@@ -0,0 +1,257 @@
+# awk - Textverarbeitung und Datenextraktion
+
+`awk` ist eine mächtige Programmiersprache für Textverarbeitung, besonders nützlich für spaltenbasierte Daten.
+
+## Grundsyntax
+
+```bash
+awk 'MUSTER { AKTION }' datei.txt
+```
+
+## Spalten ausgeben
+
+### Einzelne Spalten
+
+```bash
+awk '{print $1}' datei.txt      # Erste Spalte
+awk '{print $2}' datei.txt      # Zweite Spalte
+awk '{print $NF}' datei.txt     # Letzte Spalte
+```
+
+`$0` = ganze Zeile, `$1` = erste Spalte, `$2` = zweite, etc.
+
+### Mehrere Spalten
+
+```bash
+awk '{print $1, $3}' datei.txt
+awk '{print $1 " - " $3}' datei.txt
+```
+
+## Trennzeichen (Delimiter)
+
+### Standard (Leerzeichen/Tab)
+
+```bash
+awk '{print $1}' datei.txt
+```
+
+### Eigenes Trennzeichen
+
+```bash
+awk -F: '{print $1}' /etc/passwd    # Doppelpunkt
+awk -F, '{print $1, $3}' datei.csv  # Komma
+awk -F'|' '{print $2}' datei.txt    # Pipe
+```
+
+### Mehrere Trennzeichen
+
+```bash
+awk -F'[,:]' '{print $1}' datei.txt
+```
+
+## Muster (Pattern)
+
+### Zeilen mit bestimmtem Text
+
+```bash
+awk '/ERROR/ {print}' logfile.txt
+awk '/ERROR/' logfile.txt           # Kurzform
+```
+
+### Reguläre Ausdrücke
+
+```bash
+awk '/^[0-9]/ {print}' datei.txt    # Zeilen mit Zahl am Anfang
+awk '/ERROR|WARNING/' logfile.txt    # ERROR oder WARNING
+```
+
+### Spaltenbasierte Bedingungen
+
+```bash
+awk '$3 > 100 {print}' datei.txt           # 3. Spalte > 100
+awk '$1 == "root" {print}' /etc/passwd     # 1. Spalte = "root"
+awk '$2 != "active" {print}' status.txt    # 2. Spalte ≠ "active"
+```
+
+### Mehrere Bedingungen
+
+```bash
+awk '$3 > 100 && $4 < 200 {print}' datei.txt
+awk '$1 == "Alice" || $1 == "Bob" {print}' datei.txt
+```
+
+## Berechnungen
+
+### Summe
+
+```bash
+awk '{sum += $1} END {print sum}' zahlen.txt
+```
+
+### Durchschnitt
+
+```bash
+awk '{sum += $1; count++} END {print sum/count}' zahlen.txt
+```
+
+### Maximum/Minimum
+
+```bash
+awk 'BEGIN {max=0} {if($1>max) max=$1} END {print max}' zahlen.txt
+awk 'NR==1 {min=$1} {if($1<min) min=$1} END {print min}' zahlen.txt
+```
+
+## Formatierte Ausgabe
+
+### Mit printf
+
+```bash
+awk '{printf "%s: %d\n", $1, $2}' datei.txt
+awk '{printf "%-10s %5d\n", $1, $2}' datei.txt  # Formatiert
+```
+
+### Spalten ausrichten
+
+```bash
+awk '{printf "%-15s %10s\n", $1, $2}' datei.txt
+```
+
+## Eingebaute Variablen
+
+```bash
+awk '{print NR, $0}' datei.txt      # NR = Zeilennummer
+awk '{print NF, $0}' datei.txt      # NF = Anzahl Felder
+awk 'NR==5 {print}' datei.txt       # Nur Zeile 5
+awk 'NR>=10 && NR<=20' datei.txt    # Zeilen 10-20
+```
+
+Wichtige Variablen:
+- `NR` = Nummer der aktuellen Zeile
+- `NF` = Anzahl der Felder
+- `FS` = Field Separator (Eingabe)
+- `OFS` = Output Field Separator (Ausgabe)
+
+## BEGIN und END
+
+```bash
+awk 'BEGIN {print "Start"} {print} END {print "Ende"}' datei.txt
+```
+
+```bash
+awk 'BEGIN {FS=":"; OFS="\t"} {print $1, $3}' /etc/passwd
+```
+
+## Praktische Beispiele
+
+### /etc/passwd auswerten
+
+```bash
+# Alle Benutzernamen
+awk -F: '{print $1}' /etc/passwd
+
+# User mit UID >= 1000
+awk -F: '$3 >= 1000 {print $1}' /etc/passwd
+
+# User und Shell
+awk -F: '{print $1 ": " $7}' /etc/passwd
+```
+
+### Prozesse analysieren
+
+```bash
+# Speichernutzung
+ps aux | awk '{sum += $6} END {print sum/1024 " MB"}'
+
+# Top 5 Prozesse nach Speicher
+ps aux | awk '{print $6, $11}' | sort -rn | head -5
+```
+
+### CSV-Dateien
+
+```bash
+# Zweite Spalte summieren
+awk -F, '{sum += $2} END {print sum}' data.csv
+
+# Filtern und ausgeben
+awk -F, '$3 > 1000 {print $1, $2}' sales.csv
+```
+
+### Logfile-Analyse
+
+```bash
+# Nur ERROR-Zeilen mit Zeitstempel
+awk '/ERROR/ {print $1, $2, $0}' app.log
+
+# Fehler zählen
+awk '/ERROR/ {count++} END {print count}' app.log
+
+# Nach Zeit filtern
+awk '$1 >= "2025-11-07" && $1 <= "2025-11-08"' log.txt
+```
+
+### Apache/Nginx Logs
+
+```bash
+# IP-Adressen extrahieren
+awk '{print $1}' access.log | sort | uniq -c | sort -rn
+
+# Nur 404-Fehler
+awk '$9 == 404 {print $7}' access.log
+```
+
+### Duplikate zählen
+
+```bash
+awk '{count[$1]++} END {for(key in count) print key, count[key]}' datei.txt
+```
+
+## Arrays
+
+```bash
+awk '{arr[$1] += $2} END {for (key in arr) print key, arr[key]}' datei.txt
+```
+
+## Mehrere Dateien
+
+```bash
+awk '{print FILENAME, $0}' datei1.txt datei2.txt
+```
+
+## Mit Pipes
+
+```bash
+cat datei.txt | awk '{print $1}'
+ls -l | awk '{print $9, $5}'
+df -h | awk 'NR>1 {print $1, $5}'
+```
+
+## Komplexes Beispiel
+
+```bash
+# Benutzerdefinierte Funktion
+awk '
+  function celsius(f) {
+    return (f - 32) * 5/9
+  }
+  {
+    printf "%s: %.2f°C\n", $1, celsius($2)
+  }
+' temperatures.txt
+```
+
+## Vergleich: awk vs. andere Tools
+
+| Task | Tool |
+|------|------|
+| Spalten extrahieren | `awk '{print $2}'` oder `cut -f2` |
+| Suchen | `awk '/pattern/'` oder `grep pattern` |
+| Ersetzen | `sed 's/alt/neu/'` |
+| Rechnen | `awk '{sum+=$1}'` |
+
+## Siehe auch
+
+- [[grep]] - Textsuche
+- [[sed]] - Stream-Editor
+- [[find]] - Dateien finden
+- [[BASH Funktionen]] - awk in Funktionen nutzen
+- [[ls]] - Ausgabe mit awk verarbeiten

Linux/BASH Basics/find.md

@@ -0,0 +1,362 @@
+# find - Dateien und Verzeichnisse suchen
+
+Der Befehl `find` durchsucht Verzeichnisse rekursiv nach Dateien oder Ordnern anhand verschiedener Kriterien.
+
+## Grundsyntax
+
+```bash
+find [Pfad] [Suchkriterien] [Aktionen]
+```
+
+## Suchkriterien
+
+### Nach Namen suchen
+
+```bash
+find . -name "datei.txt"       # exakte Übereinstimmung
+find . -iname "datei.txt"      # case-insensitive
+find . -name "*.log"           # mit Wildcards
+```
+
+### Nach Dateityp suchen
+
+```bash
+find . -type f    # nur Dateien
+find . -type d    # nur Verzeichnisse
+find . -type l    # symbolische Links
+```
+
+### Nach Dateigröße suchen
+
+```bash
+find . -size +10M   # größer als 10 MB
+find . -size -100k  # kleiner als 100 KB
+find . -size 0      # leere Dateien
+```
+
+### Nach Berechtigungen suchen
+
+```bash
+find . -perm 644       # Dateien mit Rechten 644
+find . -user alice     # Dateien von User "alice"
+find . -group admins   # Dateien von Gruppe "admins"
+```
+
+### Suchtiefe begrenzen
+
+```bash
+find . -maxdepth 1 -type f
+```
+
+Nur im aktuellen Ordner, nicht in Unterordnern.
+
+## Suche nach Datum und Zeit
+
+### Zeitstempel-Typen
+
+- **mtime** (modification time) = Inhalt geändert
+- **atime** (access time) = Datei gelesen
+- **ctime** (change time) = Metadaten geändert (chmod, chown)
+
+### Relative Zeitangaben (Tage)
+
+```bash
+find . -mtime -7    # in den letzten 7 Tagen geändert
+find . -mtime +30   # älter als 30 Tage
+find . -atime -1    # in den letzten 24 Stunden geöffnet
+find . -ctime -1    # Metadaten in letzten 24h geändert
+```
+
+Dateien zwischen X und Y Tagen:
+
+```bash
+find . -mtime +7 -mtime -30
+```
+
+### Absolute Zeitangaben (Datum, GNU find)
+
+```bash
+find . -newermt "2025-04-01"                                      # mtime nach Datum
+find . -newerat "2025-04-01"                                      # atime nach Datum
+find . -newerct "2025-04-01"                                      # ctime nach Datum
+find . -newermt "2023-09-01" ! -newermt "2023-09-10"             # zwischen zwei Daten
+```
+
+**Hinweis:** `-newermt/at/ct` sind GNU-Erweiterungen (nicht auf BSD/macOS).
+
+### Mit Referenzdatei
+
+```bash
+touch -d "2025-04-01" /tmp/refdate
+find . -newer /tmp/refdate
+```
+
+### Übersicht Zeitoptionen
+
+| Option | Bedeutung |
+|--------|-----------|
+| `-mtime -7` | in den letzten 7 Tagen geändert |
+| `-mtime +30` | älter als 30 Tage |
+| `-atime -2` | in den letzten 2 Tagen geöffnet |
+| `-ctime -1` | Metadaten in letzten 24h geändert |
+| `-newermt "2023-09-01"` | mtime nach Datum (GNU) |
+| `-newerat "2023-09-01"` | atime nach Datum (GNU) |
+| `-newerct "2023-09-01"` | ctime nach Datum (GNU) |
+| `-newer datei.txt` | neuer als Referenzdatei |
+
+## Bedingungen kombinieren
+
+### UND-Verknüpfung (Standard)
+
+```bash
+find . -type f -size +1M -mtime -7
+```
+
+Dateien größer als 1 MB UND in den letzten 7 Tagen geändert.
+
+### ODER-Verknüpfung
+
+```bash
+find . -type f \( -name "*.jpg" -o -name "*.png" \)
+```
+
+Alle `.jpg` ODER `.png` Dateien.
+
+### Negation
+
+```bash
+find . -type f ! -iname "*.mp3"
+```
+
+Alle Dateien, die NICHT auf `.mp3` enden.
+
+Mehrere Endungen ausschließen:
+
+```bash
+find . -type f ! \( -iname "*.mp3" -o -iname "*.flac" \)
+```
+
+## Aktionen auf gefundene Dateien
+
+### Anzeigen
+
+```bash
+find . -name "*.log" -print     # Standard
+find . -name "*.log" -ls        # mit Details
+```
+
+### Dateien löschen
+
+**Grundprinzip:** Immer erst testen, dann löschen!
+
+```bash
+# 1. Testen
+find . -name "*.tmp" -print
+
+# 2. Anzahl prüfen
+find . -name "*.tmp" | wc -l
+
+# 3. Dry-run
+find . -name "*.tmp" -exec echo rm {} +
+
+# 4. Löschen
+find . -name "*.tmp" -delete
+```
+
+Alternative mit `-exec`:
+
+```bash
+find . -name "*.tmp" -exec rm {} +      # effizient (mehrere auf einmal)
+find . -name "*.tmp" -exec rm {} \;     # einzeln
+find . -name "*.tmp" -exec rm -i {} \;  # mit Rückfrage
+```
+
+Mit xargs (sicher bei Leerzeichen):
+
+```bash
+find . -name "*.tmp" -print0 | xargs -0 rm
+```
+
+### Mit -exec Befehle ausführen
+
+```bash
+find . -name "*.log" -exec rm {} +              # Löschen
+find . -type f -name "*.sh" -exec chmod +x {} + # Ausführbar machen
+find /etc -type f -mtime -1 -exec cp {} /backup/ \;  # Kopieren
+find . -type f -name "*.log" -mtime +7 -exec gzip {} +  # Komprimieren
+```
+
+- `{}` = Platzhalter für gefundene Datei
+- `\;` = Ende des Befehls (einzeln, langsamer)
+- `+` = mehrere Dateien gleichzeitig (effizienter)
+
+### Komplexe Shell-Befehle
+
+```bash
+find . -type f -name "*.jpg" -exec sh -c 'for f; do 
+  convert "$f" -resize 800x "${f%.jpg}_small.jpg"
+done' _ {} +
+```
+
+## Pfad- und Namensfilter
+
+### Mit -path (Glob-Muster)
+
+```bash
+find ~/Musik -type f -path "*/zzz Verschiedene/AlbumArt_*"
+```
+
+`-path` verwendet Shell-Wildcards (Globs), nicht reguläre Ausdrücke.
+
+### Mit -regex (Reguläre Ausdrücke)
+
+```bash
+find ~/Musik -type f -regextype posix-extended \
+  -regex '.*/zzz Verschiedene/AlbumArt_.*'
+```
+
+`-regex` matcht den gesamten Pfad, daher oft `.*` am Anfang nötig.
+
+## Praktische Anwendungsfälle
+
+### Alte Dateien löschen
+
+```bash
+find /tmp -type f -mtime +7 -delete
+```
+
+### Leere Dateien/Verzeichnisse finden
+
+```bash
+find . -type f -empty   # leere Dateien
+find . -type d -empty   # leere Ordner
+```
+
+### Dateien mit falschen Rechten
+
+```bash
+find / -type f -perm -o+w    # weltweit schreibbar
+```
+
+### Große Dateien finden
+
+```bash
+find /home -type f -size +100M
+find . -type f -exec du -h {} + | sort -rh | head -10  # Top 10 größte
+```
+
+### Dateien nach Datum und Pfad
+
+```bash
+find ~/Musik -type f \
+  -newermt "2025-04-01" \
+  -path "*/zzz Verschiedene/AlbumArt_*" \
+  -print
+```
+
+### Dateien sichern
+
+```bash
+find /etc -type f -mtime -1 -exec cp {} /backup/ \;
+```
+
+### Backup-Kandidaten mit Datum
+
+```bash
+find /backups -type f -name "*.tar.gz" \
+  -newermt "2023-08-01" ! -newermt "2023-08-31"
+```
+
+### Logfile-Analyse
+
+```bash
+find /var/log -type f -size +100M -newermt "2023-09-01"
+```
+
+### Nur Dateien, nicht Verzeichnisse ändern
+
+```bash
+find . -type f -exec chmod 644 {} +
+find . -type d -exec chmod 755 {} +
+```
+
+## Best Practices und Fehler vermeiden
+
+### Sicherheit beim Löschen
+
+```bash
+# IMMER erst testen
+find . -name "*.tmp" -print
+find . -name "*.tmp" | wc -l
+find . -name "*.tmp" -exec echo rm {} +
+
+# Dann löschen
+find . -name "*.tmp" -delete
+```
+
+### Leerzeichen in Dateinamen
+
+```bash
+# RICHTIG: -print0 und xargs -0
+find . -name "*.txt" -print0 | xargs -0 rm
+
+# RICHTIG: -exec mit +
+find . -name "*.txt" -exec rm {} +
+
+# FALSCH: Pipe ohne -print0
+find . -name "*.txt" | rm  # funktioniert nicht!
+```
+
+### Trailing Slash bei -path
+
+```bash
+find . -path "*/ordner/*"   # Dateien IN ordner/
+find . -path "*/ordner"     # NUR ordner/ selbst
+```
+
+### -delete Reihenfolge
+
+```bash
+# RICHTIG: -type f VOR -delete
+find . -type f -name "*.tmp" -delete
+
+# FALSCH: kann Verzeichnisse löschen
+find . -name "*.tmp" -delete
+```
+
+### Zu viele Argumente
+
+```bash
+# FALSCH: kann "Argument list too long" geben
+find . -name "*.txt" -exec rm {} \;
+
+# RICHTIG: mit +
+find . -name "*.txt" -exec rm {} +
+
+# RICHTIG: mit xargs
+find . -name "*.txt" -print0 | xargs -0 rm
+```
+
+## Alternative Tools
+
+- **fd** - moderner, schneller find-Ersatz mit besserer Syntax
+- **ripgrep (rg)** - für Textsuche in Dateien
+- **locate** - schnelle Dateinamensuche (nutzt Datenbank)
+
+Beispiel mit fd:
+
+```bash
+fd "*.log"                    # Einfacher als find
+fd -t f -s +100M              # Dateien > 100MB
+fd -e jpg -x convert {} ...   # Mit exec
+```
+
+## Siehe auch
+
+- [[ls]] - Dateien auflisten
+- [[grep]] - Textsuche in gefundenen Dateien
+- [[Dateiberechtigungen]] - Rechte und Eigentümer von Dateien
+- [[tar]] - Gefundene Dateien archivieren
+- [[rsync]] - Dateien synchronisieren
+- [[sed]] - Gefundene Dateien bearbeiten
+- [[awk]] - Ausgabe von find verarbeiten

Linux/BASH Basics/fstab Credentials.md

@@ -0,0 +1,127 @@
+# fstab - Credentials sicher speichern
+
+Zugangsdaten (Benutzername/Passwort) sollten nicht im Klartext in `/etc/fstab` stehen.
+
+## Credentials-Datei verwenden
+
+Viele Treiber wie `cifs` oder `smbfs` unterstützen separate Credential-Dateien.
+
+### fstab-Eintrag
+
+```fstab
+//server/share /mnt/share cifs credentials=/etc/samba/credentials,iocharset=utf8,uid=1000,gid=1000 0 0
+```
+
+### Credentials-Datei erstellen
+
+**/etc/samba/credentials:**
+```
+username=meinuser
+password=meinpasswort
+domain=meinedomain
+```
+
+### Datei absichern
+
+```bash
+sudo chmod 600 /etc/samba/credentials
+sudo chown root:root /etc/samba/credentials
+```
+
+Nur root kann die Datei lesen, `/etc/fstab` enthält keine Secrets.
+
+## Kernel Keyring nutzen
+
+Für temporäre Mounts (z.B. bei CIFS):
+
+```bash
+cifscreds add -u meinuser servername
+```
+
+Dann kann der Mount in fstab ohne Passwort erfolgen - der Kernel holt die Daten aus dem Keyring.
+
+**Hinweis:** Funktioniert hauptsächlich für interaktive Sessions, nicht für automatische Boot-Mounts.
+
+## Systemd-Units verwenden
+
+Statt `/etc/fstab` kann man systemd `.mount`-Units mit Credentials nutzen.
+
+**Beispiel:** `/etc/systemd/system/mnt-share.mount`
+
+```ini
+[Unit]
+Description=SMB Share Mount
+
+[Mount]
+What=//server/share
+Where=/mnt/share
+Type=cifs
+Options=credentials=/etc/samba/credentials,iocharset=utf8,uid=1000,gid=1000
+
+[Install]
+WantedBy=multi-user.target
+```
+
+Aktivieren:
+
+```bash
+sudo systemctl daemon-reload
+sudo systemctl enable mnt-share.mount
+sudo systemctl start mnt-share.mount
+```
+
+## Kerberos-Authentifizierung
+
+Für Netzwerke mit Active Directory oder Kerberos:
+
+### NFS mit Kerberos
+
+```fstab
+server:/export /mnt/nfs nfs sec=krb5,rw 0 0
+```
+
+### CIFS mit Kerberos
+
+```fstab
+//server/share /mnt/share cifs sec=krb5,multiuser,rw 0 0
+```
+
+Keine Passwörter nötig - Authentifizierung über Kerberos-Tickets.
+
+## Secrets-Management-Systeme
+
+Für Produktivumgebungen mit höheren Sicherheitsanforderungen:
+
+- **HashiCorp Vault** - zentrales Secrets-Management
+- **AWS Secrets Manager** - für Cloud-Umgebungen
+- **GPG-verschlüsselte Dateien** - lokal verschlüsselt
+
+Beispiel mit GPG:
+
+```bash
+# Credentials verschlüsselt speichern
+echo "username=user\npassword=pass" | gpg -e -r you@example.com > /etc/samba/credentials.gpg
+
+# In Mount-Skript entschlüsseln
+gpg -d /etc/samba/credentials.gpg > /tmp/credentials
+mount -t cifs -o credentials=/tmp/credentials //server/share /mnt/share
+rm /tmp/credentials
+```
+
+## Zusammenfassung
+
+| Methode | Sicherheit | Komplexität | Anwendungsfall |
+|---------|-----------|-------------|----------------|
+| Credentials-Datei | Gut | Niedrig | Standard für CIFS/SMB |
+| Kernel Keyring | Mittel | Mittel | Interaktive Sessions |
+| Kerberos | Sehr gut | Hoch | Enterprise/AD-Umgebungen |
+| Systemd-Credentials | Sehr gut | Mittel | Moderne Systeme |
+| Secrets Manager | Sehr gut | Hoch | Produktivumgebungen |
+
+**Empfehlung:** Für den Alltag ist eine separate Credentials-Datei mit restriktiven Rechten (600) der beste Kompromiss aus Sicherheit und Einfachheit.
+
+## Siehe auch
+
+- [[Symlinks]] - Symbolische Links erstellen
+- [[Dateiberechtigungen]] - Dateien absichern mit chmod/chown
+- [[lsblk]] - Block-Geräte anzeigen

Linux/BASH Basics/grep.md

@@ -0,0 +1,202 @@
+# grep - Textsuche in Dateien
+
+Der `grep`-Befehl durchsucht Dateien oder Textströme nach Mustern (Strings oder reguläre Ausdrücke).
+
+## Grundsyntax
+
+```bash
+grep [OPTIONEN] MUSTER [DATEI...]
+```
+
+## Einfache Suche
+
+```bash
+grep "suchtext" datei.txt
+```
+
+In mehreren Dateien:
+
+```bash
+grep "suchtext" *.txt
+```
+
+Rekursiv in Verzeichnissen:
+
+```bash
+grep -r "suchtext" /pfad/zum/verzeichnis
+```
+
+## Wichtige Optionen
+
+### Groß-/Kleinschreibung
+
+```bash
+grep -i "suchtext" datei.txt    # case-insensitive
+```
+
+### Zeilen mit Kontext
+
+```bash
+grep -A 3 "suchtext" datei.txt  # 3 Zeilen danach
+grep -B 3 "suchtext" datei.txt  # 3 Zeilen davor
+grep -C 3 "suchtext" datei.txt  # 3 Zeilen davor und danach
+```
+
+### Nur Dateinamen anzeigen
+
+```bash
+grep -l "suchtext" *.txt        # Dateien mit Treffer
+grep -L "suchtext" *.txt        # Dateien ohne Treffer
+```
+
+### Zeilennummern anzeigen
+
+```bash
+grep -n "suchtext" datei.txt
+```
+
+### Anzahl der Treffer
+
+```bash
+grep -c "suchtext" datei.txt
+```
+
+### Invertierte Suche (nicht enthalten)
+
+```bash
+grep -v "suchtext" datei.txt
+```
+
+Zeigt alle Zeilen, die den Suchtext NICHT enthalten.
+
+### Ganzes Wort
+
+```bash
+grep -w "wort" datei.txt
+```
+
+Findet "wort", aber nicht "worte" oder "hauptwort".
+
+## Reguläre Ausdrücke
+
+### Einfache Regex (Basic)
+
+```bash
+grep "^Start" datei.txt         # Zeilen, die mit "Start" beginnen
+grep "Ende$" datei.txt          # Zeilen, die mit "Ende" enden
+grep "^$" datei.txt             # Leere Zeilen
+```
+
+### Extended Regex
+
+```bash
+grep -E "fehler|warnung" datei.txt          # fehler ODER warnung
+grep -E "[0-9]{3}-[0-9]{4}" datei.txt       # Telefonnummern
+grep -E "^(root|admin)" /etc/passwd         # Zeilen mit root oder admin am Anfang
+```
+
+### Perl-kompatible Regex
+
+```bash
+grep -P "\d{3}-\d{4}" datei.txt
+```
+
+## Praktische Anwendungsfälle
+
+### Logfiles durchsuchen
+
+```bash
+grep -i "error" /var/log/syslog
+grep -E "error|warning|critical" /var/log/syslog
+```
+
+### Mit Zeitstempel
+
+```bash
+grep "2025-11-07" /var/log/application.log
+```
+
+### Konfigurationsdateien
+
+```bash
+# Alle nicht-kommentierten Zeilen
+grep -v "^#" /etc/ssh/sshd_config | grep -v "^$"
+```
+
+### In komprimierten Dateien
+
+```bash
+zgrep "suchtext" datei.log.gz
+```
+
+### Mit find kombinieren
+
+```bash
+find . -name "*.log" -exec grep -l "ERROR" {} +
+```
+
+### Mehrere Muster aus Datei
+
+```bash
+grep -f muster.txt datei.txt
+```
+
+**muster.txt:**
+```
+fehler
+warnung
+critical
+```
+
+## Pipe-Verwendung
+
+```bash
+ps aux | grep firefox
+cat datei.txt | grep -v "^#" | grep "wichtig"
+dmesg | grep -i usb
+```
+
+## Farbige Ausgabe
+
+```bash
+grep --color=auto "suchtext" datei.txt
+```
+
+Alias in `.bashrc` setzen:
+
+```bash
+alias grep='grep --color=auto'
+```
+
+## Alternative Tools
+
+- **ripgrep (rg)** - sehr schnell, modern, empfohlen
+- **ag (The Silver Searcher)** - schneller als grep
+- **ack** - für Code-Suche optimiert
+
+Beispiel mit ripgrep:
+
+```bash
+rg "suchtext" /pfad  # automatisch rekursiv, ignoriert .gitignore
+```
+
+## Zusammenfassung wichtiger Optionen
+
+| Option | Beschreibung |
+|--------|--------------|
+| `-i` | Case-insensitive |
+| `-r` | Rekursiv |
+| `-n` | Mit Zeilennummern |
+| `-c` | Anzahl der Treffer |
+| `-l` | Nur Dateinamen |
+| `-v` | Invertiert (nicht enthalten) |
+| `-w` | Ganzes Wort |
+| `-E` | Extended Regex |
+| `-A/-B/-C` | Kontext anzeigen |
+
+## Siehe auch
+
+- [[find]] - Dateien nach Namen/Eigenschaften suchen
+- [[sed]] - Stream-Editor für Textmanipulation
+- [[awk]] - Textverarbeitung und Datenextraktion
+- [[ls]] - Ausgabe von ls filtern

Linux/BASH Basics/ls.md

@@ -0,0 +1,390 @@
+# ls - Dateien und Verzeichnisse auflisten
+
+Der `ls`-Befehl listet Dateien und Verzeichnisse auf und zeigt deren Eigenschaften.
+
+## Grundsyntax
+
+```bash
+ls [OPTIONEN] [PFAD...]
+```
+
+## Grundlegende Verwendung
+
+### Einfache Auflistung
+
+```bash
+ls                  # Aktuelles Verzeichnis
+ls /pfad/zum/ordner # Bestimmtes Verzeichnis
+ls datei.txt       # Einzelne Datei
+```
+
+### Versteckte Dateien anzeigen
+
+```bash
+ls -a              # Alle Dateien (inkl. .dotfiles)
+ls -A              # Alle außer . und ..
+```
+
+## Detaillierte Ausgabe
+
+### Long Format (-l)
+
+```bash
+ls -l
+```
+
+Beispielausgabe:
+```
+-rw-r--r-- 1 alice developers 1234 Nov  7 10:00 datei.txt
+drwxr-xr-x 2 alice developers 4096 Nov  7 09:30 ordner
+lrwxrwxrwx 1 alice developers   15 Nov  7 08:00 link -> /pfad/zu/ziel
+```
+
+Spalten:
+- **1. Zeichen**: Typ (`-` = Datei, `d` = Verzeichnis, `l` = Link)
+- **2-10**: Rechte (rwx für User, Group, Others)
+- **Zahl**: Anzahl Hardlinks
+- **User**: Eigentümer
+- **Group**: Gruppe
+- **Größe**: in Bytes
+- **Datum/Zeit**: letzte Änderung
+- **Name**: Dateiname
+
+### Menschenlesbare Größen (-h)
+
+```bash
+ls -lh
+```
+
+Beispielausgabe:
+```
+-rw-r--r-- 1 user staff  12K Nov  7 10:00 file.txt
+-rw-r--r-- 1 user staff 1.2M Nov  7 09:30 big.dat
+drwxr-xr-x 2 user staff 4.0K Nov  7 08:00 ordner
+```
+
+Größen werden in KB, MB, GB statt Bytes angezeigt.
+
+## Sortierung
+
+### Nach Name (Standard)
+
+```bash
+ls              # Alphabetisch
+ls -r           # Umgekehrt
+```
+
+### Nach Änderungsdatum
+
+```bash
+ls -lt          # Neueste zuerst
+ls -ltr         # Älteste zuerst
+```
+
+### Nach Größe
+
+```bash
+ls -lS          # Größte zuerst
+ls -lSr         # Kleinste zuerst
+```
+
+### Nach Erweiterung
+
+```bash
+ls -lX          # Gruppiert nach Dateityp
+```
+
+## Rekursive Auflistung
+
+```bash
+ls -R           # Alle Unterverzeichnisse
+ls -R /pfad     # Ab bestimmtem Pfad
+```
+
+## Nur bestimmte Dateien
+
+### Mit Wildcards
+
+```bash
+ls *.txt        # Alle .txt Dateien
+ls *.{jpg,png}  # Alle .jpg und .png
+ls file[0-9]*   # file0, file1, file2, ...
+```
+
+### Nur Verzeichnisse
+
+```bash
+ls -d */        # Nur Verzeichnisse
+ls -ld */       # Mit Details
+```
+
+### Nur Dateien (keine Verzeichnisse)
+
+```bash
+ls -p | grep -v /
+```
+
+## Farben
+
+```bash
+ls --color=auto     # Farbige Ausgabe
+ls --color=never    # Ohne Farben
+ls --color=always   # Immer Farben (auch in Pipes)
+```
+
+Typische Farben:
+- **Blau**: Verzeichnisse
+- **Grün**: Ausführbare Dateien
+- **Cyan**: Symbolische Links
+- **Rot**: Archive
+- **Gelb**: Devices
+
+## Spezielle Formate
+
+### Einzelne Spalte
+
+```bash
+ls -1           # Eine Datei pro Zeile
+```
+
+### Komma-getrennt
+
+```bash
+ls -m           # Komma-getrennte Liste
+```
+
+### Mit Inode-Nummern
+
+```bash
+ls -i           # Zeigt Inode-Nummern
+```
+
+### Numerische UIDs/GIDs
+
+```bash
+ls -n           # User/Group als Zahlen statt Namen
+```
+
+## Dateigrößen analysieren
+
+### Größe einzelner Dateien
+
+```bash
+ls -lh datei.txt
+```
+
+Ausgabe:
+```
+-rw-r--r-- 1 user staff 12K Nov 7 10:00 datei.txt
+```
+
+### Größe mit stat
+
+Nur die Größe in Bytes:
+
+```bash
+stat -c%s datei.txt
+```
+
+Mit Dateiname:
+
+```bash
+stat -c "%s %n" *
+```
+
+### Größe von Verzeichnissen
+
+`ls` zeigt nur die Größe des Verzeichniseintrags (meist 4K), nicht den Inhalt!
+
+Für echte Verzeichnisgröße nutze `du`:
+
+```bash
+du -sh ordner/          # Gesamtgröße
+du -h --max-depth=1     # Größen aller Unterordner
+```
+
+Beispielausgabe:
+```
+200M    ./Bilder
+1.3G    ./Videos
+50K     ./Dokumente
+1.5G    .
+```
+
+Mit 1000er-Schritten statt 1024er:
+
+```bash
+du -h --si --max-depth=1
+```
+
+### Nach Größe sortiert
+
+```bash
+du -sh * | sort -h      # Alle Dateien/Ordner sortiert
+ls -lhS                 # Nur Dateien, größte zuerst
+```
+
+### Größte Dateien finden
+
+Top 10 größte Dateien:
+
+```bash
+du -ah . | sort -rh | head -n 10
+```
+
+Mit [[find]]:
+
+```bash
+find . -type f -exec du -h {} + | sort -rh | head -n 10
+```
+
+### Speicherplatznutzung überwachen
+
+Gesamter Speicherplatz:
+
+```bash
+df -h                   # Dateisysteme
+df -h /home             # Bestimmter Mountpoint
+```
+
+## Zeitstempel
+
+### Änderungszeit (Standard)
+
+```bash
+ls -l               # Zeigt mtime (modification time)
+```
+
+### Zugriffszeit
+
+```bash
+ls -lu              # Zeigt atime (access time)
+```
+
+### Statusänderungszeit
+
+```bash
+ls -lc              # Zeigt ctime (change time)
+```
+
+### Mit vollständigem Zeitstempel
+
+```bash
+ls -l --time-style=full-iso
+ls -l --time-style=long-iso
+ls -l --time-style=iso
+```
+
+## Praktische Kombinationen
+
+### Übersichtliche Dateiliste
+
+```bash
+ls -lhA             # Details, lesbar, alle außer . und ..
+ls -lhAtr           # Dazu sortiert nach Datum, älteste zuerst
+```
+
+### Schnelle Dateisuche
+
+```bash
+ls -la | grep datei  # Suche in aktueller Liste
+```
+
+### Nur Größen von Verzeichnissen
+
+```bash
+du -sh */           # Alle Unterverzeichnisse
+```
+
+### Dateien nach Änderung heute
+
+```bash
+ls -lt | head       # Neueste Dateien
+```
+
+### Ausführbare Dateien finden
+
+```bash
+ls -l | grep '^-..x'
+```
+
+### Große Dateien finden
+
+```bash
+ls -lhS | head -n 10    # Top 10 größte Dateien
+```
+
+### Versteckte Dateien zählen
+
+```bash
+ls -A | wc -l
+```
+
+## Nützliche Aliases
+
+Setze in `~/.bashrc`:
+
+```bash
+alias ll='ls -lhA'
+alias la='ls -A'
+alias l='ls -CF'
+alias lt='ls -lhAtr'
+alias lsize='ls -lhS'
+```
+
+## Zusammen mit anderen Befehlen
+
+### Mit find
+
+```bash
+find . -name "*.log" -exec ls -lh {} \;
+```
+
+### Mit grep
+
+```bash
+ls -la | grep "Nov  7"      # Dateien von heute
+ls -la | grep "^d"          # Nur Verzeichnisse
+```
+
+### Mit awk
+
+```bash
+ls -l | awk '{print $9, $5}'    # Name und Größe
+```
+
+### Mit xargs
+
+```bash
+ls *.txt | xargs rm         # VORSICHT: Löscht alle .txt
+```
+
+## Fehler vermeiden
+
+### Dateien mit Leerzeichen
+
+```bash
+# FALSCH
+ls *.txt | xargs rm
+
+# RICHTIG
+find . -name "*.txt" -print0 | xargs -0 rm
+```
+
+### Alias-Konflikte
+
+Viele Systeme haben `ls` als Alias mit `--color=auto` definiert. Um den echten Befehl zu nutzen:
+
+```bash
+\ls                 # Umgeht Alias
+command ls          # Umgeht Alias
+/bin/ls            # Direkter Pfad
+```
+
+## Siehe auch
+
+- [[find]] - Erweiterte Dateisuche mit Kriterien
+- [[grep]] - Ausgabe filtern
+- [[Dateiberechtigungen]] - Bedeutung der Rechtespalten
+- [[lsblk]] - Block-Geräte statt Dateien
+- [[du]] - Detaillierte Größenanalyse

Linux/BASH Basics/lsblk.md

@@ -0,0 +1,177 @@
+# lsblk - Block-Geräte auflisten
+
+Der Befehl `lsblk` (list block devices) zeigt eine hierarchische Übersicht aller Blockgeräte: Festplatten, SSDs, USB-Sticks, Partitionen, LVMs, RAID-Geräte usw.
+
+## Grundsyntax
+
+```bash
+lsblk [OPTIONEN] [GERÄTE...]
+```
+
+Ohne Parameter werden alle erkannten Blockgeräte in Baumstruktur angezeigt.
+
+## Typische Ausgabe
+
+```bash
+lsblk
+```
+
+Beispiel:
+
+```
+NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
+sda      8:0    0   512G  0 disk 
+├─sda1   8:1    0   512M  0 part /boot/efi
+├─sda2   8:2    0    64G  0 part /
+└─sda3   8:3    0 447.5G  0 part /home
+sdb      8:16   1   128G  0 disk 
+└─sdb1   8:17   1   128G  0 part /media/usb
+```
+
+Spalten:
+- **NAME** = Gerätename (sda, sdb, ...)
+- **SIZE** = Größe
+- **TYPE** = Art (disk, part, rom, lvm ...)
+- **MOUNTPOINTS** = Einbindungspunkt im Dateisystem
+
+## Wichtige Optionen
+
+### Bestimmte Spalten anzeigen
+
+```bash
+lsblk -o NAME,FSTYPE,SIZE,MOUNTPOINT
+```
+
+Beispiel:
+
+```
+NAME   FSTYPE SIZE MOUNTPOINT
+sda           512G 
+├─sda1 vfat   512M /boot/efi
+├─sda2 ext4    64G /
+└─sda3 ext4 447.5G /home
+```
+
+### Dateisystemtypen anzeigen
+
+```bash
+lsblk -f
+```
+
+Zeigt Dateisystemtyp, UUID und Label.
+
+### Nur Geräte ohne Partitionen
+
+```bash
+lsblk -d
+```
+
+Zeigt nur die Hauptgeräte (`sda`, `sdb`), keine Partitionen.
+
+### Alle Geräte inklusive leere
+
+```bash
+lsblk -a
+```
+
+Zeigt auch Geräte ohne Medium (z.B. leere CD-Laufwerke).
+
+### Mit UUIDs und Labels
+
+```bash
+lsblk -o NAME,SIZE,UUID,LABEL,MOUNTPOINT
+```
+
+Wichtig für eindeutige Identifizierung in `/etc/fstab`.
+
+### Nur Namen ausgeben
+
+```bash
+lsblk -n -o NAME
+```
+
+Beispiel:
+
+```
+sda
+sda1
+sda2
+sda3
+sdb
+sdb1
+```
+
+Praktisch für Skripte.
+
+### Listen- oder JSON-Format
+
+```bash
+lsblk -l   # Listenformat
+lsblk -J   # JSON-Format
+```
+
+## Praktische Anwendungsfälle
+
+### Herausfinden, welche Geräte angeschlossen sind
+
+```bash
+lsblk
+```
+
+### Prüfen, welche Partitionen wohin gemountet sind
+
+```bash
+lsblk -o NAME,SIZE,MOUNTPOINT
+```
+
+### Dateisystemtypen ermitteln
+
+```bash
+lsblk -f
+```
+
+### Neu eingesteckten USB-Stick identifizieren
+
+Vorher:
+```bash
+lsblk
+```
+
+Stick einstecken, dann:
+```bash
+lsblk
+```
+
+Das neue Gerät (z.B. `sdb1`) erscheint.
+
+### UUIDs für fstab ermitteln
+
+```bash
+lsblk -o NAME,UUID,MOUNTPOINT
+```
+
+### Geräte mit bestimmtem Dateisystem finden
+
+```bash
+lsblk -o NAME,FSTYPE,SIZE | grep ext4
+```
+
+## Zusammenfassung wichtiger Optionen
+
+| Option | Beschreibung |
+|--------|--------------|
+| `lsblk` | Baumstruktur aller Blockgeräte |
+| `lsblk -f` | Mit Dateisystemtypen |
+| `lsblk -d` | Nur Hauptgeräte |
+| `lsblk -a` | Alle inkl. leere Geräte |
+| `lsblk -o SPALTEN` | Bestimmte Spalten |
+| `lsblk -l` | Listenformat |
+| `lsblk -J` | JSON-Format |
+
+## Siehe auch
+
+- [[ls]] - Dateien und Verzeichnisse auflisten
+- [[find]] - Dateien suchen
+- [[fstab Credentials]] - Geräte automatisch einbinden
+- [[Symlinks]] - Verknüpfungen zu Geräten
+- [[Dateiberechtigungen]] - Rechte von Geräten prüfen

Linux/BASH Basics/rsync.md

@@ -0,0 +1,275 @@
+# rsync - Dateien synchronisieren
+
+Der `rsync`-Befehl synchronisiert Dateien und Verzeichnisse effizient zwischen verschiedenen Orten (lokal oder über Netzwerk).
+
+## Grundsyntax
+
+```bash
+rsync [OPTIONEN] QUELLE ZIEL
+```
+
+## Grundlegende Optionen
+
+Die häufigste Kombination:
+
+```bash
+rsync -av quelle/ ziel/
+```
+
+- `-a` = archive (behält Rechte, Zeitstempel, Symlinks)
+- `-v` = verbose (zeigt Details)
+
+## Lokale Synchronisation
+
+### Verzeichnis synchronisieren
+
+```bash
+rsync -av /quelle/verzeichnis/ /ziel/verzeichnis/
+```
+
+**Wichtig:** Trailing Slash `/` macht einen Unterschied!
+
+```bash
+rsync -av quelle/ ziel/     # Inhalt von quelle/ nach ziel/
+rsync -av quelle ziel/      # quelle/ als Unterordner in ziel/quelle/
+```
+
+## Über Netzwerk (SSH)
+
+### Zu Remote-Server
+
+```bash
+rsync -av /lokaler/pfad/ user@server:/remote/pfad/
+```
+
+### Von Remote-Server
+
+```bash
+rsync -av user@server:/remote/pfad/ /lokaler/pfad/
+```
+
+### Anderen SSH-Port
+
+```bash
+rsync -av -e "ssh -p 2222" /lokal/ user@server:/remote/
+```
+
+## Wichtige Optionen
+
+### Fortschritt anzeigen
+
+```bash
+rsync -av --progress quelle/ ziel/
+```
+
+### Dry-run (simulieren)
+
+```bash
+rsync -avn quelle/ ziel/
+```
+
+- `-n` = dry-run (nichts ändern, nur anzeigen)
+
+### Dateien löschen im Ziel
+
+```bash
+rsync -av --delete quelle/ ziel/
+```
+
+Löscht Dateien im Ziel, die in der Quelle nicht existieren.
+
+### Kompression (für Netzwerk)
+
+```bash
+rsync -avz quelle/ user@server:/remote/
+```
+
+- `-z` = compress (während Übertragung)
+
+### Teilweise übertragene Dateien behalten
+
+```bash
+rsync -av --partial quelle/ ziel/
+```
+
+Nützlich bei unterbrochenen Übertragungen.
+
+### Bandbreite begrenzen
+
+```bash
+rsync -av --bwlimit=1000 quelle/ ziel/
+```
+
+Begrenzt auf 1000 KB/s.
+
+## Dateien ausschließen
+
+### Einzelne Muster
+
+```bash
+rsync -av --exclude='*.tmp' --exclude='.git' quelle/ ziel/
+```
+
+### Aus Datei
+
+```bash
+rsync -av --exclude-from=exclude.txt quelle/ ziel/
+```
+
+**exclude.txt:**
+```
+*.tmp
+*.log
+.git/
+node_modules/
+```
+
+### Nur bestimmte Dateien
+
+```bash
+rsync -av --include='*.pdf' --exclude='*' quelle/ ziel/
+```
+
+## Praktische Beispiele
+
+### Backup erstellen
+
+```bash
+rsync -av --delete /home/user/dokumente/ /backup/dokumente/
+```
+
+### Backup mit Zeitstempel
+
+```bash
+rsync -av /quelle/ /backup/backup-$(date +%Y%m%d)/
+```
+
+### Nur geänderte Dateien kopieren
+
+```bash
+rsync -av --update quelle/ ziel/
+```
+
+Überschreibt nur, wenn Quelle neuer ist.
+
+### Große Dateien übertragen
+
+```bash
+rsync -av --progress --partial-dir=.rsync-partial quelle/ ziel/
+```
+
+### Backup auf NAS
+
+```bash
+rsync -av --delete /home/user/ user@nas:/backup/user/
+```
+
+### Website hochladen
+
+```bash
+rsync -avz --delete website/ user@webserver:/var/www/html/
+```
+
+### Mit Ausschlüssen
+
+```bash
+rsync -av --delete \
+  --exclude='node_modules' \
+  --exclude='.git' \
+  --exclude='*.log' \
+  projekt/ /backup/projekt/
+```
+
+## Inkrementelles Backup
+
+```bash
+#!/bin/bash
+CURRENT=/backup/current
+TIMESTAMP=$(date +%Y%m%d-%H%M%S)
+
+rsync -av --delete --link-dest=$CURRENT /quelle/ /backup/$TIMESTAMP/
+rm -f $CURRENT
+ln -s $TIMESTAMP $CURRENT
+```
+
+Erstellt platzsparende Backups durch Hardlinks.
+
+## Rechte und Eigentümer
+
+### Rechte bewahren
+
+```bash
+rsync -av quelle/ ziel/  # Standard mit -a
+```
+
+### Als Root mit Original-Eigentümer
+
+```bash
+sudo rsync -av quelle/ ziel/
+```
+
+### Nur als aktueller User
+
+```bash
+rsync -rlptv quelle/ ziel/
+```
+
+Ohne `-o` und `-g` (Owner und Group).
+
+## Fehler vermeiden
+
+### Dry-run erst testen
+
+```bash
+rsync -avn --delete quelle/ ziel/
+```
+
+Prüfe die Ausgabe, bevor du wirklich synchronisierst!
+
+### Slash bei Quelle beachten
+
+```bash
+rsync -av quelle/ ziel/   # Inhalt synchronisieren
+rsync -av quelle ziel/    # Ordner synchronisieren
+```
+
+### Mit --delete vorsichtig sein
+
+```bash
+# FALSCH - löscht alles im Ziel!
+rsync -av --delete /leerer/ordner/ /wichtig/
+
+# RICHTIG - erst prüfen
+rsync -avn --delete quelle/ ziel/
+```
+
+## Vergleich mit anderen Tools
+
+| Tool | Geschwindigkeit | Delta-Transfer | Netzwerk | Verschlüsselung |
+|------|----------------|----------------|----------|-----------------|
+| `rsync` | Schnell | Ja | SSH | Via SSH |
+| `scp` | Mittel | Nein | SSH | Ja |
+| `cp` | Sehr schnell | Nein | Nein | Nein |
+| `tar` | Mittel | Nein | Pipe möglich | Optional |
+
+## Monitoring
+
+### Fortschritt detailliert
+
+```bash
+rsync -av --progress --stats quelle/ ziel/
+```
+
+### Nur Zusammenfassung
+
+```bash
+rsync -av --stats quelle/ ziel/
+```
+
+## Siehe auch
+
+- [[tar]] - Archive erstellen
+- [[find]] - Dateien für Backup finden
+- [[Symlinks]] - Links bleiben mit -a erhalten
+- [[Dateiberechtigungen]] - Rechte und Eigentümer nach rsync
+- [[ls]] - Übertragene Dateien anzeigen

Linux/BASH Basics/sed.md

@@ -0,0 +1,270 @@
+# sed - Stream Editor
+
+Der `sed`-Befehl ist ein Stream-Editor für Textmanipulation. Er eignet sich besonders für Suchen-und-Ersetzen-Operationen.
+
+## Grundsyntax
+
+```bash
+sed [OPTIONEN] 'BEFEHL' [DATEI...]
+```
+
+## Suchen und Ersetzen
+
+### Grundlegendes Ersetzen
+
+```bash
+sed 's/alt/neu/' datei.txt
+```
+
+Ersetzt erste Vorkommen in jeder Zeile.
+
+### Alle Vorkommen in Zeile
+
+```bash
+sed 's/alt/neu/g' datei.txt
+```
+
+- `g` = global (alle Vorkommen)
+
+### Datei direkt ändern
+
+```bash
+sed -i 's/alt/neu/g' datei.txt
+```
+
+- `-i` = in-place (Datei wird geändert)
+
+### Backup vor Änderung
+
+```bash
+sed -i.bak 's/alt/neu/g' datei.txt
+```
+
+Erstellt `datei.txt.bak` vor Änderung.
+
+## Zeilen auswählen
+
+### Bestimmte Zeile
+
+```bash
+sed -n '5p' datei.txt       # Nur Zeile 5
+sed '5d' datei.txt          # Zeile 5 löschen
+sed '5s/alt/neu/' datei.txt # Nur in Zeile 5 ersetzen
+```
+
+### Zeilenbereich
+
+```bash
+sed -n '10,20p' datei.txt   # Zeilen 10-20 anzeigen
+sed '10,20d' datei.txt      # Zeilen 10-20 löschen
+```
+
+### Letzte Zeile
+
+```bash
+sed -n '$p' datei.txt       # Letzte Zeile
+```
+
+### Muster-basiert
+
+```bash
+sed '/^#/d' datei.txt       # Zeilen mit # am Anfang löschen
+sed '/ERROR/s/foo/bar/' datei.txt  # Nur in Zeilen mit ERROR
+```
+
+## Zeilen einfügen und anhängen
+
+### Vor Zeile einfügen
+
+```bash
+sed '3i\Neue Zeile' datei.txt
+```
+
+### Nach Zeile anhängen
+
+```bash
+sed '3a\Neue Zeile' datei.txt
+```
+
+### Nach Muster
+
+```bash
+sed '/TODO/a\WICHTIG: Bitte bearbeiten' datei.txt
+```
+
+## Zeilen löschen
+
+### Leere Zeilen
+
+```bash
+sed '/^$/d' datei.txt
+```
+
+### Kommentare
+
+```bash
+sed '/^#/d' datei.txt
+```
+
+### Mehrere Muster
+
+```bash
+sed -e '/^#/d' -e '/^$/d' datei.txt
+```
+
+## Reguläre Ausdrücke
+
+### Erweiterte Regex
+
+```bash
+sed -E 's/[0-9]{3}-[0-9]{4}/XXX-XXXX/g' datei.txt
+```
+
+- `-E` = Extended Regex
+
+### Gruppen und Backreferences
+
+```bash
+sed 's/\([0-9]*\)-\([0-9]*\)/\2-\1/' datei.txt
+```
+
+Vertauscht Zahlen vor und nach Bindestrich.
+
+Mit `-E`:
+
+```bash
+sed -E 's/([0-9]*)-([0-9]*)/\2-\1/' datei.txt
+```
+
+## Praktische Beispiele
+
+### Konfigurationsdatei ändern
+
+```bash
+sed -i 's/^#Port 22/Port 2222/' /etc/ssh/sshd_config
+```
+
+### IP-Adressen ersetzen
+
+```bash
+sed 's/192\.168\.1\./10.0.0./g' config.txt
+```
+
+### Zeilennummern hinzufügen
+
+```bash
+sed = datei.txt | sed 'N;s/\n/\t/'
+```
+
+### Kommentare und Leerzeilen entfernen
+
+```bash
+sed -e '/^#/d' -e '/^$/d' config.conf
+```
+
+### Mehrere Ersetzungen
+
+```bash
+sed -e 's/foo/bar/g' -e 's/alt/neu/g' datei.txt
+```
+
+### Case-insensitive Suche
+
+```bash
+sed 's/fehler/ERROR/gI' datei.txt
+```
+
+- `I` = case-insensitive
+
+### Zeilen mit Muster extrahieren
+
+```bash
+sed -n '/ERROR/p' logfile.txt
+```
+
+Zeigt nur Zeilen mit "ERROR".
+
+### Text zwischen Mustern
+
+```bash
+sed -n '/START/,/END/p' datei.txt
+```
+
+### Zeilen nummerieren
+
+```bash
+sed = datei.txt
+```
+
+## Mit Pipes
+
+```bash
+cat datei.txt | sed 's/alt/neu/g' | grep wichtig
+ps aux | sed -n '1p;/firefox/p'
+```
+
+## Mehrere Dateien
+
+```bash
+sed -i 's/alt/neu/g' *.txt
+```
+
+## Sed-Skripte
+
+**script.sed:**
+```sed
+# Kommentare entfernen
+/^#/d
+# Leerzeilen entfernen
+/^$/d
+# foo durch bar ersetzen
+s/foo/bar/g
+```
+
+Verwenden:
+
+```bash
+sed -f script.sed datei.txt
+```
+
+## Fehler vermeiden
+
+### Backup erstellen
+
+```bash
+sed -i.bak 's/alt/neu/g' wichtig.txt
+```
+
+### Testen ohne Änderung
+
+```bash
+sed 's/alt/neu/g' datei.txt > test.txt
+diff datei.txt test.txt
+```
+
+### Spezialzeichen escapen
+
+```bash
+# Punkt ist Wildcard
+sed 's/192.168.1.1/10.0.0.1/' config  # FALSCH
+
+# Punkt escapen
+sed 's/192\.168\.1\.1/10.0.0.1/' config  # RICHTIG
+```
+
+## Alternative Delimiter
+
+Wenn Pfade mit `/` vorkommen:
+
+```bash
+sed 's|/old/path|/new/path|g' datei.txt
+```
+
+Statt `/` kann `|`, `#` oder andere Zeichen verwendet werden.
+
+## Siehe auch
+
+- [[grep]] - Textsuche
+- [[awk]] - Komplexere Textverarbeitung
+- [[find]] - Dateien finden und mit sed bearbeiten
+- [[BASH Funktionen]] - sed in Funktionen verwenden

Linux/BASH Basics/tar.md

@@ -0,0 +1,354 @@
+# tar - Archive erstellen und Software installieren
+
+Der `tar`-Befehl (tape archive) erstellt und entpackt Archive. Oft in Kombination mit Kompression (gzip, bzip2, xz).
+
+## Grundsyntax
+
+```bash
+tar [OPTIONEN] [ARCHIV] [DATEIEN...]
+```
+
+## Archive erstellen
+
+### Einfaches Archiv (unkomprimiert)
+
+```bash
+tar -cf archiv.tar verzeichnis/
+```
+
+- `-c` = create (erstellen)
+- `-f` = file (Dateiname)
+
+### Mit gzip-Kompression (.tar.gz)
+
+```bash
+tar -czf archiv.tar.gz verzeichnis/
+```
+
+- `-z` = gzip
+
+### Mit bzip2-Kompression (.tar.bz2)
+
+```bash
+tar -cjf archiv.tar.bz2 verzeichnis/
+```
+
+- `-j` = bzip2
+
+### Mit xz-Kompression (.tar.xz)
+
+```bash
+tar -cJf archiv.tar.xz verzeichnis/
+```
+
+- `-J` = xz (beste Kompression)
+
+### Mit Fortschrittsanzeige
+
+```bash
+tar -czf archiv.tar.gz verzeichnis/ -v
+```
+
+- `-v` = verbose (Details anzeigen)
+
+## Archive entpacken
+
+### Automatische Kompressionserkennung
+
+```bash
+tar -xf archiv.tar.gz
+```
+
+- `-x` = extract (entpacken)
+
+### In bestimmtes Verzeichnis
+
+```bash
+tar -xf archiv.tar.gz -C /ziel/verzeichnis
+```
+
+### Mit Fortschrittsanzeige
+
+```bash
+tar -xvf archiv.tar.gz
+```
+
+## Archiv-Inhalt anzeigen
+
+```bash
+tar -tf archiv.tar.gz
+```
+
+- `-t` = list (auflisten)
+
+Mit Details:
+
+```bash
+tar -tvf archiv.tar.gz
+```
+
+## Praktische Beispiele
+
+### Backup erstellen
+
+```bash
+tar -czf backup-$(date +%Y%m%d).tar.gz /home/user/dokumente
+```
+
+### Bestimmte Dateien ausschließen
+
+```bash
+tar -czf archiv.tar.gz --exclude='*.tmp' --exclude='.git' verzeichnis/
+```
+
+### Nur bestimmte Dateien hinzufügen
+
+```bash
+tar -czf logs.tar.gz /var/log/*.log
+```
+
+### Zu bestehendem Archiv hinzufügen
+
+```bash
+tar -rf archiv.tar neue_datei.txt
+```
+
+**Hinweis:** Funktioniert nur bei unkomprimierten Archiven!
+
+### Einzelne Datei aus Archiv extrahieren
+
+```bash
+tar -xzf archiv.tar.gz pfad/zur/datei.txt
+```
+
+### Archiv auf andere Maschine übertragen
+
+```bash
+tar -czf - verzeichnis/ | ssh user@server "cd /ziel && tar -xzf -"
+```
+
+## Dateirechte bewahren
+
+```bash
+tar -czpf archiv.tar.gz verzeichnis/
+```
+
+- `-p` = preserve permissions
+
+Als Root entpacken und Eigentümer bewahren:
+
+```bash
+sudo tar -xpf archiv.tar.gz
+```
+
+## Inkrementelles Backup
+
+```bash
+tar -czf backup-full.tar.gz -g snapshot.file verzeichnis/
+tar -czf backup-incr.tar.gz -g snapshot.file verzeichnis/
+```
+
+- `-g` = incremental (inkrementell)
+
+## Geschwindigkeit vs. Kompression
+
+| Format | Geschwindigkeit | Kompression | Empfehlung |
+|--------|----------------|-------------|------------|
+| `.tar` | Sehr schnell | Keine | Lokale Kopien |
+| `.tar.gz` | Schnell | Gut | Standard |
+| `.tar.bz2` | Mittel | Besser | Archivierung |
+| `.tar.xz` | Langsam | Beste | Langzeit-Archiv |
+
+## Fehler vermeiden
+
+### Führenden Slash entfernen
+
+```bash
+tar -czf archiv.tar.gz --absolute-names /home/user/dokumente  # Mit /
+tar -czf archiv.tar.gz -C /home/user dokumente                # Ohne /
+```
+
+Zweite Variante ist sicherer beim Entpacken.
+
+### Große Archive
+
+Prüfe Speicherplatz vorher:
+
+```bash
+du -sh verzeichnis/
+df -h .
+```
+
+### Testen vor Löschen
+
+```bash
+tar -czf backup.tar.gz daten/
+tar -tzf backup.tar.gz | head  # Inhalt prüfen
+# Erst dann löschen:
+rm -rf daten/
+```
+
+## Mit Verschlüsselung
+
+```bash
+# Erstellen und verschlüsseln
+tar -czf - verzeichnis/ | gpg -c > archiv.tar.gz.gpg
+
+# Entschlüsseln und entpacken
+gpg -d archiv.tar.gz.gpg | tar -xzf -
+```
+
+## Software aus tar.gz installieren
+
+Eine `.tar.gz`-Datei kann verschiedene Inhalte haben:
+
+1. **Quellcode** → muss kompiliert werden
+2. **Kompilierte Binaries** → nur entpacken und ausführen
+3. **Paket für Distribution** → mit Paketmanager installieren
+
+### Archiv entpacken und untersuchen
+
+```bash
+tar -xvzf paket.tar.gz
+cd paket
+ls -la
+```
+
+Prüfe immer `README`, `INSTALL` oder `INSTALL.txt`:
+
+```bash
+cat README
+cat INSTALL
+```
+
+### Installation aus Quellcode
+
+**Voraussetzungen installieren:**
+
+Debian/Ubuntu:
+```bash
+sudo apt install build-essential
+```
+
+Fedora:
+```bash
+sudo dnf groupinstall "Development Tools"
+```
+
+**Standard-Kompilierung (autotools):**
+```bash
+./configure
+make
+sudo make install
+```
+
+**CMake-basierte Projekte:**
+```bash
+mkdir build
+cd build
+cmake ..
+make
+sudo make install
+```
+
+### Installation von fertigen Binaries
+
+Wenn das Archiv fertige Programme enthält:
+
+```bash
+chmod +x programmname
+./programmname
+```
+
+Permanent installieren nach `/usr/local/bin`:
+
+```bash
+sudo cp programmname /usr/local/bin/
+```
+
+Oder nach `~/.local/bin` (ohne sudo):
+
+```bash
+mkdir -p ~/.local/bin
+cp programmname ~/.local/bin/
+```
+
+Stelle sicher, dass `~/.local/bin` im PATH ist:
+
+```bash
+echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
+source ~/.bashrc
+```
+
+### Deinstallation
+
+Bei selbst kompilierten Programmen:
+
+```bash
+cd paket/
+sudo make uninstall
+```
+
+Falls `make uninstall` nicht verfügbar ist:
+
+**Mit checkinstall (empfohlen):**
+```bash
+sudo apt install checkinstall  # Debian/Ubuntu
+
+# Statt "sudo make install"
+sudo checkinstall
+
+# Später deinstallieren wie normales Paket
+sudo apt remove paketname
+```
+
+**Manuell:**
+```bash
+# Liste der installierten Dateien erstellen
+sudo make install > install.log 2>&1
+
+# Zum Deinstallieren Dateien aus log löschen
+```
+
+### Beispiel-Workflow
+
+```bash
+# 1. Entpacken
+tar -xzf programm-1.0.tar.gz
+cd programm-1.0
+
+# 2. Dokumentation lesen
+cat README
+cat INSTALL
+
+# 3. Konfigurieren und kompilieren
+./configure --prefix=/usr/local
+make
+
+# 4. Optional: Tests ausführen
+make check
+
+# 5. Installieren
+sudo make install
+
+# 6. Testen
+which programmname
+programmname --version
+```
+
+### Typische Verzeichnisse
+
+Nach `make install` werden Dateien meist hier installiert:
+
+- `/usr/local/bin/` - Programme
+- `/usr/local/lib/` - Bibliotheken
+- `/usr/local/share/` - Daten/Dokumentation
+- `/usr/local/etc/` - Konfiguration
+
+## Siehe auch
+
+- [[rsync]] - Alternative für Backups
+- [[find]] - Dateien für Archivierung finden
+- [[grep]] - Archiv-Inhalte durchsuchen
+- [[Dateiberechtigungen]] - Rechte in Archiven bewahren
+- [[ls]] - Archive anzeigen