Detaillierte Erklärung zur Verwendung der Stat-Funktion und des Stat-Befehls in Linux

stat-Funktion und stat-Befehl

Erklärung von [inode = Indexknoten] in der Linux-Datei: Um Inode zu verstehen, müssen Sie die Festplatte und [Verzeichniseintrag] verstehen. Inode ist eigentlich das Zwischenmaterial, das den [Verzeichniseintrag] und die Festplatte verbindet.

Der große Kreis im Bild stellt die Hardwarefestplatte dar und der kleine Kreis darin stellt eine auf der Festplatte gespeicherte Datei dar.

Der Knoten von [Inode = Indexknoten] (die Struktur, die die Knoteninformationen enthält, ist: stat, die Definition von stat folgt später) enthält:

1. Dateigröße
2. Der letzte Änderungszeitpunkt der Datei
3. Der Benutzer, dem die Datei gehört
4. Dateiberechtigungen
5. Anzahl der Hardlinks (die von ls -l angezeigte Zahl)
6. Blockspeicherort: Gibt den spezifischen Speicherort auf der Festplatte an, an dem die Datei gespeichert ist.

In der folgenden Abbildung ist „hello“ eine normale Datei und „hello.hard“ ein Hardlink zu „hello“.

Der Ordner enthält das [Verzeichniselement] jeder Datei, wie unten gezeigt. Das [Verzeichniselement] enthält:

1. Dateiname
2. Die Größe des Verzeichniseintrags
3. Dateityp
4. Inode

Wie kann ich den Inode der Datei anzeigen? Verwenden der Option -i

ls -li Dateiname

Ausführungsergebnis:

ys@ys-VirtualBox:~/lianxi1$ ls -li hallo hallo.hard
3801352 -rw-rw-r-- 2 J. J. 0 24. April 11:01 Hallo
3801352 -rw-rw-r-- 2 J. J. 0 24. April 11:01 hallo.hard

Es wurde festgestellt, dass der Inode (3801352) von hello und hello.hard identisch ist, was bedeutet, dass nur eine Kopie auf der Festplatte gespeichert ist.

Wie kann ich Verzeichniselemente anzeigen? Verwenden Sie Emacs oder Vim, um das Verzeichnis (lianxi1) zu öffnen, wie im Screenshot unten gezeigt. Aber ich kann den Inode der Datei nicht sehen.

1. stat-Funktion: Ruft die Dateiattribute der angegebenen Datei ab. Die Dateiattribute werden in der Struktur stat gespeichert.

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

int stat(const char *Pfadname, struct stat *statbuf);
int fstat(int fd, Struktur stat *statbuf);
int lstat(const char *Pfadname, struct stat *statbuf);

Struktur-Stat-Struktur:

Struktur stat {
    dev_t st_dev; /* ID des Geräts, das die Datei enthält */
    ino_t st_ino; /* Inode-Nummer */
    mode_t st_mode; /* Dateityp und Modus */
    nlink_t st_nlink; /* Anzahl der Hardlinks */
    uid_t st_uid; /* Benutzer-ID des Eigentümers */
    gid_t st_gid; /* Gruppen-ID des Eigentümers */
    dev_t st_rdev; /* Geräte-ID (bei spezieller Datei) */
    off_t st_size; /* Gesamtgröße in Bytes */
    blksize_t st_blksize; /* Blockgröße für Dateisystem-E/A */
    blkcnt_t st_blocks; /* Anzahl der zugewiesenen 512B-Blöcke */

    /* Seit Linux 2.6 unterstützt der Kernel Nanosekunden
     Genauigkeit für die folgenden Zeitstempelfelder.
     Einzelheiten vor Linux 2.6 finden Sie unter HINWEISE. */

    struct timespec st_atim; /* Zeitpunkt des letzten Zugriffs */
    struct timespec st_mtim; /* Zeitpunkt der letzten Änderung */
    struct timespec st_ctim; /* Zeitpunkt der letzten Statusänderung */

   #define st_atime st_atim.tv_sec /* Abwärtskompatibilität */
   #define st_mtime st_mtim.tv_sec
   #define st_ctime st_ctim.tv_sec
   };

st_dev: Geräte-ID, wird nicht häufig verwendet
st_ino: [Inode], was ist [Inode]? Wenn Sie es nicht wissen, schauen Sie sich einfach die Erklärung zu [inode] oben an.
st_mode: Dateityp und Berechtigungen, insgesamt 16 Bit, wie unten gezeigt.

