5. Dateioperationen. Tafelübung zu BSRvS1. Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware. Lehrstuhl für Informatik 12 TU Dortmund

Transkript

1 Tafelübung zu BSRvS1 5. Dateioperationen Olaf Spinczyk Arbeitsgruppe Eingebettete Systemsoftware Lehrstuhl für Informatik 12 TU Dortmund 1

2 Agenda Besprechung Aufgabe 4: Speicherverwaltung Aufgabe 5: Dateioperationen Öffnen/Lesen/Schreiben von Dateien/Verzeichnissen Syscall-Wrapper (open/close/write/read) libc-abstraktion Dateien (fopen/fclose/fwrite/fread) Verzeichnisse (opendir/readdir/closedir) Suchen von Strings Durchsuchen von Dateien Rechnen mit Zeigern BSRvS1: Übung 05 Dateioperationen 2

3 Besprechung Aufgabe 3 Foliensatz Besprechung BSRvS1: Übung 05 Dateioperationen 3

4 Arbeiten mit Dateien Alles unter Linux/Unix wird auf Dateien abgebildet viele verschiedene Dateitypen (Geräte, Sockets,...) Typische Dateioperationen sind Öffnen/Lesen/Schreiben/Schließen Unter Linux mehrere Möglichkeiten Syscall-Wrapper der C-Bibliothek ( low-level ), z.b. open(2) int open(const char *path, int flags) syscall( NR_open, path, flags) keine Abstraktion, sondern direkte Umsetzung in Systemcall Abstrakte Stream Schnittstelle der C-Bibliothek ( high-level ), z.b. fopen(3) FILE* fopen(const char *path, const char *mode) Abstraktion von Filedeskriptor Stream (FILE*) open(path, flags) BSRvS1: Übung 05 Dateioperationen 4

5 Low-Level Dateioperationen Öffnen von Dateien mit open(2) int open(const char *path, int flags) gibt einen Dateideskriptor zurück, der für die anderen Funktionen verwendet wird Lesen aus Dateien mit read(2) ssize_t read(int fd, void *buf, size_t count) Schreiben in Dateien mit write(2) ssize_t write(int fd, void *buf, size_t count) Schließen von offenen Dateien mit close(2) int close(int fd) Standardisiert u.a. in POSIX BSRvS1: Übung 05 Dateioperationen 5

6 Beispiel low-level #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> #define SIZE 64 int main(void) { int r_fd = 0, w_fd = 0; ssize_t r_bytes = 0, w_bytes = 0; char buf[size] = {0}; /* Datei zum Lesen öffnen */ r_fd = open( /tmp/inputfile, O_RDONLY); if (r_fd == -1) { /*... Fehler... */ }; r_bytes = read(r_fd, buf, SIZE); /* SIZE Bytes aus der Datei lesen */ /* Ausgabedatei öffnen und leeren; nicht vorhanden? -> erzeugen! */ w_fd = open( /tmp/outputfile, O_CREAT O_WRONLY O_TRUNC); if (w_fd == -1) { /*... Fehler... */ }; w_bytes = write(w_fd, buf, r_bytes); /* gelesene Bytes schreiben */ } close(r_fd); close(w_fd); return 0; BSRvS1: Übung 05 Dateioperationen 6

7 C-Streams Abstrakter, plattformunabhängiger Kommunikationskanal zu einem Gerät einer einfachen Datei einem Prozess,... Interne Pufferung Blockweises Lesen höhere Verarbeitungsgeschwindigkeit Abstraktion vom eigentlichen Datenstrom Lesen und Zurückschreiben von Daten (fgetc(3), ungetc(3)) Unabhängiges Lesen und Schreiben im Datenstrom (an verschiedenen Positionen) Stream-Repräsentation durch struct FILE enthält Zeiger auf Lese-/Schreibpuffer, aktuelle Positionen, Undo- Informationen (in stdio.h definiert) definierte Standardstreams: stdin, stdout & stderr BSRvS1: Übung 05 Dateioperationen 7

