3.3.3 Filearbeit

• zur Ausgabe wurden printf bzw. putchar benutzt
• Eingaben wurden mit scanf bzw. getchar realisiert
• diese Bibliotheksfunktionen arbeiten mit der Standardausgabe (stdout) bzw. Standardeingabe (stdin)
• stdin und stdout sind im Normalfall mit dem Terminal verbunden
• Fileumlenkung ist möglich:

  kommando > outfile	lenkt Ausgabe von kommando in File outfile
  kommando < infile	erwartet Eingabe für kommando im File infile
  komm1   |  komm2	Ausgabe von komm1 wird Eingabe von komm2 (Pipe)

• in UNIX besitzen alle Files und Verzeichnisse Zugriffsrechte (rwx)
• UNIX-Zugriffsrechte (Lesen, Schreiben, Ausführen) werden sofort beim Anlegen eines Files/Verzeichnisses für drei Benutzerklassen vergeben (bestimmt durch umask)
• Eigentümer des Files/Verzeichnisses kann nachträglich die Zugriffsrechte erweitern oder einschränken (chmod)
• Eigentümer wird derjenige Nutzer der das File/Verzeichnis anlegt
• UNIX-Benutzerklassen: Eigentümer, Gruppenmitglieder, andere Nutzer
• andere Zugriffsrechte werden nicht berücksichtigt - AFS gehört nicht zum Standard-UNIX
• in AFS-Filesystemen werden zusätzlich allen Verzeichnissen sogenannte ACL's zugeordnet, die konkreten Nutzern bzw. Gruppen differenzierte Befugnisse erteilen können (fs la)
• in UNIX besteht kein prinzipieller Unterschied zwischen dem Zugriff auf (gewöhnliche) Files und dem Zugriff auf Geräte

BEISPIELE/b333a.c: #include <stdio.h> #define FILENAME "abcd" main() /* fopen / fclose */ { FILE *fpr; fpr=fopen(FILENAME,"w"); if(fpr == NULL) { perror("fopen"); /* Reaktion auf Fehler */ } fprintf(stderr,"Datei \"abcd\" wird angelegt\n"); fprintf(fpr,"Dieser TEXT wird ins File mit dem \n"); fprintf(fpr,"Namen %s geschrieben\n",FILENAME); if((fclose(fpr)) != 0) { perror("fclose"); /* Reaktion auf Fehler */ } }

• bevor ein File gelesen oder geschrieben werden kann, muss es geöffnet werden
• beim Öffnen wird eine logische Verbindung zwischen File und Programm hergestellt
• der Name des Files muss beim Öffnen benannt werden
• stdin, stdout und stderr sind bereits beim Start des Programms geöffnet (durch die Shell) --> das Öffnen im Nutzerprogramm ist nicht notwendig

  VERBATIM/b333a: #include <stdio.h> FILE *fopen(filename, type) char *filename, *type;

• Rückkehrwert: Zeiger auf Struktur des Typs FILE (Filepointer)
  ( der Strukturtyp FILE wird in stdio.h deklariert )
• der Filepointer bleibt dem File zugeordnet
• der Filepointer wird später allen Bibliotheksfunktionen zum Lesen, Schreiben, Positionieren, Schließen ... des Files als Argument übergeben
• filename ist ein Zeiger auf den Namen des Files
• type spezifiziert die Art des Zugriffs
• folgende Werte für type sind möglich:

  ``r``	lesen
  ``w``	(über-)schreiben bzw. erzeugen
  ``a``	anfügen bzw. erzeugen
  ``r+``	update, d.h. lesen und schreiben
  ``w+``	update, wenn File existiert --> löschen
  ``a+``	update, wenn File existiert --> fortschreiben