• 0-11 Bits steuern Dateiberechtigungen
• 12-15 Bits steuern den Dateityp

0-2 Bits: andere Benutzerberechtigungen
Bits 3-5: Gruppenbenutzerberechtigungen
6-8 Bit: Benutzerberechtigungen
Bits 9-11: Sonderberechtigungen
Bits 12-15: Dateityp (da es nur 7 Dateitypen gibt, reichen die Bits 12-14 aus)

Die Dateitypmakros lauten wie folgt (die Zahlen unten sind in Oktalzahlen angegeben):

• S_IFSOCK 0140000 Sockel
• S_IFLNK 0120000 symbolischer Link
• S_IFREG 0100000 reguläre Datei
• S_IFBLK 0060000 Blockgerät (Blockgerätedatei)
• S_IFDIR 0040000 Verzeichnis
• S_IFCHR 0020000 Zeichengerät (Zeichengerätedatei)
• S_IFIFO 0010000 FIFO (Pipe)

Funktion zur Ermittlung des Dateityps, gibt true, false zurück  
 S_ISREG(stat.st_mode) ist es eine normale Datei?
 S_ISDIR(stat.st_mode)-Verzeichnis?
 S_ISCHR(stat.st_mode) Zeichengerät?
 S_ISBLK(stat.st_mode) Blockgerät?
 S_ISFIFO(m) FIFO (benannte Pipe)?
 S_ISLNK(stat.st_mode) symbolischer Link? (Nicht in POSIX.1-1996.)
 S_ISSOCK(stat.st_mode)-Socket? (Nicht in POSIX.1-1996.)

Die Makros für Dateiberechtigungen lauten wie folgt:

 S_ISUID 04000 Setze-Benutzer-ID-Bit
  S_ISGID 02000 Set-Group-ID-Bit (siehe unten)
  S_ISVTX 01000 Sticky Bit (siehe unten)

  S_IRWXU 00700 Besitzer hat Lese-, Schreib- und Ausführungsberechtigung
  S_IRUSR 00400 Besitzer hat Leseberechtigung
  S_IWUSR 00200 Besitzer hat Schreibberechtigung
  S_IXUSR 00100 Besitzer hat Ausführungsberechtigung

  S_IRWXG 00070 Gruppe hat Lese-, Schreib- und Ausführungsberechtigung
  S_IRGRP 00040 Gruppe hat Leseberechtigung
  S_IWGRP 00020 Gruppe hat Schreibberechtigung
  S_IXGRP 00010 Gruppe hat Ausführungsberechtigung

  S_IRWXO 00007 andere (nicht in der Gruppe) haben gelesen, geschrieben und
       Ausführungsberechtigung
  S_IROTH 00004 andere haben Leseberechtigung
  S_IWOTH 00002 andere haben Schreibberechtigung
  S_IXOTH 00001 andere haben Ausführungsberechtigung

• st_nlink: Anzahl der Hardlinks
• st_uid: Die ID des Benutzers, dem diese Datei gehört
• st_gid: Die Gruppen-ID des Benutzers, dem diese Datei gehört
• st_rdev: spezielle Geräte-ID, wird nicht häufig verwendet
• st_size: die Größe der Datei
• st_blksize: unbekannt, was es macht
• st_blocks: Unbekannt, was es tut
• struct timespec st_atim: Zeitpunkt des letzten Zugriffs
• struct timespec st_mtim: Zeitpunkt der letzten Änderung
• struct timespec st_ctim: Zeitpunkt der letzten Statusänderung

Struktur timespec {
	__kernel_time_t tv_sec; /* Sekunden */Die Anzahl der Sekunden von der aktuellen Zeit bis 1.1.1970 00:00:00 long tv_nsec; /* Nanosekunden *//Nanosekunden (nicht sicher, von wo bis wohin)
};
1s Sekunde = 1000ms Millisekunde 1ms Millisekunde = 1000us Mikrosekunde 1us Mikrosekunde = 1000ns Nanosekunde

Pfadname: Dateiname

Rückgabewert: 0 für Erfolg; -1 für Fehler, und Fehler wird gesetzt

Beispiel: statbuf ist die Struktur stat, und wir können sehen, dass st_mode eine Dezimalzahl ist.

st_mode

