Öffnen, Lesen und Schreiben

Öffnen: open

#include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> int open(char *filename, int oflag, mode_t mode);

filename

Der Pfad und Dateiname der zu öffnenden Datei.

oflag

Dieser Parameter bestimmt, wie die Datei geöffnet wird. Es können mehrere Attribute verwendet werden, indem sie mit einander durch den senkrechten Strich geodert werden.

Konstante	Bedeutung
O_RDONLY	Datei nur zum Lesen öffnen
O_WRONLY	Datei nur zum Schreiben öffnen
O_RDWR	Datei zum Lesen und Schreiben öffnen
O_APPEND	Es wird ans Ende der Datei angehängt
O_CREAT	Erzeuge die Datei, wenn sie nicht existiert
O_EXCL	Exklusiver Zugriff

mode

Hier werden Schreib- und Leserechte angegeben, wie sie vom chmod bekannt sind.

Bei einem Fehler gibt open -1 zurück. Der Fehlercode befindet sich in der globalen Variablen errno. Im Erfolgsfall wird ein Dateihandle vom Typ int zurückgegeben, der von den Dateifunktionen benötigt wird, um die entsprechende Datei weiter zu bearbeiten.

Paralleles Überschreiben vermeiden

Die Kombination O_CREAT | O_EXCL ist wunderbar als Semaphore verwendbar. Da dies nur ein untrennbarer Aufruf ist, kann immer nur ein Prozess die Datei im Zugriff haben. Beispielsweise wird diese Technik vom Drucksystem verwendet, um zu vermeiden, dass zwei Prozesse gleichzeitig einen Eintrag in das Spoolverzeichnis schreiben. Dazu wird vor dem eigentlichen Schreiben versucht, eine Datei namens lock mit den oben angegebenen Parameter zu eröffnen. Der Aufruf misslingt, wenn bereits eine Datei existiert. Derjenige, der also diesen Aufruf erfolgreich durchführen kann, ist also der einzige Prozess im kritischen Bereich. Nach Ende der Arbeiten löscht er einfach wieder die Datei lock und läutet damit die nächste Runde ein.

creat()

int creat(const char *filename, mode_t mode);

int close(int fd);

Dateien schließen

Als Parameter nimmt close() das Dateihandle.

#include <unistd.h> int read(int filehandle, void *buffer, size_t length);

Parameter

Rückgabewert

Schreiben: write

#include <unistd.h> int write(int filehandle, void *buffer, size_t length);

Parameter

Rückgabewert

Standardein- und ausgabe

Filter

int zeichen; while (EOF != (zeichen=getc(stdin))) { // verändere die Eingabe in gewünschter Form putc(zeichen, stdout); }

Dass die Variable zeichen ein int und kein char ist, ist kein Versehen! Eine Variable vom Typ char hat nur Platz für genau ein Zeichen. Der Typ int hat dagegen einen größeren Wertebereich und kann damit zusätzliche Zustände, also auch Fehlerzustände, aufnehmen. Nur mit einem int ist das EOF (End Of File) zu erkennen.

#include <stdio.h> int getc(int DateiHandle); int getchar(void); int putc(int c, int DateiHandle); int putchar(int c); char * gets(char *s); int puts(char *s);

Die Funktion getchar entspricht der Funktion getc, bezieht sich aber immer auf stdin. Im Beispiel hätte man also auch getchar verwenden können. Gleiches gilt für putchar. Mit gets wird eine Zeile von der Standardeingabe gelesen und puts gibt eine Zeichenkette auf der Standardausgabe aus. Dabei hängt puts noch ein Zeilenvorschubzeichen an die Ausgabe an.

Will man innerhalb der Datei an einer bestimmten Stelle anfangen zu lesen, kann man mit dem Aufruf lseek() an eine anzugebende Stelle in der Datei springen.

int lseek(int filehandle, off_t offset, int whence);

Der Parameter offset bestimmt die Position, ab der die nächste Operation beginnt. whence legt fest, von wo der Offset berechnet wird.

Konstante}	Bedeutung
SEEK_SET	ab Dateianfang
SEEK_CUR	ab der aktuellen Position
SEEK_END	ab Dateiende

Dateien mit Löchern

Datei duplizieren: dup

#include <unistd.h> int dup(int oldfd);

Diese Funktion gibt ein Dateihandle zurück, der auf die gleiche Datei zeigt. Auf diese Weise ist es beispielsweise möglich an zwei verschiedenen Stellen gleichzeitig in einer Datei zu arbeiten, da jedes Handle seinen eigenen Positionszeiger besitzt. Ist es notwendig, dass das Handle eine bestimmte Nummer hat, benötigt man dup2.

#include <unistd.h> int dup2(int oldfd}, int dupfd);

stat() und fstat()

#include <sys/types.h> #include <sys/stat.h> int stat(char *path, struct stat *buffer); int fstat(int filehandle, struct stat *buffer);

Die Ergebnisse finden sich in der Variablen von Typ stat, auf die der Parameter buffer zeigt. Die Definition der Struktur stat lautet:

struct stat { dev_t st_dev /* (P) Device, auf dem die Datei liegt */ ushort st_ino /* (P) Inode-Nummer */ ushort st_mode /* (P) Dateityp */ short st_nlink /* (P) Anzahl der Links der Datei */ ushort st_uid /* (P) Eigner-ID (uid) */ ushort st_gid /* (P) Gruppen-ID (gid) */ dev_t st_rdev /* Major- und Minornumber, falls Device */ off_t st_size /* (P) Größe in Byte */ time_t st_atime /* (P) Zeitpunkt letzter Zugriffs */ time_t st_mtime /* (P) Zeitpunkt letzte Änderung */ time_t st_ctime /* (P) Zeitpunkt letzte Statusänderung */ };