• die Bibliotheksfunktion fopen verwendet zum Öffnen des Files den Systemruf open bzw. create
• die Systemrufe können vom C-Programmierer auch direkt genutzt werden
• der Systemruf open liefert als Rückkehrwert einen Filedeskriptor (wird ein Element in der Struktur des Typs FILE)
• Filezugriff ist mit Bibliotheksfunktionen benutzerfreundlicher als mit Systemrufen

• erzeugt eine Nachricht in stderr

  VERBATIM/b333b: #include <stdio.h> void perror(s) const char *s;

• die Nachricht beschreibt den zuletzt aufgetretenen Fehler bei einem Systemruf oder einer Bibliotheks-Funktion
• Argument-String s wird vor der Nachricht ausgegeben (sinnvoll: Funktionsname)

• mit der Bibliotheksfunktion fclose wird ein File geschlossen (File schließen != File löschen)

  VERBATIM/b333c: #include <stdio.h> int fclose(stream); FILE *stream;

• beim Beenden des Programms werden alle offenen Files automatisch geschlossen
• innerhalb eines Programms kann nur eine begrenzte Anzahl Files gleichzeitig geöffnet sein
• Auch fclose liefert Rückkehrwert! Dieser sollte ausgewertet werden. Reicht z.B. beim Schreiben die Plattenkapazität nicht aus, wird das erst beim Schließen des Files bemerkt.

• neben fprintf existieren zahlreiche Bibliotheksfunktionen für das Schreiben in Files
• fwrite eignet sich z.B. gut zum Schreiben von Strukturen:

  VERBATIM/b333d: include <stdio.h> int fwrite(ptr, size, nitems, stream) char *ptr; int size, nitems; FILE *stream;

  FILE *fpt;
  ...
  struct p {
        char name[20];
        char vorname[20];
        int geb_jahr;
        char geschlecht;
        char anschrift[70];
  } person;
  ...
  i=fwrite(&person,sizeof(struct p),1,fpt);
  ...
  

• putc schreibt ein Zeichen in ein Ausgabefile

  VERBATIM/b333e: include <stdio.h> int putc(c, fpr) int c; FILE *fpr;

• Rückkehrwert: das ausgegebene Zeichen; im Fehlerfall EOF
• das auszugebende Zeichen c ist vom Typ int !

• getc liest ein Zeichen aus einem File

  VERBATIM/b333f: include <stdio.h> int getc(fpr) FILE *fpr;

• Rückkehrwert: nächstes Zeichen aus dem Datenstrom, sonst EOF

BEISPIELE/b333b.c: #include <stdio.h> main() /* Filekopieren mit Filedescriptor */ { void filecopy(); filecopy(stdin,stdout); } void filecopy(ifp, ofp) FILE *ifp, *ofp; { int c; while((c=getc(ifp)) != EOF) putc(c,ofp); }

• fgets wird zur zeilenweisen Eingabe benutzt

  VERBATIM/b333g: #include <stdio.h> char *fgets(s,n,fpr) char *s; int n; FILE *fpr;

• fgets überträgt maximal n-1 Zeichen in das Zeichenfeld s
• die Eingabe wird abgeschlossen, wenn das Zeichen Newline '\n' im Datenstrom auftritt
• das Zeichen Newline wird im Zeichenfeld abgelegt
• das Zeichenfeld wird mit '\0' abgeschlossen
• am Dateiende bzw. im Fehlerfall ist der Rückkehrwert NULL

BEISPIELE/b333c.c: #include <stdio.h> main() /* Zeilen lesen, mit Laengenangabe ausgeben */ { char zeile[80]; int i; while((i=getline(zeile,80)) != 0) printf("%2d %s\n",i,zeile); } int getline(line, max) /* eine Zeile lesen, Laenge liefern */ int max; char *line; { if((fgets(line,max,stdin)) == NULL) return 0; return(strlen(line)); }