Verwenden Sie gdb, um st_mode anzuzeigen, und stellen Sie fest, dass der zurückgegebene st_mode eine Dezimalzahl ist. Verwenden Sie den Befehl [p/o] (o steht für die Oktaldarstellung) von gdb, um die Dezimalzahl 33204 in die Oktalzahl [0100664] umzuwandeln. Die erste 0 steht für Oktal und die letzten drei Ziffern [100] stehen für den Dateityp. Aus der obigen Beschreibung können wir ersehen, dass [100] eine normale Datei darstellt und die letzten drei Ziffern [664] die Berechtigungen dieser Datei darstellen (dieser Benutzer: rw-, Gruppenbenutzer: rw-, andere Benutzer: r--). Aus st_mode können wir also den Dateityp und die Berechtigungseinstellungen ableiten (es werden nur 16 Bit verwendet, was wirklich Platz spart, super!)

st_uid

st_gid

Es wird festgestellt, dass st_uid und st_gid 1000 sind, aber wie entsprechen diese 1000 dem Benutzer? Beim Überprüfen der Datei /etc/passwd wird festgestellt, dass die für ys verwendeten uid und gid beide 1000 sind, also entsprechen sie sich.

Der Stat-Befehl entspricht der Stat-Funktion und die Ausführungsergebnisse sind wie folgt:

ys@ys-VirtualBox:~/lianxi1$ stat hallo
 Datei: hallo
 Größe: 11 Blöcke: 8 IO Blöcke: 4096 reguläre Datei
Gerät: 801h/2049d Inode: 3801352 Links: 2
Zugriff: (0764/-rwxrw-r--) Uid: ( 1000/ Jahre) Gid: ( 1000/ Jahre)
Zugriff: 2019-04-24 17:02:39.199461489 +0800
Ändern: 2019-04-24 16:54:16.407461489 +0800
Änderung: 2019-04-24 17:03:44.927461489 +0800

2. getpwuid-Funktion: Gibt die Zeile mit der angegebenen UID in der Datei /etc/passwd zurück und fügt die Informationen dieser Zeile in die Struktur passwd ein. Obwohl der Rückgabewert ein Zeiger ist, besteht keine Notwendigkeit, die Free-Funktion aufzurufen.

#include <sys/types.h>
#include <pwd.h>
Struktur passwd *getpwnam(const char *name);
Struktur passwd *getpwuid(uid_t uid);

Struktur passwd {
 char *pw_name; /* Benutzername */
 char *pw_passwd; /* Benutzerpasswort */
 uid_t pw_uid; /* Benutzer-ID */
 gid_t pw_gid; /* Gruppen-ID */
 char *pw_gecos; /* Benutzerinformationen */
 char *pw_dir; /* Home-Verzeichnis */
 char *pw_shell; /* Shell-Programm */
};

3. getgrgid-Funktion: Gibt die Zeile mit der angegebenen GID in der Datei /etc/group zurück und fügt die Informationen dieser Zeile in die Strukturgruppe ein. Obwohl der Rückgabewert ein Zeiger ist, besteht keine Notwendigkeit, die Free-Funktion aufzurufen.

#include <sys/types.h>
#include <grp.h>
Strukturgruppe *getgrnam(const char *name);
Strukturgruppe *getgrgid(gid_t gid);

Strukturgruppe {
 char *gr_name; /* Gruppenname */
 char *gr_passwd; /* Gruppenpasswort */
 gid_t gr_gid; /* Gruppen-ID */
 char **gr_mem; /* NULL-terminiertes Array von Zeigern
        an die Namen der Gruppenmitglieder */
};

4. Funktion „Localtime“: Übergeben Sie st_mtim.tv_sec (die Anzahl der Sekunden von der aktuellen Zeit bis zum 1.1.1970, 00:00:00), das Sie aus der Funktion „Stat“ erhalten haben, um die Struktur tm zu erhalten. Obwohl der Rückgabewert ein Zeiger ist, besteht keine Notwendigkeit, die Free-Funktion aufzurufen.

#include <zeit.h>
Struktur tm * Ortszeit (const time_t * timep);
Struktur tm {
 int tm_sec; /* Sekunden (0-60) */
 int tm_min; /* Minuten (0-59) */
 int tm_hour; /* Stunden (0-23) */
 int tm_mday; /* Tag des Monats (1-31) */
 int tm_mon; /* Monat (0-11) */
 int tm_year; /* Jahr - 1900 */
 int tm_wday; /* Wochentag (0-6, Sonntag = 0) */
 int tm_yday; /* Tag im Jahr (0-365, 1. Jan. = 0) */
 int tm_isdst; /* Sommerzeit */
};

5. lstat-Funktion: Wenn stat auf einen Softlink stößt, wird es zur Quelldatei zurückverfolgt und durchdringt; lstat dringt nicht ein.

