Wie funktionieren Dateideskriptoren?

Kann jemand mir sagen, warum dies nicht funktioniert? Ich bin Herumspielen mit Datei-Deskriptoren, aber fühle mich ein wenig verloren.

#!/bin/bash
echo "This"
echo "is" >&2
echo "a" >&3
echo "test." >&4

Den ersten drei Zeilen laufen, in Ordnung, aber die letzten beiden Fehler aus. Warum?

InformationsquelleAutor der Frage Trcx | 2011-08-16

74

File-Deskriptoren 0, 1 und 2 sind für stdin, stdout und stderr, bzw..

Dateideskriptoren 3, 4, .. 9 sind für zusätzliche Dateien. Um Sie zu nutzen, müssen Sie diese vorher geöffnet werden. Zum Beispiel:
```
exec 3<> /tmp/foo  #open fd 3.
echo "test" >&3
exec 3>&- #close fd 3.
```
Für mehr Informationen werfen Sie einen Blick auf Advanced Bash-Scripting Guide: Kapitel 20. I/O-Umleitung.

InformationsquelleAutor der Antwort dogbane
43

Es ist eine alte Frage, aber eine Sache Bedarf noch der Klärung.

Während die Antworten von Carl Norum und dogbane korrekt sind, ist die Annahme zu ändern Sie Ihr Skript, um es Arbeit.

Was ich möchte darauf hinweisen, dass Sie nicht brauchen, um das Skript ändern,:
```
#!/bin/bash
echo "This"
echo "is" >&2
echo "a" >&3
echo "test." >&4
```
Es funktioniert, wenn Sie es aufrufen, anders:
```
./fdtest 3>&1 4>&1
```
was bedeutet, dass die Umleitung Dateideskriptoren 3 und 4 zu 1 (das ist die standard-Ausgabe).

Der Punkt ist, dass das script ist vollkommen in Ordnung in dem Wunsch, zu schreiben, um die Deskriptoren können als nur 1 und 2 (stdout und stderr) wenn diese Deskriptoren werden von der übergeordneten Prozess.

Dein Beispiel ist eigentlich ganz interessant, weil dieses Skript schreiben können, um 4 unterschiedliche Dateien:
```
./fdtest >file1.txt 2>file2.txt 3>file3.txt 4>file4.txt
```
Nun haben Sie die Ausgabe in 4 separate Dateien:
```
$ for f in file*; do echo $f:; cat $f; done
file1.txt:
This
file2.txt:
is
file3.txt:
a
file4.txt:
test.
```
Was ist interessanter ist, dass Ihr Programm nicht haben, um die Schreibberechtigung für diese Dateien, da es nicht wirklich öffnen.

Zum Beispiel, wenn ich sudo -s zu ändern, Benutzer zu root, erstellen Sie ein Verzeichnis als root an, und führen Sie den folgenden Befehl als mein normaler Benutzer (bzw in meinem Fall) wie folgt:
```
# su rsp -c '../fdtest >file1.txt 2>file2.txt 3>file3.txt 4>file4.txt'
```
Bekomme ich eine Fehlermeldung:
```
bash: file1.txt: Permission denied
```
Aber wenn ich die Umleitung außerhalb von su:
```
# su rsp -c '../fdtest' >file1.txt 2>file2.txt 3>file3.txt 4>file4.txt
```
(beachten Sie den Unterschied in Anführungszeichen) es funktioniert und ich bekomme:
```
# ls -alp
total 56
drwxr-xr-x 2 root root 4096 Jun 23 15:05 ./
drwxrwxr-x 3 rsp  rsp  4096 Jun 23 15:01 ../
-rw-r--r-- 1 root root    5 Jun 23 15:05 file1.txt
-rw-r--r-- 1 root root   39 Jun 23 15:05 file2.txt
-rw-r--r-- 1 root root    2 Jun 23 15:05 file3.txt
-rw-r--r-- 1 root root    6 Jun 23 15:05 file4.txt
```
sind 4 Dateien, die im Besitz von root in ein Verzeichnis im Besitz von root - auch wenn das script nicht über die Berechtigungen zum erstellen dieser Dateien.

