Linupedia.org - Benutzerbeiträge [de]

LIRC

2010-08-15T18:29:52Z

K4m1K4tz3:

{{Infobox_Software|
Name= LIRC Linux - Infrared Remote Control
|Screenshot=
|Beschreibung= Ein Programm zur Benutzung von IR-Fernbedinungen
|Hersteller= Karsten Scheibler & Christoph Bartelmus
|AktuelleVersion= 0.8.1
|AktuelleVersionFreigabeDatum= 7. Januar 2007
|Betriebssystem= Linux
|Kategorie= Fernbedienung
|Lizenz= [[GNU General Public License|GPL]]
|Deutsch= Nein
|Website= http://www.lirc.org
}}
Author: [http://www.linux-club.de/profile.php?mode=viewprofile&u=2025 PrinzEisenherz1] 
Autor von Punkt 2 und 4: [http://www.linux-club.de/profile.php?mode=viewprofile&u=CowClaw CowClaw] 

'''LIRC''' bedeutet für '''L'''inux '''I'''nfrared '''R'''emote '''C'''ontrol, und ist für den Einsatz einer Fernbedienung am PC unter Linux gedacht.


Dieses Howto behandelt die Installation und Konfiguration von Lirc unter SUSE. 
Es wurde erfolgreich unter SuSE 10.0 - 10.2 getestet und dürfte auch bei den 9er-Versionen funktionieren. 
Dieses Howto beinhaltet folgende Fernbedienungsvarianten:
* MEDION X10 Funkfernbedienung (USB)
* IR-Empfänger über serielle Schnittstelle (COM)
wobei der Schwerpunkt hier bei MEDION X10 liegt.

== Vorbereitende Maßnahmen ==

Als erstes muß man mit YAST, Smart oder vergleichbaren Paketmanager folgende Pakete installieren: 
* lirc
* lirc-kmp-''<Kerneltyp>'' 
Bei ''lirc-kmp-<Kerneltyp>'' handelt es sich um ein Paket mit zusätzlichen Treibermodulen. Hier ist es wichtig das es zum installierten Kernel passt. 
Sollte man nicht wissen welcher Kernel installiert ist, dann kann man dies auf der Konsole mit ''uname -r'' herausfinden. 
z.B. 
2.6.18.2-34-default
Bei diesem Beispiel handelt es sich um einen default-Kernel. Also muß man in diesem Fall das Paket ''lirc-kmp-default'' auswählen. 
 

== Lirc Kernel-Module selbst bauen ==

Solltet ihr kein zu eurem installierten Kernel passendes Paket mit Kernel-Modulen finden, müsst ihr
es euch selbst bauen.

Hier eine Step-By-Step Anleitung:

Voraussetzungen: Die Pakete kernel-source, lirc, automake, autoconf und libtool müssen installiert sein.

1. Zunächst stellen wir sicher, dass der Link /usr/src/linux auf den richtigen Kernel zeigt.
das machen wir folgendermaßen:

In der Konsole geben wir den folgenden Befehl ein:
# uname -r
dort kommt dann soetwas raus:
2.6.21.4-default

Nun vergleichen wir.
Bitte folgendes in der Konsole eingeben:
#cd /usr/src
#ls -l | grep linux
dort steht dann hoffentlich etwas wie:
linux -> linux-2.6.21.4-default
sehr gut, der Link zeigt also auf den richtigen Kernel!

2. Nun loggen wir uns am CVS-Server des Lirc Projektes ein, und laden die Quellen herunter. 
Dazu geben wir als root folgendes in der Konsole ein.

#cd /usr/local/src
#cvs -d:pserver:anonymous@lirc.cvs.sourceforge.net:/cvsroot/lirc login
#cvs -z8 -d:pserver:anonymous@lirc.cvs.sourceforge.net:/cvsroot/lirc co lirc
Sehr schön, weiter mit Schritt 3

3. Nun kompilieren wir die Quellen, die wir gerade heruntergeladen haben.

Dazu geben wir folgendes als root in der Konsole ein.
#cd lirc
#./autogen.sh

#./setup.sh
Hier müssen wir nun den Treiber für unsere Empfänger angeben.
Haben wir das gemacht, speichern wir das ganze mit einem Klick auf save & run configure.
Configure sollte nun durchlaufen, wenn alle Tools die es dazu braucht installiert sind.

also weiter..

#make
Wenn make ohne Fehler durchläuft ist schon fast alles geschafft.

Nun bauen wir mit checkinstall ein rpm Paket.
#checkinstall
Wir müssen lediglich noch den Namen des Paketes von lirc, nach lirc-kmp ändern.

Dieses können wir nun mit yast oder einem anderen Paketmanager wie smart installieren.

Dann wünsche ich euch mal gutes Gelingen. 
[http://www.linux-club.de/profile.php?mode=viewprofile&u=CowClaw CowClaw]

== Installation MEDION X10 ==

USB-Funkempfanger anschließen und mit ''lsmod'' prüfen welche Module vom System automatisch geladen werden. 
z.B
# lsmod
snd_seq_device 7948 2 snd_seq,snd_rawmidi
snd 50692 12 snd_pcm_oss,snd_mixer_oss,snd_seq,snd_via82xx,snd_ac97_codec, ...
soundcore 8672 1 snd
uhci_hcd 27280 0
usbcore 108804 5 ati_remote,hci_usb,ehci_hcd,uhci_hcd
ide_cd 35360 0
cdrom 32288 1 ide_cd 
Wie man hier erkennen kann wird automatisch das Treibermodul ''ati_remote'' geladen. Dies ist aber nicht das passende für den MEDION X10. 
Um das Modul zu entladen gibt man als Root in der Konsole folgendes ein:
rmmod ati_remote
Damit das Modul ''ati_remote'' beim nächsten Neustart bzw. beim erneuten anstecken des USB-Empfängers nicht wieder automatisch geladen wird, setzt man es in die Blacklist. 
Die Blacklist befindet sich um Unterordner
/etc/modprobe.d/
Dazu mit einem Editor die Datei blacklist editieren.
# mcedit /etc/modprobe.d/blacklist

Dort folgenden Eintrag hinzufügen

blacklist ati_remote

Als nächstes läd man die benötigten Module für MEDION X10:
modprobe lirc_dev
modprobe lirc_atiusb

Überprüfen ob die Module geladen wurden:
# lsmod | grep lirc | grep -v
lirc_atiusb 16160 0
lirc_dev 13284 1 lirc_atiusb
usbcore 108804 5 lirc_atiusb,hci_usb,ehci_hcd,uhci_hcd

Wie man erkennen kann wurden beide Module erfolgreich geladen. 
Als nächstes muss man die Config-Datei von Lirc anpassen. Diese befindet sich bei SuSE im Verzeichnis ''/etc/sysconfig/'' 
Dazu einfach mit einem Editor z.B. MCEdit die Datei als root editieren.

# mcedit /etc/sysconfig/lirc

Dort muss man dann folgende Änderungen durchführen:

LIRCD_DEVICE=""
ändern auf
LIRCD_DEVICE="/dev/lirc0"

und dann noch

LIRC_MODULE=""
ändern auf
LIRC_MODULE="lirc_atiusb"

Dadurch wird beim starten des Runlevels ''lirc'' auch gleich das Modul ''lirc_atiusb'' mitgeladen. 

== Installation eines Empfängers einer Hauppauge TV Karte ==

Dieser Abschnitt behandelt die Konfiguration von lirc um einen Hauppauge TV Karten IR Empfänger benutzen zu können.

Voraussetzungen: lirc ist installiert, lirc kernelmodule sind installiert (Vorgehensweise oben beschrieben).

Zunächst muss man ein Paar Änderungen an der Konfigurationsdatei vornehmen.
Dazu einfach mit einem Editor z.B. MCEdit die Datei als root editieren.

# mcedit /etc/sysconfig/lirc

Dort muss man dann folgende Änderungen durchführen:

LIRCD_DEVICE=""
ändern zu
LIRCD_DEVICE="/dev/lirc0"

LIRC_MODULE=""
ändern zu
LIRC_MODULE="lirc_i2c"

Nun brauchen wir eine lircd.conf die zu Hauppauge TV-Karten passt.
Wir nehmen die folgenden Zeilen und speichern sie in Datei dieser Datei.
/etc/lircd.conf

begin remote

name hauppauge_pvr
bits 13
flags RC5|CONST_LENGTH
eps 30
aeps 100

one 969 811
zero 969 811
plead 1097
gap 114605
toggle_bit 2

begin codes
Power 0x00000000000017FD
Go 0x00000000000017FB
1 0x00000000000017C1
2 0x00000000000017C2
3 0x00000000000017C3
4 0x00000000000017C4
5 0x00000000000017C5
6 0x00000000000017C6
7 0x00000000000017C7
8 0x00000000000017C8
9 0x00000000000017C9
Back/Exit 0x00000000000017DF
0 0x00000000000017C0
Menu 0x00000000000017CD
Red 0x00000000000017CB
Green 0x00000000000017EE
Yellow 0x00000000000017F8
Blue 0x00000000000017E9
Ch+ 0x00000000000017E0
Ch- 0x00000000000017E1
Vol- 0x00000000000017D1
Vol+ 0x00000000000017D0
Ok 0x00000000000017E5
Mute 0x00000000000017CF
Blank 0x00000000000017CC
Full 0x00000000000017FC
Rewind 0x00000000000017F2
Play 0x00000000000017F5
Forward 0x00000000000017F4
Record 0x00000000000017F7
Stop 0x00000000000017F6
Pause 0x00000000000017F0
Replay 0x00000000000017E4
Skip 0x00000000000017DE
end codes

end remote

Nun laden wir testweise das Kernelmodul. Als root in einer Konsole geben wir folgendes ein.
#modprobe lirc_i2c

Nun können wir lirc mit folgendem befehl starten.
#lircd

Nun testen wir einmal ob ein Signal ankommt
#irw
und tippen ein bischen auf der Fernbedienung rum. 
[http://www.linux-club.de/profile.php?mode=viewprofile&u=CowClaw CowClaw]

== Installation IR-Empfänger über serielle Schnittstelle (COM) ==

Dieser Abschnitt behandelt die Installation eines IR-Empfängers über serielle Schnittstelle (COM). 
Solch ein Empfänger kann mit etwas Geschick und geringen Kosten selbst gebaut werden. 
Eine gute Anleitung findest sich auf folgender Website: 
[http://www.nasauber.de/linux_know_how/lang/lirc/ Bauanleitung IR-Empfänger] 
Um den IR-Empfänger mit ''lirc'' verwenden zu können, muss man die COM-Schnittstelle noch anpassen. 
Dazu muss man als erstes das Programm ''setserial'' installieren. Dies ist bei SuSE mit dabei. Man kanns auch mit Smart, opt, oder ähnlichem 
installieren. Dann gibt man als root in der Konsole folgenden Befehl ein: 
# setserial /dev/ttyS0 uart none

''/dev/ttyS0'' steht hierbei für die COM1-Schnittstelle. 
Damit dies auch bei einem Neustart geschieht, fügt man diesen Befehl am besten in folgende Datei ein:
/etc/init.d/boot.local
Somit wird es bei jedem Neustart automatisch durchgeführt. 

Als nächstes läd man als root das Modul für den seriellen IR-Empfänger:
# modprobe lirc_serial

Überprüfen ob die Module geladen wurden:
# lsmod | grep lirc | grep -v

Hier sollte dann eine Ausgabe erscheinen wo ''lirc_dev'' und ''lirc_serial'' erscheinen. 
Als nächstes muss man die Config-Datei von Lirc anpassen. Diese befindet sich bei SuSE im Verzeichnis ''/etc/sysconfig/'' 
Dazu einfach mit einem Editor z.B. MCEdit die Datei als root editieren.

# mcedit /etc/sysconfig/lirc

Dort muss man dann folgende Änderungen durchführen:

LIRCD_DEVICE=""
ändern auf
LIRCD_DEVICE="/dev/lirc0"

Gegebenenfalls muss hier ''/dev/lirc'' verwendet werden. Am besten ausprobieren. 
und dann noch

LIRC_MODULE=""
ändern auf
LIRC_MODULE="lirc_serial"

Dadurch wird beim starten des Runlevels ''lirc'' auch gleich das Modul ''lirc_serial'' mitgeladen. 

== Die lircd.conf Konfiguration ==

Damit lirc die eingehenden Signale der Fernbedienung auch den passenden Tasten zuordnen kann, benötigt man noch eine passende ''lircd.conf''. 
Diese kann man für die gebräuchlichsten Fernbedienungen von der lirc-Website runterladen.
http://lirc.sourceforge.net/remotes/ 
Beispiel lircd.conf MEDION X10: 
# Please make this file available to others
# by sending it to <lirc@bartelmus.de>
#
# this config file was automatically generated
# using lirc-0.7.0(atiusb) on Fri Feb 18 01:53:46 2005
#
# contributed by FUX 2005-02-17
#
# brand: Medion
# model no. of remote control: RF Remote Control
# FCC ID: B4S20016398
# devices being controlled by this remote:
#
begin remote
name Medion_X10
bits 16
eps 30
aeps 100
one 0 0
zero 0 0
pre_data_bits 8
pre_data 0x14
post_data_bits 16
post_data 0x0
gap 227928
toggle_bit 0
begin codes
3 0x000000000000E40F
2 0x000000000000E30E
1 0x000000000000E20D
4 0x000000000000E510
5 0x000000000000E611
6 0x000000000000E712
7 0x000000000000E813
8 0x000000000000E914
9 0x000000000000EA15
0 0x000000000000EC17
ok 0x000000000000F31E
up 0x000000000000EF1A
down 0x000000000000F722
right 0x000000000000F41F
left 0x000000000000F21D
del 0x000000000000F520
ren 0x0000000000000B36
red 0x0000000000000732
green 0x0000000000000833
yellow 0x0000000000000934
blue 0x0000000000000A35
txt 0x000000000000EB16
ch- 0x000000000000E10C
ch+ 0x000000000000E00B
vol+ 0x000000000000DE09
vol- 0x000000000000DD08
mute 0x000000000000D500
tv 0x000000000000012C
vcr 0x000000000000022D
dvd 0x000000000000D904
music 0x000000000000DB06
radio 0x000000000000032E
photo 0x000000000000DA05
preview 0x000000000000042F
list 0x0000000000000530
desktop 0x0000000000000631
setup 0x000000000000F01B
snapshot 0x000000000000ED18
acquire 0x0000000000000C37
play 0x000000000000FA25
reward 0x000000000000F924
forward 0x000000000000FB26
stop 0x000000000000FD28
rec 0x000000000000FC27
pause 0x000000000000FE29
skipr 0x000000000000F621
skipf 0x000000000000F823
dvdmenu 0x000000000000EE19
dvdaudio 0x0000000000000F3A
off 0x000000000000D702
chsearch 0x000000000000F11C
fullscreen 0x0000000000000E39
editimage 0x0000000000000D38
end codes
end remote

 
Jetzt startet man ''lirc'' 

Zum starten des Runlevels ''lirc'' als root folgenden Befehl ausführen:
# rclirc start
mit
# rclirc status
überprüfen ob ''lirc'' gestartet wurde. 
Damit der Runlevel ''lirc'' bei jedem Systemstart automatisch gestartet wird führt man als root folgendes aus: 
# chkconfig lirc on

Es werden durch ''lirc'' jetzt im Verzeichnis ''/dev'' folgende Major-Dateien angelegt:
lirc
lirc0
Diese muss man noch mit den passenden Rechten versehen damit auch ein normaler Nutzer ''lirc'' nutzen kann.
Dieses erziehlt man als root in der Konsole mit folgenden Befehlen:
# chmod 666 /dev/lirc
# chmod 666 /dev/lirc0

Um jetzt die Fernbedienung zu testen, startet man das Hilfsprogramm ''irw''

# cd /usr/bin
# ./irw

Wenn jetzt eine Taste auf der Fernbedienung gedrückt wird, dann gibt ''irw'' die Bezeichnung und den Tastencode aus! Dann weiß man das die lirc-Konfiguration läuft.
 

== Steuern von Kaffeine, XMMS, Amarok, usw mit lircrc ==

Um mit ''lirc'' auch Programme (z.B. XMMS) steuern zu können benötigt man, zwei im Hintergrund laufende, deamons. 
Diese müssen in der Konsole als normaler Nutzer aufgerufen werden. 
Bevor diese aber gestartet werden muss man im Verzeichnis ''/etc'' noch die Datei ''lircrc'' anlegen.
Diese befüllt man mit den Steuerbefehlen für z.B XMMS. 
Um XMMS mit ''lirc'' steuern zu können muss noch zusätzlich das Paket ''xmms-plugins'' installiert werden und in XMMS unter ''Optionen -> Plugins -> Allgemeine Plugins'' das Lircplugin aktiviert werden.
 
Beispiel lircrc:

begin irexec
begin
prog = irexec
button = music
config = xmms &
mode = xmms
repeat = 0
end
begin
prog = irexec
button = radio
config = amarok &
mode = amarok
repeat = 0
end
end irexec
begin xmms
begin
button = play
prog = xmms
config = play
end
begin
prog = xmms
button = pause
config = pause
end
begin
prog = xmms
button = stop
config = stop
end
begin
prog = xmms
button = skipf
config = next
end
begin
prog = xmms
button = skipr
config = prev
end
begin
prog = xmms
button = forward
config = FWD 3
repeat = 2
end
begin
prog = xmms
button = reward
config = BWD 3
repeat = 2
end
begin
prog = xmms
button = off
config = QUIT
mode = irexec
repeat = 0
end
end xmms
begin amarok
begin
prog = irexec
button = play
config = dcop amarok player playPause
end
....
begin
prog = irexec
button = off
config = dcop amarok MainApplication-Interface quit
mode = irexec
repeat = 0
end
end amarok

 
Mit folgenden Befehlen werden jetzt die beiden Deamons als normaler Nutzer gestartet: 
/usr/bin/irexec -d /etc/lircrc
/usr/bin/irxevent &

um diese automatisch bei jedem Neustart zu laden schreibt man am besten ein bash-Script und legt dieses in
/home/''<Nutzername>''/.kde/Autostart/

Beispiel bash-Script ''lircstart.sh'': 
#!/bin/bash
sleep 2
/usr/bin/irexec -d /etc/lircrc
/usr/bin/irxevent &
kdialog --passivepopup "IREXEC und IRXEVENT wurden gestartet" 3

Diese muss dann noch ausführbar gemacht werden:

# chmod +x /home/''<Nutzername>''/.kde/Autostart/lircstart.sh

== Probleme mit Lirc ==

Wenn man bei laufendem Lirc den USB-Funkempfänger entfernt dann wird innerhalb ganz kurzer Zeit das Logfile ''lircd'' unter ''/var/log/''
mit Fehlermeldungen überflutet. Bei einer Größe von über 2GB wird dann der Runlevel ''lirc'' abgeschossen und kann nicht mehr gestartet werden. 
Um dies zu vermeiden sollte man ''lirc'' nicht als Runlevel starten. Also nicht mit ''chkconfig lirc on'' auf Autostart setzten, sondern mit folgendem Script nur auf Bedarf starten bzw beenden: 

Lirc_StartStop.sh

#!/bin/bash
#
# Lirc starting script writen by Schneider Johnny 06112006
# Dieses Schript prüft wie groß das Log-File von Lirc ist und löscht es gegebenenfalls.
# Dann wird geprüft ob sich der Funkempfänger am USB-Slot befinden und startet dann Lirc.
# Wenn der Empfänger entfernt wird dann lässt sich der Lirc-deamon beenden.
# Variablen erstellen
GEFUNDEN=
FS= # Leere Variable für die Dateigrösse (FileSize)
DATEI=20000000 # Variable für den Vergleich erzeugen und mit Wert belegen
# 1. Abschnitt
# prüfen ob Log-Datei lircd vorhanden ist
if (test -f /var/log/lircd);
then
#echo "Datei gefunden!"
# Dateigrösse von /var/log/lircd ermitteln und mit Hilfe
# der Kommandosubstitution in eine Variable schreiben.
FS=$(ls -l /var/log/lircd | tr -s " " | cut -d " " -f 5)
# Bildschirmausgabe über Dateigröße
#echo "Die Log-Datei Lircd ist $FS Byte groß."
fi
if (test $FS -gt $DATEI);then
#echo "Die Datei ist zu groß und wird jetzt gelöscht ..."
kdesu rm /var/log/lircd
#else
#echo "Die Dateigröße ist ok"
fi
# Es wird geprüft ob der Funkempfänger Medion X10 angeschlossen ist
if ( ps x | grep lirc | grep -v grep );then
kdesu killall lircd
kdialog --passivepopup "Der Lirc-Deamon wurde beendet !!!!" 4
elif ( lsusb | grep X10 | grep -v grep );then
kdesu rclirc start
/usr/bin/irexec -d /etc/lircrc
/usr/bin/irxevent &
kdialog --passivepopup "IREXEC und IRXEVENT wurden gestartet" 3
#echo "Lirc-deamon wird gestartet ..."
else
exit
fi

 
Jetzt kann man bequem vom Sofa aus seine Programme steuern. 
Viel Glück und viel Spass bei der Umsetzung!

== Quellen und weiterführende Links ==

* [http://www.lirc.org Lirc-Homepage]
* [http://lirc.sourceforge.net/remotes/ lircd.conf von unterstützten Fernbedienungen]
* [http://sourceforge.net/projects/lirc/ SourceForge-Projektseite]
* http://de.wikipedia.org/wiki/LIRC
* [[Lircd Musterkonfigurationen| Musterkonfigurationen für LIRC]]

----
[[Hardware|Zurück zu Hardware]]

[[Category:Hardware]]

Apache

2008-02-10T15:12:26Z

K4m1K4tz3: toten Link ersetzt

{{Infobox Software
|Name= [[Bild:Apache-logo.png]]
|Screenshot= [[Bild:Apache.jpg|250px]]
|Beschreibung= Nach dem ersten Start auf [[openSUSE]] 10.2 mit [[Firefox]] 2.0.3 und [[OSX Desktop]]
|Hersteller= Apache Software Foundation
|AktuelleVersion= 2.2.4
|AktuelleVersionFreigabeDatum= 10. Januar 2007) 2.0.59 (27. Juli 2006) 1.3.37 (27. Juli 2006
|Betriebssystem= Mac OS X, NetBSD, FreeBSD, OpenBSD, Linux, Windows, NetWare, Amiga, OS/400, Solaris, u.a.
|Kategorie= [[LAMP]]
|Lizenz= Apache License v2.0
|Deutsch= nein
|Website= [http://httpd.apache.org/ httpd.apache.org]
}}
Autor: [http://www.yehudi.de Yehudi]
{{Box Test||
* [[openSUSE]] 10.3
* [[openSUSE]] 10.2
* SUSE Linux 10.0
* SUSE Linux 9.3
* SUSE Linux 9.2
* SUSE Linux 9.1
* SUSE Linux 9.0
* [[Ubuntu]] 6.10
* [[Debian]] 4.0
}}
'''Anmerkung:''' Der Apache ist ein sehr umpfangreiches Thema, welches alleine schon ein Wiki füllt, ich beginne einfach damit Lösungen reinzusetzen.

== Installation ==
[[Bild:YaST2 Web- und LAMP-Server Schemata.png|thumb|240px|einfache Installation unter [[openSUSE]]]]
'''[[Debian]]:''' Bei der Installation der Distribution wird man bereits gefragt, was auf dem Rechner installiert werden soll, hier wählt man die Option ''Web-Server''. Damit wird alles wichtige dafür gleich mitinstalliert, um einen funktionierenden [[LAMP]] zu haben, in dem der Apache enthalten ist. Bei Debian ist der Apachesofort nach der gesamten Installtion ohne eigenes hinzutun bereits am laufen.

'''[[openSUSE]]:''' Hier kann auch zu jedem späteren Zeitpunkt eine gesamte LAMP Umgebung mit einer Selektierung installiert werden. YaST --> Software instalieren oder Löschen --> Schemata --> Serverfunktionen --> ''Web- und LAMP-Server'' ankreuzen --> Übernehmen.

'''[[Ubuntu]]''': Hier muss die Software über Synaptic nachinstalliert werden. Alles was man außer dem Apachen für eine LAMP-Umgebung braucht liest man aus der Abbildung hier rechts von der YaST-Installation ab, und installiert diese Pakete. (bis auf das YaST Paket selbst)

== Befehle ==

'''[[openSUSE]]:'''

rcapache2 start

rcapache2 status

rcapache2 stop

== Fehler, und Fehlermeldungen ==

* index.php wird zum Download angeboten:
AddType application/x-httpd-php .php

Am Schluss der httpd.conf anhängen

== Quellen und weiterführende Links ==

=== Literatur zu Apache ===

* http://www.linux-club.de/ftopic2781.html

=== LAMP-HowTos ===
* http://baach.de/lamp_tutorial.html
* http://www.linux-club.de/ftopic46-0-asc-0.html
* http://lamps.efactory.de/e-archive.shtml
* http://www.baach.de/lamp-tutorial.orig.html
* http://www.linux-club.de/ftopic12919.html
* http://sman.informatik.htw-dresden.de/doc/manual.10.0/manual/sec.apache.install.html

Video-Tuturial: http://www.linux-club.de/ftopic62800.html

=== Mod-Verzeichnis für Apache ===
* http://httpd.apache.org/docs/2.0/mod/mod_autoindex.html

=== mod_userdir unter SuSE10.1 ===
* http://www.linux-club.de/ftopic61647.html

=== Apache2 und SSL ===
* http://www.linux-club.de/ftopic12149.html
HowTo auf der Homepage: http://www.komaii.com/

=== Webmin für Apache2 ===
ist zwar für SuSE9.0 aber die Pfade sollten soweit stimmen
* http://www.linux-club.de/ftopic6158.html

=== Dateiberechtigungen / CHMOD ===
Grundsätzlich sollte jeder die Datei lesen können, also im Zweifel sollten die Dateien einen Modus von chmod 644 bekommen. 777 ist nicht immer sinnvoll, weil dann wirklich jeder auf die Datei Vollzugriff hat und sie somit auch ändern kann. 
Ansonsten gibt es noch diesen Thread: 
* http://www.linux-club.de/ftopic10425.html

=== Virtual Hosts ===
* http://www.ag-intra.net/linux-al-virtualhost.html (leider etwas staubig -2003)
* http://www.linux-club.de/ftopic38317.html (eine Zusammenfassung wäre ganz schön)
* [[Virtual Host mit Yast konfigurieren]]

=== Webstatistiken erstellen ===
http://www.linux-club.de/ftopic40573.html

=== Apache absichern ===
* http://www.heise.de/security/artikel/69070/0
Regeln gibt es hier: http://www.gotroot.com/mod_security+rules
Welche Regeln sind sinnvoll?
* http://www.gotroot.com/tiki-index.php?page=Which+mod_security+rules

== Quellen ==
* http://www.html-world.de/program/php_art_5.php
* http://www.linux-club.de/ftopic65826.html
----
[[LAMP|zurück zum LAMP]]
[[Category:LAMP]]

Dateien mithilfe einer Playlist sortieren

2008-01-09T18:41:52Z

K4m1K4tz3:

=== playlistcopy.sh ===

'''Einleitung'''

Dieses Script ist entstanden, als ich vor dem Problem stand, geordnet meine MP3s auf eine Daten-CD zu brennen. Ziel war es, dass ein CD-Player die Lieder in der Reihenfolge abspielt, wie ich es wollte. Da ich kein passenden Programm gefunden habe, welches zudem noch die id3-Tags auswertete, um sie in den Namen der Dateien zu schreiben, machte ich mich ans Werk und schuf dieses kleine Script.

'''Funktionen'''

* lesen einer m3u Playlist
* bis zu 1000 Dateien werden kopiert und durchnummerriert
* man kann angeben, mit welcher Nummer begonnen werden soll
* Interpret und Titel werden aus den id3-Tags entnommen und im Dateinamen eingefügt
* falls keine id3-Tags vorhanden sind, wird der alte Name benutzt und nur die aktuelle Nummer davor gehängt
* kopiert ausschließlich MP3 Dateien

'''Das Script playlistcopy.sh'''
<pre>
#!/bin/sh
#
# Dieses Script liest eine m3u Playlist aus, kopiert die darin enthaltenen Dateien
# und benennt sie der Reihelfolge um, wie sie in der Playlist stehen.
# Bsp: 001-ARTIST-TITLE.mp3, 002-ARTIST-TITLE.mp3, etc.
# So können sie dann z.B. auf eine Daten-CD kopiert werden und werden der Reihe nach
# von einem CD-Player abgespielt.
#
# Die Programme id3info und recode werden benötigt
# Die letzte Zeile muss eine Lehrzeile sein!
#
# Version: 0.10
# Zuletzt geändert am: 09.01.2008
#
# Autor: Mathias Rabe
#
# Der Autor übernimmt keinerlei Garantie auf evtl. entstehende Schäden.
#
# Dieses Script steht unter der GPL. Es gelten daher die dort
# vorgeschriebenen Bedingungen für die Verwendung dieses Scriptes.

#--------------------------------Einstellungen----------------------------------

#Nummer mit der angefangen werden soll zu zählen.
STARTNUMBER=1;

#sollen alle Leerzeichen mit _ ersetzt werden?
# TODO: vielleicht mache ich das so, dass man das beim Aufruf einstellen kann
UNDERSCORES=0;

#---------------------------------Programm--------------------------------------

usage() {
echo "Usage: $(basename $0) PLAYLIST.M3U TARGETDIRECTORY" >&2;
exit 1;
};

# Prüfen ob wirklich alles angegeben wurde
if test $# -ne 2 ; then
usage;
fi;

if ! test -r $1 ; then
echo "Playlist $1 doesn't exist." >&2;
usage;
fi;

if ! test -d $2 ; then
echo "Directory $2 doesn't exist. Creating it.";
mkdir $2;
if [ $? -ne 0 ] ; then
exit 1;
fi;
fi;

# existiert das Programm id3tag?
if ! test -e /usr/bin/id3info ; then
echo "Couldn't find /usr/bin/id3info" >&2;
exit 1;
fi

# existiert das Programm recode?
if ! test -e /usr/bin/recode ; then
echo "Couldn't find /usr/bin/recode" >&2;
exit 1;
fi

ERRORNUM=0;
exec <$1;
read ROW;
while [ $? -eq 0 ] ; do
# fängt die aktuelle Zeile mit # an?
echo $ROW | grep "^#" > /dev/null;
if [ $? -eq 0 ]; then
read ROW;
continue;
fi;
# Leerzeile gefunden?
echo $ROW | grep "^$" > /dev/null;
if [ $? -eq 0 ]; then
echo "Error: Empty line found. Please clean up your playlist." >&2;
exit 2;
fi;
# Ist die Datei wirklich vorhanden, welche in der Playlist steht?
if ! test -e "$ROW" ; then
#der absolute Pfad ging nicht, also versuchen wir es nochmal mit dem relativen Pfad
DIRNAMEOFLIST=$(dirname $1);
ABSOLUTPATHOFFILE=$(printf "%s/%s" "$DIRNAMEOFLIST" "$ROW")
if ! test -e "$ABSOLUTPATHOFFILE" ; then
echo "Error: File $ABSOLUTPATHOFFILE doesn't exist. Trying next one." >&2; # Die Ausgabe ist zwar Müll, aber es funktioniert
ERRORNUM=$((ERRORNUM+1));
read ROW;
continue;
fi;
else
ABSOLUTPATHOFFILE=$ROW;
fi;
# Ist es auch eine mp3 Datei?
echo $(file -ib "$ABSOLUTPATHOFFILE") | grep "audio/mpeg" > /dev/null;
if [ $? -ne 0 ] ; then
echo "Error: File $ABSOLUTPATHOFFILE is no mp3 file. Trying next one." >&2;
ERRORNUM=$((ERRORNUM+1));
read ROW;
continue;
fi;
# Alles ok? Dann kopier und benenne sie um!
ARTIST=$(id3info "$ABSOLUTPATHOFFILE" | grep "TPE1" | tail --lines=1 | sed "s/=== TPE1 (Lead performer(s)\/Soloist(s)): //" | recode "latin-1..");
TITLE=$(id3info "$ABSOLUTPATHOFFILE" | grep "TIT2" | tail --lines=1 | sed "s/=== TIT2 (Title\/songname\/content description): //" | recode "latin-1..");
# Artist und Titel gefunden?
if [ -z "$ARTIST" -o -z "$TITLE" ] ; then
DESTINATION=$(printf "%s/%03d-%s" $2 $STARTNUMBER "$(basename "$ROW")");
else
DESTINATION=$(printf "%s/%03d-%s-%s.mp3" $2 $STARTNUMBER "$ARTIST" "$TITLE");
fi;
# Leereichen ersetzen
if (( $UNDERSCORES )) ; then
DESTINATION=${DESTINATION//\ /_}
fi;
# und endlich alles kopieren
cp -v "$ABSOLUTPATHOFFILE" "$DESTINATION";
if [ $? -ne 0 ] ; then
echo "An unexpected error occured. Abort";
exit 1;
fi;
STARTNUMBER=$((STARTNUMBER+1));
read ROW;
done;

if [ $ERRORNUM -ne 0 ]; then
echo "There where $ERRORNUM errors." >&2;
exit 2;
fi;

exit 0;
</pre>

----

[[Multimedia|Zurück zu Multimedia]][[Kategorie:Multimedia]]
[[Shellscripte|Zurück zu den Shellscripten]][[Kategorie:Shellscripte]]

Dateien mithilfe einer Playlist sortieren

2008-01-07T19:01:42Z

K4m1K4tz3:

=== playlistcopy.sh ===

'''Einleitung'''

Dieses Script ist entstanden, als ich vor dem Problem stand, geordnet meine MP3s auf eine Daten-CD zu brennen. Ziel war es, dass ein CD-Player die Lieder in der Reihenfolge abspielt, wie ich es wollte. Da ich kein passenden Programm gefunden habe, welches zudem noch die id3-Tags auswertete, um sie in den Namen der Dateien zu schreiben, machte ich mich ans Werk und schuf dieses kleine Script.

'''Funktionen'''

* lesen einer m3u Playlist
* bis zu 1000 Dateien werden kopiert und durchnummerriert
* man kann angeben, mit welcher Nummer begonnen werden soll
* Interpret und Titel werden aus den id3-Tags entnommen und im Dateinamen eingefügt
* falls keine id3-Tags vorhanden sind, wird der alte Name benutzt und nur die aktuelle Nummer davor gehängt
* kopiert ausschließlich MP3 Dateien

'''Das Script playlistcopy.sh'''
<pre>
#!/bin/sh
#
# Dieses Script liest eine m3u Playlist aus, kopiert die darin enthaltenen Dateien
# und benennt sie der Reihelfolge um, wie sie in der Playlist stehen.
# Bsp: 001-ARTIST-TITLE.mp3, 002-ARTIST-TITLE.mp3, etc.
# So können sie dann z.B. auf eine Daten-CD kopiert werden und werden der Reihe nach
# von einem CD-Player abgespielt.
#
# Die Programme id3info und recode werden benötigt
# Die letzte Zeile muss eine Lehrzeile sein!
#
# Version: 0.9
# Zuletzt geändert am: 07.01.2008
#
# Autor: Mathias Rabe
#
# Der Autor übernimmt keinerlei Garantie auf evtl. entstehende Schäden.
#
# Dieses Script steht unter der GPL. Es gelten daher die dort
# vorgeschriebenen Bedingungen für die Verwendung dieses Scriptes.

#--------------------------------Einstellungen----------------------------------

#Nummer mit der angefangen werden soll zu zählen.
STARTNUMBER=1;

#sollen alle Leerzeichen mit _ ersetzt werden?
# TODO: vielleicht mache ich das so, dass man das beim Aufruf einstellen kann
UNDERSCORES=0;

#---------------------------------Programm--------------------------------------

usage() {
echo "Usage: $(basename $0) PLAYLIST.M3U TARGETDIRECTORY" >&2;
exit 1;
};

# Prüfen ob wirklich alles angegeben wurde
if test $# -ne 2 ; then
usage;
fi;

if ! test -r $1 ; then
echo "Playlist $1 doesn't exist." >&2;
usage;
fi;

if ! test -d $2 ; then
echo "Directory $2 doesn't exist. Creating it.";
mkdir $2;
if [ $? -ne 0 ] ; then
exit 1;
fi;
fi;

# existiert das Programm id3tag?
if ! test -e /usr/bin/id3info ; then
echo "Couldn't find /usr/bin/id3info" >&2;
exit 1;
fi

# existiert das Programm recode?
if ! test -e /usr/bin/recode ; then
echo "Couldn't find /usr/bin/recode" >&2;
exit 1;
fi

ERRORNUM=0;
exec <$1;
read ROW;
while [ $? -eq 0 ] ; do
# fängt die aktuelle Zeile mit # an?
echo $ROW | grep "^#" > /dev/null;
if [ $? -eq 0 ]; then
read ROW;
continue;
fi;
# Leerzeile gefunden?
echo $ROW | grep "^$" > /dev/null;
if [ $? -eq 0 ]; then
echo "Error: Empty line found. Please clean up your playlist." >&2;
exit 2;
fi;
# Ist die Datei wirklich vorhanden, welche in der Playlist steht?
if ! test -e "$ROW" ; then
#der absolute Pfad ging nicht, also versuchen wir es nochmal mit dem relativen Pfad
DIRNAMEOFLIST=$(dirname $1);
ABSOLUTPATHOFFILE=$(printf "%s/%s" "$DIRNAMEOFLIST" "$ROW")
if ! test -e "$ABSOLUTPATHOFFILE" ; then
echo "Error: File $ABSOLUTPATHOFFILE doesn't exist. Trying next one." >&2; # Die Ausgabe ist zwar Müll, aber es funktioniert
ERRORNUM=$((ERRORNUM+1));
read ROW;
continue;
fi;
else
ABSOLUTPATHOFFILE=$ROW;
fi;
# Ist es auch eine mp3 Datei?
echo $(file -ib "$ABSOLUTPATHOFFILE") | grep "audio/mpeg" > /dev/null;
if [ $? -ne 0 ] ; then
echo "Error: File $ABSOLUTPATHOFFILE is no mp3 file. Trying next one." >&2;
ERRORNUM=$((ERRORNUM+1));
read ROW;
continue;
fi;
# Alles ok? Dann kopier und benenne sie um!
ARTIST=$(id3info "$ABSOLUTPATHOFFILE" | grep "TPE1" | tail --lines=1 | sed "s/=== TPE1 (Lead performer(s)\/Soloist(s)): //" | recode "latin-1..");
TITLE=$(id3info "$ABSOLUTPATHOFFILE" | grep "TIT2" | tail --lines=1 | sed "s/=== TIT2 (Title\/songname\/content description): //" | recode "latin-1..");
# Artist und Titel gefunden?
if [ -z $ARTIST -o -z $TITLE ] ; then
DESTINATION=$(printf "%s/%03d-%s" $2 $STARTNUMBER "$(basename "$ROW")");
else
DESTINATION=$(printf "%s/%03d-%s-%s.mp3" $2 $STARTNUMBER "$ARTIST" "$TITLE");
fi;
# Leereichen ersetzen
if (( $UNDERSCORES )) ; then
DESTINATION=${DESTINATION//\ /_}
fi;
# und endlich alles kopieren
cp -v "$ABSOLUTPATHOFFILE" "$DESTINATION";
if [ $? -ne 0 ] ; then
echo "An unexpected error occured. Abort";
exit 1;
fi;
STARTNUMBER=$((STARTNUMBER+1));
read ROW;
done;

if [ $ERRORNUM -ne 0 ]; then
echo "There where $ERRORNUM errors." >&2;
exit 2;
fi;

exit 0;
</pre>

----

[[Multimedia|Zurück zu Multimedia]][[Kategorie:Multimedia]]
[[Shellscripte|Zurück zu den Shellscripten]][[Kategorie:Shellscripte]]

Dateien mithilfe einer Playlist sortieren

2008-01-03T12:32:45Z

K4m1K4tz3:

=== playlistcopy.sh ===

'''Einleitung'''

Dieses Script ist entstanden, als ich vor dem Problem stand, geordnet meine MP3s auf eine Daten-CD zu brennen. Ziel war es, dass ein CD-Player die Lieder in der Reihenfolge abspielt, wie ich es wollte. Da ich kein passenden Programm gefunden habe, welches zudem noch die id3-Tags auswertete, um sie in den Namen der Dateien zu schreiben, machte ich mich ans Werk und schuf dieses kleine Script.

'''Funktionen'''

* lesen einer m3u Playlist
* bis zu 1000 Dateien werden kopiert und durchnummerriert
* man kann angeben, mit welcher Nummer begonnen werden soll
* Interpret und Titel werden aus den id3-Tags entnommen und im Dateinamen eingefügt
* kopiert ausschließlich MP3 Dateien

'''Das Script playlistcopy.sh'''
<pre>
#!/bin/sh
#
# Dieses Script liest eine m3u Playlist aus, kopiert die darin enthaltenen Dateien
# und benennt sie der Reihelfolge um, wie sie in der Playlist stehen.
# Bsp: 001-ARTIST-TITLE.mp3, 002-ARTIST-TITLE.mp3, etc.
# So können sie dann z.B. auf eine Daten-CD kopiert werden und werden der Reihe nach
# von einem CD-Player abgespielt.
#
# Die Programme id3info und recode werden benötigt
#
# Version: 0.8
# Zuletzt geändert am: 03.01.2008
#
# Autor: Mathias Rabe
#
# Der Autor übernimmt keinerlei Garantie auf evtl. entstehende Schäden.
#
# Dieses Script steht unter der GPL. Es gelten daher die dort
# vorgeschriebenen Bedingungen für die Verwendung dieses Scriptes.

#--------------------------------Einstellungen----------------------------------

#Nummer mit der angefangen werden soll zu zählen.
STARTNUMBER=1;

#---------------------------------Programm--------------------------------------

usage() {
echo "Usage: $(basename $0) EXTENDED.M3U DIRECTORY" >&2;
exit 1;
};

# Prüfen ob wirklich alles angegeben wurde
if test $# -ne 2 ; then
usage;
fi;

if ! test -r $1 ; then
echo "Playlist $1 doesn't exist." >&2;
usage;
fi;

if ! test -d $2 ; then
echo "Directory $2 doesn't exist. Creating it.";
mkdir $2;
if [ $? -ne 0 ] ; then
exit 1;
fi;
fi;

# existiert das Programm id3tag?
if ! test -e /usr/bin/id3info ; then
echo "Couldn't find /usr/bin/id3info" >&2;
exit 1;
fi

# existiert das Programm recode?
if ! test -e /usr/bin/recode ; then
echo "Couldn't find /usr/bin/recode" >&2;
exit 1;
fi

ERRORNUM=0;
exec <$1;
read ROW;
while [ $? -eq 0 ] ; do
# steht in der Zeile #EXTM3U ?
if [ "$ROW" == "#EXTM3U" ] ; then
read ROW;
continue;
fi;
# fängt die aktuelle Zeile mit #EXTINF an?
echo $ROW | grep "#EXTINF" > /dev/null;
if [ $? -eq 0 ]; then
read ROW;
continue;
fi;
# Leerzeile gefunden?
echo $ROW | grep "^$" > /dev/null;
if [ $? -eq 0 ]; then
echo "Error: Empty line found. Please clean up your playlist." >&2;
exit 2;
fi;
# Ist die Datei wirklich vorhanden, welche in der Playlist steht?
if ! test -e "$ROW" ; then
#der absolute Pfad ging nicht, also versuchen wir es nochmal mit dem relativen Pfad
DIRNAMEOFLIST=$(dirname $1);
ABSOLUTPATHOFFILE=$(printf "%s/%s" "$DIRNAMEOFLIST" "$ROW")
if ! test -e "$ABSOLUTPATHOFFILE" ; then
echo "Error: File $ABSOLUTPATHOFFILE doesn't exist. Trying next one." >&2; # Die Ausgabe ist zwar Müll, aber es funktioniert
ERRORNUM=$((ERRORNUM+1));
read ROW;
continue;
fi;
else
ABSOLUTPATHOFFILE=$ROW;
fi;
# Ist es auch eine mp3 Datei?
echo $(file -ib "$ABSOLUTPATHOFFILE") | grep "audio/mpeg" > /dev/null;
if ! [ $? -eq 0 ] ; then
echo "Error: File $ABSOLUTPATHOFFILE is no mp3 file. Trying next one." >&2;
ERRORNUM=$((ERRORNUM+1));
read ROW;
continue;
fi;
# Alles ok? Dann kopier und benenne sie um!
ARTIST=$(id3info "$ABSOLUTPATHOFFILE" | grep "TPE1" | tail --lines=1 | sed "s/=== TPE1 (Lead performer(s)\/Soloist(s)): //" | recode "latin-1..");
TITLE=$(id3info "$ABSOLUTPATHOFFILE" | grep "TIT2" | tail --lines=1 | sed "s/=== TIT2 (Title\/songname\/content description): //" | recode "latin-1..");
DESTINATION=$(printf "%s/%03d-%s-%s.mp3" $2 $STARTNUMBER "$ARTIST" "$TITLE");
#DESTINATION=${DESTINATION//\ /_} # Dadurch können alle Lehrzeichen durch _ ersetzt werden.
cp -v "$ABSOLUTPATHOFFILE" "$DESTINATION";
if [ $? -ne 0 ] ; then
echo "An unexpected error occured. Abort";
exit 1;
fi;
STARTNUMBER=$((STARTNUMBER+1));
read ROW;
done;

if [ $ERRORNUM -ne 0 ]; then
echo "There where $ERRORNUM errors." >&2;
exit 2;
fi;

exit 0;
</pre>

----

[[Multimedia | Zurück zu Multimedia]][[Category:Multimedia]]

Multimedia

2008-01-03T12:30:54Z

K4m1K4tz3: Link "Dateien mithilfe einer Playlist sortieren" hinzugefügt

== Multimediafähigkeit nachrüsten==
=== openSUSE ===
* [[YaST-Installationsquellen für openSUSE#Packman_.28Die_Multimediaf.C3.A4higkeiten_von_SuSE_Linux_erweitern.29|Packman als Quelle in YaST einbinden]]
*[[Suse multimediafähig machen und das Problem der DVD | Die Multimediafähigkeiten von Suse erweitern]] - Nach Anwendung dieser Anleitung spielt Suse alle erdenklichen Musikstücke (mp3, etc) und Videoformate ab.
*[[Pimp my SuSE]] - Suses Fähigkeiten erweitern und Suse aufmotzen.

===diverse Distributionen===
* [[Ubuntu multimediafähig machen und das Problem der DVD]] - Hier wird erklärt, wie man bei Ubuntu/Kubuntu die Multimediafähigkeiten nachrüstet.

== Den eigenen Desktop als Video aufnehmen ==
* [[vnc2swf]]
* [[screenkast]]
* [[recordmydesktop]]

== Anleitungen und Programme ==
* [[MPlayer]]
* [[Alsamixer]]
* [[kmix]]
* [[TV-Browser]]
=== Alles rund um MP3-Dateien ===

* [[MP3 Bitratenwandlung | Ändern der Bitrate von MP3-Dateien]]
* [[Amarok]]

=== Alles rund um die runden Medien (CDs und DVDs) ===

* [[K3b]]
* [[Nero]]

==== ISO-Dateien ====
* [[Imageerstellung mit dd und ddrescue| ISO-Images erstellen auf der Kommandozeile]]
* [[ISO-Images per Loopdevice mounten | Einbinden von ISO-Dateien als virtuelles Laufwerk]]
* [[Open SuSE auf DVD brennen | ISO-Datei brennen]]
* [[Virtuelles (CD) Laufwerk unter Linux|Noch ein Weg "virtuelle CD/DVD Laufwerke" zu erstellen und zu nutzen]]

==== DVDs ====
* [[Suse multimediafähig machen und das Problem der DVD]] - Hier wird erklärt, wie man Suse den Umgang mit nach der Installation nicht unterstützten Audio- und Videoformaten beibringt. Außerdem wird das Problem des Abspielens von Video DVDs umfassend erörtert.
* [[Videokonvertierung und DVD oder SVCD erstellen]]

==== Soundprobleme ====
*[[Mehrere Programme gleichzeitig Sound ausgeben]]

==== Videobearbeitung ====
*[[Kdenlive]]

==== Realplayer ====
* [[Realplayer spielt nichts von amazon ab]]

=== Konverter/Ripper ===
* [[Gnormalize]]

* [[Videoconverterscript|Videoconverterscript zum Formatwandel für DVD/(S/X)VCD Authoring oder für die Betrachtung auf einer PSP]]

== Internetstreaming / Internetradio ==
* [[Streamtuner]] - Internetradio hören und als mp3 rippen mit '''Streamtuner''' und '''Streamripper'''.
* [[Musterkonfigurationen#Streamingserver_Konfigurationen | Streamingserver Musterkonfigurationen]]
* [[Radiosender]]
* [[Stream-URL ermitteln]]

== Programme für Musiker ==
*[[Musikerprogramme und Links dazu]]

== Sonstiges ==

* [[Neutrino d-box]]
* [[Kaffeine DVB-Kanallisten]]
* [[Kdetv Kanallisten]]
* [[Koverartist Ubuntu Problem|Koverartist - Fehlende Vorlagen unter Ubuntu ergänzen]]
* [[Kaufberatung MVP und MP3 Player]]
* [[Dateien mithilfe einer Playlist sortieren]]

----

[[Hauptseite|Zurück zur Hauptseite]]
[[Category:Multimedia]][[Kategorie:Übersicht]]

Dateien mithilfe einer Playlist sortieren

2008-01-03T12:28:53Z

K4m1K4tz3: Die Seite wurde neu angelegt: === playlistcopy.sh === '''Einleitung''' Dieses Script ist entstanden, als ich vor dem Problem stand, geordnet meine MP3s auf eine Daten-CD zu brennen. Ziel war es, d...

=== playlistcopy.sh ===

'''Einleitung'''

Dieses Script ist entstanden, als ich vor dem Problem stand, geordnet meine MP3s auf eine Daten-CD zu brennen. Ziel war es, dass ein CD-Player die Lieder in der Reihenfolge abspielt, wie ich es wollte. Da ich kein passenden Programm gefunden habe, welches zudem noch die id3-Tags auswertete, um sie in den Namen der Dateien zu schreiben, machte ich mich ans Werk und schuf dieses kleine Script.

'''Funktionen'''

* lesen einer m3u Playlist
* bis zu 1000 Dateien werden kopiert und durchnummerriert
* man kann angeben, mit welcher Nummer begonnen werden soll
* Interpret und Titel werden aus den id3-Tags entnommen und im Dateinamen eingefügt
* kopiert ausschließlich MP3 Dateien

'''Das Script playlistcopy.sh'''
<pre>
#!/bin/sh
#
# Dieses Script liest eine m3u Playlist aus, kopiert die darin enthaltenen Dateien
# und benennt sie der Reihelfolge um, wie sie in der Playlist stehen.
# Bsp: 001-ARTIST-TITLE.mp3, 002-ARTIST-TITLE.mp3, etc.
# So können sie dann z.B. auf eine Daten-CD kopiert werden und werden der Reihe nach
# von einem CD-Player abgespielt.
#
# Die Programme id3info und recode werden benötigt
#
# Version: 0.8
# Zuletzt geändert am: 03.01.2008
#
# Autor: Mathias Rabe
#
# Der Autor übernimmt keinerlei Garantie auf evtl. entstehende Schäden.
#
# Dieses Script steht unter der GPL. Es gelten daher die dort
# vorgeschriebenen Bedingungen für die Verwendung dieses Scriptes.

#--------------------------------Einstellungen----------------------------------

#Nummer mit der angefangen werden soll zu zählen.
STARTNUMBER=1;

#---------------------------------Programm--------------------------------------

usage() {
echo "Usage: $(basename $0) EXTENDED.M3U DIRECTORY" >&2;
exit 1;
};

# Prüfen ob wirklich alles angegeben wurde
if test $# -ne 2 ; then
usage;
fi;

if ! test -r $1 ; then
echo "Playlist $1 doesn't exist." >&2;
usage;
fi;

if ! test -d $2 ; then
echo "Directory $2 doesn't exist. Creating it.";
mkdir $2;
if [ $? -ne 0 ] ; then
exit 1;
fi;
fi;

# existiert das Programm id3tag?
if ! test -e /usr/bin/id3info ; then
echo "Couldn't find /usr/bin/id3info" >&2;
exit 1;
fi

# existiert das Programm recode?
if ! test -e /usr/bin/recode ; then
echo "Couldn't find /usr/bin/recode" >&2;
exit 1;
fi

ERRORNUM=0;
exec <$1;
read ROW;
while [ $? -eq 0 ] ; do
# steht in der Zeile #EXTM3U ?
if [ "$ROW" == "#EXTM3U" ] ; then
read ROW;
continue;
fi;
# fängt die aktuelle Zeile mit #EXTINF an?
echo $ROW | grep "#EXTINF" > /dev/null;
if [ $? -eq 0 ]; then
read ROW;
continue;
fi;
# Leerzeile gefunden?
echo $ROW | grep "^$" > /dev/null;
if [ $? -eq 0 ]; then
echo "Error: Empty line found. Please clean up your playlist." >&2;
exit 2;
fi;
# Ist die Datei wirklich vorhanden, welche in der Playlist steht?
if ! test -e "$ROW" ; then
#der absolute Pfad ging nicht, also versuchen wir es nochmal mit dem relativen Pfad
DIRNAMEOFLIST=$(dirname $1);
ABSOLUTPATHOFFILE=$(printf "%s/%s" "$DIRNAMEOFLIST" "$ROW")
if ! test -e "$ABSOLUTPATHOFFILE" ; then
echo "Error: File $ABSOLUTPATHOFFILE doesn't exist. Trying next one." >&2; # Die Ausgabe ist zwar Müll, aber es funktioniert
ERRORNUM=$((ERRORNUM+1));
read ROW;
continue;
fi;
else
ABSOLUTPATHOFFILE=$ROW;
fi;
# Ist es auch eine mp3 Datei?
echo $(file -ib "$ABSOLUTPATHOFFILE") | grep "audio/mpeg" > /dev/null;
if ! [ $? -eq 0 ] ; then
echo "Error: File $ABSOLUTPATHOFFILE is no mp3 file. Trying next one." >&2;
ERRORNUM=$((ERRORNUM+1));
read ROW;
continue;
fi;
# Alles ok? Dann kopier und benenne sie um!
ARTIST=$(id3info "$ABSOLUTPATHOFFILE" | grep "TPE1" | tail --lines=1 | sed "s/=== TPE1 (Lead performer(s)\/Soloist(s)): //" | recode "latin-1..");
TITLE=$(id3info "$ABSOLUTPATHOFFILE" | grep "TIT2" | tail --lines=1 | sed "s/=== TIT2 (Title\/songname\/content description): //" | recode "latin-1..");
DESTINATION=$(printf "%s/%03d-%s-%s.mp3" $2 $STARTNUMBER "$ARTIST" "$TITLE");
#DESTINATION=${DESTINATION//\ /_} # Dadurch können alle Lehrzeichen durch _ ersetzt werden.
cp -v "$ABSOLUTPATHOFFILE" "$DESTINATION";
if [ $? -ne 0 ] ; then
echo "An unexpected error occured. Abort";
exit 1;
fi;
STARTNUMBER=$((STARTNUMBER+1));
read ROW;
done;

if [ $ERRORNUM -ne 0 ]; then
echo "There where $ERRORNUM errors." >&2;
exit 2;
fi;

exit 0;
</pre>

Diskussion:OpenSUSE und Multimedia

2007-07-22T14:11:35Z

K4m1K4tz3:

{{Diskussionsziele|Forenlink=http://www.linux-club.de/forum18.html|Forenname=Multimedia}}

Ich denke man sollte auch ffmpeg in der Liste mit aufnehmen.

[[Benutzer:K4m1K4tz3|K4m1K4tz3]] 17:05, 20. Jul 2007 (CEST)

::Trag es ein. ;-) --[[Benutzer:Griffin|Griffin]] 17:36, 20. Jul 2007 (CEST)

::: w32-codecs-all liefern doch auch wmv/wma support oder? wodrin unterscheiden die sich?--[[Benutzer:DerMani|derMani]] 18:08, 20. Jul 2007 (CEST)

::::Notwendig ist das Paket wohl nicht. Ich habe es nicht installiert und bisher auch nicht vermisst. Die Erwähnung ist wohl "entbehrlich" oder andersrum positiv ausgedrückt "unschädlich". Es ist ein interessantes Multimediapaket von Packman, das man aber wohl nicht unbedingt benötigt, aber gleichwohl gutartig installieren kann.
::::Ob man es demnach erwähnen muss? => Nö.
::::Ob man es erwähnen kann? => Jo.
::::Schlussfolgerung? => Aus den benötigten Paketen nehme ich es mal raus. Bei den interessanten Paketen kann man es aber sehr gut stehen lassen. ;-)
::::Damit dürften alle zufrieden sein, oder? Wer genaueres weiß, kann ja hier genaueres schreiben. ;-) --[[Benutzer:Griffin|Griffin]] 13:52, 22. Jul 2007 (CEST)

:::::Ich habe dafür keine w32codec-all installiert und habe es bisher nicht vermisst. Kann alles abspielen.
:::::Ob man es demnach erwähnen muss? => Nö.
:::::Ob man es erwähnen kann? => Jo.
::::: ;-) [[Benutzer:K4m1K4tz3|K4m1K4tz3]] 15:45, 22. Jul 2007 (CEST)

::::::Na, dann hammers ja jetzt. :-) Als interessantes und optionales Paket ist es erwähnt. Das kann es, das darf es und da ist es richtig. :-) Perfekt also! So soll es sein. ;-) --[[Benutzer:Griffin|Griffin]] 15:50, 22. Jul 2007 (CEST)

:::::::Naja, ich wollte sagen das die w32codec-all genauso als Optional anzusehen sind. Habe mal geschaut, ich spiele 90% aller Videos mit ffmpeg ab. Egal ob wmv9 oder mpeg4 oder ...
:::::::Früher konnte ich mit den w32 Codecs keine wmv9 Dateien abspielen, geht das jetzt? Und hat vielleicht jemand ein wmv10 Video für mich um auch das mal zu prüfen? [[Benutzer:K4m1K4tz3|K4m1K4tz3]] 15:55, 22. Jul 2007 (CEST)

Hab ich beides noch nicht bewusst probiert. Ich spiele die Dinger ab, wie sie kommen. Was es ist, interessiert mich meistens nicht. Wenn das mit w32 nicht geht (w32 aber andere Dinge kann), die Codecs also nicht identisch sind, dann müssen wir natürlich beide Pakete bei den wichtigen Paketen erwähnen. W32 ist das bekanntere und verbreitetere Paket, deshalb habe ich es bevorzugt benannt. Ich lasse mich da aber auch gerne von besseren Alternativen belehren, wenn es den tatsächlich welche sind.

Na ja, erwähnt haben wir es ja jetzt und das erscheint mir m.E. auch völlig richtig zu sein. --[[Benutzer:Griffin|Griffin]] 16:00, 22. Jul 2007 (CEST)

:: Also mich interessiert es schon wie weit die w32 Codecs mitlerweile sind. Ich möchte hier gerne das aktuellste und natürlich Beste stehen haben. Leider kann ich ffmpeg nicht deinstallieren um dann zu testen was die w32 Codecs können, da ich einfach zu viele Abhängigkeiten zerstören würde.

::PS: Kaffeine zeigt welchen Codec er nimmt, wenn man im Video mal rechtsklickt und dann auf Stück-Info geht.

Diskussion:OpenSUSE und Multimedia

2007-07-22T13:55:45Z

K4m1K4tz3:

Diskussion:OpenSUSE und Multimedia

2007-07-22T13:45:20Z

K4m1K4tz3:

OpenSUSE und Multimedia

2007-07-20T15:50:46Z

K4m1K4tz3:

openSUSE mit einem Klick Mulitmedia/DVD fähig machen:
* http://de.opensuse.org/KonvenientSUSE
= Suses Multimediafähigkeiten erweitern =
Ein frisch installiertes Suse Linux bietet nicht sehr viele Multimediamöglichkeiten. Sogar gängigste Formate, wie das mp3 Format, werden von Suse nicht ab Werk abgespielt. Um die Multimediafähigkeiten von Suse zu erweitern bedarf es daher eines kleinen Eingriffs, den aber auch ein Anfänger leicht bewerkstelligen kann und innerhalb weniger Minuten erledigt haben dürfte.

== mp3 Support nachrüsten ==
Damit die bei Suse mitgelieferten Mediaplayer mp3-Dateien abspielen können, muss man einige wenige Dateien Nachinstallieren. Hierzu fügt man sich die nachfolgend in Klammern genannten Quellen als alternative Installationsquellen in YaST ein. Wie dies geht, wird [[YaST-Installationsquellen für SuSE Linux|hier für die verschiedenen Suse Versionen beschrieben]]. Siehe hierzu auch [[Suse multimediafähig machen und das Problem der DVD#Die Vorgehensweise|unten im Abschnitt "Die Vorgehensweise"]]. Erforderlich sind '''[[YaST-Installationsquellen für SuSE Linux#Packman (Die Multimediafähigkeiten von SuSE Linux erweitern)|Packman]]''', der '''[[YaST-Installationsquellen für SuSE Linux#Empfohlene Quellen|Suse Server]]''' ("Suse Linux Installationsquelle" oder auch "Suse Base" ("[[YaST-Installationsquellen für SuSE Linux#SuSE Linux Installationsquelle|oss]]" und "[[YaST-Installationsquellen für SuSE Linux#SuSE Linux Extra CD (non-oss Installationsquelle)|non-oss]]"!)) und '''[[YaST-Installationsquellen für SuSE Linux#Suser-Guru (Verschieden - zum Teil i686 optimierte - Pakete)|Suser-Guru (Guru)]]'''.

Anschließend installiert man sich über YaST (YaST => Software => Software installieren oder löschen => Filter "Suche" => Eingabe der unten genannten Paketnamen in das Suchfeld) die nachfolgenden Pakete:
amarok (von Guru)
amarok-xine (von Guru)
libxine1 (von Packman)
xine-ui (von Packman)
kaffeine (von Packman)
w32codec-all (von Packman)
libffmpeg0 (von Packman)
xmms (von Packman, damit xmms mp3 abspielen kann)
xmms-lib (von Packman)

== Suse den Umgang mit sonstigen Multimediaformaten beibringen ==
Rpm-Pakete zur Erweiterung der Multimediafähigkeiten von Suse werden traditionell von [http://packman.links2linux.de/ Packman] angeboten. Da Packman Pakete aber häufig Paketabhängigkeiten zu anderen Paketen besitzen, wird dringend angeraten, zur Installation von Packman Paketen einen Paketmanager wie z.B. YaST (mit alternativen Installationsquellen) oder apt zu verwenden. Nachfolgend wird die Verwendung von YaST beschrieben, da sie für einen Anfänger den einfachsten und am leichtesten verständlichen Weg darstellt.

=== Die Vorgehensweise ===
# Zunächst muss man sich '''[[YaST-Installationsquellen für SuSE Linux#Packman (Die Multimediafähigkeiten von SuSE Linux erweitern)|Packman]]''' und den '''[[YaST-Installationsquellen für SuSE Linux#Empfohlene Quellen|Suse Server]]''' ("Suse Linux Installationsquelle" oder auch "Suse Base" ("[[YaST-Installationsquellen für SuSE Linux#SuSE Linux Installationsquelle|oss]]" und "[[YaST-Installationsquellen für SuSE Linux#SuSE Linux Extra CD (non-oss Installationsquelle)|non-oss]]"!)) als alternative Installationsquelle in YaST einfügen. Wie das geht, wird [[YAST-Installationsquellen für SuSE Linux | hier für die verschiedenen Suse Versionen beschrieben]]. Da Packman Pakete grundsätzlich nur Abhängigkeiten zu anderen Packman Paketen und zu Suse Paketen besitzen, ist es erforderlich, sich Packman und den Suse-Server als Installationsquelle in YaST einzufügen.
# Nachdem man die Installationsquellen wie beschrieben eingefügt hat, startet man YaST.
# Punkt "Software" anwählen.
# "Software installieren oder löschen" anklicken. Da jetzt sämtliche Daten von den Servern geholt werden, kann dieser Punkt etwas dauern.
# Jetzt wählt man oben Filter "Suche".
# in das Suchfeld gibt man nun die Namen der Pakete ein, die man installieren möchte.

=== Benötigte oder interessante Pakete ===
* '''w32codec-all''' - das Paket enthält Windows Codec dlls für diverse Multimediaformate.
* '''libxine1''' - ersetzt das kastrierte "xine-lib" Paket von Suse.
* '''xine-ui''' - der Xine Player.
* '''kaffeine''' - großartiger Video-Player, der auf xine basiert. Von Packman garantiert unkastriert und aktuell.
* '''lame''' - mp3 Encoder (wird z.B. für [http://www.easylinux.de/2003/08/048-grip/ Grip] benötigt, wenn Grip CDs in das mp3 Format rippen soll).
* '''libffmpeg0''' - Beinhaltet verschiedene Bibliotheken. Unter anderem auch für *.wmv und *.wma Dateien.
* '''mplayer''' - Leistungsfähiger Multimediaplayer.
* '''vlc''' - besonders von Windows Umsteigern gerne genutzter Multimediaplayer.
Da [http://packman.links2linux.de/ Packman] ein wirklich reichhaltiges Angebot von Paketen bereithält, möchte ich es dem geneigten Leser an dieser Stelle empfehlen, sich selbst einmal bei [http://packman.links2linux.de/ Packman] umzusehen und dort nach interessanten Paketen zu stöbern. Alle Pakete können, nachdem man Packman als alternative Installationsquelle in YaST eingefügt hat [[YaST-Installationsquellen für SuSE Linux|(wie hier für die verschiedenen Suse Versionen beschrieben wird)]], über YaST installiert werden.

== Zusammenfassende Liste aller erforderlichen oder interessanten Multimediapakete ==
Die nachfolgende Liste nennt nochmals alle erforderlichen oder interessanten Pakete. Verwender anderer Paketmanager als YaST (apt, smart, etc.) können die Pakete dieser Liste einfach über ihren jeweiligen Paketmanager installieren.
* '''amarok''' - Der Audioplayer amaroK
* '''amarok-xine'''
* '''xmms'''
* '''xmms-lib'''
* '''w32codec-all''' - das Paket enthält Windows Codec dlls für diverse Multimediaformate.
* '''libxine1''' - ersetzt das kastrierte "xine-lib" Paket von Suse.
* '''xine-ui''' - der Xine Player.
* '''kaffeine''' - großartiger Video-Player, der auf xine basiert. Von Packman garantiert unkastriert und aktuell.
* '''lame''' - mp3 Encoder (wird z.B. für [http://www.easylinux.de/2003/08/048-grip/ Grip] benötigt, wenn Grip CDs in das mp3 Format rippen soll).
* '''libffmpeg0''' - Beinhaltet verschiedene Bibliotheken. Unter anderem auch für *.wmv und *.wma Dateien.
* '''mplayer''' - Leistungsfähiger Multimediaplayer.
* '''vlc''' - besonders von Windows Umsteigern gerne genutzter Multimediaplayer.

= Das Problem: DVD abspielen =

== Die rechtliche Grauzone ==
DVDs abzuspielen ist unter Linux ein besonderes Problem. Video-DVDs sind nämlich mit einem Abspielschutz, dem Content-Scrambling-Verfahren (CSS), versehen, von dem teilweise auch behauptet wird, dass es sich hierbei auch um einen Kopierschutz handle. Ohne einen entsprechenden Schlüssel ist es daher nicht möglich, diese DVDs abzuspielen. Kommerzielle Abspielprogramme oder Heim-DVD-Player verfügen über eine entsprechende Lizenz und somit über den besagten Schlüssel. Open Source Anwendungen verfügen dagegen in aller Regel nicht über eine entsprechende kostenpflichtige Lizenz, weswegen Video-DVDs im allgemeinen unter Linux-Systemen nicht out-of-the-Box abspielbar sind.

Es gibt zwar für Linux ein Paket namens [http://de.wikipedia.org/wiki/Libdvdcss libdvdcss2], welches DVDs entschlüsselt, die mit dem CSS Verfahren verschlüsselt sind und mit dem man unter Linux seine legal erworbenen Video-DVDs abspielen kann, die rechtliche Lage um dieses Paket ist jedoch leider unklar. Es erscheint nämlich fraglich, ob es sich bei CSS um eine "wirksame technische Maßnahme" nach [http://www.gesetze-im-internet.de/urhg/__95a.html § 95a UrhG] handeln könnte. Zu dieser Frage gibt es jedoch derzeit keine Rechtsprechung. Sollte das CSS Verfahren unter den Begriff der "wirksamen technischen Maßnahme" im Sinne des [http://www.gesetze-im-internet.de/urhg/__95a.html § 95a UrhG] zu subsumieren sein, so wäre die Umgehung von CSS durch die libdvdcss2 nicht gestattet. Die libdvdcss2 dürfte in diesem Fall nicht verwendet werden. Da es zu dieser Frage keine Rechtsprechung gibt, die Frage kontrovers diskutiert und mit unterschiedlichen Begründungen auch sehr unterschiedlich und uneinheitlich beantwortet wird, kann die Rechtslage um das Paket libdvdcss2 nur als unklar und ungewiss angesehen werden.

Wegen dieser unklaren Rechtslage wird hier auf eine Installationsanleitung, einen Link auf das Paket und auf eine Empfehlung des Pakets ausdrücklich verzichtet. Auch wenn eine Installation über apt und smart möglich ist, so wird an dieser Stelle ausdrücklich darauf hingewiesen, dass auch dies aus den geschilderten rechtlichen Gründen an dieser Stelle nicht empfohlen werden kann. Eine Nennung der entsprechenden Quellen kann daher ebenfalls nicht erfolgen.

Zur rechtlichen Problematik um das Paket libdvdcss2 siehe außerdem [http://www.linux-user.de/ausgabe/2006/02/060-multimedia-recht/index.html diesen Artikel der Zeitschrift LinuxUser], [http://packman.links2linux.de/?action=122 bei Packman] und [http://de.wikipedia.org/wiki/Libdvdcss bei Wikipedia] (jeweils m.w.N.), sowie in den unten angeführten Quellenangaben.

== Eine legale Möglichkeit zum Abspielen von DVDs unter Linux ==
Wer die oben beschriebene rechtliche Grauzone gerne umgehen möchte, dem wird geraten das kommerzielle Programm '''LinDVD''' käuflich zu erwerben. Dieses Programm bringt alle erforderlichen Lizenzen mit und ermöglicht es so, legal DVDs unter Linux anzusehen.

Homepage von LinDVD: http://www.intervideo.com/jsp/LinDVD.jsp 
Artikel zu LinDVD in der Zeitschrift LinuxUser: http://www.linux-user.de/ausgabe/2007/02/008-lindvd/index.html 
Artikel zu LinDVD in der Zeitschrift LinuxUser: http://www.linux-user.de/ausgabe/2007/01/072-lindvd 

= Quellenangaben und weiterführende Links =
* [http://packman.links2linux.de/ Packman Seite]
* [http://www.linux-user.de/ausgabe/2006/02/060-multimedia-recht/index.html Zeitschrift LinuxUser, Artikel "Legal, illegal, multimedial"]
* [http://www.easylinux.de/2004/09/064-basics/ Zeitschrift EasyLinux, Artikel "Multimedia und Rechte - DVD und MP3 -- nein danke?]
* [http://de.wikipedia.org/wiki/Libdvdcss Wikipedia, Artikel "libdvdcss2"]
* [http://www.easylinux.de/2003/08/048-grip/ Artikel der Zeitschrift EasyLinux zu Grip (mit guter Anleitung)]
* [http://de.wikipedia.org/wiki/Content_Scrambling_System Wikipedia, Artikel zum "CSS"]
* [http://de.wikipedia.org/wiki/DVD-Video Wikipedia, Artikel "DVD-Video"]
* [http://de.wikipedia.org/wiki/DVD-Video#Verschl.C3.BCsselung Wikipedia, Artikel "DVD-Video", Abschnitt "Verschlüsselung"]
* [http://www.gesetze-im-internet.de/urhg/index.html Das Urhebergesetz]

----

[[Multimedia | Zurück zu Multimedia]][[Category:Multimedia]][[Kategorie:HowTo]]

Dd

2007-07-20T15:07:52Z

K4m1K4tz3:

{{UnderConstruction}} --[[Benutzer:Robi|Robi]] 19:40, 7. Jul 2007 (CEST)
{{Box Achtung||
viele der auf dieser Seite vorgestellten Befehle werden nur unter Rootkennung funktionieren und die Befehle müssen auf die Gegebenheiten des eigenen Rechners abgestimmt werden. Nur kleine Schreib- oder Denkfehler können schon zu ernsten Datenverlusten führen, desshalb '''vor dem Betätigen der Enter-Taste den Befehl genau anschauen'''
}}

= das Kommando dd =

== allgemeines zum Kommando dd ==

dd ist ein Kommando das noch aus der Urzeit von [http://de.wikipedia.org/wiki/Unix Unix] stammt. Der Name sollte früher ''Copy and Convert'' bedeuten, das Programmkürzel '''"cc"''' ('''C'''ompiler '''C'''ollection) war jedoch schon an den [http://de.wikipedia.org/wiki/C_%28Programmiersprache%29 C-][http://de.wikipedia.org/wiki/Compiler Compiler] vergeben. Daher kam es wohl kurzerhand zu "'''dd'''". Heute wird dieses Kürzel oftmals als '''disk dump''' oder ähnlich übersetzt, ursprünglich sollte es wohl doch mehr an das [http://de.wikipedia.org/wiki/Job_Control_Language JCL]-Kommando "Data Definition" erinnern, auch die für UNIX-Befehle doch sonderbaren Optionensschreibweisen erinnern noch sehr stark an diese Abstammung.

Das UNIX-Kommando '''dd''' dient dem Umleiten von [http://de.wikipedia.org/wiki/Datenstrom Datenstömen]. Dabei kann es diese Datenströme [http://de.wikipedia.org/wiki/Byte Byteweise] bearbeiten und universell blocken. Als Quelle und Ziel der Datenströme können sowohl normale Dateien, die normalen Ein- und Ausgabekanäle der Prozesse und auch Geräteknoten verwendet werden. In früherer Zeit benötigte man das Programm dd , um inkompatible Formate und Zeichensätze zwischen unterschiedlichen Betriebssystemen und Geräten zu kopieren, und um Daten auf externen [http://de.wikipedia.org/wiki/Peripherieger%C3%A4t Peripheriegeräten] (oftmals [http://de.wikipedia.org/wiki/Bandlaufwerk Bandgeräte]) lesen und schreiben zu können.

Typischen Beispielaufgaben aus dieser Zeit könnten heute auf Linux etwa so ausgesehen:
* Auslesen eines [http://de.wikipedia.org/wiki/EBCDIC EBCDIC]-Bandes (80 Zeichen pro Record, 10 Records pro Block, Dichte 1600 bpi) Ausgabe als [http://de.wikipedia.org/wiki/ASCII Ascii]-Datei:
dd if=/dev/nst1 of=/datei ibs=800 cbs=80 conv=ascii,lcase

Für Konvertierungsaufgaben benötigt man heute '''dd''' nur noch wenig. Dort wo noch mit solchen inkompatiblen Daten gearbeitet wird, benutzt man heute meist Programme die schon die entsprechende Ein- und Ausgabefilter mitbringen. Wohl aber benötigt man auch heute noch die universellen Bockungsmöglichkeiten von '''dd''' in Bezug auf Datenströme und [http://de.wikipedia.org/wiki/Ger%C3%A4tedatei#Blockorientierte_Ger.C3.A4te Geräteknoten], sowie die Möglichkeit im Datenstrom gezielt zu positionieren. Besondere "Berühmtheit" hat heutzutage jedoch die Möglichkeit erlangt, Partitionen und ganze Festplatten bytegenau zu kopieren, was fälschlicher Weise dazu verleitet mag '''dd''' auch noch in den Rang eines [[Liste_von_Backupprogrammen|Backuptools]] zu erheben.

== die Optionen von dd ==

Die Optionen von '''dd''' unterscheiden sich grundlegend von denen der meisten UNIX/Linux Kommandos. Eine Übersicht erhaltet ihr mit der Option '''--help''' oder der
[http://usr-share-man.org/man1/dd.html Manpage von dd] ''( Achtung: evtl. sind nicht alle Optionen in eurer installierten Version vorhanden)''. Auch eine Infoseite "'''info:/coreutils/dd invocation'''" sollte bei vielen installiert sein.

Die genaue '''SYNOPSIS''' ''(ältere Version)'' 
dd [--help] [--version] [if=file] [of=file] [ibs=bytes] [obs=bytes] [bs=bytes] [cbs=bytes] [skip=blocks]
[seek=blocks] [count=blocks] [conv={ascii, ebcdic, ibm, block, unblock, lcase, ucase, swab, noerror, notrunc, sync}]

{| border="0"
|+ ''' Die wichtigsten Optionen im Überblick '''

!''if=Datei''
||
Der Datenstrom, der umgeleitet werden soll. Das kann eine Datei oder Gerätedatei, also auch eine Festplatte oder ein anderes Gerät sein. Wird ''if'' weggelassen liest '''dd''' von der Standardeingabe.
|-
!''of=Datei''
||
Die Datei, auf die geschrieben werden soll. Dies kann wieder eine Datei oder ein Gerät sein. Wird ''of'' weggelassen schreibt '''dd''' auf die Standardausgabe.
|-
!''ibs=Bytes''
||
Eingabe-Blockgröße (''input block size''), gibt an, wie viele Bytes auf ein Mal gelesen werden sollen.
|-
!''obs=Bytes''
||
Ausgabe-Blockgröße (''output block size''), gibt an, wie viele Bytes auf ein Mal geschrieben werden sollen.
|-
!''bs=bytes''
||
Kurzschreibweise für ''ibs=bytes obs=bytes''. Der Standardwert bei Nichtangabe ist 512 Bytes.
|-
!''count=Blocks''
||
Angabe, um nur eine begrenzte Menge Blöcke zu kopieren.
|-
!''skip=Blocks''
||
Angabe, um eine Anzahl Blocks beim lesen am Anfang zu überspringen.
|-
!''seek=blocks''
||
Überspringt diese Anzahl Blöcke beim schreiben auf die Ausgabe.
|-
!''conv=Schlüsselwörter ''
||
Wandelt den Datenstrom entsprechend einer Kommagetrennten Liste von Schlüsselwörtern.
|-
!''cbs=Bytes''
||
Umwandlungs-Blockgröße (convert block size): Größe der Blöcke zum Umwandeln auf ein Mal.
|}

=== die Ein- und Ausgabefile ===

Beide Filenamen werden in den Optionen angegeben nach folgenem Prinzip
if=/PATH/EINGABEDATEI #die Datei oder Gerät aus dem gelesen wird
of=/PATH/AUSGABEDATEI #die Datei oder Gerät auf das geschrieben wird
sollte einer oder beide nicht explizid so angegeben werden, dann wird von '''dd''' automatisch mit dem entsprechenden Standard-Ein/Ausgabe-Kanal gearbeitet. Man kann immer jeweils nur einen Dateinamen angeben, es geht also weder eine Space- noch eine Kommaseparierte Liste und auch die Shell übernimmt hier keine Path- oder Filenamensexpansionen. Nur relative und absolute Dateiadressierung sowie die '''tilde expansion''' sind zulässig, ansonsten sind immer komplette absolute oder relative Path und kompletter Dateinamen anzugeben. Auf den Inhalt von Variablen für die Dateinamen kann zugegriffen werden. Soweit im Dateinamen Sonderzeichen enthalten sind, muß das aber im dd-Komando unbedingt berücksichtigt werden. 
Beispiel:
NULL=/dev/null
INFILE="/home/user/datei orginal"
dd if="$INFILE" of=$NULL

{{Box Achtung||
Beim Zugriff auf Geräteknoten, also zB Festplatten, Partitionen, Bandgeräte usw. immer einmal mehr prüfen ob nicht doch '''if''' und '''of''' verwechselt wurden. Es droht hier bei Verwechslungen unter Userkennung root Datenverlust.
}}

=== die Blockgröße ===

Die Blockgröße gibt an, wieviele Byte bei einem read- oder write-Kommando gleichzeitig verarbeitet werden. Im Normalfall ist man unter Linux ja gewohnt, dass man sich darum überhaupt nicht kümmern muss, das macht Linux im Hintergrund für uns immer richtig. Da wird zB von der Tastatur jedes einzelne Zeichen gelesen, Eingaben werden zeilenweise nach Bestätigung der ENTER-Taste verarbeitet, auf die Festplatte wird mittels des Caches mit 4KB Blockgröße lesend und schreibend zugegriffen, über Internet werden Pakete mit maximaler Größe von 1500 Byte gesendet usw. Alles Dinge von denen wir gar nichts mitbekommen, und von denen wir auch die meisten überhaupt nicht beeinflussen könnten, selbst wenn wir das wollten.

Anders jedoch beim Befehl dd. Hier arbeitet der Befehl, sollten wir nichts anderes angeben, immer mit 512 Byte lesend und schreibend und hier können wir das sowohl beim lesenden- wie auch den schreibenden-Zugriff und sogar getrennt beeinflussen. 

'''Zu was soll das gut sein, werden sich die meisten fragen'''. 
Eine Regentonne voll mit Wasser kann man sowohl mit einem Eimer, mit einer Suppenkelle aber auch mit einem Kaffeelöffelchen "leerschaufeln", was ist wohl die schnellste und rückenschonendste Methode? Ähnlich verhalten sich viele Geräte wenn wir direkt zB über dd auf sie zugreifen.

Im folgende Beispiel wird eine kleine Partition einer SCSI-Platte mit "NULLEN" überschrieben, wobei mit der Blockgröße von dd gespielt wird. 
time dd if=/dev/zero of=/dev/sdb1 bs=512
(wobei bei bs= die Werte 16 64 512 2K 8K 32K und 128K zum Einsatz kamen)

{| border="1"
! width="20%" | Blockgröße
! width="20%" | real time
! width="20%" | user time
! width="20%" | sys time
|-
!16 Byte
|| 2m26.593s|| 0m7.898s || 1m2.839s
|-
!64 Byte
|| 1m39.600s ||0m2.734s || 0m23.812s
|-
!512 Byte
|| 1m18.710s||0m0.465s || 0m6.942s
|-
! 2 KByte
||1m16.131s ||0m0.100s || 0m3.552s
|-
! 8 KByte
|| 0m29.137s || 0m0.016s || 0m1.299s
|-
! 32 KByte
|| 0m29.159s || 0m0.012s || 0m1.507s
|-
! 128 KByte
|| 0m29.115s || 0m0.003s || 0m1.474s
|}
Wir erkennen, die default Einstellung von dd (512 Byte) ist zwar auf dieser Platte nicht die Allerschlechteste, aber es geht durchaus noch 3 Mal schneller. Da moderne Festplatten in der Regel heute einen Cache haben der zumindestens beim Lesen genutzt ist, ergeben sich beim Lesen von Partitionen oder ganzen Festplatten oftmals ganz andere (weniger unterschiedliche) Werte.

Wesentlich gravierender sind die Unterschiede jedoch bei Bandlaufwerken, es gibt verschiedene Möglichkeiten wie das Laufwerk die ihm übertragene Blockgröße interpretieren soll, man muss prinzipiell jeden Block mit der selben Blocksize lesen, mit der der Block auch geschrieben wurde, eine ungünstige Blockgröße kostet nicht nur Zeit sondern bedeutet auch erhöhten Verschleiß an Bandmaterial und Laufwerk und nicht zuletzt auch noch ein höheres Fehlerrisiko. Wer sich näher damit befassen will oder muss kann unter [[Bandlaufwerke_und_LINUX|Bandlaufwerke und Linux]] und speziell über die [[Bandlaufwerke_und_LINUX#Die_richtige_Blockgröße|richtige Blockgröße bei Bandlaufwerken]] im Wiki näher infomieren.

Es gibt im Internet die abendteuerlichsten Berechnungsmodelle für die "richtige Blockgröße" von dd für den Zugriff auf Festplatten. Man geht dabei von der Ausgabe des [http://www.die.net/doc/linux/man/man8/fdisk.8.html fdisk-Befehles] aus, und errechnet aus den dort ausgegebenen Werten der Köpfen, Sektoren, Cylindern und Units irgendwie eine "optimale Blockgröße" und kommt dann auf solche Werte wie zB. 16065 Byte.[http://linuxwiki.de/dd ] 
Abgesehen, dass solche Werte dann manchmal nicht einmal durch 512 (die kleinste Speichereinheit auf einer Festplatte) teilbar sind, schon eine einfache Überlegung müsste den völligen Unsinn eines solchen Unterfangens aufzeigen. 
<pre>
LINUX:~ # fdisk -l /dev/sdb

Disk /dev/sdb: 18.2 GB, 18275768320 bytes
255 heads, 63 sectors/track, 2221 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
.......
</pre>
Diese Festplatte, die laut Hersteller 5 Scheiben mit je 2 Köpfen hat, sollte jetzt plötzlich 255 Köpfe haben. Damit müsste sie nach heutiger Bauweise in etwa 30 bis 35 cm dick sein und hätte ein stattliches Gewicht von einigen kg. '''Also absolute Vorsicht mit solchen Berechnungen.''' Die heutigen Platten verwalten intern ihre eigene [http://de.wikipedia.org/wiki/Festplattengeometrie Geometrie] und werden von außen nur über [http://de.wikipedia.org/wiki/Logical_Block_Addressing LBA]-Verfahren angesprochen. Die Geometrie die uns zB ''fdisk'' nach außen zeigt, ist eine reine logische die mit der tatsächlichen nur eines gemein hat, die ungefähre (etwas kleiner) Gesamtgröße, und kann mit Befehlen wie zB. ''fdisk'' bei Bedarf auch angepasst oder geändert werden.

Die optimalsten Werte sind von eine Vielzahl von vor allem baulichen Faktoren abhängig und werden heute in vielen Geräten obendrein noch über Cache in den Geräten gepuffert, womit man mit größeren Werten nie falsch liegen kann. 
Prinzipiell, (wenn keine anderen Faktoren dagegen sprechen- siehe Positionierung im Datenstrom) nur Werte die durch 512 teilbar sind, für Disketten, kleine Speicherkarten und kleine Sticks und ganz alte oder schon teilweise defekte Platten 512 Byte, für die restlichen Platten 4 oder 8 KByte, bei CD-ROM und DVD 1 oder 2 KByte und für [http://de.wikipedia.org/wiki/Magneto_Optical_Disk MO-Disk] [http://de.wikipedia.org/wiki/Ultra_Density_Optical UDO] und andere [http://de.wikipedia.org/wiki/WORM WORM], nur die vom Hersteller und der jeweiligen Technologie vorgeschriebenen Blockgröße, und man sollte auf der richtigen Spur sein.

=== Positionierung innerhalb des Datenstrom ===

Als Datenstrom bezeichnen wir hier mal alles, womit dd arbeiten kann, also zB. Pipe, Datei, Gerät,... 
DD kennt als Bezugspunkt immer nur den Anfang von Eingangsstrom und Anfang vom Ausgangsstrom. Da man aber nicht immer den kompletten Eingangsstrom bis zum Ende auf Ausgangsstrom von Anfang an kopieren will, muss man innerhalb dieser beide Datenströme auch positionieren können. Das geht mit den Optionen '''skip= seek=''' und '''count=''' und diese sind jeweils von den gesetzten Blockgrössen abhängig.

Wenn wir dd ohne solche Positionierungs-Optionen starten, dann kopiert dd den Eingangsdatenstrom von Anfang bis ein EOF ('''E'''nd '''O'''f '''F'''ile) kommt, komplett auf den Ausgangsdatenstrom. Bei Lese- oder Schreibfehlern wird an dieser Stelle dd abgebrochen. Ein EOF kann das Ende einer normalen File sein, aber auch zB der Abbruch eines am Eingang über Pipe verbundenen Befehles. Auch der Versuch zB. über eine Gerätegrenze (zB Partition zu Ende) zu lesen oder schreiben, führt zu einen EOF Fehler.

Die Gesamtanzahl der zu kopierenden Blöcke kann mit der Option '''count=''' begrenzt werden. 
count=100
kopiert genau 100 Blöcke ( Eingangsblockgröße )

Es können am Eingangsstrom anfänglich Blöcke (Eingangsblockgröße) übersprungen werden, die dann nicht mit kopiert werden, und die auch nicht von einem eventuell gesetzem count-Wert abgezogen werden. Die Option dazu ist '''skip=''' 
skip=100 count=50
kopiert genau 50 Blöcke (Eingangsblockgröße) wobei am Anfang 100 (Eingangsblockgröße) übersprungen werden, bevor mit dem kopieren begonnen wird.

Es können am Ausgangsstrom anfänglich Blöcke (Ausgangsblockgröße) übersprungen werden bevor der erste Block dorthin kopiert wird. Diese Option ist '''seek='''. 
seek=100 count=50
kopiert die ersten 50 Blöcke (Eingangsblockgröße) vom Eingangstrom ab dem 101 Block (Ausgangsblockgröße) in den Ausgangsstrom. (''Die ersten 100 Blocke der Größe obs= bleiben also im Ausgangsstrom unberührt, erst danach kommt der erste kopierte Block'') Diese Option macht nicht mit allen Ausgangsdatenströmen Sinn, und führt zB. in Verbindung mit der Standardausgabe zum "hängenbleiben" des Befehles, da ja erstmal auf Daten gewartet werden muss, die gar nicht kommen können. Beim Anwenden auf normale Dateien führt ein zu großer seek-Wert (größer als Ausgangsdatei) zum weiterschreiben der Datei am Ende.

Soweit zur Theorie und zu den wichtigsten Optionen

== die Ausgaben von dd ==

Wir untersuchen dazu einmal exemplarisch eine Ausgabe eines dd-Befehls, hier wurde von der Partition /dev/sda2 mit einer Blockgröße von 8KByte gelesen und auf ein Tape /dev/nst0 mit 256 KByte Blockgröße geschrieben.
<pre>
LINUX:~ # dd if=/dev/sda2 of=/dev/nst0 ibs=8K obs=256K
262256+0 records in
8195+1 records out
2148401152 bytes (2.1 GB) copied, 74.8721 seconds, 28.7 MB/s
</pre>
; 262256+0 records in :
es wurden '''262256''' Blöcke a. 8K gelesen, die '''+0''' bedeuten, es gab am Ende keine Rest, also der letzte Block hatte wirklich auch 8K Größe.

; 8195+1 records out :
es wurden '''8195''' Blöcke a. 256K geschrieben, die '''+1''' bedeutet, es wurde zusätzlich noch ein Restbock geschreiben, der nicht die volle Größe von 256K hatte. Wenn mit der Option "bs=" gearbeitet wird, oder die Blockgrößen sonst wie für Ein/Ausgabe gleich sind, dann sollten bei einem ordnungsgemäßen Ablauf des Befehls beide Werte immer gleich ausfallen.

;2148401152 bytes (2.1 GB) copied, 74.8721 seconds, 28.7 MB/s :
die Schlußzeile erhalten wir nur in neueren Versionen von dd. Sie beinhaltet hier die Gesamtanzahl der übertragenen Byte die Zeit und die durchschnittliche Geschwindigkeit.

Solange der Befehl dd läuft erhalten wir ansonsten von ihm keinerlei Ausgaben. Wir können uns aber den Status der aktuell übertragenen Daten in der oben beschriebenen Form anzeigen lassen, indem wir dem dd-Prozess ein Signal 10 '''(SIGUSR1)''' senden. Alle diese Ausgaben kommen über den Standardfehlerausgabekanal des Prozesses dd.

== Anwendungsgebiete und Beispiele ==

=== mit dd Dateien erzeugen ===

Hin und wieder benötigt man spezielle Dateien in bestimmter Größe und mit typischen oder speziellen Inhalt. Das können einfach Dateien sein, die man zum testen benötigt oder auch Dateien um darin zB Filesysteme anzulegen oder oder oder. 
Das geht mit dd sehr einfach. Wir benötigen nur einen Quelldatenstrom dazu. Auf die Blockgrößen brauchen wir hier meistens gar nicht zu achten (eventuell/selten könnte aber der gewünschte Quelldatenstrom eine Blockgröße fordern), da das Filesystem in das wir unsere Datei schreiben sowieso gebuffert ist, also können wir mit '''bs=''' und '''count=''' unsere gewünschte eindeutige Dateigröße sehr schön festlegen.
Blockgröße x Count = Dateigröße

==== Erzeugen einer mit Nullen gefüllten Datei ====

Als Quelldatenstrom nutzen wir dazu '''/dev/zero''' ( nicht /dev/null , da beim lesen von /dev/null nur ein EOF zurückgeliefert wird und wir eine Datei mit Länge Null erhalten würden)
<pre>
robi@LINUX:~/test> dd if=/dev/zero of=file.leer bs=1M count=1024
1024+0 Datensätze ein
1024+0 Datensätze aus
</pre>
erzeugt eine 1GB große (ergibt sich aus 1MByte x 1024) Datei voller Nullen

==== Erzeugen von Sparse Dateien ====
<pre>
robi@LINUX:~/test> dd if=/dev/zero of=file.sparse count=0 obs=1 seek=1G
0+0 Datensätze ein
0+0 Datensätze aus
robi@LINUX:~/test> ls -l file.*
-rw-r--r-- 1 robi users 1073741824 2007-06-29 23:37 file.leer
-rw-r--r-- 1 robi users 1073741824 2007-06-30 01:24 file.sparse
-rw-r--r-- 1 robi users 1073741824 2007-06-30 00:12 file.zufall
robi@LINUX:~/test> stat file.sparse
File: ,,file.sparse"
Size: 1073741824 Blocks: 0 IO Block: 4096 reguläre Datei
Device: 802h/2050d Inode: 1038268 Links: 1
Access: (0644/-rw-r--r--) Uid: ( 1001/ robi) Gid: ( 100/ users)
Access: 2007-06-30 01:24:39.168204352 +0200
Modify: 2007-06-30 01:24:39.168204352 +0200
Change: 2007-06-30 01:24:39.168204352 +0200
</pre>
Schreibt 0 Mal 1 Byte (also nichts) ab der Position 1073741824 und erzeugt somit ein 1GB große [http://de.wikipedia.org/wiki/Sparse-Datei Sparse Datei] ohne jeglichen Inhalt.
Man erkennt es eindeutig an der scheinbaren Differenz zwischen '''Size''' und der Anzahl der benutzen '''Blocks''' mit [http://www.die.net/doc/linux/man/man1/stat.1.html stat]

{{Box Achtung||
An solchen sparse Dateien ist schon mancher Admin zB bei Backups verzweifelt, man kann ein solches File meist schon durch umkopieren mit cp in ein normales Files umwandeln.
}}

==== Erzeugen einer Datei gefüllte mit Zufallszahlen ====

Als Quelldatenstrom nutzen wir dazu unter Linux '''/dev/urandom''' (nicht /dev/random , das dauert sonst viel viel zu lange und bringt auch nur das selbe Ergebnis)
<pre>
robi@LINUX:~/test> dd if=/dev/urandom of=file.zufall bs=1M count=1024
1024+0 Datensätze ein
1024+0 Datensätze aus
robi@LINUX:~/test> hexdump -C file.zufall | more
00000000 60 b2 03 a4 f5 13 46 d0 25 a4 f2 09 1c 31 9f 3f |`².€õ.FÐ%€ò..1.?|
00000010 17 b0 8e 32 af a0 87 67 cf 87 2c 4f 6d 92 de 4d |.°.2¯ .gÏ.,Om.ÞM|
00000020 38 3c a2 29 58 09 fd b7 ........
.......
</pre>
Als Größe wurde hier wieder wie schon oben 1GByte festgelegt. Mit [http://bashcurescancer.com/man/cmd/hexdump hexdump] haben wir gleich mal hineingeschaut, ob auch alles schön zufällig ist. ;-)

==== Erzeugen einer Datei mit typischen Eigenschaften und genau definierter Länge ====

Die unterschiedlichen Dateien haben unterschiedliche Eigenschaften zB beim Komprimieren. ZB. Zufallsdateien lassen sich überhaupt nicht komprimieren, Dateien mit lauter Nullen dagegen extrem, Logdateien sehr gut, Textdateien auch noch gut, aber Binärdateien nicht besonders gut. Wenn wir jetzt so eine Datei mit solchen typischen Komprimierungseigenschaften zu Testzwecken benötigen, dann können wir und mit dd eine solche mit genaue definierter Länge erzeugen.

Als Beispiel wollen wir hier eine genau 5MByte große Datei aus einigen Bilddateien erzeugen.
<pre>
robi@LINUX:~/test> ls -l bild*.jpg
-rw-r--r-- 1 robi users 277960 2007-06-29 22:34 bild0.jpg
-rw-r--r-- 1 robi users 312872 2007-06-29 22:48 bild10.jpg
-rw-r--r-- 1 robi users 120061 2007-06-29 22:08 bild1.jpg
-rw-r--r-- 1 robi users 164171 2007-06-29 22:10 bild2.jpg
-rw-r--r-- 1 robi users 179737 2007-06-29 22:13 bild3.jpg
-rw-r--r-- 1 robi users 173341 2007-06-29 22:13 bild4.jpg
-rw-r--r-- 1 robi users 165532 2007-06-29 22:14 bild5.jpg
-rw-r--r-- 1 robi users 161892 2007-06-29 22:16 bild6.jpg
-rw-r--r-- 1 robi users 126340 2007-06-29 22:17 bild7.jpg
-rw-r--r-- 1 robi users 125396 2007-06-29 22:19 bild8.jpg
-rw-r--r-- 1 robi users 289134 2007-06-29 22:21 bild9.jpg
robi@LINUX:~/test> cat bild*.jpg bild*.jpg bild*.jpg bild*.jpg | dd of=file.bild bs=1024K count=5
5+0 Datensätze ein
5+0 Datensätze aus
robi@LINUX:~/test> ls -l file.bild
-rw-r--r-- 1 robi users 5242880 2007-06-30 00:40 file.bild
</pre>
Unsere Bilddateien haben zusammen nicht ganz 2 MB Größe. Wir Nutzen desshalb [http://linuxreviews.org/man/cat/index.html.de cat] , um die Dateien aneinander zu hängen, und da die Gesammtgröße aller Dateien nicht ausreichen würde, haben wir sie einfach durch '''"bild*.jpg bild*.jpg bild*.jpg bild*.jpg"''' mehrere Male angegeben, (4 Mal sollte dann hier dicke reichen). ''(wenn man hier bei anderer Gelegenheit einmal zu viele Dateien dazu verwenden müsste, könnte eventuell die Bash einen Fehler bringen, '''zu viele Argumente''', dann kann man auch schrittweise vorgehen)'' 
Den so erzeugten Datenstrom von '''cat''' leiten wir per Pipe an '''dd''' weiter und mit '''"bs=1024K count=5"''' erzeugen wir dann ein genau 5MB großes File daraus, die typische Eigenschaften einer solchen JPEG Bilddatei hat, obwohl sie selbst kein (ein fehlerbehaftes) Bild ist.

=== dd auf Partitionen und ganze Festplatten anwenden ===

==== Allgemeine Bemerkungen und Warnungen ====

Was passiert wenn wir mit dd auf eine Partition oder einer Festplatte zugreifen? 
* Die Byte werden alle sequentiell von der Festplatte gelesen. Dabei werden nicht nur die Inhalte der Dateien, sondern auch die Verwaltungsdaten und die Struktur der Partitionen und der Filesysteme mit gelesen, Ebenfalls mitgelesen werden natürlich auch derzeit unbenutzte- und leere Böcke, und Blöcke die derzeit zu gelöschten Dateien gehören. Die gesamte Partition oder Festplatte wird also Byte für Byte gelesen und so gegebenfalls auch Byte für Byte kopiert.

* dd greift dabei direkt auf die Festplatte zu, also unter Umgehung des Cache der Filesysteme und des Swap. Das Filesystem bekommt das auch gar nicht mit. Wir sollten aus diesem Grunde auch für dd eine geeignete Blockgröße für die Zugriffe angeben (oder mit den default 512 Byte leben). Es ist also keinesfalls immer sichergestellt, dass zu jedem Zeitpunkt wirklich das mit dd gelesen wird, was auch wirklich im Filesystem in diesem Moment aktuell ist.

* Werden Filesysteme mit dd kopiert die aktuell noch '''readonly gemountet''' sind, dann ist das Ergebnis ein Image von diesem Filesystem das nicht sauber ausgehängt ist. Bevor wir es mounten können, muss erst ein [http://www.die.net/doc/linux/man/man8/fsck.8.html fsck] gemacht werden.

* Werden Filesysteme mit dd kopiert die aktuell noch '''read-write gemountet''' sind, dann '''muss vor dem mounten des Images oder der Kopie bei Jounalfilesystemen ein kompletter Filesystemcheck gemacht werden'''. Ansonsten wird bei fsck nur das Journal abgearbeitet ( die Daten im Journal sind aber weder aktuell noch wirklich gültig und zutreffend) und entstandene Inkonsitenzen und Fehler werden nicht behoben. Solche Fehler und Inkonsitenzen entstehen, da dd ein Filesystem nicht innerhalb eines Bruchteiles von Sekunden lesen kann, sondern dazu einige Minuten oder gar Stunden benötigt. In dieser Zeit arbeitet aber der Cache vom Filesystem ganz normal weiter und ändert auch den Inhalt auf der Platte. Wird jetzt zB. während dd eine Partition ließt, ein Cronjob gestartet der die Logdateien großflächig umorganisiert. Dann kann es natürlich sein, das bestimmte Blöcke von dd schon verarbeitet sind, die später jedoch ungültig werden oder durch andere Blöcke ersetzt werden die dd erst dann ließt wenn sie schon geändert sind. Es ist also durchaus möglich, das selbst nach einem kompletten Filesystemcheck eines so entstandenen Images einige Dateien fehlen, oder einfach einen falschen Inhalt haben, oder im Extremfall, das das Filesystem so defekt ist, das es nur unter enormen Datenverlust wiederhergestellt werden kann. Besonders gefährlich wird das, wenn man bei einem Filesystemcheck nur das Journal abarbeitet, und dann ganz normal unwissentlich mit einem strukturdefektem Filesystem weiterarbeitet. Man denkt alles in Ordnung, und plötzlich geht irgendwas nicht richtig oder es geht gar nichts mehr. Jetzt kann ein kompletter Filesystemcheck richtig böse Sachen aufzeigen.

* Zu den Verwaltungsdaten auf den Festplatte und Partitionen gehören natürlich auch die Partitionstabellen und gegebenenfalls Bootloader und auch Kennungs- Zustands- und Verwaltungsdaten von Softwareraid oder Virtuellen Laufwerken, vom Rechner als eindeutig gedeutete Filesystemkennungen, eventuell auch dem Filesystem bekannt gemachte defekte Blöcke. Werden diese Daten auf andere Festplatten kopiert und es sich dabei nicht um eine identischen Festplatte handeln sollte, die die ursprüngliche Festplatte ersetzen soll, sollte man sich hier sehr genau überlegen was man da macht, oder hin und wieder auch einmal mit einer Überraschung beim nächten Bootvorgang rechnen.

==== Festplatte testen durch Lesen ====

* Hin und wieder muss man mal eine Festplatte testen, ob denn diese überhaupt noch richtig angesprochen werden kann.
dd if=/dev/hdb of=/dev/null bs=4K count=1000
:dieser Test dauert nur eine Sekunde, reicht aber aus, um zu erkennen ob die Platte überhaupt noch was tut.

* Hat man viele SCSI-Platten im System, dann kann es hin und wieder vorkommen, man muss unbedingt wissen. welche physikalische Platte ist zB. /dev/sdf 
:solange die Platte bisher nicht mit Fehlern oder Totalausfall geglänzt hat:
dd if=/dev/sdf of=/dev/null bs=8K count=100000
:dieser Test könnte so 30 bis 60 Sekunden laufen, in dieser Zeit sollte die Aktivitäts-LED dieser Platte permanet an sein. Sobald der Befehl beendet ist, oder mit "STRG + C" abgebrochen wird, ist sie aus, oder flackert sporatisch wieder wie eventuell die anderen auch. Wenn diese Platte aber Probleme bereitet, dann ist es meist besser diese nicht direkt anzusprechen, sondern die benachbarten Platten , hier im Beispiel also /dev/sde und /dev/sdg, die Platte zwischen diesen Beiden sollte dann die gesucht /dev/sdf sein.

* Sollte es Busprobleme geben, zB wegen defekten oder ungeeigneten Kabel oder falschen DMA-Einstellungen oder Unverträglichkeit von 2 Geräten am Bus, kann man Lesetests über mehrere Minuten machen, gegebenenfalls über mehrere Geräte am selben Kontroller. Dabei die /var/log/messages auf Einträge beobachten. (Bei IDE Geräten: Fehler- und Befehlsbeschreibung [[Linux mit hdparm beschleunigen|hdparm]])

* Steht eine Platte in Verdacht auf sporatische oder gelegentliche Leseprobleme, und ist der erste kurze Ansprechtest erfolgreich gewesen, kann man einmal die gesamte Platte oder die entsprechend fehlerverdächtige Partition auslesen. '''(Achtung kann eventuell die Performance des Systems über einen längeren Zeitraum sehr negativ beeinflussen, je nachdem welche Filesysteme sich auf dieser Platte befinden)'''
dd if=/dev/hda of=/dev/null bs=4k
:kommt es zum Abbruch des Befehles wegen Lesefehler, dann wird es allerhöchste Eisenbahn sich eine Reserve Platte zu besorgen, und das letzte Backup auf Vollständigkeit zu prüfen. Eventuell gleich noch ein Backup dieser Platte versuchen. Einige Backup-Programme haben auch Optionen die bei Lesefehlern nicht gleich abbrechen, sondern versuchen erstmal noch weiterzumachen. Fehlerhafte Dateien oder Abschnitte werden übersprungen.

{{Box Achtung ||
Sollte die Elektonik des Kontrollers oder die Elektronik der Festplatte der Verursacher der zu untersuchenden Fehler gewesen sein, dann kann es in Einzelfällen dazu führen, dass der dd-Befehl hängen bleibt, aber weder eine Fehlermeldung ausgibt, noch sich mit [http://www.die.net/doc/linux/man/man1/kill.1.html kill] beenden läßt. Mit [http://www.die.net/doc/linux/man/man1/top.1.html top] oder [http://www.die.net/doc/linux/man/man1/ps.1.html ps] ist der Prozessstatus '''"D"''' beim dd-Prozess zu erkennen. Hier einfach erst einmal einige Minuten warten, eventuell greift doch noch ein Befehlstimeout oder eines der Geräte am Bus forciert einen Busreset. Wenn dem nicht so ist und es nach 15 Minuten keine Änderung ergeben hat, dann hilft hier dann oft nur noch ein reboot, um den hängenden dd-Befehl loszuwerden.
}}

==== der MBR und dd ====

===== mit dd den Master Boot Record auf Festpatten lesen und schreiben =====

Auf sehr vielen Seiten im Internet wird aufgezeigt wie man mit ''dd'' den [http://de.wikipedia.org/wiki/Master_Boot_Record MBR] ('''M'''aster '''B'''oot '''R'''ecord) einer Festplatte sichern und wieder zurückschreiben kann. Was auf vielen Seiten allerdings meistens fehlt, sind genauere Erklärungen dazu, was sich dort alles befindet, damit man besser abschätzen kann, unter welchen Bedingungen man was damit genau machen kann oder besser lassen sollte, und welche Alternativen es für einzelne Bereiche bzw. Abschnitte gibt. Aus diesem Grunde werden wir das hier einmal etwas ausführlicher behandeln.

{{ Box Anmerkung ||
Wir sprechen im Weiteren hier von [http://de.wikipedia.org/wiki/BIOS BIOS]-basierten Computern der [http://de.wikipedia.org/wiki/X86-Prozessor x86-Architektur], es gibt durchaus bei anderen Betriebssystemen und Plattformen auch noch ganz andere Architekturen und Strukturen, aber wir bleiben hier mal bei der typischen IBM-kompatiblen PC-Technik, mit der wohl bis auf ganz wenige Ausnahmen hier alle ihr Linux installiert haben werden
}}

Sichern könnte man den MBR von zB der Festplatte /dev/hda folgend:
dd if=/dev/hda of=/PATH/DATEI bs=512 count=1
Zurückspielen dieser Datei wieder in den MBR dieser Festplatte
dd if=/PATH/DATEI of=/dev/hda bs=512 count=1
Sich nur den Inhalt einmal [http://de.wikipedia.org/wiki/Hexadezimalsystem hexadezimal] anschauen, kann man zB so hier
dd if=/dev/hda bs=512 count=1 | hexdump -C | more

Wie wir aus den Befehlen herauslesen können, es handelt sich hier beim MBR um die ersten 512 Byte der Festplatte. Wie der Name es schon vermuten läßt, es hat irgend etwas mit dem booten zu tun. Und in der Tat, beim Start des Rechners, schaut der BIOS welches Medium soll ich booten, und dann läd er von diesem Medium genau diese 512 ersten Byte. Findet er darin etwas für ihn interessantes, dann versucht er damit den Bootvorgang zu starten.
findet er nichts interessantes, dann schaut er ob noch weitere Medien konfiguriert und vorhanden sind, von denen er booten soll, und versucht dort sein Glück. Findet er dabei gar nichts brauchbares, dann kommt die Fehlermeldung, er hat kein Betriebssystem zum booten gefunden.

===== Was befindet sich nun in diesen ersten 512 Byte einer Festplatte? =====

Wir werden das hier mal von hinten aufrollen. ''( Das erste Byte bezeichnen wir als Byte 0 demnach umfasst der Bereich den wir untersuchen Byte 0 bis Byte 511 )'' 
# '''Byte 510''' (0x1fe) und '''Byte 511''' (0x1ff) enthalten eine Kennung (auch MBR-Signatur genannt) die dem BIOS mitteilt, das was hier im MBR steht, ist für dich ein gültiger MBR oder nicht gültig. Der BIOS erkennt den MBR als gültig nur dann an, wenn dort '''0x55 0xAA''' steht. Bei nicht bootfähigen Platten darf hier auch etwas anderes stehen, allerdings wurden schon BIOSe erwischt, die vorsichtshalber eine solche Platte dann gleich mal mit geringer Geschwindigkeit bedient haben, so dass hier prinzipiell immer dieser Wert stehen sollte, wenn eine gültige Partitionstabelle vorliegt.
# Die 64 Byte, '''Byte 446 bis Byte 509''' (0x1be bis 0x1fd) dort befindet sich prinzipiell auf jeder Festplatte immer die [http://de.wikipedia.org/wiki/Partitionstabelle Partitionstabelle] für die Partitionen 1 bis 4 . Pro Partition 16 Byte das ganze 4 Mal. Nicht definierte Partitionen sind mit NULLEN gefüllt.
# Die '''Byte 444''' (0x1bc) '''und Byte 445''' (0x1bd) enthalten den Wert '''0x0000''' und dienen nur zur Trennung und dem Schutz der einzelnen Bereiche
# Der Bereich von '''Byte 0 bis Byte 443''' (0x000 - 0x1bb) ist reserviert für einen [http://de.wikipedia.org/wiki/Boot-Loader Bootloader] ( wobei in einigen Windowssystemen noch ein Teilbereich davon fest definiert ist '''Byte 440-443''' (0x1b8 -0x1bb). hier befindet sich eine Disk-Signatur, mit deren Hilfe zB die Zuordnung zu den Laufwerksbuchstaben vorgenommen wird.) Es sind also in diesem Bereich maximal 444 Byte für einen Bootloader möglich, Es handelt sich dabei um ein kleines mittels [http://de.wikipedia.org/wiki/Assemblersprache Assemblerprogrammierung] geschrieben ausführbares Programm. Dieser Bereich kann aber durchaus auch leer sein (alles NULL) es können aber auch zB. Bootloader dort installiert sein, die bei Versuch diesen zu starten nur ausgeben, dass das Medium nicht bootfähig ist, oder Bootloader die nur einen anderen Bootloader von einer der Partitionen laden und diesen dann starten oder nur ein Auswahlmenu bringen, um daraus dann auf andere Bootloader zu verzweigen. Aber auch Bootvieren sind dort möglich. Wie die einzelnen Bootloader arbeiten ist recht unterschiedlich. Jedoch können sie nur auf die wenigen Funktionen des BIOS zugreifen und ihre Aufgabe ist es, damit den Betriebssystemkern auf der Platte in den Arbeitsspeicher zu laden und zu starten, oder ein oder mehrere (größere) Programme zu laden, die genau das können. In vielen Bootloadern ist desshalb genau hinterlegt oder festgeschrieben, in welchen pysikalischem Bereich (genauer Block) der Festplatte sich die Datei befindet, die als nächstes geladen werden soll, denn die komplizierten Strukturen von Filesystemen würden natürlich in diese 444 Byte nicht hinein zu programmieren sein.

===== Schlußfolgerungen für das kopieren des MBR mittels dd =====

Daraus ergeben sich jetzt eine ganze Reihe von Beschränkungen für das so schön einfache kopieren des MBR wie es oben angegeben ist. Prinzipiell gilt, es wird mit dd direkt in einen sehr sensieblen Bereich der Festplatte hineinschreiben, und dabei kann keinerlei logische Überprüfung vorgenommen werden. Solche Vorgehensweisen und Methoden sollten möglichst immer erst das letzte Mittel der Wahl darstellen.
* Das kopieren eines solchen MBR (512 Byte) auf die selbe Platte bringt nur Erfolg, wenn sich in der Zwischenzeit weder die Partitionstabelle noch der physikalische Ort (Block auf Festplatte) der Dateien geändert hat, die dieser Bootloader über den BIOS laden soll.
* Das kopieren eines solchen MBR (512 Byte) auf eine andere Platte macht nur dann Sinn, wenn es sich auch wirklich um eine identische Platte handelt. (Ausnahme wenn wir eine Platte durch eine größere Platte ersetzen müssten, und wir die Differenz sowieso nie benutzen möchten)
* Baugleiche Platten könnten ( ist im PC-Bereich ehr die Ausnahmen) logisch anders organisiert sein, da die [http://de.wikipedia.org/wiki/Festplattengeometrie Festplattengeometie] wie wir sie sehen nicht mit dem physikalischen Aufbau der Platte gleich ist und die Platte das selbst verwaltet. Solche Differenzen könnten in Ausnahmefällen schon beim Erwerb gleicher Platten aus unterschiedlichen Bezugsquellen vorliegen, oder irgendwann einmal über Software manuell geändert worden sein. Es ist auch nicht gänzlich auszuschließen, daß der eine oder andere Raidkontroller durchaus auch einmal so eine logische Plattengeometrie geändert haben könnte. Ein kopieren einer Partitionstabelle mit andere logischer Geometie könnte uU. durchaus dann zu defekten oder ungültigen Partitionstabellen führen.
* Wenn wir 512 Byte anfassen, sollten wir bedenken, das damit immer die Partitionstabelle der Partitionen 1-4 enthalten ist. Die logischen Partitionen jedoch nicht, und somit beim neu Beschreiben des MBR sogar verloren gehen können.
* Die Partitionstabelle wird in der Regel nur beim Start des Rechners oder bei speziellen Komandos von Linux neu ausgelesen. Wird mit dd die Partitionstabelle geändert, dann arbeitet der Kernel nach wie vor nach der alten Partitionstabelle weiter. Wird also eine komplette Platte überschrieben, und anschließend eine Partition versucht zu mounten, dann wird der Kernel das Filesystem an einer eventuell falschen Stelle suchen.
* Im Windowsumfeld könnten unter Umständen geklonte MBR (und somit enthaltene gleiche Disk-Signatur auf unterschiedlichen Platten) im gleichen System zu instabilem Betrieb oder Bootproblemen führen.

===== Anwendungsbeispiele und Alternativen =====

Den Bootloader sollte man nach dem kopieren oder verschieben der Rootpartition am besten wieder mit den dafür vorgesehen Tools neu schreiben. Siehe dazu [http://www.die.net/doc/linux/man/man8/grub-install.8.html grub-install] oder [[Grub-Install via "chroot" und Knoppix]] hier im Wiki, bei LILO gilt das analog, immer am Besten mit [http://www.die.net/doc/linux/man/man8/lilo.8.html lilo] wieder installieren, hilfreich sicher auch [[Lilo wieder herstellen]] hier im Wiki 
Die Partitionstabelle sollte man wenn möglich immer komplett (also auch die eventuellen logischen Partitionen) sichern und gegebenenfalls zurückschreiben oder clonen. Obwohl es nicht unmöglich ist, auch die logischen Partitionen mittels dd zu kopieren und wieder zurückzuschreiben, ist es so kompliziert, dass darauf verzichtet wird, es an dieser Stelle vorzustellen. Statt dessen soll hier auf den Artikel [[Partitionstabelle sichern und wiederherstellen]] verwiesen werden. Dort wird erklärt wie man die komplette Partitionstabelle mittels des Befehles [http://www.die.net/doc/linux/man/man8/sfdisk.8.html sfdisk] einfach und sicher speichern und wieder zurückschreiben kann. 

Für die jetzt nur noch ganz wenigen verbleibenden Ausnahmen hier einige Beispiele (auf eigenen Gefahr) wie man mittels dd im MBR bestimmte Dinge erledigen kann.
{{Box Wichtig||
nach jeder geschriebenen Manipulation an der Partitionstabelle mittels dd wird der Kernel so lange mit der alten Partitionstabelle weiterarbeiten, bis der Rechner wieder neu gebootet wurde, oder wir dem Kernel explizied dazu gezwungen haben die jetzt neue Partitionstabelle von der Platte neu einzulesen. Dazu darf keine Partition dieser Platte mehr gemountet sein und auch kein Swap auf dieser Platte aktiv, dann '''sfdisk -R /dev/PLATTE''' }}

'''Bootloader als Datei sichern und zurückschreiben'''
dd if=/dev/hda of=/PATH/DATEI bs=1 count=444
dd if=/PATH/DATEI of=/dev/hda bs=1 count=444
'''Bootloader mit Nullen überschreiben'''
dd if=/dev/zero of=/dev/hda bs=1 count=444
'''Partitionstabelle (nur Partitionen 1 bis 4) hexadezimal anschauen'''
dd if=/dev/hda bs=1 count=66 skip=446 | hexdump -C
'''Partitionstabelle (nur Partitionen 1 bis 4) als Datei sichern /zurückschreiben'''
dd if=/dev/hda of=/PATH/DATEI bs=1 count=66 skip=446
dd if=/PATH/DATEI of=/dev/hda bs=1 count=66 seek=446
'''Partitionstabelle (nur Partitionen 1 bis 4) auf andere Platte direkt kopieren (hda -> hdb)'''
dd if=/dev/hda of=/dev/hdb bs=1 count=66 skip=446 seek=446
'''Partitionstabelle löschen'''
dd if=/dev/zero of=/dev/hda bs=1 count=64 seek=446
'''Windows Disk-Signatur mit Nullen überschreiben'''
dd if=/dev/zero of=/dev/hdb bs=1 count=4 seek=440
'''MBR-Signatur wieder mit 0x55 0xAA beschreiben ( MBR wieder gültig machen)'''
echo -en "\x55\xaa" | dd of=/dev/hda bs=1 count=2 seek=510

==== einzelne Partitionen und ganze Platten mit dd ====

Das kopieren, klonen, oder als Image ablegen und wieder zurückschreiben von einzelnen Partitionen und ganzen Platten mittels dd, so wie es in unzähligen Beiträgen beschrieben ist, ist und bleibt eine riskante Angelegenheit, solange man sich nicht bewußt ist, was man da eigentlich genau macht. 
Es werden genau genommen jedes Byte der Festplatte oder der Partition genau so gelesen, wie sie derzeit auf der Platte gespeichert sind, und wieder zurückgeschrieben, wie sie zum jeweiligen Zeitpunkt des Lesens auf der Festplatte vorhanden waren. [[# Allgemeine Bemerkungen und Warnungen| (siehe auch die allgemeinen Warnungen)]] Somit benötigt man ein zweites Medium, das auch groß genug ist, diese Daten auch wirklich aufzunehmen, den ein Image einer 200GB Festplatte ist nun einmal 200GB groß, auch wenn nur 10% davon mit Dateien belegt sind. Pinzipiell ist es demnach umso interessanter, je kleiner die Festplatte oder die Partition ist, und um so mehr Daten darauf aktuell abgelegt sind. Solange man ein solches Image dann auch wieder auf die gleiche Festplatte oder in die gleiche Partition zurück schreibt, ist das auch relativ ungefählich. Wird eine größere Festplatte zum zurückspielen benutzt, dann wird die größere Festplatte auf die Orginalgröße der ursprünglichen Festplatte "herunterkonfiguriert", ein Benutzen des übrigen unbenutzten Festplattenplatzes ist erst einmal ausgeschlossen und Versuche diesen doch noch nutzbar zu machen, sind sehr riskant für die Daten auf dieser Platte. Eine zu kleine Festplatte würde dann mindestens ein unvollständiges Filesystem ergeben, das sich gar nicht mounten läßt. Das selbe gilt für Partitionen analog. Sehr gefährlich ist zB. ein zurückschreiben von erweiterten und logischen Partitionen, wenn sich die Partitionstabelle geändert hat, bzw auf eine andere logische oder erweiterte Partition. Hierbei ist es durchaus möglich, das nach dem nächsten booten ein Teil der Daten auf der Platte gar nicht mehr aufzufinden sind.

===== Beispiele Clonen, Backup und Sicherung =====

Es gilt, möglichst alle Filesysteme ungemountet auslesen, wo das nicht möglich ist, zumindestens '''Readonly''' gemountet auslesen und dann auf das Image einen [http://www.phpman.info/index.php?parameter=fsck.ext3&mode=man Filesystemcheck] machen.

einzelne Partition als Image ablegen / Image temporär mounten / zurückschreiben
# dd if=/dev/hda2 of=/PATH/DATEI.IMAGE bs=8K
# mount -o loop /PATH/DATEI.IMAGE /mnt # eventuell weitere Mountoptionen notwendig
# dd if=/PATH/DATEI.IMAGE of=/dev/hda2 bs=8K

Filesystemtype und Zustand eines Images ermitteln/korrieren (Konsolauszug)
<pre>
LINUX:/ # file DATEI.IMAGE
DATEI.IMAGE: Linux rev 1.0 ext2 filesystem data (mounted or unclean)
LINUX:/ # fsck /PATH/DATEI.IMAGE # evtl. weitere Optionen notwendig ; kompletten Path des Images
fsck 1.38 (30-Jun-2005)
e2fsck 1.38 (30-Jun-2005)
/PATH/DATEI.IMAGE was not cleanly unmounted, check forced.
Pass 1: Checking inodes, blocks, and sizes
Pass 2: Checking directory structure
Pass 3: Checking directory connectivity
Pass 4: Checking reference counts
Pass 5: Checking group summary information
/PATH/DATEI.IMAGE: 72/16632 files (12.5% non-contiguous), 24776/66432 blocks
LINUX:/ # file DATEI.IMAGE
DATEI.IMAGE: Linux rev 1.0 ext2 filesystem data
</pre>

einzelne Partition auf eine Festplatte mit identischem Partitionstabelle kopieren
# dd if=/dev/hda2 of=/dev/hdb2 bs=8K

ganze Festplatte als Image ablegen / zurückschreiben
# dd if=/dev/hda of=/PATH/DATEI.IMAGE bs=8K
# dd if=/PATH/DATEI.IMAGE of=/dev/hda bs=8K
man kann von einem solchem Image auch [http://www.linux-club.de/viewtopic.php?t=79797 einzelne Partitionen temporär gemounten], dabei muss für das [http://www.phpman.info/index.php?parameter=mount&mode=man mount] der jeweilige Offset benutzt werden.

Festplatte auf einen andere Festplatte clonen
# dd if=/dev/hda of=/dev/hdb bs=8K

===== Problem Komprimierung von dd-Image =====

Hin und wieder besteht die Notwendigkeit ein solches Image zu komprimieren, weil eben nur wenige wirkliche Daten auf der Platte/Partition liegen. Dabei wird man auf das Problem stoßen, das kann recht gut funktionieren aber muss nicht zwangsläufig. Das liegt dann meistens an den zur Zeit nicht benutzten oder gelöschten Datenblöcken. Sind diese zum großen Teil nicht oder nicht richtig komprimierbar, dann wird man auch wenig Erfolg bei der Komprimierung der gesamten Platte/Partition haben. 
Nachfolgend eine Möglichkeit wie man die leeren/unbenutzten Datenblöcke einer Partition sehr gut komprimierbar machen kann, ohne das die richtigen Daten dabei beschädigt werden. Man legt einfach neue "NULL"-Dateien an bis das Filesystem fast voll ist, danach löscht man sie wieder. Wir machen uns hier zum Vorteil, dass ein normaler User im Normalfall auf LINUX-Filesystemen nur bis zu 95% voll auf ein Filesystem schreiben kann. Ausnahme natürlich wenn [[Disk Quota]] eingerichtet ist.

Als root in das Filesystem ein neues Verzeichnis anlegen und für Schreibrechte des Users sorgen
# mkdir /PATH/test
# chmod a+w /PATH/test

Danach als User folgendes Script ausführen
<pre>
#!/bin/bash
VERZEICHNIS=/PATH/test

dd if=/dev/zero of=/tmp/file.null count=1024 bs=1K 2>/dev/null
echo "anlegen von Dateien bitte warten"
for i in {a..z}{a..z}{a..z}
do
for j in {0..9}{0..9}{0..9}{0..9}
do
NAME=${VERZEICHNIS}/leer$i$j
cp /tmp/file.null $NAME 2>/dev/null || break 2
done
done
rm /tmp/file.null
</pre>
Als VERZEICHNIS ist hier genau das eben von root angelegte Verzeichnis anzugeben. Je nach Größe und Benutzungsgrad des Filesystems kann das schon seine Zeit dauern. Es werden 1MByte große Dateien in diesem Verzeichnis angelegt. 
Ist das Script fertig, muss erst einmal der Cache des Filesystems die Daten alle auf Platte schreiben, also entweder abwarten oder wenn möglich das Filesystem [http://www.phpman.info/index.php?parameter=umount&mode=man umounten] und anschließend wieder [http://www.phpman.info/index.php?parameter=mount&mode=man mounten]. ( Das ist vor allem wichtig bei sehr kleinen Filesystemen die eventuell sogar komplett im Speicher gecacht sein könnten.)

Root kann jetzt das komplette Verzeichnis wieder löschen (Achtung "'''rm *'''" im Verzeichnis wird meist wegen zu vieler Argumente nicht funktionieren)
rm -rf /PATH/test

Jetzt muss erst einmal wieder der Cache das Filesystem neu mit der Platte abgleichen, also hier auch am Besten umount / mount (der [http://www.phpman.info/index.php?parameter=sync&mode=man sync] Befehl hat hier erstaunlicherweise bei meinen Tests nicht immer das erhoffte Resultat gebracht)

Jetzt ist diese Partition bereit zum Erstellen eines effektiven komprimierten Images.
dd if=/dev/hda2 bs=4K | gzip > /PATH/DATEI.IMAGE.gz
Zurückschreiben könnte man dieses komprimierte Images zB.:
zcat /PATH/DATEI.IMAGE.gz | dd of=/dev/hda2 bs=4K

Mit ganzen Platten geht das analog, nur sollte man für optimale Ergebnisse eben alle Filesysteme vorher "aufräumen".

===== Beispiel: dd nach einem Super-GAU im Filesystem =====

Konstruieren wir uns doch einmal ein Super-GAU Szenario

''(Ähnlichkeiten mit realen Ereignissen oder Personen sind rein zufällig ;-) )''
{{Box Beispiel ||
Nach monatelanger allnächtlicher Mühe ist die Doktorarbeit mit all ihren Texten, Bildern und Zeichnungen nun entgültig fertig. Korrektur ist gelesen, ist gut geworden, und man hat die Doktorwürden jetzt schon so gut wie in der Hand. Nur noch ausdrucken und fertig. Da man in den letzten Wochen leichtsinnigerweise kein Backup gemacht hat, man ist eben so optimistisch, es wird jetzt aber aller höchste Eisenbahn, dieses nachzuholen. Mit dem Kopf schon am überlegen ob wohl der Drucker auch noch genug Tinte hat, nur schnell noch ein paar alte temporäre Dateien löschen die nicht mit ins Backup brauchen. Doch was ist das jetzt für eine Fehlermeldung '''rm: cannot remove directory `./': Invalid argument''' und '''ls -l''' zeigt plötzlich auch nur '''total 0''' ??? 
Der geschärfte Blick auf die Konsole läßt erkennen, die gesamte Doktorarbeit rekursiv gelöscht. Das Adrenalin schießt in den Kopf, wie war das nochmal mit reiserfs und gelöschten Dateien? - ein Aufschrei - ein Hechtsprung - den Kaltgerätestecker aus dem Rechner ziehen - alles Eins. 
Super-GAU komplett und morgen ist Abgabetermin.}}

Wird jetzt an dieser Stelle der Rechner hochgefahren und normal gestartet hat man eventuell genau einen Reparaturversuch wieder an seine gelöschte Doktorarbeit zu kommen. Misslingt dieser Versuch ganz oder teilweise, dürfen eventuell größere Teile ganz neu geschreiben werden. Wohl dem der in dieser Situation jetzt genau das richtige Howto findet.

Besser hier, eine große Festplatte suchen und zusätzlich anschließen. Den Rechner von CD booten und zu aller erst mittels dd ein Image der betroffenen Partition oder der gesamten Festplatte auf diese Platte erstellen. Erst dann einen normalen Boot versuchen oder mit der Reparatur der Filesysteme beginnen. Sollte der erste Versuch fehlschlagen, dann wieder das Image zurückspielen und das nächste Howto ausprobieren. Man kann so über das zurückschreiben des Images die haargenaue ursprünglich defekte Situation des Filesystems beliebig oft rekonstruieren und so seine Changen auf die Wiederherstellung der Daten bedeutend verbessern.

===== Beispiel: mit dd nach verlorenen Dateiinhalten suchen =====

{{Box Beispiel||
Wir haben eine Textdatei verloren, an der wir in den letzten Tagen rumgebastelt haben. Alle bisherigen Versuche die Datei wiederzufinden waren ergebnisslos.
}}

Sollte es sich um eine Textdatei, script, Quelltext oder ähnliches handeln, haben wir eine gute Change hier doch noch an den Inhalt heranzukommen, sollte sich dieser noch irgendwo in einem gelöschtem Datenblock befinden. Alles was wir benötigen ist die Paritition auf der sich das Filesystem befindet in der sich die Datei befunden haben muss, die ungefähre Größe dieser Datei in Zeilen, eine sehr markante Wortkombination innerhalb einer Zeile die nur in dieser Datei oder deren Kopien vorkommen kann, und eine etwaige Position dieses Suchbegriffes in Zeilen innerhalb der Datei.

Wir nehmen folgendes an:
# Partition /dev/hda2
# Größe der Datei 100-150 Zeilen
# genaue Wortkombination im letztem Drittel "darf ich mir vormerken"

dd if=/dev/hda2 bs=4K | strings | grep -B 150 -A 100 "darf ich mir vormerken" > /tmp/gefunden.txt

Damit lesen wir mittels dd die Partition aus, [http://www.phpman.info/index.php?parameter=strings&mode=man strings] entfernt aus diesem Datenstrom schon einmal alles was nicht nach druckbaren aussieht, [http://www.phpman.info/index.php?parameter=grep&mode=man grep] durchsucht jetzt diesen Datenstrom nach dem Vorkommen der Wortkombination und wenn er eine solche gefunden hat, dann schreibt grep die Zeilen von 150 Zeilen davor bis 100 Zeilen danach in eine Datei Namens /tmp/gefunden.txt , werden mehrere solcher Wortkombinationen gefunden, dann auch die entsprechenden Bereiche aus diesen Blöcken.

Wenn sich also ein Datenblock auf der Festplatte befindet, der die genaue Zeilenwortkombination beinhaltet, dann werden wir den Textinhalt irgendwo innerhalb der gefunden.txt wiederfinden. Jedoch ohne eventuelle Leerzeilen, auch extrem kurze Zeilen (weniger als 4 druckbare Zeichen) sind verschwunden. Diesen Inhalt können wir aber immerhin jetzt aus gefunden.txt herauskopieren und wieder neu zu einer entsprechenden Datei formatieren.

===== mit dd Partitionen und Festplatten sicher löschen =====

Ein löschen ( besser ein überschreiben) von Partitionen und Festplatten mit dd ist ein weiteres beliebtes Anwendungsgebiet. Abzuraten jedoch bei Logischen Partitionen, hier könnten innerhalb der ersten 512 Byte Teile der Gesamt-Partitionstabelle überschrieben werden, und somit andere logische Partitionen nach dem nächsten reboot nicht mehr sichtbar sein. Siehe hierzu auch [[Wie eine Platte unwiederherstellbar und sicher loeschen]]

=== CD DVD und Floppy mit dd ===

==== Floppy Images mit dd ====

Der Eine oder Andere wird sie noch verstaubt in der Ecke habe, die gute alte 1,44er Floppy. Von den eventuell noch benötigten Floppys kann man aber auch mit dd Image erstellen und diese dann übersichtlich auf seiner Festplatte verwalten.

dd if=/dev/fd0 of=/PATH/DATEI.IMG bs=1440K
als Blockgröße kann man bei intakten Floppys gleich 1440 KByte nehmen, sollte die Floppy schon "faule Stellen" haben, dann ist 512 Byte angesagt. (Einen gravierenden Geschwindigkeitsvorteil konnte ich bei Tests jetzt unter Linux nicht ausmachen)

Bei Bedarf kann man dieses Image dann auch gleich temporär mounten
mount -o loop /PATH/DATEI.IMG /mnt
Die Auto-Option wird hier die meisten Filesysteme von Floppy automatisch erkennen, ansonsten noch mit Mountoptionen nachhelfen.

Wird wirklich einmal wieder eine dieser Image als Diskette zB als Bootdiskette benötigt, dann das Ganze wieder rückwärts.
dd if=/PATH/DATEI.IMG of=/dev/fd0 bs=512

Floppy die beim Lesen schon Lesefehler produzieren kann man trotzdem zu einem Image abziehen. Solange nur einige wenige Blöcke kaputt sind, und nicht gerade ein geziptes Tar darauf abgelegt ist, kann man oftmals noch das wirklich Wichtige benutzen.
dd if=/dev/fd0 of=/PATH/DATEI.IMG bs=512 conv=noerror,sync
Die Blockgröße hier zwingend 512 und die Option '''conv=noerror,sync''' sorgt dafür, das bei einem Lesefehler der entsprechende Block mit NULLen gefüllt wird, und dd bei diesem Lesefehler nicht abbricht. Es sind also alle intakten Blöcke hinterher an der richtigen Position und das Image läßt sich meist problemlos mounten, so das man in aller Ruhe und ohne nervige Lesefehler vom Floppylaufwerk, die defekten Dateien suchen kann. 
Die Ausgabe von dd in diesem Fall ist auch so präzise, dass man genau die fehlerhaften Stellen (mit den jetzt NULLen im Image) aus dem Fehlerausgabe herauslesen kann. Somit könnte man auch mit [http://www.phpman.info/index.php?parameter=hexdump&mode=man hexdump] schon mal nachschauen, ob es nicht doch nur die README erwischt hat.

==== CD DVD und dd ====

Es gibt eine ganze Reihe von [http://de.wikipedia.org/wiki/Compact_Disk#Physische_Formate CD-] und [http://de.wikipedia.org/wiki/DVD#DVD-Datenstrukturen DVD-]Formaten, und es gibt allerlei Bemühungen, damit nicht unbedingt jeder mit solchen Scheiben machen kann, was er gerne möchte. Wir wollen das an dieser Stelle etwas unterstützen und hier nicht allzu tiefgründig werden, desshalb nur einige kurze Bemerkungen. 
# Mit einer Vielzahl dieser Scheiben könnte man bestimmt analog wie mit einer Floppy verfahren. Die Blockgröße innerhalb normaler Grenzen sollte bei den heutigen Laufwerken bei dd meist wenig bis keinen Einfluß auf die Lesegeschwindigkeit haben, fällt also oft erst beim Auftreten von Lesefehlern ins Gewicht.
# Ein Mounten eines Images wie oben beschrieben, funktioniert nicht zwangläufig mit jedem Type von Scheibenimage.
# Versucht nicht mit dd eine CD oder DVD zu brennen, dazu gibt es genügend Brenntools die auch die Kontrolle über die Brennerhardware haben.
# Den Inhalt zB. einer Audio-CD oder eine Video-DVD muss man noch lange nicht aufgeben, nur weil der Player immer an der selben Stelle abbricht. Mit dd könnte man hier schon noch etwas ausrichten, aber dd ist zwar universell aber nicht speziell für solche Zwecke gemacht, und hier nicht unbedingt die allerbeste Wahl.

=== Bandlaufwerke und dd ===

Bei den Bandlaufwerken sind wir dort, wofür dd ursprünglich einmal gedacht war. Hier kann dd als "Schweizer Taschenmesser" seine Stärken voll auspielen. In den letzten Jahren hat sich jedoch die Hardware entschieden verbessert, aber dd ist in seinen Grundzügen immer noch das Alte. dd ist nicht in der Lage den Datenstrom im Speicher erwähneswert zu cachen, so wie man es für moderne Laufwerke mit ihrem enomen Daten- und Durchsatzhunger gerne hätte. Wer sich näher damit befassen möchte, [[Bandlaufwerke und LINUX]] gibt eine Überblick und stellt auch [[Bandlaufwerke und LINUX#Pufferung der Daten zwischen Laufwerk und LINUX|Alternativen]] vor. Dennoch für viele nicht alltägliche Problemchen kann man sich immer wieder auf dd verlassen, auch wenn man die Laufwerke damit nicht immer im optimalen Bereich ansteuern kann. Die Einsatzmöglichkeiten sind hier vielfältig und in Zusammenarbeit mit einigen Spezialtools kann man nach Art eines [http://de.wikipedia.org/wiki/MacGyver MacGyver] schon mal das Unmögliche möglich machen.

Hier nur ein paar einfache Beispiele: ''(Voreinstellungen und Positionierungsbefehle für das Laufwerk lassen wir der Einfachheit halber bei der Vorstellung reiner Befehle weg, bei Konsolauszügen sind sie ansatzhalber enthalten)''

Eine ganze Festplatte als Image auf ein Laufwerk sichern. / zurückspielen
dd if=/dev/hda of=/dev/nst0 ibs=8K obs=64K
dd if=/dev/nst0 of=/dev/hda ibs=64K obs=8K
Wir arbeiten hier also mit 8KByte mit der Festplatte aber mit 64KByte ''( oder Größer Laufwerkstypeabhängig)'' mit dem Bandlaufwerk. Durch die Hardwarkomprimierung der meisten Bandlaufwerke ist das übrigens sehr Speichereffektiv, wenn wir wie oben beschreiben [[#Problem Komprimierung von dd-Image|die ungenutzten Blöcke der Partitionen hin und wieder einmal NULLen]]. Das Image belegt dann oft nur unwesentlich mehr Platz auf dem Band wie eine Tarsicherung. Eine Zeiteinsparung erreichen wir hier in der Regel allerdings nicht, denn die ganzen Nullen müssen trotzdem über Kontroller und Bus zum Laufwerk transportiert werden.

Prinzipiell können wir auf diese Art mit '''dd''' jede Datei, jeden Datenstrom auf ein Band schreiben und auch wieder lesen. Wir können mit '''dd''' auch das auslesen was mit anderen Backupprogrammen geschrieben wurde, Wichtig nur beim Lesen, wir müssen die selbe Blöckgröße verwenden mit der geschrieben wurde. Was wir allerdings komplett verlieren, wenn wir Dateien auf ein Band schreiben, den Dateinamen und Zugriffsrechte und alles was dazu gehört. Ist ein '''dd''' Befehl fertig, wird ein EOF-Marke aufs Band geschrieben. Es käme also jede Datei als ein eigenes Filearchiv auf dem Band an. Das lohnt sich nur bei sehr großen Dateien, oder bei Dateien die schon selbst ein Archiv sind, wie folgendes Beispiel zeigt.
<pre>
LINUX:/tmp # tar -cf ./test.tar /etc
tar: Removing leading `/' from member names
LINUX:/tmp # mtst -f /dev/nst0 rewind
LINUX:/tmp # mtst -f /dev/nst0 setblk 0
LINUX:/tmp # dd if=./test.tar of=/dev/nst0 bs=64K
348+1 records in
348+1 records out
LINUX:/tmp # mtst -f /dev/nst0 rewind
LINUX:/tmp # tar -tvb 128 -f /dev/nst0 | more
drwxr-xr-x root/root 0 2007-07-16 20:08:35 etc/
drwxr-xr-x root/root 0 2006-06-01 14:21:44 etc/X11/
drwxr-xr-x root/root 0 2004-10-24 14:58:35 etc/X11/fs/
-rw-r--r-- root/root 2523 2004-04-06 04:27:19 etc/X11/fs/config
drwxr-xr-x root/root ....................
................
</pre>
wir haben hier zum Test ein Tararchiv aus '''/etc''' erstellt und als Datei abgelegt, diese Datei dann auf das Band geschrieben und anschließend mit''' tar''' das Inhaltsverzeichnis direkt vom Bandarchiv ausgelesen. (Zu beachten hier, da wir mit '''dd''' mit 64 KByte geschrieben haben, müssen wir jetzt mit '''tar''' auch mit 64KByte zugreifen.)

Da wir nun alles mögliche auf ein Band schreiben könnten, stellt sich die Frage, woher erkenne ich an einem unbekannten Band, was darauf abgelegt ist und mit welcher Blockgröße geschreiben wurde. Sprich, welches Tool müßte ich mit welchen Optionen verwenden, um das Band überhaupt lesen zu können. Die Lösung bietet dd. 
Nehmen wir ein Beispiel, wir bekommen ein Band von einem Freund, und dieser sagt, wir sollen und das einmal anschauen. Es sollte ein selbst geschriebenes Programm im Quelltext sein, soviel wissen wir, aber nicht mit welchem Programm es gesichert wurde, geschweige mit welcher Blockgröße geschrieben wurde.

<pre>LINUX:/tmp # mtst -f /dev/nst0 rewind
LINUX:/tmp # mtst -f /dev/nst0 setblk 0
LINUX:/tmp # dd if=/dev/nst0 of=/tmp/block.data bs=128K count=1
0+1 records in
0+1 records out
LINUX:/tmp # ls -l block
-rw-r--r-- 1 root root 5120 Jul 16 18:57 block
LINUX:/tmp # file block.data
block.data: ASCII cpio archive (SVR4 with no CRC)
</pre>
wir legen das Band ein, und lesen mittels '''dd''' und der größtmöglichen Blockgröße mit der Linux und das Laufwerk arbeiten würde, (hier im Beispiel ein EXABYTE Laufwerk das maximal 128KByte Blockgroße zulassen würde.) An der Ausgabe von '''dd''' erkennen wir, es wurde ein Block gelesen und als Datei abgespeichert der allerdings (erwartungsgemäß) nicht die 128KByte Größe erreicht hat. 
mit '''ls''' können wir jetzt erkennen wie groß die Datei und somit unser erster Block auf dem Band war, genau 5120 Byte (also 10 x 512Byte). 
mit '''file''' können wir jetzt auch noch Linux bemühen für uns herauszubekommen, was das für ein File sein könnte. '''file''' kann das aus dem Anfang einer Datei von sehr vielen Dateitypen erkennen. Den ersten Block der Datei, also den Anfang haben wir ja vom Band geholt, also setzen wir '''file''' darauf an. Als Ergebniss sehen wir, es würde mit '''cpio''' geschrieben und Blockgröße 5120 Byte (bei cpio der Defaultwert) geschrieben, eine genaue Formatbezeichnung hätten wir auch noch, wenn sie von '''cpio''' nicht selbst erkannt werden würde. Jetzt sollten wir alles wissen, um das Band auszulesen zu können.

Neben Dateien und Archiven können wir auch Datenstöme auf Band schreiben. Das könnten jetzt zB Debugtraces von irgendwelchen Befehlen oder Trace von Netzverbindungen sein. Niemand kann genau vorhersagen wie schnell solche Datenstöme riesige Ausmaße annehmen, und niemand kann vorhersagen was alles für unbrauchbare und uninteressante Meldungen jetzt mitgelogt werden. Statt also hier noch irgend welche Filter nachzuschalten (und damit und einem zusätzlichen Schreiben der Logdatei auf die Festplatte den Rechner jetzt noch unnötig weiter zu belasten) - wir haben doch ein Bandlaufwerk - also schreiben wir den gesamten Trace einfach auf das Band, egal wie lang er wird, da passt schon ordentlich was drauf. Angenommen der Tracelog kommt in der Befehlskette als Standardausgabekanal an, dann einfach nach dd weiterleiten und auf Band schreiben.
BEFEHL | AM_ENDE | DER-TRACELOG | dd of=/dev/nst0 bs=64K
Befehl fertig, dann kann entweder der Stream vom Laufwerk jetzt auf diesem oder einem anderem Rechner mittels '''dd''' in eine Datei zurückgespielt werden, oder dabei gleich noch mit '''grep''' gefiltert werden, um nur das wirklich Wichtige auszuwerten. Hat der Filter nicht funktioniert oder müssen noch weitere Filter hinzugefügt werden, kein Problem, der Stream kann ja beliebig oft vom Band ausgelesen werden, wir müssen also nicht nocheinmal den ganzen "Versuchsaufbau" rekonstruieren.

Wir müssen dabei auch nicht immer nur das Ende einer Kette anzapfen. Zapfen wir doch mal eine mittels Pipe verbundene Befehlskette in der Mitte an, genau dort, wo der dickste Datenstrom anliegt, und schreiben diesen Datenstrom parallel zur normalen Befehlsverarbeitung aufs Band. 

Wir nehmen dazu einmal das Beispiel von vorhin, als wir auf der Platte nach verlorenen Dateiinhalten gesucht haben, und schreiben parallel dazu gleich noch das komplette Image dieser Partition auf das Band. Somit haben wir abgesichert, wird der von uns gesuchte Block später überschrieben, und wir ihn vorher immer noch nicht gefunden haben, können wir ihn immernoch beim Durchsuchen des Bandimages finden.

<pre>
LINUX:/tmp # mkfifo /tmp/pipe
LINUX:/tmp # mtst -f /dev/nst0 rewind
LINUX:/tmp # mtst -f /dev/nst0 setblk 0
LINUX:/tmp # dd if=/dev/sdb1 bs=4K | tee /tmp/pipe | strings | grep -B 50 -A 20 "Starker Schneefall" > /tmp/gefunden.txt &
[1] 6373
LINUX:/tmp # dd if=/tmp/pipe of=/dev/nst0 bs=64K
126504+0 records in
126504+0 records out
0+63252 records in
0+63252 records out
[1]+ Done dd if=/dev/sdb1 bs=4K | tee /tmp/pipe | strings | grep -B 50 -A 20 "Starker Schneefall" >/tmp/gefunden.txt
</pre>
Wir legen uns eine [http://www.phpman.info/index.php?parameter=mkfifo&mode=man Named Pipe] an.
In der Suchbefehlskette duplizieren wir mittels [http://www.phpman.info/index.php?parameter=tee&mode=man tee] den Datenstrom in Richtung dieser Pipe.
Die gesamte Befehlskette schicken wir in den Hintergrund. Dort wird sie so lange untätig warten, bis jemand die Pipe zum lesen öffnet. Zum Lesen öffnen wir die Pipe dann mit dem nächsten '''dd''' Kommando und leiten die Ausgabe an das Laufwerk weiter. Wenn der '''dd''' Befehl beendet ist, ist auch unser Hintergrundbefehl beendet.

Die Pipe brauchen wir jetzt nicht mehr, die können wir löschen, aber schauen wir uns das Ergebnis an.
<pre>
LINUX:/tmp # rm /tmp/pipe
LINUX:/tmp # ls -l /tmp/gefunden.txt
-rw-r--r-- 1 root root 4044 Jul 16 19:43 /tmp/gefunden.txt
</pre>
wir haben eine Datei ''gefunden.txt'' und wirklich, wir haben auch etwas gefunden
<pre>
LINUX:/tmp # mtst -f /dev/nst0 rewind
LINUX:/tmp # dd if=/dev/nst0 of=/tmp/test.img bs=64K
0+63252 records in
0+63252 records out
LINUX:/tmp # file /tmp/test.img
/tmp/test.img: Linux rev 1.0 ext2 filesystem data
LINUX:/tmp # fsck /tmp/test.img
fsck 1.34 (25-Jul-2003)
e2fsck 1.34 (25-Jul-2003)
/tmp/test.img: clean, 40/126976 files, 51084/506016 blocks
LINUX:/tmp # mount -o loop /tmp/test.img /mnt
</pre>
Und wir können vom Band unser Partitionsimage lesen. Zum Test wird auch gleich noch einen Filesystemcheck gemachen und das mounten probiert.

=== mit dd über Rechnergrenzen ===

Daten von einem auf einen anderen Rechner übertragen oder weiterleiten ist eine häufig benötigte Funktion. Da '''dd''' problemlos mit den Standardein- und Ausgabekanälen arbeitet, könnten wir es in jede Pipe und somit auch in Verbindungen über Rechnergrenzen einschleusen. Einfache Verbindungen lassen sich so zB bequem über [http://www.phpman.info/index.php?parameter=rsh&mode=man rsh] [http://www.phpman.info/index.php?parameter=ssh&mode=man ssh] oder [http://linux.die.net/man/1/nc netcat] mit '''dd''' auf einer oder auf beiden Seiten der Pipe aufbauen.

Beispiel: clonen einer Festplatte auf einen anderen Rechner
dd if=/dev/hda bs=8K | ssh RECHNER2 "dd of=/dev/hdb bs=8K"
damit würden wir die ''/dev/hda'' unseres Rechners auf die ''/dev/hdb'' von RECHNER2 clonen. 

Ähnlich könnten wir wohl vieles andere auch über Netwerk weiterleiten. Der größte Teil der weiter oben vorgestellten Beispiele ginge also auch über Rechnergrenzen hinweg. Inwieweit das immer auch Sinn macht, sei mal dahingestellt, da sich vieles wahrscheinlich sogar auch ohne '''dd''' realisieren ließe. Das obrige Beispiel würde mit Sicherheit so hier genauso funktionieren.
cat /dev/hda | ssh RECHNER2 "cat > /dev/hdb"
Die Performancevorteile, die wir aus der Blockung mit '''dd''' ziehen, würde durch die Netzverbindung und der zusätzlichen Verschlüsselung über '''ssh''' sowieso zu nichte gemacht. Wenn wir also nicht irgendwelche andere Funktionen, wie zB Byte-Konvertierungen oder die Positionierungsfunktionen im Datenstrom von dd mit benutzen können, und auch auf eine Blockung des Datenstromes verzichten können, dann ist '''dd''' über das Netzwerk in vielen Fällen überflüssig. ''(die Befehlsverkettung mit dd würde aber wahrscheinlich leichter zu interpretierende Befehlszeilen ergeben ;-))''

Ganz anders, wenn wir die Blockung an irgend Stelle zwingend benötigen. Wie zum Beispiel beim Schreiben und Lesen auf Bandlaufwerke.
<pre>
LINUX:/ # tar -cf - /etc | ssh RECHNER2 "dd of=/dev/nst0 obs=64K"
tar: Removing leading `/' from member names
tar: Removing leading `/' from hard link targets
49404+8 records in
386+0 records out
</pre>
Hiermit würden wir eine Sicherung mit '''tar''' gleich auf das Bandlaufwerk eines anderen Rechner schreiben.
Sicherung wieder recovern,
ssh RECHNER2 "dd if=/dev/nst0 bs=64K" | tar -xvf -
oder nur das Inhaltsverzeichnis anschauen
ssh RECHNER2 "dd if=/dev/nst0 bs=64K" | tar -tvf -
Wir hätten hier also mittels der Verlängerung über '''ssh''' und '''dd''' ein remote Bandlaufwerk.

Der Vervollständigkeit halber: wir müssen das Laufwerk auch von unserem eigenem Rechner aus steuern können, also remote, aber das geht genau so. 
Beispiele:
ssh RECHNER2 "mtst -f /dev/nst0 setblk 0"
ssh RECHNER2 "mtst -f /dev/nst0 rewind"
und wir müssen natürlich für root [[Einrichten von public keys mit ssh|Publickey-Authentifizierung]] einrichten, denn sonst müssten wir bei jedem ssh-Befehl das Passwort eingeben. Aber dann steht hier auch einer Sicherung durch ein Script auf ein entferntes Laufwerk nichts mehr im Wege.
-- außer --
Das Ganze würde, wenn wir es tag täglich benutzen möchten, nur mit etwas älteren Laufwerken wirklich Sinn machen. Moderne Bandlaufwerke würden wir mit dem Datenstrom den wir somit dem Laufwerk anbieten nur zu tote langweilen. 
Es gibt jedoch Programme, die auch Blockfunktionen wie '''dd''' anbieten und darüber hinaus noch im Hauptspeicher oder auf Festplatte den Datenstrom cachen können. Darüber hinaus unter anderem auch noch die Eigenschaft haben, selbst mit TCP/IP Ports zu kommunizieren. Solchen Programmen ist hier bei regelmäßiger Anwendung auf moderne Bandlaufwerke der absolute Vorzug gegenüber von '''dd''' einzuräumen. [[Bandlaufwerke und LINUX#Das Programm mbuffer |Beispiele]] findet ihr unter [[Bandlaufwerke und LINUX]]. Auch bei vielen anderen Anwendungen können solche neuen Programme den guten alten dd-Befehl 100%ig und oft auch besser ersetzen. dd ist und bleibt dennoch der Kultbefehl mit dem man unter Linux oder Unix mal eben schnell "zaubert".

== Alternative Programme ==

* [http://www.gnu.org/software/ddrescue/ddrescue.html ddrescue] 
eine moderne Erweiterung von dd speziell geeignet um teilweise defekte Platten und Wechselmedien zu lesen oder zu kopieren. Es ist in der Handhabung etwas einfacher und die wichtige Optionen sind analog zu benutzen. Siehe auch [http://www.linux-user.de/ausgabe/2004/08/048-dd-rescue/ LinuxUser - Das Magazin für die Praxis - LU 08/2004: Datenrettung mit ddrescue]

* [http://www.maier-komor.de/mbuffer.html mbuffer] 
eine Programm das einen Datenstrom im Speicher oder auf Festplatte sehr effektiv '''(buffern)''' kann, es wurde speziell für die Benutzung mit Bandlaufwerken entwickelt. Es ist nur eine indirekte Alternative für dd, ist aber durchaus in der Lage viele andere Aufgaben die bisher mit dd erledigt werden konnten, sehr effektiv zu meistern. Die Bedienung und Benutzung hat mit dd nichts gemein, und ist bisweilen sehr knifflig. Es hat eine ganze Reihe von nützlichen Zusatzfunktionen die in dd nicht enthalten sind.

== weiterführende Links ==

[[Category:Konsole]]

Diskussion:OpenSUSE und Multimedia

2007-07-20T15:05:45Z

K4m1K4tz3:

Linupedia.org:GeschÃ¼tzte Seiten

2007-06-21T15:01:50Z

K4m1K4tz3:

Folgende Seiten wurden im LinucClub Wiki gesperrt. Wenn jemand diese Seiten ändern möchte sollte er sich an die zuständige Person(en) wenden.

 
{| border=2
|'''''Seite'''''
|'''''Begründung'''''
|'''''Zuständige Person(en)'''''
|-
|[[backupdate.sh]]
|Aus Sicherheitsgründen wurde dieses Script gesperrt
|[[Benutzer:framp|framp]]
|-
|[[Make_snapshotLC.sh]]
|Aus Sicherheitsgründen wurde dieses Script gesperrt
|[[Benutzer:framp|framp]]
|}

Linupedia.org:GeschÃ¼tzte Seiten

2007-06-16T10:14:31Z

K4m1K4tz3:

Diskussion:Backupprogramme

2007-06-15T11:57:42Z

K4m1K4tz3: Trotzdem dd erwähnen mit Warnung?

hieß der nicht tomte? --[[Benutzer:Yehudi|Yehudi]] 21:06, 6. Jun 2007 (CEST)

Joa, stimmt :-) --[[Benutzer:K4m1K4tz3|K4m1K4tz3]] 11:58, 8. Jun 2007 (CEST)

== G4L oder G4U? ==

Ich wäre aufgrund der Lizenzstreitigeiten bei G4L und G4U dafür, daß G4L aus der Liste fliegt, da dort Rechte des G4U Autoren offenbar bewusst ignoriert wurden und die Lizenzierung bei G4L daher wohl recht zweifelhaft sein dürfte. Siehe dazu auch im Link zum G4U Text im Artikel....aus dem MosNis ists deswegen auch schon länger rausgekegelt worden seit mir der Lizenzstreit da bekannt wurde, zumal beide ungefähr denselben Leistungsumfang bieten und damals (als ichs in den Anfangstagen des MosNis dort mit reinnahm) G4L einfach nur ein nettes Menü dazu lieferte was bei G4U nicht mitgeliefert wurde..
Lizenzverstöße/Codediebstahl durch Lizenzignorierung sollte man auch bei OSS nicht fördern find ich...
Bis denne,
--[[Benutzer:TomcatMJ|TomcatMJ]] 23:30, 10. Jun 2007 (CEST)

:Nur ein Gerücht. Außerdem sind laut Wikipedia die angeblich Ähnlichkeiten weitgehend verschwunden, so daß ich wirklich keinerlei Veranlassung zu einer Entfernung sehe. Und außerdem: Was haben wir mit irgendwelchen Lizenzstreitereien zu tun? --[[Benutzer:Stefan Staeglich|Stefan Staeglich]] 17:48, 14. Jun 2007 (CEST)

::Also als ich letzten Herbst mal den Vergleich selbst gemacht hab der auf http://www.feyrer.de/g4u/g4l.html vom g4u Programmierer bereits gemacht und doumentiert wurde, sah es nicht nach irgendwelchen nennenswerten Änderungen an den beanstandeten Codeteilen aus. Wenn da also nicht jetzt das Ganze g4l Projekt komplett umgekrempelt wurde, dann halte ich eher den Status als "Gerücht" für das eigentliche Gerücht...naja,auf alle Fälle ists da jedenfalls betreffs g4l leider noch hakelig mit dem Rechtsstatus. da bisher noch keine von beiden Seiten für eine eindeutige Klärung durch ein Gericht oder eine definitive Stellunsgnahme seitens den g4l Leuten, die ja nichmal eine eigene Website für ihr Projekt haben wo sie dazu was sagen würden, weswegen es für mich eben auch nicht wirklich astrein zu sein scheint. Rechtlich haben wir damit natürlich nicht wirklich was zu tun,aber moralisch find ichs eben schon bedenlich wenn Codediebstahl dadurch unterstützt wird, daß man die Projekte in denen das auftritt und nicht umgehend abgeändert wird pusht...ist eben so wie mit Linux in der (ja nun definitiv unfriedlichen) Waffensystemtechnik, verboten ist es nicht wirklich aber damit dürften sich auch die wenigsten zivilen Programmierer anfreunden können und es eher ablehnen als dafür zu streiten.....bei KKW-Steuerungsanlagen dürften diese Bedenken hingegen weniger wenn auch immer noch vorhanden sein (um mal 2 Vergleichsbeispiele für moralisch-ethische Bedenken anzubringen) ...--[[Benutzer:TomcatMJ|TomcatMJ]] 19:04, 14. Jun 2007 (CEST)

:::Ich schließe mich Stefan an. Ich habe bei dieser Frage nicht genügend Einblick und Wissen, wer da was von wem abgeschrieben haben soll. Es interessiert mich auch nicht. Solange wir hier nur über Behauptungen einer Firma reden, ist das für mich etwa so, als ob der berühmte Sack Reis in China umfällt. Da es keinerlei Auswirkungen auf unser Wiki hat, sollen die das ruhig mal unter sich ausmachen. Uns betrifft es nicht und wir haben auch nicht zu beurteilen, wer da möglicherweise wessen Lizenzen verletzt hat.
:::=> Ich sehe derzeit keinen Handlungsbedarf in dieser Angelegenheit.
:::--[[Benutzer:Griffin|Griffin]] 19:17, 14. Jun 2007 (CEST)

::::'''''Uns betrifft es nicht und wir haben auch nicht zu beurteilen, wer da möglicherweise wessen Lizenzen verletzt hat.'''''<- Also ich denke schon, daß ich als denkfähiger Mensch durchaus von meinem Verstand Gebrauch machen darf und durchaus mir eine eigene Beurteilung der Sachlage zusteht. Das es uns betreffs dem Wiki hier nicht direkt tangiert ist nicht strittig, aber dieses "wir haben es nicht zu beurteilen" liest sich in meinen Augen wie "du darfst da nicht drüber nachdenken" und sorry, aber wer mir das Denken verbieten will muss mich schon erschiessen*g*...ich finde es halt bedenklich es kommentarlos einfach so stehen zu lassen hinsichtlich gerade der Codediebstahlsache und bisher konnte ich leider nur Argumente im Netz finden die '''für''' diese Codediebstahl sprachen aber noch kein einiziges was dagegen sprach und genau deshalb erwähne ich das eben hier auch und habe es ja deshalb auch aus dem offziziellen MosNis Projet gekegelt bis da die Lage endich mal defintiv geklärt wurde....solang das ungeklärt ist, ist es in meinen Augen ebenso bedenklich wie die Nutzung der libdvdcss (also nicht daß es nicht funktionieren würde, nur rechtlich halte ich es eben für eine ziemlich dunkelgraue Sache)...--[[Benutzer:TomcatMJ|TomcatMJ]] 19:26, 14. Jun 2007 (CEST)

:::::Ich schließe mich da der Meinung von TomcatMJ an. --[[Benutzer:Yehudi|Yehudi]] 19:35, 14. Jun 2007 (CEST)

Niemand verbietet hier irgendwem, über irgendwas nachzudenken. So war meine Aussage weder gemeint noch sollte sie so verstanden werden. Es dürfte jedoch unstreitig sein, dass keiner von uns hinreichend mit der Materie vertraut ist, um hier irgendwelche Lizenzverletzungen in dem hier gegenständlichen Streit konkret nachweisen zu können. Wir sind weder Sachverständige noch haben wir diesen Sachverhalt als Richter zu beurteilen. Redmond wirft Linux ständig Patentverletzungen vor. Und? Hören wir deshalb auf, Linux zu supporten? Für mich gilt hier neben meiner völligen Gleichgültigkeit zu dem konkreten Problem die Unschuldsvermutung. Denkt ihr, was und worüber ihr wollt. Ich sehe unser Wiki nicht tangiert und kann demnach nicht erkennen, warum wir hier einen der Kandidaten streichen sollten. --[[Benutzer:Griffin|Griffin]] 19:45, 14. Jun 2007 (CEST)

:Hast du dir denn http://www.feyrer.de/g4u/g4l.html ma angesehen? Im gegensatz zu dem Redmond FUD liefert der Programmierer von g4u wenigstens auch offen einsehbare und von jedem selbst überprüfbare Belege dazu, daß es dir egal ist ist eine Sache, aber das eben da keine haltlosen Anschuldigungen sondern belegbares die Konfliktursache ist lässt sich auch als nicht-Sachverständiger (btw.:Woher willst du eigentlich wissen was alle LC-Wikileser beruflich machen?*g* Es kann durchaus auch der ein oder andere vereidigte Sachverständige für Softwarefragen mit gerichtlicher Zulassung darunter sein ohne daß du davon weisst..) erkennen sofern man nur mal die gelieferten Informationen überprüft.
:Das deine Aussage missverstanden wurde lag wohl an der eindeutigen Formulierung die du dann wohl eigentlich nicht so treffen wolltest wie du sie trafst, daher sag ich einfach mal "Schwamm über diesen Punt,nächstesmal besser erst denken,dann posten*g*". Naja, Löschung des Eintrags mag angesichts des bis heute nicht wirlich geklärten Status, auch wenn er sehr dubios ist, vieleicht etwas zu rigide sein, aber dann sollte zumindest schon beim Eintrag auf die Konfliktproblematik hingewiesen werden damit sich die User selbst ein Bild davon machen und dann entscheiden was sie davon halten, denn wenn wirs unommentiert lassen sehe ich das Wiki schon etwas tangiert da wir damit auch eine Art Stellungsnahme dazu äußern, nämlich Ignoranz gegenüber der Codediebstahlprobematik, was dann wiederum auch ein schlechtes Bild (nämlich indirekte Unterstützung solcher Vorgehensweisen) abgeben kann von dem ich mich hiermit ausdrücklich distanziere. --[[Benutzer:TomcatMJ|TomcatMJ]] 20:02, 14. Jun 2007 (CEST)

:: Gegen einen sachlichen und neutral formulierten Hinweis auf die Problematik habe ich nichts. --[[Benutzer:Griffin|Griffin]] 20:07, 14. Jun 2007 (CEST)

:::Ich hab mal einen entsprechenden Hinweis eingefügt. Falls jemand eine bessere Formulierung dafür findet nur zu...:-) --[[Benutzer:TomcatMJ|TomcatMJ]] 20:16, 14. Jun 2007 (CEST)

== dd hinzufügen? ==

Vielleicht sollte man noch dd hinzufügen. Ist zwar kein richtiges Backupprogramm, aber Daten kann man damit trotzdem sichern ;-)
http://linuxwiki.de/dd

--[[Benutzer:K4m1K4tz3|K4m1K4tz3]] 15:29, 14. Jun 2007 (CEST)

: Lasst das dd bitte erst mal raus. Ich bin ein bekennender und strikter Gegner hier im Forum und auch im Wiki "Halbwissende" mit unvollständig und schlecht dokumentierten Befehlenszeilen und Beispielen mittels dd auf die Platten und Partitionen loszulassen. Habe das im Forum auch schon mehrfach kritisiert, aber auf mich hört ja keiner. http://www.linux-club.de/ftopic66240-0-asc-13.html . Und ich sage das nicht aus lauter Spaß, sonder weil ich dienstlich täglich mit diesem Befehl zu tun habe. Übrigens nach deiner Begründung müßte auch zB cat als Backupprogram aufgenommen werden.
cat /dev/hda1 > /dev/hdb1
: macht auch eine Kopie von dieser Partition ;-) und etwas abgewandel und in eine Datei geschrieben oder übers Netzwerk auf einen anderen Rechner geht das so auch noch, habe ich dann wohl mit cat auch ein nenneswertes Backupprogramm ? Wenn ich mich ein bisschen anstrenge dann schaffe ich das auch noch ganz ohne Befehl nur mit der Shell und Ausgabeumleitungen. Also Backup ganz ohne Programm ??????? müssen wir wohl auch noch eine Leerzeile in die Tabelle einfügen.
: Den dd Wikiartikel den du erwähnst, halte ich für oberflächlich, unvollständig und stellenweise kreuzgefährlich. Sollte ich demnächst mal wieder etwas mehr Zeit haben, dann schreibe ich hier mal einen umfassenden Wikiartikel über dd , aber zur Zeit sieht es mit der Zeit bei mir mehr als traurig aus.
--[[Benutzer:Robi|Robi]] 01:41, 15. Jun 2007 (CEST)

War ja nur ne Frage :-p
Zudem finde ich es sehr praktisch dass man halt mit dd ein komplettes Backup machen kann und dies auch noch komprimieren kann. Aber ich denke dass man da trotzdem etwas erwähnen sollte, wie etwa: dd sollte nur von erfahrenen Benutzern benutzt werden und wird deshalb nicht weiter erwähnt. Oder so ähnlich.
--[[Benutzer:K4m1K4tz3|K4m1K4tz3]] 13:57, 15. Jun 2007 (CEST)

Diskussion:Backupprogramme

2007-06-14T13:28:25Z

K4m1K4tz3:

Backupprogramme

2007-06-08T09:58:40Z

K4m1K4tz3:

Die folgenden Tabellen sind das Ergebnis der Linux-Club Community, die in http://www.linux-club.de/ftopic81889-0-asc-0.html ihre bevorzugten Backupprogramme und -scripte empfohlen bzw vorgestellt haben.
 
=== Liste von Linux Backupprogrammen ===

 
{| border=2
|'''''Name'''''
|'''''Typ'''''
|'''''Abstract'''''
|-
|[[backupdate.sh]]
|Befehlszeilenscript
| # Script zum sichern eines beliebigen Verzeichnisses mit rsync
# Es werden mehrere Ordner angelegt, mithilfe von Hardlinks,
# mit dem jeweils aktuellen Datum (backup_JahrMonatTag).
# Die ältesten Ordner werden gelöscht
|-
|[http://backup2l.sourceforge.net backup2l]
|Befehlszeile
|Low-Maintenance Backup/Restore Tool - Tool für automatische, inkrementelle Backups nach dem Generationenprinzip. Einfache, aber flexible Konfiguration über Kontrolldatei in Shell-Syntax. Basiert auf Standard-Tools tar, gzip und find. Einfache "Treiber"-Schnittstelle (Shell-Funktion) für alternative Archivprogramme oder Zusatzfunktionen wie Splitten oder Verschlüsseln.
|-
|[http://clonezilla.sourceforge.net Clonezilla]
|Befehlszeile
|Clonezilla basiert auf DRBL, Partition Image, ntfsclone, und udpcast, und erlaubt massiv paralleles clonen von 40 plus Computern
|-
|[https://faracvs.cs.uni-magdeburg.de/projects/christsc-darbackup darbackup]
|Befehlszeile
|
# Erzeugung von Referenz-Sicherungen, die ein maximales Alter nicht überschreiten
# Erzeugung von differenziellen Sicherungen, die ein maximales Alter nicht überschreiten
# Erzeugung neuer Referenz-Sicherungen, falls existierende Sicherungen zu alt sind
# Erzeugung neuer Referenz-Sicherungen, falls die Gesamtgröße der differenziellen Sicherungen einen Grenzwert überschreitet
# Transfer von erzeugten Sicherungen per SSH auf entfernte Rechner
# Verwendung von bdelta/xdelta zur Speicherung von ausschliesslich geänderten Daten zwischen zwei differentiellen Sicherungen
# Verwendung von Konfigurationsdateien für unterschiedliche Sicherungs-Quellen und -Ziele
|-
|[http://sourceforge.net/projects/g4l Ghost for Linux]
|Befehlszeile
|Ghost for Linux ist ein disk und partition imaging und cloning tool ähnlich wie Norton Ghost(c). Die erzeugten Images werden optional compressed und per ftp transferiert oder lokal abgelegt.
|-
|[http://packman.links2linux.de/package/grsync%20 grsync]
|GUI
|Graphisches Interface für rsync
|-
| [http://kbackup.sourceforge.net/ kbackup]
|Befehlszeile/GUI
| Erstellt ein tar-Verzeichnisse, der ausgewählten Ordner. Nicht sehr viele Einstellungsmöglichkeiten, aber für den privaten Gebrauch ist es ausreichend.
|-
|-
| [http://krusader.sourceforge.net/ krusader]
|GUI
|Ein Feature von Krusader ist der Synchronizer, mit dem man Verzeichnisse komfortabel synchronisieren kann. Ein Verzeichnis kann dabei auch auf einem ftp-Server liegen.

Der Synchronizer kann Verzeichnisse additiv zusammenführen, oder ein Zielverzeichnis auf den Stand eines Quellverzeichnisses bringen (inkl. Löschungen).
|-
|[http://mkcdrec.ota.be/ mkCDrec]
|Befehlszeile
|mkCDrec erzeugt ein bootable (El Torito) disaster recovery image (CDrec.iso), und schreibt Backups von einem Linux System auf derselben CD-ROM (oder CD-RW) wenn der Platz dazu reicht oder auf ein multi-volume CD-ROM set. Backups können auch auf einer lokalen Disk, NFS disk oder (remote) tape abgelegt werden.
|-
| [http://man.cx/star star]
|Befehlszeile
|Ist eine sehr schnelle und moderne Erweiterung von tar das eine Reihe von Beschränkungen von tar aufhebt, und wesentlich mehr moderne tar-Formate unterstützt.
Bietet auch unter anderem ACL-Unterstützung.
|-
|[[rsync]]
|Befehlszeile
|'''Das''' Standard Synchronisationsprogramm von Linux. Sehr nützlich bei regelmäßigen (z.B. wöchentlichen) Snapshorts die jederzeit direkt verfügbar sind (kein Entpacken der Daten notwendig) durch Einsatz von Hardlinks.
|-
|tar
|Befehlszeile
|'''Das''' Standard Backupprogramm von Linux
|}
 

=== Ihre Backupprogramme für die obige Liste haben empfohlen ===
# joka
# tomte
# lips
# ginka
# robi
# [[Benutzer:framp|framp]]

=== Ihre Backupscripte haben beigesteuert ===

# K4m1K4tz3

Diskussion:Backupprogramme

2007-06-08T09:58:16Z

K4m1K4tz3:

hieß der nicht tomte? --[[Benutzer:Yehudi|Yehudi]] 21:06, 6. Jun 2007 (CEST)

Joa, stimmt :-) --[[Benutzer:K4m1K4tz3|K4m1K4tz3]] 11:58, 8. Jun 2007 (CEST)

Backupdate sh

2007-06-08T09:23:03Z

K4m1K4tz3:

<pre>
#!/bin/sh
#
# Script zum sichern eines beliebigen Verzeichnisses mit rsync
# Es werden mehrere Ordner angelegt, mithilfe von Hardlinks,
# mit dem jeweils aktuellen Datum (backup_JahrMonatTag).
# Die ältesten Ordner werden gelöscht
#
# Dieses Skript kann durch einen Cron Job alle X Tage aufgerufen werden.
# Für weitere Infos siehe hier: http://www.newbie-net.de/anleitung_cron.html
# oder hier: http://www.selflinux.org/selflinux/html/cron.html
# Bsp. für ein Backup welches jeden Tag um 24 Uhr gestartet wird:
# 00 24 */1 * * User /Ordner/mit/Script/backup.sh
#
# Version: 1.0
# Zuletzt geändert am: 07.06.2007
#
# Autor Mathias Rabe
# mathiasrabe@web.de
#
# Dieses Script steht unter der GPL. Es gelten daher die dort
# vorgeschriebenen Bedingungen für die Verwendung dieses Scriptes.

#--------------------------------Einstellungen----------------------------------

# Wovon soll ein Backup gemacht werden?
# Bsp wenn nur ein paar Ordner/Dateien kopiert werden sollen und nicht der gesamte Inhalt:
# SOURCE_LOCATION="/home/USER/original/Ordner1 /home/USER/original/Ordner2";
SOURCE_LOCATION=/home/master/backuptest/original;

# Wohin soll das Backup geschrieben werden?
BACKUP_LOCATION=/home/master/backuptest/backup;

# Wie viele Backups sollen maximal existieren? Achtung: zu der Anzahl kommt noch das neu hinzugefügte Backup!
# Bsp: Wenn hier 3 eingetragen ist, sind höchstens 4 Ordner vorhanden.
BACKUPS_UNTIL_ERASE=3;

#---------------------------------Programm--------------------------------------

if ! test -d $BACKUP_LOCATION ; then
echo "Backupverzeichnis $BACKUP_LOCATION existiert nicht";
exit 0;
fi

cd $BACKUP_LOCATION;

DATE=$(date +"%Y%m%d");

# TODO: Nachfolgende Funktionen schmeißen noch Fehlermeldungen beim Programm ls,
# wenn kein backup_* Ordner existiert. Die Funktionen werden anscheinend auch schon
# am Anfang ausgeführt, obwohl sie erst später ausgeführt werden sollen.
# Beeinträchtigt aber keineswegs die Funktioninalität!
NEWEST_BACKUP() {
VAR_NEWEST_BACKUP=$(ls -d $BACKUP_LOCATION/backup_* | tail --lines=1) ;
return $? ; } ;

OLDEST_BACKUP() {
VAR_OLDEST_BACKUP=$(ls -rd $BACKUP_LOCATION/backup_* | tail --lines=1) ;
return $? ; } ;

FILECOUNT() {
VAR_FILECOUNT=$(ls -d $BACKUP_LOCATION/backup_* | wc -w) ;
return $? ; } ;

if test -d $BACKUP_LOCATION/backup_$DATE ; then
echo "Ein aktuelles Backup existiert bereits";
exit 0;
fi;

#älteste Ordner löschen, Anzahl wie viele Ordner vorhanden sein sollen bei BACKUPS_UNTIL_ERASE definieren!
FILECOUNT;

while [ $VAR_FILECOUNT -gt $BACKUPS_UNTIL_ERASE ] ; do
OLDEST_BACKUP;
rm -rfv $VAR_OLDEST_BACKUP ;
FILECOUNT;
done;

#neues Backup erstellen:
NEWEST_BACKUP;

rsync -arbuv --delete --progress --link-dest=$VAR_NEWEST_BACKUP $SOURCE_LOCATION $BACKUP_LOCATION/backup_$DATE/ ;
</pre>

Backupdate sh

2007-06-07T21:25:30Z

K4m1K4tz3:

<pre>
#!/bin/sh
#
# Script zum sichern eines beliebigen Verzeichnisses mit rsync
# Es werden mehrere Ordner angelegt, mithilfe von Hardlinks,
# mit dem jeweils aktuellen Datum (backup_JahrMonatTag).
# Die ältesten Ordner werden gelöscht
#
# Dieses Skript kann durch einen Cron Job alle X Tage aufgerufen werden.
# Für weitere Infos siehe hier: http://www.newbie-net.de/anleitung_cron.html
# oder hier: http://www.selflinux.org/selflinux/html/cron.html
# Bsp. für ein Backup welches jeden Tag um 24 Uhr gestartet wird:
# 00 24 */1 * * User /Ordner/mit/Script/backup.sh
#
# Version: 1.0
# Zuletzt geändert am: 07.06.2007
#
# Autor Mathias Rabe
# mathiasrabe@web.de

#--------------------------------Einstellungen----------------------------------

# Wovon soll ein Backup gemacht werden?
# Bsp wenn nur ein paar Ordner/Dateien kopiert werden sollen und nicht der gesamte Inhalt:
# SOURCE_LOCATION="/home/USER/original/Ordner1 /home/USER/original/Ordner2";
SOURCE_LOCATION=/home/master/backuptest/original;

# Wohin soll das Backup geschrieben werden?
BACKUP_LOCATION=/home/master/backuptest/backup;

# Wie viele Backups sollen maximal existieren? Achtung: zu der Anzahl kommt noch das neu hinzugefügte Backup!
# Bsp: Wenn hier 3 eingetragen ist, sind höchstens 4 Ordner vorhanden.
BACKUPS_UNTIL_ERASE=3;

#---------------------------------Programm--------------------------------------

if ! test -d $BACKUP_LOCATION ; then
echo "Backupverzeichnis $BACKUP_LOCATION existiert nicht";
exit 0;
fi

cd $BACKUP_LOCATION;

DATE=$(date +"%Y%m%d");

# TODO: Nachfolgende Funktionen schmeißen noch Fehlermeldungen beim Programm ls,
# wenn kein backup_* Ordner existiert. Die Funktionen werden anscheinend auch schon
# am Anfang ausgeführt, obwohl sie erst später ausgeführt werden sollen.
# Beeinträchtigt aber keineswegs die Funktioninalität!
NEWEST_BACKUP() {
VAR_NEWEST_BACKUP=$(ls -d $BACKUP_LOCATION/backup_* | tail --lines=1) ;
return $? ; } ;

OLDEST_BACKUP() {
VAR_OLDEST_BACKUP=$(ls -rd $BACKUP_LOCATION/backup_* | tail --lines=1) ;
return $? ; } ;

FILECOUNT() {
VAR_FILECOUNT=$(ls -d $BACKUP_LOCATION/backup_* | wc -w) ;
return $? ; } ;

if test -d $BACKUP_LOCATION/backup_$DATE ; then
echo "Ein aktuelles Backup existiert bereits";
exit 0;
fi;

#älteste Ordner löschen, Anzahl wie viele Ordner vorhanden sein sollen bei BACKUPS_UNTIL_ERASE definieren!
FILECOUNT;

while [ $VAR_FILECOUNT -gt $BACKUPS_UNTIL_ERASE ] ; do
OLDEST_BACKUP;
rm -rfv $VAR_OLDEST_BACKUP ;
FILECOUNT;
done;

#neues Backup erstellen:
NEWEST_BACKUP;

rsync -arbuv --delete --progress --link-dest=$VAR_NEWEST_BACKUP $SOURCE_LOCATION $BACKUP_LOCATION/backup_$DATE/ ;
</pre>

Backupdate sh

2007-06-07T16:46:37Z

K4m1K4tz3:

<pre>
#!/bin/sh
#
# Script zum sichern eines beliebigen Verzeichnisses mit rsync
# Es werden mehrere Ordner angelegt, mithilfe von Hardlinks,
# mit dem jeweils aktuellen Datum (backup_JahrMonatTag).
# Die ältesten Ordner werden gelöscht
#
# Dieses Skript kann durch einen Cron Job alle X Tage aufgerufen werden.
# Für weitere Infos siehe hier: http://www.newbie-net.de/anleitung_cron.html
# oder hier: http://www.selflinux.org/selflinux/html/cron.html
# Bsp. für ein Backup welches jeden Tag um 24 Uhr gestartet wird:
# 00 24 */1 * * User /Ordner/mit/Script/backup.sh
#
# Version: 1.0
# Zuletzt geändert am: 07.06.2007
#
# Autor Mathias Rabe
# Albert-Einstein-Str. 47
# 63263 Neu-Isenburg
# mathiasrabe@web.de

#--------------------------------Einstellungen----------------------------------

# Wovon soll ein Backup gemacht werden?
# Bsp wenn nur ein paar Ordner/Dateien kopiert werden sollen und nicht der gesamte Inhalt:
# SOURCE_LOCATION="/home/USER/original/Ordner1 /home/USER/original/Ordner2";
SOURCE_LOCATION=/home/master/backuptest/original;

# Wohin soll das Backup geschrieben werden?
BACKUP_LOCATION=/home/master/backuptest/backup;

# Wie viele Backups sollen maximal existieren? Achtung: zu der Anzahl kommt noch das neu hinzugefügte Backup!
# Bsp: Wenn hier 3 eingetragen ist, sind höchstens 4 Ordner vorhanden.
BACKUPS_UNTIL_ERASE=3;

#---------------------------------Programm--------------------------------------

if ! test -d $BACKUP_LOCATION ; then
echo "Backupverzeichnis $BACKUP_LOCATION existiert nicht";
exit 0;
fi

cd $BACKUP_LOCATION;

DATE=$(date +"%Y%m%d");

# TODO: Nachfolgende Funktionen schmeißen noch Fehlermeldungen beim Programm ls,
# wenn kein backup_* Ordner existiert. Die Funktionen werden anscheinend auch schon
# am Anfang ausgeführt, obwohl sie erst später ausgeführt werden sollen.
# Beeinträchtigt aber keineswegs die Funktioninalität!
NEWEST_BACKUP() {
VAR_NEWEST_BACKUP=$(ls -d $BACKUP_LOCATION/backup_* | tail --lines=1) ;
return $? ; } ;

OLDEST_BACKUP() {
VAR_OLDEST_BACKUP=$(ls -rd $BACKUP_LOCATION/backup_* | tail --lines=1) ;
return $? ; } ;

FILECOUNT() {
VAR_FILECOUNT=$(ls -d $BACKUP_LOCATION/backup_* | wc -w) ;
return $? ; } ;

if test -d $BACKUP_LOCATION/backup_$DATE ; then
echo "Ein aktuelles Backup existiert bereits";
exit 0;
fi;

#älteste Ordner löschen, Anzahl wie viele Ordner vorhanden sein sollen bei BACKUPS_UNTIL_ERASE definieren!
FILECOUNT;

while [ $VAR_FILECOUNT -gt $BACKUPS_UNTIL_ERASE ] ; do
OLDEST_BACKUP;
rm -rfv $VAR_OLDEST_BACKUP ;
FILECOUNT;
done;

#neues Backup erstellen:
NEWEST_BACKUP;

rsync -arbuv --delete --progress --link-dest=$VAR_NEWEST_BACKUP $SOURCE_LOCATION $BACKUP_LOCATION/backup_$DATE/ ;
</pre>

Backupdate sh

2007-06-07T16:45:40Z

K4m1K4tz3:

<pre>
#!/bin/sh
#
# Script zum sichern eines beliebigen Verzeichnisses mit rsync
# Es werden mehrere Ordner angelegt, mithilfe von Hardlinks,
# mit dem jeweils aktuellen Datum (backup_JahrMonatTag).
# Die ältesten Ordner werden gelöscht
#
# Dieses Skript kann durch einen Cron Job alle X Tage aufgerufen werden.
# Für weitere Infos siehe hier: http://www.newbie-net.de/anleitung_cron.html
# oder hier: http://www.selflinux.org/selflinux/html/cron.html
# Bsp. für ein Backup welches jeden Tag um 24 Uhr gestartet wird (nicht getestet!):
# 00 24 */1 * * User /Ordner/mit/Script/backup.sh
#
# Version: 1.0
# Zuletzt geändert am: 07.06.2007
#
# Autor Mathias Rabe
# Albert-Einstein-Str. 47
# 63263 Neu-Isenburg
# mathiasrabe@web.de

#--------------------------------Einstellungen----------------------------------

# Wovon soll ein Backup gemacht werden?
# Bsp wenn nur ein paar Ordner/Dateien kopiert werden sollen und nicht der gesamte Inhalt:
# SOURCE_LOCATION="/home/USER/original/Ordner1 /home/USER/original/Ordner2";
SOURCE_LOCATION=/home/master/backuptest/original;

# Wohin soll das Backup geschrieben werden?
BACKUP_LOCATION=/home/master/backuptest/backup;

# Wie viele Backups sollen maximal existieren? Achtung: zu der Anzahl kommt noch das neu hinzugefügte Backup!
# Bsp: Wenn hier 3 eingetragen ist, sind höchstens 4 Ordner vorhanden.
BACKUPS_UNTIL_ERASE=3;

#---------------------------------Programm--------------------------------------

if ! test -d $BACKUP_LOCATION ; then
echo "Backupverzeichnis $BACKUP_LOCATION existiert nicht";
exit 0;
fi

cd $BACKUP_LOCATION;

DATE=$(date +"%Y%m%d");

# TODO: Nachfolgende Funktionen schmeißen noch Fehlermeldungen beim Programm ls,
# wenn kein backup_* Ordner existiert. Die Funktionen werden anscheinend auch schon
# am Anfang ausgeführt, obwohl sie erst später ausgeführt werden sollen.
# Beeinträchtigt aber keineswegs die Funktioninalität!
NEWEST_BACKUP() {
VAR_NEWEST_BACKUP=$(ls -d $BACKUP_LOCATION/backup_* | tail --lines=1) ;
return $? ; } ;

OLDEST_BACKUP() {
VAR_OLDEST_BACKUP=$(ls -rd $BACKUP_LOCATION/backup_* | tail --lines=1) ;
return $? ; } ;

FILECOUNT() {
VAR_FILECOUNT=$(ls -d $BACKUP_LOCATION/backup_* | wc -w) ;
return $? ; } ;

if test -d $BACKUP_LOCATION/backup_$DATE ; then
echo "Ein aktuelles Backup existiert bereits";
exit 0;
fi;

#älteste Ordner löschen, Anzahl wie viele Ordner vorhanden sein sollen bei BACKUPS_UNTIL_ERASE definieren!
FILECOUNT;

while [ $VAR_FILECOUNT -gt $BACKUPS_UNTIL_ERASE ] ; do
OLDEST_BACKUP;
rm -rfv $VAR_OLDEST_BACKUP ;
FILECOUNT;
done;

#neues Backup erstellen:
NEWEST_BACKUP;

rsync -arbuv --delete --progress --link-dest=$VAR_NEWEST_BACKUP $SOURCE_LOCATION $BACKUP_LOCATION/backup_$DATE/ ;
</pre>

Backupprogramme

2007-06-07T16:14:05Z

K4m1K4tz3:

Die folgenden Tabellen sind das Ergebnis der Linux-Club Community, die in http://www.linux-club.de/ftopic81889-0-asc-0.html ihre bevorzugten Backupprogramme empfohlen haben.
 
=== Liste von Linux Backupprogrammen ===

 
{| border=2
|'''''Name'''''
|'''''Typ'''''
|'''''Abstract'''''
|-
|backupdate.sh (Script s.u.)
|Befehlszeile
| # Script zum sichern eines beliebigen Verzeichnisses mit rsync
# Es werden mehrere Ordner angelegt, mithilfe von Hardlinks,
# mit dem jeweils aktuellen Datum (backup_JahrMonatTag).
# Die ältesten Ordner werden gelöscht
|-
|[http://backup2l.sourceforge.net backup2l]
|Befehlszeile
|Low-Maintenance Backup/Restore Tool - Tool für automatische, inkrementelle Backups nach dem Generationenprinzip. Einfache, aber flexible Konfiguration über Kontrolldatei in Shell-Syntax. Basiert auf Standard-Tools tar, gzip und find. Einfache "Treiber"-Schnittstelle (Shell-Funktion) für alternative Archivprogramme oder Zusatzfunktionen wie Splitten oder Verschlüsseln.
|-
|[http://clonezilla.sourceforge.net Clonezilla]
|Befehlszeile
|Clonezilla basiert auf DRBL, Partition Image, ntfsclone, und udpcast, und erlaubt massiv paralleles clonen von 40 plus Computern
|-
|[https://faracvs.cs.uni-magdeburg.de/projects/christsc-darbackup darbackup]
|Befehlszeile
|
# Erzeugung von Referenz-Sicherungen, die ein maximales Alter nicht überschreiten
# Erzeugung von differenziellen Sicherungen, die ein maximales Alter nicht überschreiten
# Erzeugung neuer Referenz-Sicherungen, falls existierende Sicherungen zu alt sind
# Erzeugung neuer Referenz-Sicherungen, falls die Gesamtgröße der differenziellen Sicherungen einen Grenzwert überschreitet
# Transfer von erzeugten Sicherungen per SSH auf entfernte Rechner
# Verwendung von bdelta/xdelta zur Speicherung von ausschliesslich geänderten Daten zwischen zwei differentiellen Sicherungen
# Verwendung von Konfigurationsdateien für unterschiedliche Sicherungs-Quellen und -Ziele
|-
|[http://sourceforge.net/projects/g4l Ghost for Linux]
|Befehlszeile
|Ghost for Linux ist ein disk und partition imaging und cloning tool ähnlich wie Norton Ghost(c). Die erzeugten Images werden optional compressed und per ftp transferiert oder lokal abgelegt.
|-
|[http://packman.links2linux.de/package/grsync%20 grsync]
|GUI
|Graphisches Interface für rsync
|-
| [http://kbackup.sourceforge.net/ kbackup]
|Befehlszeile/GUI
| Erstellt ein tar-Verzeichnisse, der ausgewählten Ordner. Nicht sehr viele Einstellungsmöglichkeiten, aber für den privaten Gebrauch ist es ausreichend.
|-
|-
| [http://krusader.sourceforge.net/ krusader]
|GUI
|Ein Feature von Krusader ist der Synchronizer, mit dem man Verzeichnisse komfortabel synchronisieren kann. Ein Verzeichnis kann dabei auch auf einem ftp-Server liegen.

Der Synchronizer kann Verzeichnisse additiv zusammenführen, oder ein Zielverzeichnis auf den Stand eines Quellverzeichnisses bringen (inkl. Löschungen).
|-
|[http://mkcdrec.ota.be/ mkCDrec]
|Befehlszeile
|mkCDrec erzeugt ein bootable (El Torito) disaster recovery image (CDrec.iso), und schreibt Backups von einem Linux System auf derselben CD-ROM (oder CD-RW) wenn der Platz dazu reicht oder auf ein multi-volume CD-ROM set. Backups können auch auf einer lokalen Disk, NFS disk oder (remote) tape abgelegt werden.
|-
|[[rsync]]
|Befehlszeile
|'''Das''' Standard Synchronisationsprogramm von Linux. Sehr nützlich bei regelmäßigen (z.B. wöchentlichen) Snapshorts die jederzeit direkt verfügbar sind (kein Entpacken der Daten notwendig) durch Einsatz von Hardlinks.
|-
|tar
|Befehlszeile
|'''Das''' Standard Backupprogramm von Linux
|}
 

=== Kleine BackupScripte ===

==== backupdate.sh ====

Eingereicht von K4m1K4tz3

<pre>
#!/bin/sh
#
# Version: 20070607
#
# Script zum sichern eines beliebigen Verzeichnisses mit rsync
# Es werden mehrere Ordner angelegt, mithilfe von Hardlinks,
# mit dem jeweils aktuellen Datum (backup_JahrMonatTag).
# Die ältesten Ordner werden gelöscht
#
# Dieses Skript kann durch einen Cron Job alle X Tage aufgerufen werden.
# Für weitere Infos siehe hier: http://www.newbie-net.de/anleitung_cron.html
# oder hier: http://www.selflinux.org/selflinux/html/cron.html
# Bsp. für ein Backup welches jeden Tag um 24 Uhr gestartet wird (nicht getestet!):
# 00 24 */1 * * User /Ordner/mit/Script/backup.sh

#--------------------------------Einstellungen----------------------------------

# Wovon soll ein Backup gemacht werden?
SOURCE_LOCATION=/home/master/backuptest/original;

# Wohin soll das Backup geschrieben werden?
BACKUP_LOCATION=/home/master/backuptest/backup;

# Wie viele Backups sollen maximal existieren? Achtung: zu der Anzahl kommt noch das neu hinzugefügte Backup!
# Bsp: Wenn hier 3 eingetragen ist, sind höchstens 4 Ordner vorhanden.
BACKUPS_UNTIL_ERASE=3;

#---------------------------------Programm--------------------------------------

if ! test -d $BACKUP_LOCATION ; then
echo "Backupverzeichnis $BACKUP_LOCATION existiert nicht";
exit 0;
fi

cd $BACKUP_LOCATION;

DATE=$(date +"%Y%m%d");

NEWEST_BACKUP() {
VAR_NEWEST_BACKUP=$(ls -d $BACKUP_LOCATION/backup_* | tail --lines=1) ;
return $? ; } ;

OLDEST_BACKUP() {
VAR_OLDEST_BACKUP=$(ls -rd $BACKUP_LOCATION/backup_* | tail --lines=1) ;
return $? ; } ;

FILECOUNT() {
VAR_FILECOUNT=$(ls -d $BACKUP_LOCATION/backup_* | wc -w) ;
return $? ; } ;

if test -d $BACKUP_LOCATION/backup_$DATE ; then
echo "Ein aktuelles Backup existiert bereits";
exit 0;
fi;

#älteste Ordner löschen, Anzahl wie viele Ordner vorhanden sein sollen bei BACKUPS_UNTIL_ERASE definieren!
FILECOUNT;

while [ $VAR_FILECOUNT -gt $BACKUPS_UNTIL_ERASE ] ; do
OLDEST_BACKUP;
rm -rfv $VAR_OLDEST_BACKUP ;
FILECOUNT;
done;

#neues Backup erstellen:
NEWEST_BACKUP;

rsync -arbuv --delete --progress --link-dest=$VAR_NEWEST_BACKUP $SOURCE_LOCATION $BACKUP_LOCATION/backup_$DATE/ ;
</pre>

=== Ihre Backupprogramme für die obige Liste haben empfohlen ===
# joka
# tompte
# lips
# ginka
# [[Benutzer:framp|framp]]

=== Ihre Backupscripte haben beigesteuert ===

# K4m1K4tz3

Backupprogramme

2007-06-07T15:49:22Z

K4m1K4tz3:

Die folgenden Tabellen sind das Ergebnis der Linux-Club Community, die in http://www.linux-club.de/ftopic81889-0-asc-0.html ihre bevorzugten Backupprogramme empfohlen haben.
 
=== Liste von Linux Backupprogrammen ===

 
{| border=2
|'''''Name'''''
|'''''Typ'''''
|'''''Abstract'''''
|-
| [[Liste von Backupprogrammen#240008.php] 240008.php]
|Befehlszeile
| # Script zum sichern eines beliebigen Verzeichnisses mit rsync
# Es werden mehrere Ordner angelegt, mithilfe von Hardlinks,
# mit dem jeweils aktuellen Datum (backup_JahrMonatTag).
# Die ältesten Ordner werden gelöscht
|-
|[http://backup2l.sourceforge.net backup2l]
|Befehlszeile
|Low-Maintenance Backup/Restore Tool - Tool für automatische, inkrementelle Backups nach dem Generationenprinzip. Einfache, aber flexible Konfiguration über Kontrolldatei in Shell-Syntax. Basiert auf Standard-Tools tar, gzip und find. Einfache "Treiber"-Schnittstelle (Shell-Funktion) für alternative Archivprogramme oder Zusatzfunktionen wie Splitten oder Verschlüsseln.
|-
|[http://clonezilla.sourceforge.net Clonezilla]
|Befehlszeile
|Clonezilla basiert auf DRBL, Partition Image, ntfsclone, und udpcast, und erlaubt massiv paralleles clonen von 40 plus Computern
|-
|[https://faracvs.cs.uni-magdeburg.de/projects/christsc-darbackup darbackup]
|Befehlszeile
|
# Erzeugung von Referenz-Sicherungen, die ein maximales Alter nicht überschreiten
# Erzeugung von differenziellen Sicherungen, die ein maximales Alter nicht überschreiten
# Erzeugung neuer Referenz-Sicherungen, falls existierende Sicherungen zu alt sind
# Erzeugung neuer Referenz-Sicherungen, falls die Gesamtgröße der differenziellen Sicherungen einen Grenzwert überschreitet
# Transfer von erzeugten Sicherungen per SSH auf entfernte Rechner
# Verwendung von bdelta/xdelta zur Speicherung von ausschliesslich geänderten Daten zwischen zwei differentiellen Sicherungen
# Verwendung von Konfigurationsdateien für unterschiedliche Sicherungs-Quellen und -Ziele
|-
|[http://sourceforge.net/projects/g4l Ghost for Linux]
|Befehlszeile
|Ghost for Linux ist ein disk und partition imaging und cloning tool ähnlich wie Norton Ghost(c). Die erzeugten Images werden optional compressed und per ftp transferiert oder lokal abgelegt.
|-
|[http://packman.links2linux.de/package/grsync%20 grsync]
|GUI
|Graphisches Interface für rsync
|-
| [http://kbackup.sourceforge.net/ kbackup]
|Befehlszeile/GUI
| Erstellt ein tar-Verzeichnisse, der ausgewählten Ordner. Nicht sehr viele Einstellungsmöglichkeiten, aber für den privaten Gebrauch ist es ausreichend.
|-
|-
| [http://krusader.sourceforge.net/ krusader]
|GUI
|Ein Feature von Krusader ist der Synchronizer, mit dem man Verzeichnisse komfortabel synchronisieren kann. Ein Verzeichnis kann dabei auch auf einem ftp-Server liegen.

Der Synchronizer kann Verzeichnisse additiv zusammenführen, oder ein Zielverzeichnis auf den Stand eines Quellverzeichnisses bringen (inkl. Löschungen).
|-
|[http://mkcdrec.ota.be/ mkCDrec]
|Befehlszeile
|mkCDrec erzeugt ein bootable (El Torito) disaster recovery image (CDrec.iso), und schreibt Backups von einem Linux System auf derselben CD-ROM (oder CD-RW) wenn der Platz dazu reicht oder auf ein multi-volume CD-ROM set. Backups können auch auf einer lokalen Disk, NFS disk oder (remote) tape abgelegt werden.
|-
|[[rsync]]
|Befehlszeile
|'''Das''' Standard Synchronisationsprogramm von Linux. Sehr nützlich bei regelmäßigen (z.B. wöchentlichen) Snapshorts die jederzeit direkt verfügbar sind (kein Entpacken der Daten notwendig) durch Einsatz von Hardlinks.
|-
|tar
|Befehlszeile
|'''Das''' Standard Backupprogramm von Linux
|}
 

=== Kleine BackupScripte ===

==== backupdate.sh ====

Eingereicht von K4m1K4tz3

<pre>
#!/bin/sh
#
# Version: 20070607
#
# Script zum sichern eines beliebigen Verzeichnisses mit rsync
# Es werden mehrere Ordner angelegt, mithilfe von Hardlinks,
# mit dem jeweils aktuellen Datum (backup_JahrMonatTag).
# Die ältesten Ordner werden gelöscht
#
# Dieses Skript kann durch einen Cron Job alle X Tage aufgerufen werden.
# Für weitere Infos siehe hier: http://www.newbie-net.de/anleitung_cron.html
# oder hier: http://www.selflinux.org/selflinux/html/cron.html
# Bsp. für ein Backup welches jeden Tag um 24 Uhr gestartet wird (nicht getestet!):
# 00 24 */1 * * User /Ordner/mit/Script/backup.sh

#--------------------------------Einstellungen----------------------------------

# Wovon soll ein Backup gemacht werden?
SOURCE_LOCATION=/home/peter/*.pdf;

# Wohin soll das Backup geschrieben werden?
BACKUP_LOCATION=/home/peter/backups;

# Wie viele Backups sollen maximal existieren? Achtung: zu der Anzahl kommt noch das neu hinzugefügte Backup!
Bsp: Wenn hier 3 eingetragen ist, sind höchstens 4 Ordner vorhanden.
BACKUPS_UNTIL_ERASE=3;

#---------------------------------Programm--------------------------------------

if ! test -d $BACKUP_LOCATION ; then
echo "Backupverzeichnis $BACKUP_LOCATION existiert nicht";
exit 0;
fi

cd $BACKUP_LOCATION;

DATE=$(date +"%Y%m%d%S");

NEWEST_BACKUP() {
VAR_NEWEST_BACKUP=$(ls -d $BACKUP_LOCATION/backup_* | tail --lines=1) ;
return $? ; } ;

OLDEST_BACKUP() {
VAR_OLDEST_BACKUP=$(ls -rd $BACKUP_LOCATION/backup_* | tail --lines=1) ;
return $? ; } ;

FILECOUNT() {
VAR_FILECOUNT=$(ls -d $BACKUP_LOCATION/backup_* | wc -w) ;
return $? ; } ;

if test -d $BACKUP_LOCATION/backup_$DATE ; then
echo "Ein aktuelles Backup existiert bereits";
exit 0;
fi;

#älteste Ordner löschen, Anzahl wie viele Ordner vorhanden sein sollen bei BACKUPS_UNTIL_ERASE definieren!
FILECOUNT;

while [ $VAR_FILECOUNT -gt $BACKUPS_UNTIL_ERASE ] ; do
OLDEST_BACKUP;
rm -rfv $VAR_OLDEST_BACKUP ;
FILECOUNT;
done;

#neues Backup erstellen:
NEWEST_BACKUP;

rsync -arbuv --delete --progress --link-dest=$VAR_NEWEST_BACKUP $SOURCE_LOCATION $BACKUP_LOCATION/backup_$DATE/ ;
</pre>

=== Ihre Backupprogramme für die obige Liste haben empfohlen ===
# joka
# tompte
# lips
# ginka
# [[Benutzer:framp|framp]]

=== Ihre Backupscripte haben beigesteuert ===

# K4m1K4tz3