Beispiel: ls -l-Datei imitieren

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <pwd.h>//getpwuid
#include <stdlib.h>
#include <time.h>//lokale Zeit
#include <grp.h> //getgrgid

int main(int argc, char* argv[]){

 Struktur stat sbuf;
 //stat(argv[1], &sbuf);
 lstat(argv[1], &sbuf);

 char str[11] = {0};
 memset(str, '-', (Größe von str - 1));
 
 //Dateityp if(S_ISREG(sbuf.st_mode)) str[0] = '-';
 if(S_ISDIR(sbuf.st_mode)) str[0] = "d";
 if(S_ISCHR(sbuf.st_mode)) str[0] = 'c';
 if(S_ISBLK(sbuf.st_mode)) str[0] = 'b';
 wenn(S_ISFIFO(sbuf.st_mode)) str[0] = "p";
 if(S_ISLNK(sbuf.st_mode)) str[0] = "l";
 wenn(S_ISSOCK(sbuf.st_mode)) str[0] = 's';

 //Dateiberechtigungen für diesen Benutzer if(sbuf.st_mode & S_IRUSR) str[1] = 'r';
 wenn(sbuf.st_mode & S_IWUSR) str[2] = "w";
 wenn(sbuf.st_mode & S_IXUSR) str[3] = 'x';
 
 //Dateiberechtigungen der Gruppe dieses Benutzers if(sbuf.st_mode & S_IRGRP) str[4] = 'r';
 wenn(sbuf.st_mode & S_IWGRP) str[5] = "w";
 wenn(sbuf.st_mode & S_IXGRP) str[6] = 'x';
 
 //Dateiberechtigungen für andere Benutzer if(sbuf.st_mode & S_IROTH) str[7] = 'r';
 wenn(sbuf.st_mode & S_IWOTH) str[8] = "w";
 wenn(sbuf.st_mode & S_IXOTH) str[9] = 'x';

 char ymd[20] = {0};
 //Datum und Uhrzeit abrufen struct tm* tm = localtime(&sbuf.st_atim.tv_sec);
 sprintf(ymd, "%2d bis %2d %02d:%02d", tm->tm_mon + 1, tm->tm_mday,
	 tm->tm_Stunde + 1,tm->tm_Sek);
 
 //-rw-r--r-- 1 J J 134 25. April 09:21 st2.c
 printf("%s %ld %s %s %ld %s %s\n", str, sbuf.st_nlink,
	 getpwuid(sbuf.st_uid)->pw_name, getgrgid(sbuf.st_gid)->gr_name,
	 sbuf.st_size, ymd, argv[1]);
 gebe 0 zurück;
}

6. Zugriffsfunktion: Ermitteln Sie die Berechtigungen des Benutzers, der das Programm aufruft, für die angegebene Datei (lesbar? beschreibbar? ausführbar?)

#include <unistd.h>
int-Zugriff (const char *Pfadname, int-Modus);

Beispiel:

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

int main(int argc, char* argv[]){
 wenn (Zugriff(argv[1], R_OK) == 0)
 printf("lesen ok\n");
 wenn (Zugriff(argv[1], W_OK) == 0)
 printf("schreiben ok\n");
 wenn (Zugriff(argv[1], X_OK) == 0)
 printf("exe ok\n");
 wenn (Zugriff(argv[1], F_OK) == 0)
 printf("existiert\n");
}

Überprüfen Sie zunächst mit ls -l die Berechtigungen der Datei /usr/include/time.h. Die Ergebnisse sind wie folgt

ys@ys-VirtualBox:~/lianxi$ ls -l /usr/include/time.h
-rw-r--r-- 1 root root 10360 17. April 2018 /usr/include/time.h

Führen Sie das Beispielprogramm als Benutzer ys aus und zeigen Sie die Datei /usr/include/time.h an. Die Ergebnisse sind wie folgt. Da time.h dem Root-Benutzer gehört und für andere Benutzer [r--] ist, wird das folgende Ergebnis erzielt.

ys@ys-VirtualBox:~/lianxi$ ./ac /usr/include/time.h
lesen ok
existiert

Führen Sie es weiterhin mit dem Benutzer ys aus, fügen Sie aber sudo hinzu. Das Ergebnis ist wie folgt. Die Ergebnisse sind dieselben wie die des Root-Benutzers. Durch die Hinzufügung von sudo wurde der Root-Benutzer programmiert.

