Ein- und Ausgabe

ANSI-C definiert die plattformunabhängige Schnittstelle für den Dateizugriff basierend auf der Datenstruktur FILE. Intern werden selbstverständlich Dateideskriptoren und die Grundoperationen open, read, write, close verwendet.

`stdio.h`

Datenströme puffern

Datenstrom
#define	EOF		Symbol für Dateiende
#define	BUFSIZ		Puffergröße, meist zwischen 256 und 8192 Oktette
#define	FILENAME_MAX		Pfadnamen, meist bis zu 256 Zeichen
#define	FOPEN_MAX		Mindestens 8 gleichzeitig offene Dateien
#define	TMP_MAX		Mindestens 25 (POSIX) bzw. 10000 (XSI) temporäre Dateien
typedef	FILE		Datenstruktur mit Schreib-/Lesepuffer
extern FILE *	stdin		Standardeingabe
extern FILE *	stdout		Standardausgabe
extern FILE *	stderr		Standardfehlerausgabe
FILE *	tmpfile	(void)	Erzeugt eine temporäre Datei und löscht diese beim Schließen
FILE *	fopen	(const char * path, const char * mode)	Öffnet einen gepufferten Datenstrom
FILE *	freopen	(const char * path, const char * mode, FILE * stream)	Ändert den Zugriffsmodus eines bereits geöffneten Datenstroms
FILE *	fdopen	(int fd, const char * mode)	Öffnet einen Datenstrom anhand eines Dateideskriptors
FILE *	popen	(const char * command, const char * mode)	Öffnet Pipe zur Standardein- oder -ausgabe eines neuen Prozesses
FILE *	fmemopen	(void * buf, size_t max, const char * mode)	Operiert auf einem statischem Puffer
FILE *	open_memstream	(char ** ptr, size_t * sizeloc)	Operiert auf einem dynamisch wachsenden Puffer
int	fileno	(FILE * stream)	Liefert den einem Datenstrom zu Grunde liegenden Dateideskriptor
void	setbuf	(FILE * stream, char * buf)	Jubelt dem Datenstrom einen Puffer der Größe `BUFSIZ` unter
int	setvbuf	(FILE * stream, char * buf, int mode, size_t max)	Ändert Pufferungsmodus
void	setbuffer	(FILE * stream, char * buf, size_t max)	Jubelt dem Datenstrom einen Puffer beliebiger Größe unter
void	setlinebuf	(FILE * stream)	Verwendet zeilenweise Pufferung
int	ferror	(FILE * stream)	Prüft Fehlerstatus des Datenstroms
int	feof	(FILE * stream)	Prüft Erreichen des Endes des Datenstroms
void	clearerr	(FILE * stream)	Setzt den Fehlerstatus zurück
int	fflush	(FILE * stream)	Schreibt den Puffer hinaus
int	fclose	(FILE * stream)	Schließt den Datenstrom
int	pclose	(FILE * stream)	Schließt eine Pipe
Wahlfreier Zugriff
void	rewind	(FILE * stream)	Setzt Position auf den Dateianfang
long	ftell	(FILE * stream)	Liefert aktuelle Position
off_t	ftello	(FILE * stream)	Liefert aktuelle Position für große Dateien
int	fseek	(FILE * stream, long offset, int whence)	Setzt aktuelle Position
int	fseeko	(FILE * stream, off_t offset, int whence)	Setzt aktuelle Position für große Dateien
int	fgetpos	(FILE * stream, fpos_t * pos)	Bestimmt Position
int	fsetpos	(FILE * stream, fpos_t * pos)	Setzt Position
Lese- und Schreiboperationen
int	getc	( FILE * stream)	Liest Zeichen aus Datenstrom
int	getw	( FILE * stream)	Liest Integer aus Datenstrom
int	fgetc	( FILE * stream)	Liest nächstes Zeichen aus Datenstrom
int	putc	(int c, FILE * stream)	Schreibt Zeichen in Datenstrom.
int	putw	(int w, FILE * stream)	Schreibt Integer in Datenstrom.
int	fputc	(int c, FILE * stream)	Schreibt Zeichen in Datenstrom
int	ungetc	(int c, FILE * stream)	Schiebt Zeichen in Puffer zurück
char *	fgets	( char * buf, int size, FILE * stream)	Liest Zeile aus Datenstrom
int	fputs	(const char * buf, FILE * stream)	Schreibt Zeile in Datenstrom
size_t	fread	( void * ptr, size_t max, size_t nmemb, FILE * stream)	Liest blockweise aus Datenstrom
size_t	fwrite	(const void * ptr, size_t max, size_t nmemb, FILE * stream)	Schreibt Block in Datenstrom
ssize_t	getline	(char ** lineptr, size_t * n, FILE * stream)	Liest Zeile in einen dynamisch wachsenden Puffer
ssize_t	getdelim	(char ** lineptr, size_t * n, int delim, FILE * stream)	Liest Daten in einen dynamisch wachsenden Puffer
Standard Ein-/Ausgabe
int	getchar	(void)	Liest ein Zeichen von der Standardeingabe
int	putchar	(int c)	Schreibt ein Zeichen auf die Standardausgabe-
char *	gets	( char * buf)	Liest eine Zeile ohne Längenbeschränkung von der Standardeingabe
int	puts	(const char * buf)	Schreibt eine Zeile auf die Standardausgabe
void	perror	(const char * buf)	Gibt aktuelle Fehlermeldung auf `stderr` aus
Formatierte Ein-/Ausgabe
int	scanf	( const char * format, ...)	Zerlegt formatierte Daten von der Standardeingabe
int	printf	( const char * format, ...)	Schreibt formatierte Daten auf die Standardausgabe
int	fscanf	(FILE * stream, const char * format, ...)	Zerlegt formatierte Daten aus Datenstrom
int	fprintf	(FILE * stream, const char * format, ...)	Schreibt formatierte Daten in Datenstrom
int	dprintf	(int fd, const char * format, ...)	Schreibt formatierte Daten in Datei
int	vdprintf	(int fd, const char * format, va_list)	Schreibt formatierte Daten in Datei
int	sscanf	(const char * str, const char * format, ...)	Zerlegt formatierte Eingabe aus Zeichenkette
int	sprintf	( char * str, const char * format, ...)	Schreibt formatierte Ausgabe ohne Längenbeschränkung in Zeichenkette
int	snprintf	( char * str, size_t max, const char * format, ...)	Schreibt formatierte Ausgabe in Zeichenkette
Sperren
int	ftrylockfile	( FILE * stream)	Sperrt Datenstrom für andere Threads, aber wartet nicht
void	flockfile	( FILE * stream)	Sperrt Datenstrom für andere Threads
void	funlockfile	( FILE * stream)	Gibt Datenstrom für andere Threads frei
int	fgetc_unlocked	( FILE * stream)	Liest Zeichen aus Datenstrom
int	fputc_unlocked	(int c, FILE * stream)	Schreibt Zeichen in Datenstrom
int	getc_unlocked	( FILE * stream)	Liest Zeichen aus Datenstrom. (Makro)
int	putc_unlocked	(int c, FILE * stream)	Schreibt Zeichen in Datenstrom. (Makro)
char *	fgets_unlocked	( char * str, int max, FILE * stream)	Liest Zeile aus Datenstrom
int	fputs_unlocked	(const char * str, FILE * stream)	Schreibt Zeile in Datenstrom
size_t	fread_unlocked	( void * ptr, size_t max, size_t nmemb, FILE * stream)	Liest blockweise aus Datenstrom,
size_t	fwrite_unlocked	(const void * ptr, size_t max, size_t nmemb, FILE * stream)	Schreibt blockweise in Datenstrom
int	getchar_unlocked	(void)	Liest ein Zeichen von der Standardeingabe
int	putchar_unlocked	(int c)	Schreibt ein Zeichen auf die Standardausgabe-
Pfade
int	rename	(const char * oldpath, const char * newpath)	Benennt Link zu einer Datei um
int	remove	(const char * path)	Löscht Link zu einer Datei
char *	tmpnam	(char * s)	Erzeugt einen temporären Dateinamen, verwende `tmpfile`
char *	tempnam	(const char * path, const char * prefix)	Erzeugt einen temporären Dateinamen mit Präfix
Terminal
char *	ctermid	(char * s)	Liefert Pfad des kontrollierenden Terminals

