• Navigation überspringen
  • Zur Navigation
  • Zum Seitenende
Organisationsmenü öffnen Organisationsmenü schließen
Friedrich-Alexander-Universität Lehrstuhl für Informatik 4 (Systemsoftware)
  • FAUZur zentralen FAU Website
  1. Friedrich-Alexander-Universität
  2. Technische Fakultät
  3. Department Informatik
Suche öffnen
  • English
  • Campo
  • StudOn
  • FAUdir
  • Stellenangebote
  • Lageplan
  • Hilfe im Notfall
  1. Friedrich-Alexander-Universität
  2. Technische Fakultät
  3. Department Informatik
Friedrich-Alexander-Universität Lehrstuhl für Informatik 4 (Systemsoftware)
Menu Menu schließen
  • Lehrstuhl
    • Team
    • Aktuelles
    • Kontakt und Anfahrt
    • Leitbild
    • 50-jähriges Jubiläum
    Portal Lehrstuhl
  • Forschung
    • Forschungsbereiche
      • Betriebssysteme
      • Confidential Computing
      • Eingebettete Systemsoftware
      • Verteilte Systeme
    • Projekte
      • AIMBOS
      • BALu
      • BFT2Chain
      • DOSS
      • Mirador
      • NEON
      • PAVE
      • ResPECT
      • Watwa
    • Projektkampagnen
      • maRE
    • Seminar
      • Systemsoftware
    Portal Forschung
  • Publikationen
  • Lehre
    • Sommersemester 2025
      • Applied Software Architecture
      • Ausgewählte Kapitel der Systemsoftware
      • Betriebssystemtechnik
      • Projekt angewandte Systemsoftwaretechnik
      • System-Level Programming
      • Systemnahe Programmierung in C
      • Systemprogrammierung 1
      • Verteilte Systeme
    • Wintersemester 2024/25
      • Betriebssysteme
      • Middleware – Cloud Computing
      • Systemprogrammierung 2
      • Verlässliche Echtzeitsysteme
      • Virtuelle Maschinen
      • Web-basierte Systeme
    Portal Lehre
  • Examensarbeiten
  1. Startseite
  2. Extern

Extern