ys@ys-VirtualBox:~/lianxi$ sudo ./ac /usr/include/time.h
[sudo] Passwort für ys: 
lesen ok
schreib ok
existiert

7. Truncate-Funktion: Dateigröße kürzen und erweitern

#include <unistd.h>
#include <sys/types.h>
int truncate(const char *Pfad, off_t Länge);

Pfad: Datei
Länge:
Wenn die Länge größer als die ursprüngliche Dateigröße ist, wird die Dateigröße auf die Länge erweitert.
Wenn die Länge kleiner als die ursprüngliche Dateigröße ist, wird die Dateigröße auf die Länge gekürzt.

8. Linkfunktion: Erstellen Sie einen Hardlink

#include <unistd.h>
int link(const char *alterPfad, const char *neuerPfad);

Rückgabewert: Gibt 0 zurück, wenn erfolgreich, -1, wenn fehlgeschlagen, und legt errno fest.

9. Symlink-Funktion: Erstellen Sie einen Softlink

#include <unistd.h>
int symlink(const char *Ziel, const char *Linkpfad);

Rückgabewert: Gibt 0 zurück, wenn erfolgreich, -1, wenn fehlgeschlagen, und legt errno fest.

10. Readlink-Funktion: Suchen Sie die tatsächliche Datei, die dem Softlink entspricht, und fügen Sie den Dateinamen in den Puffer ein. Hinweis: Hardlinks funktionieren nicht.

#include <unistd.h>
ssize_t readlink(const char *Pfadname, char *buf, size_t bufsiz);

Rückgabewert: Bei Erfolg wird die Anzahl der in den Puffer geschriebenen Bytes zurückgegeben. Bei einem Fehler wird -1 zurückgegeben und errno festgelegt.

11. Verknüpfung aufheben-Funktion: Löscht Soft- und Hardlinks und kann auch Dateien löschen.

#include <unistd.h>
int unlink(const char *Pfadname);

Rückgabewert: Gibt 0 zurück, wenn erfolgreich, -1, wenn fehlgeschlagen, und legt errno fest.

Es gibt eine spezielle Verwendung: Der folgende geöffnete Code möchte eine Hallo-Datei erstellen und sie dann direkt mit unlink löschen, sie kann jedoch erfolgreich geschrieben werden, ret ist größer als 0 und nachdem das Programm ausgeführt wurde, wird festgestellt, dass die Hallo-Datei nicht erstellt wurde.

Fazit: Nach der Ausführung von „unlink“ ist der Zähler 0, aber es wird festgestellt, dass andere Prozesse immer noch auf diese Datei verweisen. Zu diesem Zeitpunkt wird diese Datei durch „unlink“ nicht gelöscht. Sie wird gelöscht, nachdem dieser Prozess beendet ist, sodass der folgende Schreibcode erfolgreich geschrieben werden kann.
Mit dieser Funktion können Sie Folgendes erreichen: Beim Online-Ansehen von Videos wird die Videodatei tatsächlich auf den lokalen Computer heruntergeladen (dann wird im Code die Verknüpfung aufheben verwendet). Nach dem Ansehen des Videos ist die Anzahl der Videodateien 0 und sie werden automatisch gelöscht, sodass Sie sich keine Sorgen machen müssen, dass das Video durchsickert.

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(){
 int fd = open("hallo", O_WRONLY | O_CREAT, 0666);
 Verknüpfung aufheben("hallo");
 int ret = schreiben(fd, "aaa", 4);
 wenn(ret > 0){
 printf("Schreiben OK\n");
 }
 
}

12. chown-Funktion: Ändern Sie den Benutzer und die Gruppe, zu der die Datei gehört

#include <unistd.h>
int chown(const char *Pfadname, uid_t-Eigentümer, gid_t-Gruppe);

Pfadname: Datei

Besitzer: Benutzer-ID (numerisch) /etc/passwd

group: Gruppen-ID (numerisch) /etc/group

Rückgabewert: 0 bei Erfolg, -1 bei Fehler.

13. Umbenennungsfunktion: Umbenennen

#include <stdio.h>
int umbenennen(const char *alterPfad, const char *neuerPfad);

oldpath: der ursprüngliche Dateiname oder das ursprüngliche Verzeichnis

newpath: neuer Dateiname oder neues Verzeichnis

Rückgabewert: 0 bei Erfolg, -1 bei Fehler.

14. getcwd-Funktion: Ruft das aktuelle Arbeitsverzeichnis ab

#include <unistd.h>
char *getcwd(char *buf, size_t Größe);