Modus	Beschreibung	Lesepos.	Schreibpos.
`r`	Nur lesen	Anfang	–
`r+`	Lesen und schreiben	Anfang	Anfang
`w`	Nur schreiben	–	trunc
`w+`	Lesen und schreiben	trunc	trunc
`a`	Nur anhängen	–	Ende
`a+`	Anhängen und lesen	Anfang	Ende

Flag
%[`Flag`][`Width`][`Length`]`Conversion`
#	`0` für Oktal oder `0x` für Hexadezimal voranstellen
0	Zahl vorne mit `0` auffüllen
-	Zeichenkette Linksbündig ausrichten
+	Vorzeichen immer ausgeben
	Leerzeichen statt Positives Vorzeichen ausgeben
'	Tausender gruppieren
Width
*	`int` in Argumentliste
`Number`[.`Number`]	Vor- (und Nach-)kommastellen
Length
hh	`char`
h	`short`
l	`long`
ll	`long long`
j	`intmax_t`
t	`ptrdiff_t`
L	`long double`
z	`size_t`
Conversion
c	Zeichen
d	Ganzzahl mit Vorzeichen
u	Ganzzahl ohne Vorzeichen
o	Ganzzahl Oktal
x	Ganzzahl Hexadezimal mit `abcdef`
X	Ganzzahl Hexadezimal mit `ABCDEF`
e	Gleitpunktzahl in Exponentialschreibweise
f	Gleitpunktzahl in Dezimalschreibweise
g	Gleitpunktzahl mit signifikanten Stellen
…

