Programmiersprache C/C++

Zugriff auf das Dateisystem

rename

  #include <stdio.h>

  int rename(const char *oldname, const char *newname);

Rückgabewert:
Bei fehlerfreier Ausführung liefert rename den Wert 0 zurück. Ansonsten ist das Funktionsergebnis -1 und errno erhält einen der folgenden Werte:

  EACCES     Zugriff nicht gestattet
  ENOENT     Pfad/Datei nicht gefunden
  ENOTSAM    Ziel- und Quell-Laufwerk sind nicht identisch

  #include <stdio.h>

  int main(void)
  {
    char oldname[80], newname[80];

    printf("Umzubenennende Datei : ");
    gets(oldname);
    printf("Neuer Name           : ");
    gets(newname);

    if ( rename(oldname, newname) == 0 )
      printf("%s wurde umbenannt in %s\n", oldname, newname);
    else
      perror("rename");

    return 0;
  }

  rename: No such file or directory

remove

  #include <stdio.h>

  int remove(const char *filename);

Rückgabewert:
Bei fehlerfreier Ausführung liefert remove den Wert 0 zurück. Im Fehlerfall ist der Rückgabewert -1 und die globale Variable errno erhält einen der folgenden Werte:

  EACCES     Zugriff nicht gestattet
  ENOENT     Pfad/Datei nicht gefunden

  #include <stdio.h>

  int main(void)
  {
    char file[80];

    printf("Zu loeschende Datei: ");
    gets(file);

    if ( remove(file) == 0 )
      printf("Datei %s geloescht\n", file);
    else
      perror("remove");

    return 0;
  }

stat

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

  int stat(const char *path, struct stat *info);

Die Struktur vom Typ stat besitzt folgenden Aufbau:

  struct stat {
    time_t    st_atime;      /* Datum des letzten Zugriffs */
    time_t    st_ctime;      /* Datum der letzten Statusänderung */
    dev_t     st_dev;        /* Gerätenummer */
    gid_t     st_gid;        /* Gruppennummer */
    ino_t     st_ino;        /* i-node Nummer */
    mode_t    st_mode;       /* Dateiattribute */
    time_t    st_mtime;      /* Datum der letzten Modifikation */
    nlink_t   st_nlink;      /* Anzahl der Dateiverweise (links) */
    off_t     st_size;       /* Dateigröße in Byte */
    off_t     st_blksize;    /* Blockgröße in Byte */
    uid_t     st_uid;        /* Eigentümernummer */
    dev_t     st_rdev;       /* Geräteidentifikationsnummer */
  };

Beispiel:

  #include <stdio.h>
  #include <time.h>
  #include <sys/types.h>
  #include <sys/stat.h>

  int main(int argc, char *argv[])
  {
    struct stat s;

    stat(argv[0], &s);
    printf("%-40s : %s\n", "Dateiname", argv[0]);
    printf("%-40s : %d\n", "Dateilaenge", s.st_size);
    printf("%-40s : %ud\n", "Dateiattribute", s.st_mode);
    printf("%-40s : %d\n", "Eigentuemer", s.st_uid);
    printf("%-40s : %d\n", "Gruppe", s.st_gid);
    printf("%-40s : %s\n", 
           "Datum der letzten Modifikation", ctime(&s.st_mtime));
    printf("%-40s : %s\n", 
           "Datum der letzten Statusaenderung", ctime(&s.st_ctime));
    printf("%-40s : %s\n", 
           "Datum des letzten Lesezugriffs", ctime(&s.st_atime));

    return 0;
  }

chmod

  #include <sys/stat.h>    oder    #include <io.h>

  int chmod(const char *path, int amode);

amode kann eine (oder beide) der in sys/stat.h definierten symbolischen Konstanten enthalten.
Die Zugriffsmöglichkeiten hängen vom verwendeten Betriebssystem ab.

Für amode kann z.B. angegeben werden:

  S_IWRITE    Schreiben erlaubt
  S_IREAD     Lesen erlaubt
  S_IEXEC     Ausführen erlaubt bzw. Verzeichnis durchsuchen erlaubt

  S_IREAD | S_IWRITE

  EACCES     Zugriff nicht erlaubt
  ENOENT     Pfad/Datei nicht gefunden

  #include <stdio.h>
  #include <stdlib.h>
  #include <io.h>
  #include <sys/stat.h>

  int main(void)
  {
    char filename[64];
    struct stat stbuf;
    int amode;

    printf("Dateiname : ");
    scanf("%s", filename);
    if ( stat(filename, &stbuf) != 0 ) {
      perror("Kein Zugriff auf Datei-Informationen moeglich");
      exit(1);
    }
    
    if ( stbuf.st_mode & S_IWRITE ) {
      printf("Neuer Modus: read-only\n");
      amode = S_IREAD;
    }
    else {
      printf("Neuer Modus: read-write\n");
      amode = S_IREAD | S_IWRITE;
    }
  
    if ( chmod(filename, amode) != 0 )
    {
      perror("Dateimodus konnte nicht veraendert werden");
      exit(1);
    }

    return 0;
  }