8 High-Level Dateioperationen Öffnen von Dateien mit fopen(3) FILE *fopen(const char *path, const char *mode) Modi: r/r+ (lesen/+schreiben), w/w+ (schreiben/+lesen), a/a+ (anhängen/+lesen) (siehe Manpage) Lesen aus Dateien mit fread(3) size_t fread(void *buf, size_t size, size_t count, FILE *stream) Schreiben in Dateien mit fwrite(3) size_t fwrite(void *buf, size_t size, size_t count, FILE *stream) Schließen von offenen Dateien mit fclose(3) int fclose(file *stream) Im C-Standard enthalten, plattformunabhängig! BSRvS1: Übung 05 Dateioperationen 8

9 Beispiel High-Level #include <stdio.h> #define SIZE 64 int main(void) { FILE *r_file = NULL, *w_file = NULL; size_t r_bytes = 0, w_bytes = 0; char buf[size] = {0}; /* Datei zum Lesen öffnen */ r_file = fopen("/tmp/inputfilef", "r"); if (r_file == NULL) { /*... Fehler... */ } r_bytes = fread(buf, sizeof(char), SIZE, r_file); /* Ausgabedatei öffnen und leeren; nicht vorhanden? -> erzeugen! */ w_file = fopen("/tmp/outputfilef", "w"); if (w_file == NULL) { /*... Fehler... */ } /* gelesene Bytes schreiben */ w_bytes = fwrite(buf, sizeof(char), r_bytes, w_file); } fclose(r_file); fclose(w_file); return 0; BSRvS1: Übung 05 Dateioperationen 9

10 Dateieigenschaften und stat(2) Dateien unter Linux haben verschiedenste Eigenschaften Besitzer/Gruppe Größe Anzahl der belegten Blöcke Anlegezeitpunkt, letzter Zugriffs- und Änderungszeitpunkt Typ: Verzeichnis, Gerätedatei, (Symbolischer) Link, Named Pipe,... Abfrage dieser Eigenschaften mit stat(2) int stat(const char *path, struct stat *buf) Rückgabe der Werte in eine Struktur, Typ struct stat Dateityp kann über Makros abgefragt werden, z.b. S_ISREG(st_mode) = reguläre Datei S_ISDIR(st_mode) = Verzeichnis Benötigte Header: <sys/types.h>, <sys/stat.h>, <unistd.h> BSRvS1: Übung 05 Dateioperationen 10

11 Beispiel stat(2) #include <unistd.h> #include <sys/types.h> #include <sys/stat.h> #include <stdio.h> int main(void) { struct stat fileinfo = {0}; int retval = 0; retval = stat("/etc/passwd", &fileinfo); if (retval == -1) { /*... Fehler... */ }; printf("normale Datei: %d\n", S_ISREG(fileinfo.st_mode)); printf("verzeichnis : %d\n", S_ISDIR(fileinfo.st_mode)); printf("größe : %d\n", (int) fileinfo.st_size); /* Extraktion der Rechteinformationen aus st_mode (siehe manpage) */ printf("rechte : %o\n", fileinfo.st_mode & 0777); } return 0; BSRvS1: Übung 05 Dateioperationen 11

12 High-Level Verzeichnisoperationen Öffnen von Verzeichnissen mit opendir(3) DIR *opendir(const char *path) Auslesen der Verzeichnisinhalte mit readdir(3) struct dirent* readdir(dir *dir) Rückgabe = NULL alle Verzeichniseinträge gelesen, keine weiteren vorhanden oder Fehler sonst: in dirent.d_name steht der Name des Verzeichniseintrages Schließen von geöffneten Verzeichnissen mit closedir(3) int closedir(dir *dir) Benötigte Header: <sys/types.h>, <dirent.h> BSRvS1: Übung 05 Dateioperationen 12