`sys/ioctl.h`

int

ioctl

(int d, int request, ...)

Spezialkommandos für die Ein/Ausgabe

`fcntl.h`

Dateien erzeugen

int	creat	(const char * path, mode_t mode)
int	open	(const char * path, int flags, mode_t mode)
int	openat	(int dirfd, const char * path, int flags, ...)
int	faccessat	(int dirfd, const char * path, int mode, int flags)
int	fchmodat	(int dirfd, const char * path, mode_t mode, int flags)
int	fchownat	(int dirfd, const char * path, uid_t owner, gid_t group, int flags)
int	fstatat	(int dirfd, const char * path, struct stat * buf, int flags)
int	utimensat	(int dirfd, const char * path, const struct timespec times[2], int flags)
int	futimens	(int fd, const struct timespec times[2])
int	posix_fadvise	(int fd, off_t, off_t, int)
int	posix_fallocate	(int fd, off_t, off_t)
int	posix_openpt	(int flags)

Optionale Flags
`O_RDONLY`	Nur Lesen
`O_WRONLY`	Nur Schreiben
`O_RDWR`	Lesen und Schreiben
`O_EXEC`	Ausführen (bei Dateien)
`O_SEARCH`	Suchen (bei Verzeichnissen)
`O_ACCMODE`	Maske für alle Zugriffsmodi
`O_CREAT`	Erzeugt die Datei, wenn sie noch nicht existiert.
`O_EXCL`	Meldet einen Fehler, wenn die Datei bereits existiert.
`O_TRUNC`	Entleere den Inhalt der Datei.
`O_APPEND`	Hängt Daten hinten an die Datei an
`O_NONBLOCK`	Aktiviert den nicht-blockierender Modus
`O_NOCTTY`	Weist kein kontrollierendes Terminal zu-
`O_TTY_INIT`	Initialisiert Terminal mit vernünftigen Werten.
`O_SYNC`	Blockiert bis die Daten sicher auf Platte geschrieben sind.
`O_DSYNC`	Synchronisiert Schreiboperationen.
`O_RSYNC`	Synchronisiert Leseoperationen.
`O_TMPFILE`	Legt eine im Dateisystem unsichtbare Datei an.

Dateien sperren

struct flock
short	l_type		Art
short	l_whence		Richtung
off_t	l_start		Versatz
off_t	l_len		Länge
pid_t	l_pid		Prozessnummer
int	fcntl	(int fd, int cmd, ...)
int	fcntl	(int fd, int cmd, long arg)
int	fcntl	(int fd, int cmd, struct flock * lock)
int	lockf	(int fd, int cmd, off_t len)	Verwendet `fcntl`

`sys/file.h`

BSD enthält einen weiteren Sperr-Mechanismus, der mit dem Datei-Deskriptor assiziiert ist.

int flock (int fd, int operation) Legt Sperre auf Dateideskriptor, nicht zu verwechseln mit lockf

`unistd.h`

Blöcke lesen & schreiben