BEISPIELE/b333d.c: /* Kopieren von Files zur Standardausgabe; Argumente sind Filenamen oder - fuer Standardeingabe */ #include <stdio.h> #define MAX 512 main(argc, argv) char **argv; { void copy(); register char **argp; register FILE *file; if (argc == 1) copy (stdin); else { argp=argv; while (--argc > 0) if ((*++argp)[0] == '-' && (*argp)[1]== '\0') copy(stdin); else if ((file = fopen(*argp, "r")) != NULL) { copy(file); fclose(file); } else fprintf(stderr, "%s: can't open %s\n", *argv, *argp); } } void copy(file) FILE *file; { char zf[MAX]; while ((fgets(zf,MAX,file)) != NULL) fputs(zf,stdout); }

• standardmäßig werden Files sequentiell gelesen/geschrieben
• für nachfolgende Lese- oder Schreiboperationen kann die Byteposition im File mit fseek eingestellt werden

  VERBATIM/b333h: #include <stdio.h> int fseek(fpr,offset,origin) FILE *fpr; long offset; int origin;

• offset (BEACHTE Typ long !) wird relativ zu origin eingestellt
• mögliche Angaben für origin sind:

  SEEK_SET = Dateianfang
  SEEK_CUR = aktuelle Position
  SEEK_END = Dateiende
  

• bei fehlerhafter Positionierung liefert fseek als Rückkehrwert -1
• Um Satz Nummer i aus einem File mit fester Satzstruktur (z.B die oben definierte Struktur person) zu lesen, kann man fseek so einsetzen:

int lies_satz(i)
int i;
{ FILE *fp;
  if((fp=fopen(...,"r")) == NULL) {/* Fehlerbehandlung */}
  i--;
  if((fseek(fp,(long)i*sizeof(struct p),SEEK_SET)) == -1) {
             /* Fehlerbehanulung */                       
  }
  if((fread(&person,sizeof(struct p),1,fp)) == 0) {
             /* Fehlerbehanulung */ 
  }
  fclose(fp);
}

• Statusinformationen zu einem File bereitstellen
• stat --> Bezugnahme über den Namen des Files
• fstat --> Bezugnahme mit Filedeskriptor ( --> nur geöffnete Files)
• File-Statusinformationen enthalten u.a.:
  • Filetyp (Verzeichnis, reguläres File, Specialfile, ...)
  • Filegröße
  • UID (Nutzer-Identifikationsnummer)
  • GID (Gruppen-Identifikationsnummer)
  • Zugriffsrechte
  • Zeitpunkt des letzten Zugriffs
  • Anzahl der Links

  VERBATIM/b333i: #include <sys/types.h> #include <sys/stat.h> int stat(filename,status) char *filename; struct stat *status; int fstat(fd, status) int fd; struct stat *status;

• die Struktur stat ist im Headerfile sys/stat.h deklariert

  VERBATIM/b333j: /* Status einer Datei beschreiben */ struct stat { dev_t st_dev; ino_t st_ino; mode_t st_mode; short st_nlink; uid_t st_uid; gid_t st_gid; .... off_t st_size; .... time_t st_mtime; .... };

• sys/stat.h enthält auch symbolische Konstanten, die die Auswertung der Statusbits erleichtern

BEISPIELE/b333e.c: #include <stdio.h> #include <sys/types.h> #include <sys/stat.h> main(argc,argv) /* Filestatus anzeigen */ int argc; char **argv; { struct stat buf; if(stat(argv[1],&buf) == -1) { perror("stat"); exit(1);} printf("Filename: %s \nUID: %ld\n",argv[1],buf.st_uid); printf("GID: %ld\n",buf.st_gid); if(buf.st_mode & S_IFDIR) printf("is dir\n"); /* klappt nur, wenn S_IFDIR genau 1 Bit belegt */ if((buf.st_mode & S_IWUSR)==S_IWUSR) printf("owner write\n"); /* besser */ if((buf.st_mode & S_IRGRP)==S_IRGRP) printf("group read\n"); if((buf.st_mode & S_IXOTH)==S_IXOTH) printf("other execute\n"); }