Bereichsnavigation: Lehre
  • Systemnahe Programmierung in C (für Wiederholer)
    • SPiCboard
      • Prüfung
        • Evaluation
          • Linux libc-Doku
            • Intern

            Linux libc-Doku

            Files | Functions
            File System

            Files

            file  dirent.h
             
            file  stdio.h
             
            file  stat.h
             
            file  types.h
             

            Functions

            DIR * opendir (const char *name)
             Open a directory. More...
             
            int closedir (DIR *dirp)
             Close a directory. More...
             
            struct dirent * readdir (DIR *dirp)
             Read an entry of a directory. More...
             
            FILE * fopen (const char *pathname, const char *mode)
             Open a file. More...
             
            int fclose (FILE *fp)
             Close a file. More...
             
            int stat (const char *path, struct stat *buf)
             Retrieve metadata of a file. More...
             
            int lstat (const char *path, struct stat *buf)
             Retrieve metadata of a file. More...
             

            Detailed Description

            Checking whether a regular file exists, open it, and close it:

            char *file = "./testfile";
            // get file metadata
            struct stat sbuf;
            if (lstat(file, &sbuf) == -1){
            perror("lstat");
            exit(EXIT_FAILURE);
            }
            // check file type
            if (!S_ISREG(sbuf.st_mode)) {
            fprintf(stderr, "%s is not a regular file.", file);
            exit(EXIT_FAILURE);
            }
            // open file
            FILE *fd = fopen(file, "r+");
            if (fd == NULL) {
            perror("fopen");
            exit(EXIT_FAILURE);
            }
            // use file
            // [...]
            // close file, check for errors (like full disk)
            if (fclose(fd) != 0) {
            perror("fclose");
            exit(EXIT_FAILURE);
            }
            fclose
            int fclose(FILE *fp)
            Close a file.
            stat
            int stat(const char *path, struct stat *buf)
            Retrieve metadata of a file.
            fopen
            FILE * fopen(const char *pathname, const char *mode)
            Open a file.
            lstat
            int lstat(const char *path, struct stat *buf)
            Retrieve metadata of a file.
            perror
            void perror(const char *s)
            Print an error message.
            fprintf
            int fprintf(FILE *stream, const char *format,...)
            Print formatted data to stream.
            exit
            void exit(int status)
            Terminate process.

            Iterating over all entries of a directory. Be aware, that readdir() also returns hidden files (starting with a .) including the two entries pointing to the current directory (.) and the parent directory (..).

            const char *path = "test/";
            // open directory
            DIR *dir = opendir(path);
            if (dir == NULL) {
            perror("opendir");
            exit(EXIT_FAILURE);
            }
            // iterate over directory entries
            struct dirent *dirent;
            while (errno = 0, (dirent = readdir(dir)) != NULL) {
            printf("%s\n", dirent->d_name);
            }
            if (errno != 0) {
            perror("readdir");
            exit(EXIT_FAILURE);
            }
            // close directory
            closedir(dir);
            errno
            int errno
            Error code set by various library functions.
            opendir
            DIR * opendir(const char *name)
            Open a directory.
            readdir
            struct dirent * readdir(DIR *dirp)
            Read an entry of a directory.
            closedir
            int closedir(DIR *dirp)
            Close a directory.
            printf
            int printf(const char *format,...)
            Print formatted data to stdout

            Function Documentation

            DIR* opendir ( const char *  name)

            The opendir() function opens a directory stream according to name. The stream is positioned at the first entry of the directory. Opened directories must be closed by closedir().

            Parameters
            namename of the directory to be opened
            Return values
            DIR*on success
            NULLon error, errno is set
            int closedir ( DIR *  dirp)

            A directory opened by the opendir() function, can be closed by the closedir() function, which frees all allocated resources.

            We do not expect error handling when closing directories, so simply do:

            closedir(dir);
            Parameters
            dirpdirectory stream to be closed
            struct dirent* readdir ( DIR *  dirp)

            The readdir() function reads the next entry from an opened directory stream pointed to by dirp. It allocates a struct dirent structure and returns a pointer to the allocated structure containing the information about the next directory entry. The caller of readdir() must not provide (or free) memory for the struct dirent structure.

            readdir() returns NULL if an error occurs or if the end of the directory stream is reached. To be able to distinguish these two events, a caller must set the errno variable to 0 before each call of readdir(). If errno is still 0 after readdir() returned NULL the end of the directory stream has been reached, otherwise an error has occurred.

            The struct dirent contains information about a directory entry. The most important information are the inode number and the name of the entry:

            struct dirent {
            ino_t d_ino; // Inode number
            [...]
            char d_name[256]; // Null-terminated filename
            };
            Parameters
            dirpdirectory stream to read next entry from
            Return values
            dirent*pointer to the next directory entry
            NULLon error (errno is set) or if the end of the directory stream is reached
            FILE* fopen ( const char *  pathname,
            const char *  mode 
            )

            The fopen() (file open) function opens the file at pathname with the mode as specified in mode. Opened files must be closed by fclose().

            The path in pathname can specify a relative (based on the current working directory) or an absolute path.

            Valid file modes are:

            Mode Description
            r read only
            r+ read and write
            w write only, create file if it does not exist yet
            w+ read and write file, create file if it does not exist yet
            a write only, append only, create file if it does not exist yet
            a+ write append only, read from beginning only, create file if it does not exist yet
            Parameters
            pathnamepath to file
            modefile mode
            Return values
            FILE*on success
            NULLon error, errno is set
            int fclose ( FILE *  fp)

            A file opened by the fopen() function, can be closed with the fclose() (file close) function, which writes all remaining buffered operations to the file and frees all allocated resources.

            Parameters
            fpfile stream to be closed
            Return values
            0on success
            EOFon error, errno is set
            int stat ( const char *  path,
            struct stat *  buf 
            )

            The stat() function retrieves information about the file pointed to by path. If path is a symbolic link, stat() returns information about the underlying file instead of the link itself. Be aware that the caller is responsible to provide the memory for the struct stat structure pointed to by buf!

            The struct stat contains, amongst others, the following information:

            struct stat {
            [...]
            ino_t st_ino; // Inode number
            mode_t st_mode; // File type and mode
            nlink_t st_nlink; // Number of hard links
            uid_t st_uid; // User ID of owner
            gid_t st_gid; // Group ID of owner
            [...]
            off_t st_size; // Total size, in bytes
            [...]
            };

            The st_mode field encodes the file type and permissions. In order to check whether a file is regular file, a symbolic link, or a directory, some macros exist:

            struct stat buf;
            stat(pathname, &buf);
            [...] // error handling
            if (S_ISREG(buf.st_mode)) { printf("regular file"); }
            if (S_ISDIR(buf.st_mode)) { printf("directory "); }
            if (S_ISLNK(buf.st_mode)) { printf("link"); } // only with lstat()
            Parameters
            pathfile to be analyzed
            bufpointer to a buffer storing the retrieved information
            Return values
            0on success
            -1on error, errno is set
            int lstat ( const char *  path,
            struct stat *  buf 
            )

            The lstat() function retrieves information about the file pointed to by path. If path is a symbolic link, lstat() returns information about the link itself instead of the underlying file. Be aware that the caller is responsible to provide the memory for the struct stat structure pointed to by buf!

            For more details see the stat() function.

            Parameters
            pathfile to be analyzed
            bufpointer to a buffer storing the retrieved information
            Return values
            0on success
            -1on error, errno is set
            Friedrich-Alexander-Universität
            Erlangen-Nürnberg

            Schlossplatz 4
            91054 Erlangen
            • Impressum
            • Datenschutz
            • Barrierefreiheit
            • Facebook
            • RSS Feed
            • Xing
            Nach oben