#define	STDIN_FILENO	0	Standardeingabe
#define	STDOUT_FILENO	1	Standardausgabe
#define	STDERR_FILENO	2	Standardfehlerausgabe
ssize_t	read	(int fd, void * buf, size_t count)	Liest Daten aus Datei
ssize_t	pread	(int fd, void * buf, size_t count, off_t offset)	Liest Daten ab Position
ssize_t	write	(int fd, const void * buf, size_t count)	Schreibt Daten in Datei
ssize_t	pwrite	(int fd, const void * buf, size_t count, off_t offset)	Schreibt Daten an Position
int	close	(int fd)	Schließt Datei (siehe auch `open` und `creat`)
int	dup	(int fd)	Klont Dateideskriptor
int	dup2	(int oldfd, int newfd)	Klont Dateideskriptor und schließt gegebenenfalls `newfd`
int	pipe	(int fd[2])	Öffnet unidirektionale Pipe
void	sync	(void)	Vollendet alle gepufferten Schreiboperationen
int	syncfs	(int fd)	Vollendet alle gepufferten Schreiboperationen eines Dateisystems
off_t	lseek	(int fd, off_t offset, int whence)	Setzt Schreib-/Leseposition für wahlfreien Zugriff
int	ftruncate	(int fd, off_t length)	Kürzt eine geöffnete Datei auf eine bestimmte Länge
long	fpathconf	(int fd, int name)	Liefert Konfiguration
int	fchdir	(int fd)	Wechselt das Arbeitsverzeichnis
int	fchown	(int fd, uid_t owner, gid_t group)	Ändert Benutzer und Gruppe
int	fsync	(int fd)	Vollendet alle gepufferten Schreiboperationen einer Datei
int	fdatasync	(int fd)	Schreibt nur Daten aber keine Metadaten

`sys/uio.h`

Atomar über mehrere Puffer verteilte Daten lesen und schreiben.

struct iovec
void *	iov_base		Startadresse
size_t	iov_len		Anzahl Oktette
ssize_t	readv	(int fd, const struct iovec * vector, int iovcnt)
ssize_t	writev	(int fd, const struct iovec * vector, int iovcnt)
ssize_t	preadv	(int fd, const struct iovec * vector, int iovcnt, off_t offset)
ssize_t	pwritev	(int fd, const struct iovec * vector, int iovcnt, off_t offset)
ssize_t	preadv2	(int fd, const struct iovec * vector, int iovcnt, off_t offset, int flags)
ssize_t	pwritev2	(int fd, const struct iovec * vector, int iovcnt, off_t offset, int flags)

`aio.h`

Asynchron lesen & schreiben

struct aiocb
int	aio_fildes		Dateideskriptor
off_t	aio_offset		Offset
volatile void *	aio_buf		Position im Puffer
size_t	aio_nbytes		Länge des Transfers
int	aio_reqprio		Priorität
struct sigevent	aio_sigevent		Signalnummer und -wert
int	aio_lio_opcode		Auszuführende Operation
ssize_t	aio_return	( struct aiocb * buf)
int	aio_read	( struct aiocb * buf)
int	aio_write	( struct aiocb * buf)
int	aio_cancel	(int fd, struct aiocb * buf)
int	aio_fsync	(int op, struct aiocb * buf)
int	aio_error	( const struct aiocb * buf)
int	aio_suspend	( const struct * const aiocb list[], int nitems, const struct timespec * timeout)
int	lio_listio	(int mode, struct aiocb * const list[], int nitems, struct sigevent * event)

struct sigevent
int	sigev_notify	Methode zur Benachrichtigung
int	sigev_signo	Signalnummer
union sigval	sigev_value	Zusätzliche Daten
void	(* sigev_notify_function) (union sigval)	Thread-Funktion
void	* sigev_notify_attributes	Attribute für Threads
pid_t	sigev_notify_thread_id	Threadnummer
union sigval
int	sival_int	Zahlenwert
void *	sival_ptr	Zeiger

`sys/select.h`

Ereignisse pollen

typedef	fd_set		Menge von Dateideskriptoren
#define	FD_SETSIZE		Maximale Anzahl an Dateideskriptoren
#define	FD_ZERO	( fd_set * set)	Löscht alle Deskriptoren
#define	FD_CLR	(int fd, fd_set * set)	Entfernt einen Deskriptor
#define	FD_SET	(int fd, fd_set * set)	Fügt einen Deskriptor hinzu
#define	FD_ISSET	(int fd, fd_set * set)	Prüft, ob ein Deskriptor enthalten ist
int	select	(int n, fd_set * readfds,
		fd_set * writefds,
		fd_set * exceptfds,
		struct timeval * timeout)