Die Bestandteile dieser Struktur können sich je nach System unterscheiden. Die mit (P) gekennzeichneten Elemente sind aber zwingend von POSIX vorgeschrieben.

st_dev und st_ino

st_mode

Zugriffsrecht ermitteln

access()

#include <unistd.h> int access(const char *pathname}, int mode);

An den Parameter mode können folgende Konstanten übergeben werden:

Konstante}	Bedeutung
F_OK	Existenz der Datei
R_OK	Prozess darf lesen
W_OK	Prozess darf schreiben
X_OK	Prozess darf die Datei ausführen

Zugriffsrechte ändern

#include <sys/stat.h> int chmod(const char *pathname}, mode_t mode); int fchmod(int fd}, mode_t mode);

chmod()

Besitzer und Gruppe ändern

#include <sys/stat.h> int chown(char *pathname}, uid_t user, gid_t group); int fchown(int fd}, uid_t user, gid_t group);

chown()

Maske für die Rechte neuer Dateien: umask

#include <sys/stat.h> int umask(int mask);

Dateisystem muss Sperren erlauben

Sperren nach POSIX

#include <fcntl.h> #include <unistd.h> #include <sys/types.h> fcntl(int filehandle, int command, struct flock *sperre);

Der Parameter command gibt die Funktion an und kann folgende Werte annehmen:

Konstante	Bedeutung
F_GETLK	Ermittle, ob eine Sperre gesetzt ist
F_SETLK	Eine Sperre setzen oder Fehler zurückgeben
F_SETLKW	Eine Sperre setzen oder warten

Die Elemente der Struktur flock geben die näheren Informationen über die Sperre an.

Element}	Wert	Bedeutung
l_type	F_WRLCK	exklusiv
	F_RDLCK	geteilt, verhindere Schreibzugriff
	F_UNLCK	Sperre aufheben
l_whence	SEEK_SET	vom Dateianfang
	SEEK_CUR	ab aktueller Dateiposition
	SEEK_END	vom Dateiende
l_start		Offset des Sperrbereichs
l_len		Länge des Bereichs, bei 0 bis Dateiende

Das flock-Element l_pid liefert bei F_GETLK den Prozess, der die Sperre gesetzt hat.

Beispielprogramm one

/* Sperren() aus one.c */ #include <unistd.h> #include <stdio.h> int Sperren(char *name) { long data; int fh; struct flock sperre; fh = open(name, O_RDWR, 0644); if (0<fh) { sperre.l_type = F_WRLCK; sperre.l_whence = SEEK_SET; sperre.l_start = 5*sizeof(data); sperre.l_len = sizeof(data); if (0> fcntl(fh, F_SETLK, &sperre)) { perror("Versuche die erste Sperre"); } getchar(); /* nun ist der Satz gesperrt */ sperre.l_type = F_UNLCK; if (0> fcntl(fh, F_SETLK, &sperre)) { perror("Löse die erste Sperre"); } close(fh); } else { perror("Kann Datei nicht öffnen"); } }

Beispielprogramm two

int Sperren(char *name) { long data; int fh; struct flock sperre; fh = open(name, O_RDWR, 0644); if (0<fh) { puts("two: vor lock"); sperre.l_type = F_WRLCK; sperre.l_whence = SEEK_SET; sperre.l_start = 5*sizeof(data); sperre.l_len = sizeof(data); if (0> fcntl(fh, F_SETLKW, &sperre)) { perror("Versuche die zweite Sperre"); } puts("two: nach lock"); getchar(); sperre.l_type = F_UNLCK; if (0> fcntl(fh, F_SETLKW, &sperre)) { perror("Löse die zweite Sperre"); } close(fh); } }

Verhaltenstest

Versuche die erste Sperre: Resource temporarily unavailable

Ganz offensichtlich blockiert one nicht, sondern bekommt eine Fehlerrückgabe durch fcntl().

Wer blockiert hier?

int Sniff(char *name) { long data; int fh; struct flock sperre; fh = open(name, O_RDWR, 0644); if (0<fh) { sperre.l_type = F_WRLCK; sperre.l_whence = SEEK_SET; sperre.l_start = 5*sizeof(data); sperre.l_len = sizeof(data); if (0> fcntl(fh, F_GETLK, &sperre)) { perror("Problem bei fcntl"); } printf("Prozess: %d\n", sperre.l_pid); close(fh); } }

#include <sys/file.h> int lockf(int fd, int cmd, off_t len);

Der Parameter cmd wird mit einer Konstanten besetzt, die die Funktion angibt.

F_LOCK

Setzt eine exklusive Sperre. Ist der Bereich bereits gesperrt, blockiert der Prozess. So ist gewährleistet, dass nur ein Prozess eine Sperre setzen kann.

F_TLOCK

wie F_LOCK wir ein Bereich exklusiv gesperrt. Bei einer bereits vorliegenden Sperre blockiert der Prozess aber nicht. Statt dessen gibt die Funktion einen Fehler zurück.

F_ULOCK

hebt die Sperre auf

F_TEST

Prüft, ob eine Sperre auf diesem Bereich liegt. Die Funktion gibt -1, wenn ein anderer Prozess die Sperre gesetzt hat. Der Rückgabewert 0 bedeutet, dass keine Sperre vorliegt oder die Sperre vom eigenen Prozess stammt.

flock

flock(int filehandle, int operation)

Der Parameter operation kann folgende Werte annehmen.