Wer sich mit File-Locking beschäftigt, der wird vermutlich auf zwei Möglichkeiten stoßen: die Funktion flock und Locking mit fcntl. Es gibt zwei wichtige Unterschiede zwischen diesen beiden Funktionen.
Locks, die mit flock erstellt wurden, werden bei einem fork an den Kind-Prozess weitergegeben. Es wird jedoch nicht der Lock kopiert, wenn durch fork oder dup der Filedescriptor dupliziert wird, denn jeder Filedescriptor auf die gelockte Datei enthält nur eine Referenz auf den selben Lock. Der Lock bleibt bestehen bis entweder alle Filedeskriptoren geschlossen sind, oder explizit eine Unlock-Operation auf einen Filedescriptor mit diesem Lock, egal in welchem Prozess, ausgeführt wird.
Mit fcntl erstellte Locks werden bei einem fork hingegen gar nicht weitergegeben. Der Lock gilt immer nur für den Prozess, der ihn erstellt hat. Außerdem wird ein Lock entfernt, wenn auch nur ein Filedescriptor der gelockten Datei geschlossen wird.
Der andere große Unterschied ist, dass nur Locking mit fcntl Posix-spezifiziert ist. Die Funktion flock hingegen ist eine BSD-Erfindung, die jedoch auch von Linux übernommen wurde. Andere Unixe, wie z.B. Solaris, unterstützen flock gar nicht.
Außerdem unterscheidet sich auch das Interface der beiden Funktionen deutlich. Mit fcntl hat man ein bisschen mehr Schreibarbeit, dafür ist es auch möglich nur einen Bereich einer Datei zu locken, wärend flock etwas primitiver ist.
Locking mit fcntl:
int fd = open(path, O_RDWR);
struct flock lock;
memset(&lock, 0, sizeof(struct flock));
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0;
fcntl(fd, F_SETLK, &lock);
Locking mit flock:
int fd = open(path, O_RDWR);
flock(fd, LOCK_EX);
Die Verlockung ist vielleicht groß, flock zu nutzen, wenn man nur schnell und einfach eine ganze Datei locken möchte. Ich würde aber empfehlen, immer fcntl zu nutzen, außer man möchte wirklich Locks mit mehreren Prozessen teilen.
Eine tar-Datei besteht immer aus 512 Bytes großen Blöcken. Jede Datei im Archiv hat einen Header-Block gefolgt von weiteren Blöcken für den Dateiinhalt. Verzeichnisse oder Links haben logischerweise keine Content-Blöcke sondern nur den Header-Block. Am Ende des Archivs werden dann zwei 512 Bytes Blöcke mit Null-Bytes angehängt, die das Ende markieren.
Der Header besteht fast nur aus Plain-Text, nur ein paar Null-Bytes kommen vor. Integer-Werte werden als Oktal-Strings gespeichert. Auch sind alle Felder des Headers an fixen Adressen, was das parsen vereinfacht. Eine Beschreibung des Headers findet sich auf der Open Group Webseite.
Da der Header nur begrenzt viel Platz hat, hat das Original UStar-Format (Unix Standard TAR) ein paar Limitierungen. Z.B. können Dateinamen oder Pfade nicht beliebig lang sein. Auch die Größe einzelner Dateien ist durch die spezielle Kodierung auf 8 Gb begrenzt. Erweiterungen dieses Formats, wie das neue POSIX Format pax oder auch GNU tar und star, haben diese Begrenzung nicht.
Wer tar-Dateien im alten UStar-Format in seinem eigenen Programm erstellen will, für den habe ich dieses Beispielprogramm, welches als Argument ein oder mehrere Dateipfade erwartet und dann eine tar-Datei daraus erstellt, die auf stdout ausgegeben wird.
Für den Zugriff auf Extended Attributes hat macOS die Syscalls listxattr, getxattr, setxattr und removexattr. Sie heißen genauso wie die Linux-Syscalls und funktionieren auch fast genauso, nur haben sie ein paar Parameter für Options mehr. Die Syscalls finden sich im Header sys/xattr.h.
Um den Inhalt eines Attributs zu erhalten, benutzen wir den Syscall getxattr:
ssize_t
getxattr(const char *path, const char *name, void *value, size_t size,
u_int32_t position,
int options);
Dabei gibt man den Dateipfad, den Namen des Attributs, einen Pointer auf einen Buffer sowie dessen Größe an. Wie im vorherigen Artikel erwähnt, haben macOS Extended Attributes keinen Namespace, daher ist name ein frei wählbarer Name. Mit value und size gibt man einen vorher allozierten Puffer und seine Größe an. Falls value NULL ist, wird von der Funktion nur die Länge des Inhalts zurück gegeben. Der Parameter position funktioniert nicht mit allen Typen von Attributen und sollte daher 0 sein. Der Parameter options kann abgesehn von 0 noch XATTR_NOFOLLOW oder XATTR_SHOWCOMPRESSION sein.
char *buf = malloc(1024);
ssize_t attrlen = ("file.txt", "myattribute", buf, 1024, 0, 0);
if(attrlen > 0) {
printf("myattribute: %.*s\n", (int)attrlen, buf);
}
Attribute hinzufügen oder verändern geht mit setxattr.
int setxattr(const char *path, const char *name, void *value, size_t size,
u_int32_t position,
int options);
position sollte auch hier wieder 0 sein. Bei den options gibt es wieder XATTR_NOFOLLOW und die interessanten Options XATTR_CREATE, um zu erzwingen, dass das Attribut nur gesetzt wird, falls es noch nicht existiert, oder XATTR_REPLACE, um nur den Inhalt eines bereits existierenden Attributs zu ändern.
char *value = "Hello World!";
setxattr("file.txt", "myattribute", value, strlen(value), 0, 0);
Alle existierenden Attribute auflisten geht mit listxattr.
ssize_t listxattr(const char *path, char *namebuf, size_t size, int options);
Dies schreibt in den vorher allozierten Buffer die Namen aller Attribute, getrennt durch ein 0-Byte. Hier findet sich ein Beispielprogramm, welches alle Attribute einer Datei auflistet.
Nach Teil 1 hier die Fortsetzung:
#include <stdio.h>
int main(int argc, const char* argv[printf("Hello, World!\n")]) {}
Gefunden hab ich das Beispiel hier.