int	pselect	(int n, fd_set * readfds,
		fd_set * writefds,
		fd_set * exceptfds,
		struct timeval * timeout)
		const sigset_t * sigmask)

`poll.h`

Auf Aktivität auf einer Menge von Dateideskriptoren warten.

struct pollfd
typedef	nfds_t	unsigned long int
int	fd		Dateideskriptor
short	events		Angeforderte Ereignisse
short	revents		Aufgetrene Ereignisse
int	poll	(struct pollfd * ufds, nfds_t nfds, int timeout)

`stdlib.h`

Pseudo-Terminals steuern

int	grantpt	(int fd)	Ändert Zugriffsrechte für Pseudo-Terminal
int	unlockpt	(int fd)	Entkoppelt Pseudo-Terminal vom Master
char *	ptsname	(int fd)	Liefert den Pfad eines Pseudo-Terminals
int	ptsname_r	(int fd, char * buf, size_t buflen)	Liefert den Pfad eines Pseudo-Terminals in einen Puffer

Mehr Standard

#include	<unistd.h>
int	isatty	(int fd)	Prüft, ob der Dateideskriptor auf ein Terminal verweist
char *	ttyname	(int fd)	Liefert den Namen des Terminals
int	ttyname_r	(int fd, char * buf, size_t buflen)
void	swab	(const void * from, void * to, ssize_t len)	Tauscht Oktette an geraden und ungeraden Positionen

`termios.h`

Attribute

struct termios
tcflag_t	c_iflag		Eingabemodus
tcflag_t	c_oflag		Ausgabemodus
tcflag_t	c_cflag		Kontrollen
tcflag_t	c_lflag		Lokale Modi
cc_t	c_cc[NCCS]		Steuerzeichen
speed_t	cfgetispeed	(const struct termios * term)
speed_t	cfgetospeed	(const struct termios * term)
int	cfsetispeed	( struct termios * term, speed_t speed)
int	cfsetospeed	( struct termios * term, speed_t speed)
int	tcdrain	(int fd)
int	tcflow	(int fd, int action)
int	tcflush	(int fd, int queue)
int	tcsendbreak	(int fd, int duration)
pid_t	tcgetsid	(int fd)
int	tcgetattr	(int fd, struct termios * term)
int	tcsetattr	(int fd, int action, const struct termios * term)

`fmtmsg.h`

Die Systemkonsole ist ein spezielles Terminal, auf dem der Kernel seine Meldungen ausgibt.

int	addseverity	(int severity, const char * s)	Führt eine neue Schwere-Stufe ein
int	fmtmsg	(long classification,	Bitmaske
		const char * label, int severity,	Quelle und Schwere des Fehlers
		const char * text,	Beschreibung des Fehlers
		const char * action,	Maßnahmen zur Behebung des Fehlers
		const char * tag)	Verweis auf die Dokumentation

Ziel
MM_PRINT	Nachricht auf der Standardfehlerausgabe (`stderr`) ausgeben
MM_CONSOLE	Nachricht auf der Systemkonsole ausgeben
Quelle
MM_SOFT	Quelle des Problems ist die Software
MM_HARD	Quelle des Problems ist die Hardware
MM_FIRM	Quelle des Problems ist die Firmware
Erkennung
MM_APPL	Problem wurde erkannt von der Anwendung selbst
MM_UTIL	Problem wurde erkannt von einem anderen Programm
MM_OPSYS	Problem wurde erkannt vom Betriebssystem
Behebung
MM_RECOVER	Problem wird behoben
MM_NRECOV	Problem kann nicht behoben werden

`syslog.h`

Der Syslog Daemon nimmt Meldungen entgegen und schreibt diese entweder auf die Systemkonsole oder in eine Protokolldatei.

void	openlog	(const char * ident, int option, int facility)	Öffnet das Systemprotokoll, `ident` ist der Name des Programms
int	setlogmask	(int mask)	Unterdrückt bestimmte Prioritätsstufen
void	syslog	(int priority, const char * format, ...)	Schreibt Meldung ins Systemprotokoll
void	closelog	(void)	Schließt das Systemprotokoll