13 Beispiel: Verzeichnis Auslesen #include <sys/types.h> #include <dirent.h> #include <stdio.h> int main(void) { int retval = 0, count = 0; DIR *dir = NULL; struct dirent *entry = NULL; dir = opendir("/tmp"); /* Verzeichnis öffnen, DIR-Zeiger erstellen */ if (!dir) { /*... Fehler... */ } /* jeder Aufruf liefert einen Eintrag, NULL -> Listenende */ while ((entry = readdir(dir))) { printf("eintrag %d: %s\n", ++count, entry->d_name); } printf("anzahl: %d\n", count); retval = closedir(dir); /* Verzeichnis wieder schließen */ if (retval == -1) { /*... Fehler... */ }; } return 0; BSRvS1: Übung 05 Dateioperationen 13

14 A5: Suchen von Strings in Dateien Beispiel: Wir suchen den String schwimmen in der Datei entchen.txt entchen.txt Alle meine Entchen schwimmen auf dem See, schwimmen auf dem See Köpfchen unters Wasser, Schwänzchen in die Höh. Einfacher Ansatz: Die Datei komplett in den Speicher laden und dann mit strstr durchsuchen (wie in der Aufgabe gefordert). char *buf = malloc(dateigroesse + 1); read(fd, buf, dateigroesse); buf[dateigroesse] = 0; /* Puffer Null-Terminieren! */ strstr(buf, schwimmen ); passt! Alle meine Entchen schwimmen auf dem See,\nschwimmen auf dem See\nKöpfchen unters Wasser,\nSchwänzchen in die Höh. strstr(3) kann den Speicher sequentiell durchsuchen BSRvS1: Übung 05 Dateioperationen 14

15 A5: Suchen von Strings in Dateien Beispiel: Wir suchen den String schwimmen in der Datei entchen.txt entchen.txt Alle meine Entchen schwimmen auf dem See, schwimmen auf dem See Köpfchen unters Wasser, Schwänzchen in die Höh. Einfacher Ansatz: Die Datei komplett in den Speicher laden und dann mit strstr durchsuchen (wie in der Aufgabe gefordert). char *buf = malloc(dateigroesse + 1); read(fd, buf, dateigroesse); buf[dateigroesse] = 0; /* Puffer Null-Terminieren! */ strstr(buf, schwimmen ); passt! Alle meine Entchen schwimmen auf dem See,\nschwimmen auf dem See\nKöpfchen unters Wasser,\nSchwänzchen in die Höh. strstr(3) kann den Speicher sequentiell durchsuchen BSRvS1: Übung 05 Dateioperationen 15

16 Suchen von Strings in Dateien(2) Einfacher Ansatz: Sehr einfach zu realisieren Je größer die Dateien, um so größer der benötigte Speicher Was tun bei sehr großen Dateien (mehrere GB)? Aber: bei der Suche wird immer nur ein kleiner Ausschnitt betrachtet, nie die ganze Datei gleichzeitig! Zweiter Ansatz: Schrittweises Einlesen der Datei in einen Speicherblock, der kleiner ist als die Dateigröße. Alle_meine_Entch passt! en_schwimmen_auf _ = Leerzeichen, Blockgröße: 16 Byte... Alle meine Entchen schwimmen auf dem See,\nschwimmen auf dem See\nKöpfchen unters Wasser,\nSchwänzchen in die Höh. men_auf_dem_see\n _dem_see,\nschwim So findet strstr den String nicht! BSRvS1: Übung 05 Dateioperationen 16

17 Suchen von Strings in Dateien(3) Blockbasierter Ansatz braucht weniger Speicher, aber es müssen Sonderfälle betrachtet werden: Das Vorkommen eines Suchstrings kann über mehr als einen Block verteilt sein strstr funktioniert nicht mehr. Der Suchstring ist größer als die verwendete Blockgröße u.u. Blockgröße an Suchstring anpassen? BSRvS1: Übung 05 Dateioperationen 17

18 Rechnen mit Zeigern Speicheradressen in Zeigern sind Zahlen, mit denen man Rechnen kann char *a, *b, *c, *d; char *buf = malloc(size); /* den Zeigern werden Adressen zugewiesen... */ a = buf + 0x10; /* a = Adresse von buf + 16 */ /*... mit denen man Rechnen kann */ int l1 = b-a; int l2 = c-b; int l3 = d-c;... l4 l1 l2 l3 a b c d BSRvS1: Übung 05 Dateioperationen 18