buf: aktuelles Arbeitsverzeichnis

Größe: Puffergröße

Rückgabewert: Gibt bei Erfolg das aktuelle Arbeitsverzeichnis zurück, bei Fehlschlag NULL.

15. chdir-Funktion: Ändern Sie das Arbeitsverzeichnis des Prozesses

#include <unistd.h>
int chdir(const char *Pfad);

Pfad: Zielarbeitsverzeichnis

Rückgabewert: 0 für Erfolg, -1 für Fehler

16. mkdir-Funktion: Erstellen Sie ein Verzeichnis

#include <sys/stat.h>
#include <sys/types.h>
int mkdir(const char *Pfadname, mode_t Modus);

Pfadname: Zielarbeitsverzeichnis Modus: Modus & ~umask & 0777 . Beachten Sie, dass Sie nicht per CD in dieses Verzeichnis wechseln können, wenn Sie nicht über die X-Berechtigungen verfügen. Rückgabewert: 0 für Erfolg, -1 für Fehler

17. rmdir-Funktion: Löschen Sie ein Verzeichnis. Das Verzeichnis muss leer sein, das heißt, es darf keine Dateien enthalten.

#include <unistd.h>
int rmdir(const char *Pfadname);

18. opendir-Funktion: Öffnen Sie ein Verzeichnis

#include <sys/types.h>
#include <dirent.h>
DIR *opendir(const char *name);

Name: Verzeichnisname

Rückgabewert: ein Zeiger auf den Verzeichnisstream

19. readdir-Funktion: Verzeichnis lesen

#include <sys/types.h>
#include <dirent.h>
DIR *opendir(const char *name);

dirp: der Rückgabewert der Opendir-Funktion

Rückgabewert: Dirent-Struktur, die als der oben erwähnte „Verzeichniseintrag“ verstanden werden kann. NULL bedeutet, dass bis zum Ende gelesen wurde oder ein Fehler aufgetreten ist. Anders als NULL bedeutet dies den Inhalt des Verzeichniseintrags.

20. closedir-Funktion: Verzeichnis schließen

#include <sys/types.h>
#include <dirent.h>
int closedir(DIR *dirp);

dirp: der Rückgabewert der Opendir-Funktion

21. Strerron-Funktion: Druckt die Textinformationen aus, die errno entsprechen.

#include <string.h>
char *strerror(int errnum);

Das Errnum-Makro wird in der Datei platziert: /usr/include/asm-generic/errno.h

Beispiel:

#include <string.h>
#include <stdio.h>
#include <asm-generic/errno.h> //EDEADLK
int main(){
 char* buf = strerror(EDEADLK);
 printf("%s\n", buf); // Ressourcen-Deadlock vermieden
}

22. dup- und dup2-Funktionen: Umleitung von Dateideskriptoren

#include <unistd.h>
int dup(int oldfd);
int dup2(int altesfd, int neuesfd);

dup: Ähnlich wie bei „open“ wird zuerst ein neuer Dateideskriptor geöffnet und der neue Dateideskriptor wird ebenfalls dorthin zeigen, wo oldfd hinzeigt. Gibt bei Erfolg den neu geöffneten Dateideskriptor zurück; bei Misserfolg -1.

dup2: Lösche zuerst den Zeiger auf newfd und lasse newfd dann auf die Stelle zeigen, auf die oldfd zeigt. Gib newfd zurück, wenn erfolgreich; gib -1 zurück, wenn fehlgeschlagen.

Beispiel: Rufen Sie printf zweimal auf. Das erste printf schreibt den Inhalt in die Datei; das zweite printf druckt den Inhalt auf dem Bildschirm.

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(){

 int oldfd = dup(STDOUT_FILENO);
 int fd = öffnen("www", O_WRONLY | O_CREAT, 0666);
 dup2(fd, STDOUT_FILENO);
 printf("aaaa\n");
 fflush(stdout);
 int ret = dup2(oldfd, STDOUT_FILENO);
 //int ret = dup2(oldfd, 6);
 //perror("dup2:");
 printf("reg:%d\n", ret);
 printf("aaaa\n");
 schließen(fd);
}

Dies ist das Ende dieses Artikels über die detaillierte Verwendung der Stat-Funktion und des Stat-Befehls in Linux. Weitere relevante Inhalte zu Linux-Stat-Funktionen und Stat-Befehlen finden Sie in den vorherigen Artikeln von 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, dass jeder 123WORDPRESS.COM in Zukunft unterstützen wird!