Symbol	Oktal	Beschreibung
`S_IFMT`	0170000	Bitmaske für alle Typfelder
`S_IFSOCK`	0140000	Erzeugt Sockel
`S_IFLNK`	0120000	Erzeugt Symlink
`S_IFREG`	0100000	Erzeugt reguläre Datei
`S_IFBLK`	0060000	Erzeugt Blockgerät
`S_IFDIR`	0040000	Erzeugt Verzeichnis
`S_IFCHR`	0020000	Erzeugt Zeichengerät
`S_IFIFO`	0010000	Erzeugt FIFO
`S_ISUID`	0004000	Vererbt Benutzernummer
`S_ISGID`	0002000	Vererbt Gruppennummer an neu angelegte Dateien und Verzeichnisse
`S_ISVTX`	0001000	Sticky Bit
`S_IRWXU`	0000700	Besitzer bekommt alle Rechte
`S_IRUSR`	0000400	Besitzer bekommt Leserechte
`S_IWUSR`	0000200	Besitzer bekommt Schreibrechte
`S_IXUSR`	0000100	Besitzer bekommt Ausführrechte
`S_IRWXG`	0000070	Gruppe bekommt alle Rechte
`S_IRGRP`	0000040	Gruppe bekommt Leserechte
`S_IWGRP`	0000020	Gruppe bekommt Schreibrechte
`S_IXGRP`	0000010	Gruppe bekommt Ausführrechte
`S_IRWXO`	0000007	Andere bekommen alle Rechte
`S_IROTH`	0000004	Andere bekommen Leserechte
`S_IWOTH`	0000002	Andere bekommen Schreibrechte
`S_IXOTH`	0000001	Andere bekommen Ausführrechte

`SEEK_CUR`	Relativ zum Dateianfang
`SEEK_END`	Relativ zur zum Dateiende
`SEEK_SET`	Relativ zur aktuellen Position

`_IOFBF`	Ungepuffert
`_IOLBF`	Zeilenweise
`_IONBF`	Blockweise

time_t	tv_sec		Sekunden
long int	tv_nsec		Nanosekunden

dev_t	st_dev	Gerätenummer
ino_t	st_ino	Indexknotennummer
mode_t	st_mode	Zugriffsrechte
nlink_t	st_nlink	Referenzzähler
uid_t	st_uid	Besitzer
gid_t	st_gid	Gruppe
dev_t	st_rdev	Typ
off_t	st_size	Oktette
blksize_t	st_blksize	Blöcke
blkcnt_t	st_blocks	Belegte Blöcke
time_t	st_atime	Letzter Zugriff
time_t	st_mtime	Letzte Änderung
time_t	st_ctime	Letzte Statusänderung

`AT_FDCWD`	Interpretiert Pfadname relativ zum Arbeitsverzeichnis.
`AT_EACCESS`	Prüft Zugriffsrechte gegen Effektive Benutzer- und Gruppen-ID
`AT_SYMLINK_FOLLOW`	Folgt symbolischen Verknüpfungen.
`AT_SYMLINK_NOFOLLOW`	Folgt symbolischen Verknüpfungen nicht.

`F_RDLCK`	Gemeinsame Lesesperre
`F_WRLCK`	Exklusive Schreibsperre
`F_UNLCK`	Freigabe

`SEEK_SET`	Ab dem Anfang der Datei
`SEEK_CUR`	Ab aktueller Position
`SEEK_END`	Rückwärts ab dem Ende der Datei

`POSIX_FADV_DONTNEED`	Erwartet demnächst keinen Datenzugriff.
`POSIX_FADV_NOREUSE`	Erwartet einmaligen Datenzugriff
`POSIX_FADV_NORMAL`	Nichts besonderes
`POSIX_FADV_RANDOM`	Erwartet Daten in zufälliger Ordnung
`POSIX_FADV_SEQUENTIAL`	Erwartet Daten sequentiell
`POSIX_FADV_WILLNEED`	Erwartet Daten demnächst

`O_RDWR`	Lesen & Schreiben
`O_NOCTTY`	Nicht zum kontrollierenden Terminal machen