Ein weiteres Beispiel wäre die Verwendung von chroot-Gefängnis oder ein container und ein Programm ausführen im inneren, wo es hätte nicht auf diese Dateien zugreifen, auch wenn es als root laufen und trotzdem umleiten diejenigen Deskriptoren außen, wo Sie brauchen, ohne tatsächlich Zugriff auf das gesamte file-system oder irgendetwas anderes zu diesem Skript.

Der Punkt ist, dass Sie haben entdeckt, ein sehr interessanter und nützlicher Mechanismus. Sie müssen nicht zu öffnen, alle Dateien in Ihrem Skript, wie vorgeschlagen wurde, in anderen Antworten. Manchmal ist es nützlich, lenken Sie während der Skript-Aufruf.

Um es zusammenzufassendiese:
```
echo "This"
```
ist eigentlich äquivalent zu:
```
echo "This" >&1
```
ausführen des Programms:
```
./program >file.txt
```
ist das gleiche wie:
```
./program 1>file.txt
```
Die Nummer 1 ist einfach nur ein Standard-Zahl, und es ist stdout.

Aber auch dieses Programm:
```
#!/bin/bash
echo "This"
```
kann produzieren ein "Bad descriptor" Fehler. Wie? Bei der Ausführung als:
```
./fdtest2 >&-
```
Ist die Ausgabe:
```
./fdtest2: line 2: echo: write error: Bad file descriptor
```
Hinzufügen >&- (das ist das gleiche wie 1>&-) bedeutet die Schließung der standard-Ausgabe. Hinzufügen 2>&- würde bedeuten, schließen die stderr.

Können Sie selbst tun eine etwas komplizierte Sache. Ihre ursprüngliche Drehbuch:
```
#!/bin/bash
echo "This"
echo "is" >&2
echo "a" >&3
echo "test." >&4
```
beim ausführen mit nur:
```
./fdtest
```
Drucke:
```
This
is
./fdtest: line 4: 3: Bad file descriptor
./fdtest: line 5: 4: Bad file descriptor
```
Aber Sie können Deskriptoren 3 und 4 funktionieren, aber die Nummer 1 scheitern, indem Sie Folgendes ausführen:
```
./fdtest 3>&1 4>&1 1>&-
```
It-Ausgänge:
```
./fdtest: line 2: echo: write error: Bad file descriptor
is
a
test.
```
Wenn Sie wollen-Deskriptoren 1 und 2 fehlschlagen, führen Sie es wie folgt:
```
./fdtest 3>&1 4>&1 1>&- 2>&-
```
Erhalten Sie:
```
a
test.
```
Warum? Nicht alles, was scheitern? Es hat aber ohne stderr (file descriptor Nummer 2) Sie nicht sehen, die Fehler Meldungen!!!

Ich denke, es ist sehr nützlich, zu Experimentieren, auf diese Weise zu erhalten ein Gefühl von wie die Deskriptoren und Ihre Umleitung arbeiten.

Dein script ist ein sehr Interessantes Beispiel in der Tat - und ich behaupte, dass es ist nicht gebrochen, Sie waren nur mit es falsch! 🙂

InformationsquelleAutor der Antwort rsp
18

Es fehlschlägt, weil diese Datei-Deskriptoren, nicht Punkt-zu nichts! Die normale Standard-file-Deskriptoren sind die standard-Eingabe 0die standard-Ausgabe 1und die standard-Fehler-stream 2. Da Ihr Skript nicht öffnen andere Dateien, es gibt keine anderen gültigen Datei-Deskriptoren. Sie können eine Datei öffnen, in der bash mit exec. Hier ist eine änderung Ihrer Beispiel:
```
#!/bin/bash
exec 3> out1     # open file 'out1' for writing, assign to fd 3
exec 4> out2     # open file 'out2' for writing, assign to fd 4

echo "This"      # output to fd 1 (stdout)
echo "is" >&2    # output to fd 2 (stderr)
echo "a" >&3     # output to fd 3
echo "test." >&4 # output to fd 4
```
"Und jetzt werden wir es:
```
$ ls
script
$ ./script 
This
is
$ ls
out1    out2    script
$ cat out*
a
test.
$
```
Wie Sie sehen können, die extra-Ausgabe gesendet wurde, um die angeforderten Dateien.

InformationsquelleAutor der Antwort Carl Norum

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.