access

  #include <io.h>

  int access(const char *filename, int amode);

  06	Prüfung auf "Lesen und Schreiben erlaubt"
  04	Prüfung auf "Lesen erlaubt"
  02	Prüfung auf "Schreiben erlaubt"
  01	Prüfung auf "Ausführung erlaubt"
  00	Prüfung auf "Datei existiert"

Rückgabewert:
Ist der durch amode angegebene Zugriff erlaubt, so liefert access den Wert 0 zurück. Ansonsten ist der Rückgabewert -1 und die globale Variable errno wird auf einen der folgenden Werte gesetzt:

  ENOENT    Pfad oder Datei nicht vorhanden
  EACCES    Datei vorhanden, aber Zugriff nicht erlaubt

getcwd

  #include &stdlib.h>         oder    #include <dir.h>

  char *getcwd(char *buf, int buflen);

Rückgabewert:
getcwd liefert folgende Werte zurück:

• Ist buf bei der Eingabe ungleich NULL, wird bei fehlerfreier Ausführung buf, im Fehlerfall NULL zurückgeliefert.
• Ist buf bei der Eingabe gleich NULL, liefert getcwd bei fehlerfreier Ausführung einen Zeiger auf den reservierten Puffer zurück.

  ENODEV    Gerät nicht bereit/nicht vorhanden
  ENOMEM    Nicht genug Platz im Hauptspeicher (buf gleich NULL)
  ERANGE    Verzeichnisname länger als buflen (buf ungleich NULL)

  #include <stdio.h>
  #include <stdlib.h>      /* oder andere Header-Datei */
 
  #define BUFSIZE 200

  int main(void)
  {
    char buffer[BUFSIZE];

    getcwd(buffer, BUFSIZE);
    printf("Das aktuelle Verzeichnis ist : %s\n", buffer);

    return 0;
  }

mkdir

  #include <dir.h>                oder  #include <direct.h>
                                     oder  #include <sys/stat.h>

  int mkdir(const char *path);                           /* DOS  */
  int mkdir(const char *path, const int filemode);       /* Unix */

Rückgabewert:
mkdir liefert den Wert 0 zurück, wenn das neue Verzeichnis erzeugt werden konnte. Wenn ein Fehler auftritt, so ist der Rückgabewert -1 und die globale Variable errno wird auf einen der beiden folgenden Werte gesetzt:

  EACCES    Zugriff nicht gestattet
  ENOENT    Datei oder Verzeichnis nicht gefunden

  #include <stdio.h>
  #include <dir.h>
  #include <stdlib.h>
  #include <dir.h>      /*  oder  #include <direct.h>  */

  #define DIRNAME "testdir.$$$"

  int main(void)
  {
    int stat;

  #ifdef __MSDOS__
    stat = mkdir(DIRNAME);
    #define CMD "COMMAND.COM"
  #else  /* Annahme: Unix */
    stat = mkdir(DIRNAME, 777);
    #define CMD "ksh"
  #endif

    if ( !stat )
      printf("Verzeichnis angelegt\n");
    else {
      printf("Verzeichnis kann nicht angelegt werden\n");
      exit(1);
    }

    printf("Temporaerer Wechsel zum Kommando-Interpreter\n");
    printf("Pruefen Sie, ob das Verzeichnis angelegt wurde\n");
    printf("Geben Sie anschliessend den Befehl exit\n");
    system(CMD);

    stat = rmdir(DIRNAME);
    if ( !stat )
      printf("\nVerzeichnis geloescht\n");
    else {
      perror("\nVerzeichnis kann nicht geloescht werden\n");
      exit(1);
    }

    return 0;
  }

rmdir

  #include <dir.h>

  int rmdir(const char *path);

chdir

  #include <dir.h>

  int chdir(const char *path);

#include <stdio.h>
#include <stdlib.h>
#include <dir.h>

char old_dir[MAXDIR];
char new_dir[MAXDIR];

int main(void)
{
   if (getcurdir(0, old_dir))
   {
      perror("getcurdir()");
      exit(1);
   }
   printf("Current directory is: \\%s\n", old_dir);

   if (chdir("\\"))
   {
      perror("chdir()");
      exit(1);
   }

   if (getcurdir(0, new_dir))
   {
      perror("getcurdir()");
      exit(1);
   }
   printf("Current directory is now: \\%s\n", new_dir);

   printf("\nChanging back to original directory: \\%s\n", old_dir);
   if (chdir(old_dir))

   {
      perror("chdir()");
      exit(1);
   }

   return 0;
}

Zurück zum Menü
Zurück zur vorigen Seite Weiter zur nächsten Seite

---

P. Böhme, 10.03.1996