`F_DUPFD`	Klont Dateideskriptor
`F_DUPFD_CLOEXEC`	Klont Dateideskriptor mit `FD_CLOEXEC`
`F_GETFD`	Liest Dateideskriptor-Flags.
`F_SETFD`	Setzt Dateideskriptor-Flags.
`F_GETFL`	Liest Dateistatus-Flags und Zugriffsrechte.
`F_SETFL`	Setzt Dateistatus-Flags.
`F_GETOWN`	Liest Prozess- oder -gruppennummer um `SIGURG` Signal zu erhalten.
`F_SETOWN`	Setze Prozess- oder -gruppennummer um `SIGURG` Signal zu erhalten.

`F_GETLK`	Liest Datenseatz-Sperrinformationen.
`F_SETLK`	Setzt Datenseatz-Sperrinformationen.
`F_SETLKW`	Setzt Datenseatz-Sperrinformationen aber wartet wenn blockiert.

`LOCK_SH`	Gemeinsame Lesesperre
`LOCK_EX`	Exklusives Schreibsperre
`LOCK_UN`	Freigabe

`LIO_WAIT`	Warten, bis die Operation abgeschlossen ist.
`LIO_NOWAIT`	Weitermachen und nicht benachrichtigen, wenn die Operation abgeschlossen ist.

`LIO_NOP`	Keine Operation angefragt
`LIO_READ`	Leseoperation
`LIO_WRITE`	Schreiboperation

`AIO_ALLDONE`	Alle Operationen waren fertig.
`AIO_CANCELED`	Alle Operationen wurden abgebrochen.
`AIO_NOTCANCELED`	Einige Operationen laufen noch.

`POLLIN 0x0001`	Daten zum Lesen liegen vor
`POLLPRI 0x0002`	Dringende Daten zum Lesen liegen vor
`POLLOUT 0x0004`	Schreiben wird nicht blockieren
`POLLERR 0x0008`	Fehler aufgetreten
`POLLHUP 0x0010`	Aufgelegt
`POLLNVAL 0x0020`	Ungültige Anfrage

MM_OK	Okay
MM_NOTOK	Fehler

MM_NOSEV	Keine Angabe
MM_INFO	Informative Nachricht
MM_WARNING	Das Programm hat einen ungewöhnlichen Zustand bemerkt
MM_ERROR	Das Programm kann fortgesetzt werden
MM_HALT	Das Programm muss beendet werden

LOG_CONS	Auf die Systemkonsole ausweichen
LOG_NDELAY	Verbindung nicht verzögert etablieren
LOG_NOWAIT	Nicht auf Kindprozesse warten (Kein Effekt unter Linux)
LOG_ODELAY	Verbindung verzögert etablieren
LOG_PERROR	Meldungen auch auf die Standardfehlerausgabe schreiben
LOG_PID	Prozess-Identität mitprotokollieren

LOG_AUTH	Obsolet, verwende `LOG_AUTHPRIV`
LOG_AUTHPRIV	Sicherheitsrelevante Meldungen
LOG_CRON	Uhrzeit (cron und at)
LOG_DAEMON	Daemonen ohne eigene Einrichtung
LOG_FTP	FTP Daemon
LOG_KERN	Kernelmeldungen
LOG_LOCAL0-7	Reserviert für lokale Meldungen
LOG_LPR	Drucker Subsystem
LOG_MAIL	Elektropost Subsystem
LOG_NEWS	Usenet Subsystem
LOG_SYSLOG	Interne Nachrichten
LOG_UUCP	UUCP Subsystem
LOG_USER	Benutzerspezifische Nachrichten

LOG_EMERG	System zusammengebrochen
LOG_ALERT	Alarm
LOG_CRIT	Kritischer Zustand
LOG_ERR	Fehlerhafter Zustand
LOG_WARNING	Warnung
LOG_NOTICE	Interessantes Ereignis
LOG_INFO	Informative Nachricht
LOG_DEBUG	Nachricht zur Fehlersuche

LOG_MASK (LOG_EMERG)	System zusammengebrochen
LOG_MASK (LOG_ALERT)	Alarm
LOG_MASK (LOG_CRIT)	Kritischer Zustand
LOG_MASK (LOG_ERR)	Fehlerhafter Zustand
LOG_MASK (LOG_WARNING)	Warnung
LOG_MASK (LOG_NOTICE)	Interessantes Ereignis
LOG_MASK (LOG_INFO)	Informative Nachricht
LOG_MASK (LOG_DEBUG)	Nachricht zur Fehlersuche