Schnittstelle zum Betriebssystem

POSIX erweitert den plattformübergreifenden ANSI C Standard um Schnittstellen zum Betriebsystem. Plattformspezifische Erweiterungen werden farblich gekennzeichnet. Grundsätzlich gilt: Je heller desto älter desto portabler.

ANSI C
Internationalisierung
Initialisierung
Nebenläufigkeit
Portable Operating System Interface
X/Open System Interfaces
Internet Protocol Version 6
Optionale Funktionen
Message Passing
Spawn Extension
X/Open STREAMS (obsolet)
Trace Extension (obsolet)
System V Release 2
System V Release 4
BSD Erweiterung
GNU Erweiterung
Linux Erweiterung

`aio.h`

Asynchrone Ein-/Ausgabe

struct	aiocb
int	aio_fildes		Dateideskriptor
off_t	aio_offset		Offset
volatile void *	aio_buf		Datenpuffer
size_t	aio_nbytes		Transferlänge
int	aio_reqprio		Priorität
struct sigevent	aio_sigevent		Signalnummer
int	aio_lio_opcode		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

`arpa/inet.h`

Umrechnung von Internet-Adressen

uint32_t	htonl	(uint32_t hostlong)	Adresse
uint32_t	ntohl	(uint32_t netlong)
uint16_t	htons	(uint16_t hostshort)	Kanalnummer
uint16_t	ntohs	(uint16_t netshort)
in_addr_t	inet_addr	(const char * cp)	Dezimaldarstellung
int	inet_aton	(const char * cp, struct in_addr * in)
char *	inet_ntoa	(struct in_addr in)
const char *	inet_ntop	(int af, const void * src, char * dst, socklen_t cnt)
int	inet_pton	(int af, const char * src, void * dst)
struct in_addr	inet_makeaddr	(int net, int host)	Kombination
in_addr_t	inet_lnaof	(struct in_addr in)	Hostadresse
in_addr_t	inet_netof	(struct in_addr in)	Netzwerkadresse
in_addr_t	inet_network	(const char * cp)	Netzwerkadresse

`assert.h`

Zusicherung von Invarianten

#define	assert	(expression, message)	Abbruch, wenn Ausdruck `false` ergibt
#define	static_assert	(expression, message)	Fehler, wenn Ausdruck `false` ergibt

Das assert-Makro wird durch Definition von NDEBUG deaktiviert. Der ausgewertete Ausdruck darf keine Seiteneffekte aufweisen, andernfalls führt dies zu einem sogenannten Heisenbug: Einem Fehler, der nur im Produktivsystem auftritt.

`complex.h`

Komplexe Arithmetik

#define	complex	_Complex	Real- und Imaginärteil
#define	I		Imaginärzahl
double	cimag	(double complex z)	Imaginärteil
double	creal	(double complex z)	Realteil
double	cabs	(double complex z)	Abstand vom Ursprung
double	carg	(double complex z)	Phasenwinkel
double	c[a]sin[h]	(double complex z)	Sinus
double	c[a]cos[h]	(double complex z)	Kosinus
double	c[a]tan[h]	(double complex z)	Tangens
double complex	conj	(double complex z)	Konjugat
double complex	cexp	(double complex z)	Exponent
double complex	cpow	(double complex x, double complex y)	Potenz
double complex	clog	(double complex z)	Natürlicher Logarithmus
double complex	clog2	(double complex z)	Binärer Logarithmus
double complex	clog10	(double complex z)	Dezimaler Logarithmus
double complex	csqrt	(double complex x)	Quadratwurzel
double complex	cproj	(double complex z)	Projiziert Punkt in die Riemannsche Zahlenkugel

Die Funktionen gibt es jeweils auch in einer float- und long float-Variante.

`crypt.h`

GNU Erweiterung für Verschlüsselung von Passwörtern, binden mit -lcrypt

struct	crypt_data
char	keysched[16 * 8]
char	sb0[32768]
char	sb1[32768]
char	sb2[32768]
char	sb3[32768]
char	crypt_3_buf[14]
char	current_salt[2]
long	current_saltbits
int	direction
int	initialized
char *	crypt	(const char * phrase, const char * setting)
char *	crypt_r	(const char * phrase, const char * setting, struct crypt_data * data)
char *	crypt_rn	(const char * phrase, const char * setting, struct crypt_data * data, int size)
char *	crypt_ra	(const char * phrase, const char * setting, void ** data, int * size)
void	setkey_r	(const char * key, struct crypt_data * data)
void	encrypt_r	(char * block, int edflag, struct crypt_data * data)

`ctype.h`

Klassifizierung von Zeichen (Umgebungsvariable LC_CTYPE)

int	isdigit	(int c)	Ziffer ('0'...'9')
int	isxdigit	(int c)	Hexadezimalziffer ('0'...'9','A'...'F','a'...'f')
int	islower	(int c)	Kleinbuchstabe ('a'...'z')
int	isupper	(int c)	Grossbuchstabe ('A'...'Z')
int	isalpha	(int c)	Buchstabe ('A'...'Z','a'...'z')
int	isalnum	(int c)	Alphanumerisches Zeichen ('0'...'9','A'...'Z','a'...'z')
int	iscntrl	(int c)	Steuerzeichen (0...31, 127)
int	isprint	(int c)	Druckbares Zeichen (32...126)
int	isgraph	(int c)	Graphisches Zeichen ausser Leerzeichen (33...)
int	ispunct	(int c)	Interpunktion (32...47, 58...63, 91...96, 123...126)
int	isspace	(int c)	Leerraum (HT, LF, VT, FF, CR, SPACE)
int	isblank	(int c)	Leerzeichen oder Tabulator (SPACE, HT)
int	toupper	(int c)	Wandelt Klein- in Grossbuchstaben um
int	tolower	(int c)	Wandelt Gross- in Kleinbuchstaben um
int	isdigit_l	(int c, locale_t locale)	Ziffer ('0'...'9')
int	isxdigit_l	(int c, locale_t locale)	Hexadezimalziffer ('0'...'9','A'...'F','a'...'f')
int	islower_l	(int c, locale_t locale)	Kleinbuchstabe ('a'...'z')
int	isupper_l	(int c, locale_t locale)	Grossbuchstabe ('A'...'Z')
int	isalpha_l	(int c, locale_t locale)	Buchstabe ('A'...'Z','a'...'z')
int	isalnum_l	(int c, locale_t locale)	Alphanumerisches Zeichen ('0'...'9','A'...'Z','a'...'z')
int	iscntrl_l	(int c, locale_t locale)	Steuerzeichen (0...31, 127)
int	isprint_l	(int c, locale_t locale)	Druckbares Zeichen (32...126)
int	isgraph_l	(int c, locale_t locale)	Graphisches Zeichen ausser Leerzeichen (33...)
int	ispunct_l	(int c, locale_t locale)	Interpunktion (32...47, 58...63, 91...96, 123...126)
int	isspace_l	(int c, locale_t locale)	Leerraum (HT, LF, VT, FF, CR, SPACE)
int	isblank_l	(int c, locale_t locale)	Leerzeichen oder Tabulator (SPACE, HT)
int	toupper_l	(int c, locale_t locale)	Wandelt Klein- in Grossbuchstaben um
int	tolower_l	(int c, locale_t locale)	Wandelt Gross- in Kleinbuchstaben um
int	isascii	(int c)	Zeichen aus dem ASCII Alphabet
int	toascii	(int c)	Löscht höherwertige Bits
int	_toupper	(int c)	Wandelt Klein- in Grossbuchstaben um
int	_tolower	(int c)	Wandelt Gross- in Kleinbuchstaben um

Klassifizierungs-Matrix
Zeichen	NUL…	HT	LF	VT	FF	CR	SO…	SP	!…	0…9	:…	A…Z	[…	a…z	{…
iscntrl
isspace
isblank
isprint
ispunct
isxdigit												A…F		a…f
isdigit
isupper
islower

`dirent.h`

Iteration über Verzeichnisse

struct	dirent
ino_t	d_ino		Knotennummer
char	d_name[]		Dateiname
int	scandir	(const char * path, struct dirent *** dir, int (* filter) (const struct dirent * entry), int (* compare) (const struct dirent lhs, const struct dirent rhs))
int	alphasort	(const struct dirent lhs, const struct dirent rhs)	Mit `strcoll` sortieren
int	versionsort	(const struct dirent lhs, const struct dirent rhs)	Mit `strverscmp` sortieren
typedef	DIR		Iterator
DIR *	opendir	(const char * path)	Verzeichnis öffnen
DIR *	fdopendir	(int dirfd)
int	dirfd	(DIR * dir)	Deskriptor für `openat`
struct dirent *	readdir	(DIR * dir)	Eintrag lesen
int	readdir_r	(DIR * dir, struct dirent * entry, struct dirent ** result)
long	telldir	(DIR * dir)	Index der Leseposition
void	seekdir	(DIR * dir, long offset)	Leseposition setzen
void	rewinddir	(DIR * dir)	Leseposition auf Anfang
int	closedir	(DIR * dir)	Deskriptor schließen

`dlfcn.h`

Bindung dynamisch ladbarer Bibliotheken

void *	dlopen	(const char * filename, int flag)	Bibliothek öffnen
void *	dlsym	(void * handle, const char * symbol)	Symbol laden
char *	dlerror	(void)	Fehlerbeschreibung
int	dlclose	(void * handle)	Bibliothek schließen

Zusätzlich:
RTLD_LAZY	Referenzen auf Funktionen erst beim Ausführen auflösen.
RTLD_NOW	Referenzen auf Funktionen sofort auflösen.
RTLD_GLOBAL	Symbole für nachfolgend geladene Bibliothken sichtbar machen.
RTLD_LOCAL	Default
GNU Erweiterungen:
RTLD_NODELETE	Bibliothek mit Schließen mit `dlclose` nicht entfernen.
RTLD_NOLOAD	Bibliothek nicht laden, nur die Parameter verändern.
RTLD_DEEPBIND	Symbole ganz nach vorne packen.

`errno.h`

Fehlercodes des Betriebssystems

Die meisten Systemaufrufe liefern im Fehlerfall -1 (oder NULL) als Rückgabewert und speichern in der Variable errno einen Fehlercode. Generische Fehlerberschreibungen dazu liefert strerror().

extern thread_local int	errno	Letzte Fehlernummer
extern char *	program_invocation_name	Name des Programms
extern char *	program_invocation_short_name	Nur mit GNU Linker

`fcntl.h`

Kontrolle von Dateien

struct	flock
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)
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`

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.

`fenv.h`

Gleitkomma-Umgebung

#pragma	STD FENV_ACCESS	OFF
#pragma	STD FP_CONTRACT	ON
#pragma	STD CX_LIMITED_RANGE	OFF
int	fegetexcept	(void)
int	feenableexcept	( int excepts)
int	fedisableexcept	( int excepts)
int	feclearexcept	( int excepts)
int	fegetexceptflag	( fexcept_t * flagp, int excepts)
int	feraiseexcept	( int excepts)
int	fesetexceptflag	(const fexcept_t * flagp, int excepts)
int	fetestexcept	( int excepts)
int	feholdexcept	( fenv_t * envp)
int	fesetenv	(const fenv_t * envp)
int	fegetenv	( fenv_t * envp)
int	feupdateenv	(const fenv_t * envp)
int	fegetround	(void)
int	fesetround	(int rounding_direction)

`float.h`

Gleitkomma-Typen

Der Datentyp Float repräsentiert eine Teilmenge der Rationalen Zahlen. Da nicht alle Prozessoren eine FPU. besitzen, sind Funktionen für Gleitpunktzahlen in eine Bibliothek namens libm ausgelagert. Beim Binden von Programen, die darauf zugreifen, muss die Option -lm gesetzt werden.

#define	DBL_MIN	Kleinster darstellbarer Wert
#define	DBL_MAX	Größter darstellbarer Wert
…

`fmtmsg.h`

Meldungen auf der Systemkonsole (siehe syslog)

int	addseverity	(int severity, const char * s)	Neuer Schweregrad
int	fmtmsg	(long classification,	Bitmaske
		const char * label, int severity,	Quelle und Schwere des Fehlers
		const char * text,	Beschreibung
		const char * action,	Maßnahmen zur Behebung
		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

`fnmatch.h`

Muster für Dateinamen

int

fnmatch

(const char * pattern, const char * string, int flags)

`ftw.h`

Traversierung des Verzeichnisbaums (File Tree Walk)

typedef	FTW
int	ftw	(const char * path, fn1, int flags)
int	nftw	(const char * path, fn2, int nopen, int flags)
int	base
int	level
int	fn1	(const char * path, const struct stat * st, int type)
int	fn2	(const char * path, const struct stat * st, int type, struct FTW * ftwbuf)

`fts.h`

Traversierung des Verzeichnisbaums (File Tree Scan)

Die BSD-Variante arbeitet analog zu readdir mit wiederholten Aufrufen von fts_read.

struct _ftsent	FTSENT
typedef	FTS		Zustandsautomat
FTS *	fts_open	(char * path_argv[], int options, int (compar) (const FTSENT , const FTSENT *))
int	fts_close	(FTS * ftsp)
unsigned short	fts_info		Klassifizierung
char *	fts_accpath		Relativ zum CWD
char *	fts_path		Relativ zum Start
short	fts_pathlen		Länge des Pfades
char *	fts_name		Dateiname
short	fts_namelen		Länge des Namens
short	fts_level		Rekursionstiefe
int	fts_errno		Fehlercode
long	fts_number		Nutzlast
void *	fts_pointer		Nutzlast
struct _ftsent *	fts_parent		Elternverzeichnis
struct _ftsent *	fts_link		Nächster Eintrag
struct _ftsent *	fts_cycle		Zyklen
struct stat *	fts_statp		Metadaten
FTSENT *	fts_read	(FTS * ftsp)	Nächster Eintrag
FTSENT *	fts_children	(FTS * ftsp, int instr)	Verkettete Liste
int	fts_set	(FTS * ftsp, FTSENT * f, int instr)

`gdbm.h`

GNU Datenbank Manager (GDBM). Alternative zu ndbm, binden mit -lgdbm

Datenzugriff
typedef	GDBM_FILE
GDBM_FILE	gdbm_open	(const char * path, int block_size, int flags,
		int mode, void (* fatal_func) (const char *))
void	gdbm_close	(GDBM_FILE dbf)
datum	gdbm_firstkey	(GDBM_FILE dbf)
datum	gdbm_nextkey	(GDBM_FILE dbf, datum key)
int	gdbm_exists	(GDBM_FILE dbf, datum key)
int	gdbm_store	(GDBM_FILE dbf, datum key, datum content, int flag)
datum	gdbm_fetch	(GDBM_FILE dbf, datum key)
int	gdbm_delete	(GDBM_FILE dbf, datum key)
Organisation
int	gdbm_reorganize	(GDBM_FILE dbf)
void	gdbm_sync	(GDBM_FILE dbf)
int	gdbm_setopt	(GDBM_FILE dbf, int option, void * value, int size)
int	gdbm_fdesc	(GDBM_FILE dbf)
int	gdbm_count	(GDBM_FILE dbf, gdbm_count_t * pcount)
int	gdbm_version_cmp	(int const a[], int const b[])
char *	gdbm_strerror	(gdbm_error errno)
Import/Export
int	gdbm_import	(GDBM_FILE dbf, const char * file, int flag)
int	gdbm_import_from_file	(GDBM_FILE dbf, FILE * fp, int flag)
int	gdbm_export	(GDBM_FILE dbf, const char * file, int flag,
		int mode)
int	gdbm_export_to_file	(GDBM_FILE dbf, FILE * fp)
int	gdbm_load	(GDBM_FILE * dbf, const char * file, int flag,
		int meta_mask, unsigned long * errline)
int	gdbm_load_from_file	(GDBM_FILE * dbf, FILE * fp, int flag,
		int meta_mask, unsigned long * errline)
int	gdbm_dump	(GDBM_FILE dbf, const char * file, int format,
		int flags, int mode)
int	gdbm_dump_to_file	(GDBM_FILE dbf, FILE * fp, int format)

Einer von
GDBM_READER	Nur Lesen
GDBM_WRITER	Exklusiv Lesen und Schreiben
GDBM_WRCREAT	Dito, Datenbank erzeugen
GDBM_NEWDB	Dito, Leere Datenbank erzeugen
Optional	verordern
GDBM_SYNC	Änderungen synchron auf Platte schreiben
GDBM_NOLOCK	Nicht für exklusiven Schreibzugriff sperren
GDBM_NOMMAP	Kein Memory-Mapping verwenden
GDBM_FAST	Standardmäßig gesetzt und damit obsolet
GDBM_CLOEXEC	Handle schließen, wenn `exec` ausgeführt wird

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

`glob.h`

Muster für Pfade im Arbeitsverzeichnis

typedef	glob_t
size_t	gl_pathc		Anzahl der Pfade, die auf das Muster passen
char **	gl_pathv		Zeiger auf eine Liste von passenden Pfaden
size_t	gl_offs		Initiale Größe
int	glob	(const char * pattern,
		int flags,
		int (* errfunc) (const char * epath, int eerrno),
		glob_t * glob)
void	globfree	(glob_t * glob)

`grp.h`

Gruppendatenbank

struct	group
char *	gr_name		Gruppenname
char *	gr_passwd		Passwort
gid_t	gr_gid		Nummer
char **	gr_mem		Liste der Benutzernamen
void	setgrent	(void)	Datenbank öffnen
void	endgrent	(void)	Datenbank schließen
struct group *	getgrnam	(const char * name)	Gruppe für Name
struct group *	getgrgid	(gid_t group)	Gruppe für Nummer
struct group *	getgrent	(void)	Nächster Eintrag
int	getgrnam_r	(const char * name, struct group * gbuf, char * buf, size_t len, struct group ** gbufp)
int	getgrgid_r	(gid_t group, struct group * gbuf, char * buf, size_t len, struct group ** gbufp)
int	getgrent_r	( struct group * gbuf, char * buf, size_t len, struct group ** gbufp)
int	fgetgrent_r	(FILE * stream, struct group * gbuf, char * buf, size_t len, struct group ** gbufp)
struct group *	fgetgrent	(FILE * stream)
int	initgroups	(const char * user, gid_t group)
int	getgrouplist	(const char * user, gid_t group, gid_t * groups, int * ngroups)
int	getgroups	(size_t size, gid_t * groups)
int	setgroups	(size_t size, const gid_t * groups)

`iconv.h`

Konversion von Zeichensätzen

typedef	iconv_t
iconv_t	iconv_open	(const char * to, const char * from)	Konstruktur
size_t	iconv	(iconv_t cd, char ** inbuf, size_t * inbytesleft	Eingabepuffer
		char ** outbuf, size_t * outbytesleft)	Ausgabepuffer
int	iconv_close	(iconv_t cd)	Destruktor

`inttypes.h`

Arithmetik für Ganze Zahlen

typedef	imaxdiv_t
long int	quot		Zähler
long int	rem		Nenner
imaxdiv_t	imaxdiv	(intmax_t numererator, intmax_t denominator)
intmax_t	imaxabs	(intmax_t n)
intmax_t	strtoimax	(const char * nptr, char ** endptr, int base)
uintmax_t	strtoumax	(const char * nptr, char ** endptr, int base)
intmax_t	wcstoimax	(const wchar_t * nptr, wchar_t ** endptr, int base)
uintmax_t	wcstoumax	(const wchar_t * nptr, wchar_t ** endptr, int base)

`iso646.h`

Alternative Schreibweise für Bit-Operatoren aus C++

#define	and	&&	Logischer UND Operator
#define	and_eq	&=	Zuweisung mit UND Operator
#define	bitand	&	Bitweise UND Verknüpfung
#define	bitor	\|	Bitweise ODER Verknüpfung
#define	compl	~	Bitumkehr
#define	not	!	Logisches Komplement
#define	not_eq	!=	Ungleichheit
#define	or	\|\|	Logischer ODER Operator
#define	or_eq	\|=	Zuweisung mit ODER Operator
#define	xor	^	Exclusives logisches ODER
#define	xor_eq	^=	Zuweisung mit exclusivem ODER

`langinfo.h`

Lokalisierung der Sprache

char *	nl_langinfo	(nl_item item)
char *	nl_langinfo_l	(nl_item item, locale_t locale)

`libgen.h`

Trennung von Pfad- und Dateinamen

char *	basename	(char * path)	Entfernt Verzeichnispfad: `/foo/bar/snafu.txt`
char *	dirname	(char * path)	Entfernt den Dateinamen: `/foo/bar/snafu.txt`

`limits.h`

Implementierungsspezifische Konstanten

Die Minima und Maxima der eingebauten Ganzzahltypen hängen von der Architektur des Prozessors ab. Auf 32-Bit Architekturen deckt der Typ int typischerweise 4 Milliarden Werte und Zeiger einen Adressraum von 4 Gigabyte ab. Die angegebenen Zahlen markieren das garantierte Minimum.

#define	CHAR_BIT	8	Immer 8 Bit
#define	CHAR_MIN	-128
#define	CHAR_MAX	127
#define	SCHAR_MIN	-128
#define	SCHAR_MAX	127
#define	UCHAR_MAX	255
#define	SHRT_MIN	-32768	Mindestens 16 Bit
#define	SHRT_MAX	32767
#define	USHRT_MAX	65535
#define	INT_MIN	-32768	Mindestens 16 Bit
#define	INT_MAX	32767
#define	UINT_MAX	65535	64 Kilobyte
#define	LONG_MIN	-2147483648
#define	LONG_MAX	2147483647
#define	ULONG_MAX	4294967295	4 Gigabyte (10⁹)
#define	LLONG_MIN	-9223372036854775808	Mindestens 64 Bit
#define	LLONG_MAX	9223372036854775807
#define	ULLONG_MAX	18446744073709551615	16 Exabyte (10¹⁸)
#define	MB_LEN_MAX	4	Oktette pro Multibyte Zeichen
#define	MB_CUR_MAX	4	Dito in der aktuellen Sprache

`locale.h`

Lokalisierung von Schreibweisen

Währungssymbol
Datumsformat
Dezimaltrennzeichen
Ziffern-Gruppierung
Tausender-Trennzeichen

struct	lconv
#define	LC_ALL
#define	LC_COLLATE		Sortierung (`strcoll`)
#define	LC_CTYPE		Klassifizierung (`ctype.h`)
#define	LC_MESSAGES		Nachrichten (`catopen`)
#define	LC_MONETARY
#define	LC_NUMERIC
#define	LC_TIME
char *	decimal_point
char *	grouping
char *	thousands_sep
…
struct lconv *	localeconv	(void)
typedef	locale_t
char *	setlocale	(int category, const char * locale)
locale_t	newlocale	(int category, const char * locale, locale_t base)
locale_t	uselocale	(locale_t dataset)
locale_t	duplocale	(locale_t dataset)
locale_t	freelocale	(locale_t dataset)

`malloc.h`

Dynamische Speicherverwaltung

struct	mallinfo
int	arena		Speicher im nicht-`mmap` Bereich
int	ordblks		Anzahl freier Blöcke
int	smblks		Anzahl freier Fastbin Blöcke
int	hblks		Anzahl per `mmap` eingebelendeter Bereiche
int	hblkhd		Speicher im `mmap` Bereich
int	usmblks		Maximal belegter Speicher
int	fsmblks		Speicher in freien Fastbin Blöcken
int	uordblks		Gesamter belegter Speicher
int	fordblks		Gesamter freier Speicher
int	keepcost		Oberster freigebbarer Speicher
struct mallinfo	mallinfo	(void)	Gibt Einblick in die dynamische Speicherverwaltung

`math.h`

Arithmetik für den Coprozessor (-lm)

Vergleich
double	fabs	(double x)	Absolutwert
double	copysign	(double x, double y)	`fabs(x)` und `sgn(y)`
double	nan	(const char * tagp)	Nicht darstellbare Zahl
double	fdim	(double x, double y)	Positive Differenz
double	fmin	(double x, double y)	Kleinerer Wert
double	fmax	(double x, double y)	Größerer Wert
Division
double	fmod	(double x, double y)	Divisionsrest: `x % y`
double	fma	(double x, double y, double z)	Schnelle Variante: `x*y+z`
double	modf	(double x, double * i)	Nachkommastellen trennen
double	remainder	(double x, double y)	Divisionsrest
double	remquo	(double x, double y, int * quo)	…mit zusätzlichen Bits
Wurzelziehen
double	sqrt	(double x)	Quadratwurzel
double	cbrt	(double x)	Kubikwurzel
Trigonometrie
double	[a]sin[h]	(double x)	(Arcus) Sinus (hyperbolicus)
double	[a]cos[h]	(double x)	(Arcus) Cosinus (hyperbolicus)
double	[a]tan[h]	(double x)	(Arcus) Tangens (hyperbolicus)
double	atan2	(double y, double x)	Arcus Tangens für 2 Variablen
double	hypot	(double x, double y)	Hypothenuse: sqrt(x²+y²)
Exponent
double	pow	(double x, double n)	Potenz: xⁿ
double	exp	(double x)	Natürlichen Exponent: e^x
double	exp2	(double x)	Zweierpotenz: 2^x
double	expm1	(double x)	Zweierpotenz Minus Eins: 2^x-1
double	ldexp	(double x, int exp)
double	frexp	(double x, int * exp)
double	scalbln	(double x, long int n)	x * 2ⁿ
Logarithmus
double	log	(double x)	Natürlicher Logarithmus: ln(x)
double	log10	(double x)	Dezimaler Logarithmus: log₁₀(x)
double	log2	(double x)	Binärer Logarithmus: log₂(x)
double	logb	(double x)	Exponent einer Gleitpunktzahl
double	log1p	(double x)	Logartihmus plus Eins: log(x + 1)
int	ilogb	(double x)
Rundung
double	floor	(double x)	Nächstgrößere Ganzzahl
double	ceil	(double x)	Nächstkleinere Ganzzahl
double	trunc	(double x)	Dezimalstellen Abschneiden
double	round	(double x)	Rundung
double	rint	(double x)
long	lround	(double x)
long	lrint	(double x)
long long	llround	(long double x)
long long	llrint	(long double x)
double	nearbyint	(double x)
double	nextafter	(double x, double y)	Nächste darstellbare Zahl in `[x, y]`
double	nexttoward	(double x, long double y)
Besondere-Funktionen
double	erf	(double x)	Fehlerfunktion: `2/√π·∫_0…x e^(-t·t) dt`
double	erfc	(double x)	Komplementäre Fehlerfunktion
double	tgamma	(double x)	Gammafunktion: `∫_0…∞ t^(x-1) e^-t dt`
double	lgamma	(double x)	`log(fabs(tgamma(x)))`
extern int	signgam		Vorzeichen der Gammafunktion
double	j0	(double x)	Bessel-Funktionen erster Art
double	j1	(double x)
double	jn	(int n, double x)
double	y0	(double x)	Bessel-Funktionen zweiter Art
double	y1	(double x)
double	yn	(int n, double x)
Klassifikations-Makros
int	fpclassify	(double x)	Klassifikation
int	signbit	(double x)	Vorzeichenbit gesetzt
int	isnan	(double x)	Keine darstellbare Zahl
int	isinf	(double x)	Unendlich große Zahl
int	isnormal	(double x)	Keine besondere Zahl
int	isfinite	(double x)	Endliche Zahl
int	isgreater	(double x, double y)	`x` größer als `y`
int	isgreaterequal	(double x, double y)	`x` größer oder gleich `y`
int	isless	(double x, double y)	`x` kleiner als `y`
int	islessequal	(double x, double y)	`x` kleiner oder gleich `y`
int	islessgreater	(double x, double y)	`x` ungleich `y`
int	isunordered	(double x, double y)	`x` oder `y` nicht darstellbar

`monetary.h`

Landeswährung

ssize_t	strfmon	(char * str, size_t max, const char * format, ...)
ssize_t	strfmon_l	(char * str, size_t max, locale_t locale, const char * format, ...)

Flags
%`FlagsWidth`[#`Prefix`.`Prec`]`Format`
=`Char`	Verwende Füllzeichen.
^	Gruppiere Ziffern nicht.
(	Schließe negative Werte in Klammern ein
+	Behandle Vorzeichen wie bei den Zahlen.
!	Lasse das Währungssymbol weg.
-	Richte all Felder linksbündig aus.
Format
i	Stelle `double`-Variable im internationalen Währungsformat dar.
n	Stelle `double`-Variable im nationalen Währungsformat dar.

`mqueue.h`

Nachrichten-Warteschlange (Echtzeit-Erweiterung)

Weder Linux noch Solaris unterstützen POSIX Message Queues, aber immerhin AIX.

typedef	mqd_t
mqd_t	mq_open	(const char * name, int oflag, mode_t mode)	Erzeugen
int	mq_unlink	(const char * name)	Löschen
int	mq_close	(mqd_t queue)	Schließen
struct	mq_attr
long	mq_flags		Optionen
long	mq_maxmsg		Obergrenze
long	mq_msgsize		Größe
long	mq_curmsgs		Anzahl
int	mq_getattr	(mqd_t queue, struct mq_attr * attr)
int	mq_setattr	(mqd_t queue, const struct mq_attr * attr, struct mq_attr * oldattr)
int	mq_notify	(mqd_t queue, const struct sigevent * event)
int	mq_send	(mqd_t queue, const char * buf, size_t len, unsigned priority)
ssize_t	mq_receive	(mqd_t queue, char * buf, size_t len, unsigned * priority)
int	mq_timedsend	(mqd_t queue, const char * buf, size_t len, unsigned priority, const struct timespec * timeout)
ssize_t	mq_timedreceive	(mqd_t queue, char * buf, size_t len, unsigned * priority, const struct timespec * timeout)

`ndbm.h`

Name-Wert Datenbank (NDBM)

typedef	DBM
DBM *	dbm_open	(const char * path, int oflag, mode_t mode)
void	dbm_close	(DBM * handle)
int	dbm_error	(DBM * handle)
int	dbm_clearerr	(DBM * handle)
typedef	datum
void *	dptr
size_t	dsize
datum	dbm_firstkey	(DBM * handle)
datum	dbm_nextkey	(DBM * handle)
datum	dbm_fetch	(DBM * handle, datum key)
int	dbm_delete	(DBM * handle, datum key)
int	dbm_store	(DBM * handle, datum key, datum content, int mode)

`netdb.h`

Auflösung von Hostnamen via NSS.

struct	addrinfo
extern int	h_errno
int	ai_flags
int	ai_family
int	ai_socktype
int	ai_protocol
size_t	ai_addrlen
struct sockaddr *	ai_addr
char *	ai_canonname
struct addrinfo *	ai_next
int	getaddrinfo	(const char * node, const char * service, const struct addrinfo * hints, struct addrinfo ** res)
int	getnameinfo	(const struct sockaddr * sa, socklen_t salen, char * host, size_t hostlen, char * serv, size_t servlen, int flags)
void	freeaddrinfo	(struct addrinfo * res)
const char *	gai_strerror	(int errcode)

Lesen von /etc/hosts

struct	hostent
char *	h_name
char **	h_aliases
int	h_addrtype
int	h_length
char **	h_addr_list
void	sethostent	(int stayopen)
void	endhostent	(void)
struct hostent *	gethostent	(void)
struct hostent *	gethostbyaddr	(const void * addr, int len, int type)
struct hostent *	gethostbyname	(const char * name)
struct hostent *	gethostbyname2	(const char * name, int domain)
int	gethostent_r	(struct hostent * ret, char * buf, size_t len, struct hostent ** result, int * err)
int	gethostbyname_r	(const char * name, struct hostent * ret, char * buf, size_t len, struct hostent ** result, int * err)
int	gethostbyname2_r	(const char * name, int af, struct hostent * ret, char * buf, size_t len, struct hostent ** result, int * err)
void	herror	(const char * s)
const char *	hstrerror	(int err)

Lesen von /etc/services

struct	servent
char *	s_name
char **	s_aliases
int	s_port
char *	s_proto
void	setservent	(int stayopen)
void	endservent	(void)
struct servent *	getservent	(void)
struct servent *	getservbyname	(const char * name, const char * proto)
struct servent *	getservbyport	(int port, const char * proto)

Lesen von /etc/networks

struct	netent
char *	n_name
char **	n_aliases
int	n_addrtype
uint32_t	n_net
void	setnetent	(int stayopen)
void	endnetent	(void)
struct netent *	getnetent	(void)
struct netent *	getnetbyname	(const char * name)
struct netent *	getnetbyaddr	(uint32_t net, int type)

Lesen von /etc/protocols

struct	protoent
char *	p_name
char **	p_aliases
int	p_proto
void	setprotoent	(int stayopen)
void	endprotoent	(void)
struct protoent *	getprotoent	(void)
struct protoent *	getprotobyname	(const char * name)
struct protoent *	getprotobynumber	(int proto)

`net/if.h`

Schnittstellen (ip link)

struct	if_nameindex
unsigned int	if_index
char *	if_name
struct if_nameindex *	if_nameindex	(void)
void	if_freenameindex	(struct if_nameindex * ptr)
char *	if_indextoname	(unsigned int index, char * name)
unsigned int	if_nametoindex	( const char * name)

`netinet/in.h`

Internet-Adressen

struct	in_addr
typedef	in_addr_t	uint32_t	IPv4-Adresse
typedef	in_port_t	uint16_t	Kanalnummer
in_addr_t	s_addr		IPv4-Adresse (32 Bit)
struct	sockaddr_in
sa_family_t	sin_family		`AF_INET`
in_port_t	sin_port		Kanalnummer
struct in_addr	sin_addr		IPv4-Adresse
unsigned char	sin_zero[]		Padding
struct	in6_addr
uint8_t	s6_addr[16]		IPv6-Adresse (128 Bit)
struct	sockaddr_in6
sa_family_t	sin_family		`AF_INET6`
in_port_t	sin6_port		Kanalnummer auf der Transportschicht
uint32_t	sin6_flowinfo		IPv6 Flussinformation
struct in6_addr	sin6_addr		IPv6 Adresse
uint32_t	sin6_scope_id		IPv6 scope-id

`netinet/tcp.h`

Flags für TCP

#define

TCP_NODELAY

`nl_types.h`

Internationalisierung (LC_MESSAGES)

typedef	nl_catd
nl_catd	catopen	(const char * name, int flag)
char *	catgets	(nl_catd catalog, int setno, int msgno, const char * message)
int	catclose	(nl_catd catalog)

`poll.h`

Aktivität auf Dateideskriptoren (siehe select)

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)

`pwd.h`

Benutzerdatenbank

struct	passwd
char *	pw_name		Benutzername
char *	pw_passwd		Passwort
uid_t	pw_uid		Benutzernummer
gid_t	pw_gid		Primäre Gruppe
char *	pw_gecos		Vor- und Nachname
char *	pw_dir		Benutzerverzeichnis
char *	pw_shell		Pfad der Shell
void	setpwent	(void)	Datenbank öffnen
void	endpwent	(void)	Datenbank schließen
struct passwd *	getpwent	(void)	Nächster Eintrag
struct passwd *	getpwnam	(const char * name)	Benutzer für Name
struct passwd *	getpwuid	(uid_t uid)	Benutzer für Nummer
int	getpwnam_r	(const char * name, struct passwd * pwbuf, char * buf, size_t len, struct passwd ** pwbufp)
int	getpwuid_r	(uid_t uid, struct passwd * pwbuf, char * buf, size_t len, struct passwd ** pwbufp)
int	getpwent_r	( struct passwd * pwbuf, char * buf, size_t len, struct passwd ** pwbufp)
int	fgetpwent_r	(FILE * stream, struct passwd * pwbuf, char * buf, size_t len, struct passwd ** pwbufp)
struct passwd *	fgetpwent	(FILE * stream)
int	putpwent	(const struct passwd * pwbuf, FILE * stream)
int	getpw	(uid_t uid, char * buf)

`regex.h`

Reguläre Ausdrücke (siehe fnmatch und glob)

typedef	regex_t		Opake Datenstruktur
size_t	re_nsub		Unterausdrücke
int	regcomp	( regex_t * preg, const char * regex, int cflags)
void	regfree	( regex_t * preg)	Destruktur
typedef	regmatch_t		Element in der Trefferliste
regoff_t	rm_so		Start-Offset
regoff_t	rm_eo		End-Offset
int	regexec	(const regex_t * preg, const char * string, size_t nmatch, regmatch_t pmatch[], int eflags)
size_t	regerror	(int errcode, const regex_t * preg, char * buf, size_t size)

`sched.h`

Priorisierung des Prozesses

struct	sched_param
int	sched_priority		Priorität
int	sched_ss_low_priority		Geringe Priorität für Sporadic Server Algorithmus
struct timespec	sched_ss_repl_period		Periode
struct timespec	sched_ss_init_budget		Initiales Budget
int	sched_ss_max_repl		Maximum
int	sched_yield	(void)
int	sched_setscheduler	(pid_t pid, int policy, const struct sched_param * param)
int	sched_getscheduler	(pid_t pid)
int	sched_setparam	(pid_t pid, const struct sched_param * param)
int	sched_getparam	(pid_t pid, struct sched_param * param)
int	sched_setaffinity	(pid_t pid, unsigned int len, unsigned long * mask)
int	sched_getaffinity	(pid_t pid, unsigned int len, unsigned long * mask)
int	sched_get_priority_max	(int policy)
int	sched_get_priority_min	(int policy)
int	sched_rr_get_interval	(pid_t process, struct timespec * tp)

`search.h`

Globale Suchtabellen

Globale Warteschlange
void	insque	(void * elem, void * prev)
void	remque	(void * elem)
Globaler Baum
int	(* compar)	(void * lhs, void * rhs)
void	(* action)	(const void * node, VISIT which, int depth)
void	(* free)	(void * node)
void *	tfind	(const void * key, const void ** root, compar)
void *	tsearch	(const void * key, void ** root, compar)
void *	tdelete	(const void * key, void ** root, compar)
void	twalk	(const void * root, action)
void	tdestroy	( void * root, free)
Globale Streutabelle
typedef	ENTRY
char *	key
void *	data
int	hcreate	(size_t nelem)
ENTRY *	hsearch	(ENTRY item, ACTION action)
void	hdestroy	(void)
Lineare Suche
void *	lfind	(const void * key, const void * base, size_t * nmemb, size_t size, compar)
void *	lsearch	(const void * key, void * base, size_t * nmemb, size_t size, compar)
Lokale Streutabelle
struct	hsearch_data
ENTRY *	table
unsigned int	size
unsigned int	filled
int	hcreate_r	(size_t nelem, struct hsearch_data * htab)
int	hsearch_r	(ENTRY item, ACTION action,
		ENTRY ** ret, struct hsearch_data * htab)
void	hdestroy_r	( struct hsearch_data * htab)

`semaphore.h`

Wechselseitiger Ausschluss

sem_t *	sem_open	(const char * name, int oflag, mode_t mode)	Erzeugen
int	sem_unlink	(const char * name)	Löschen
int	sem_close	(sem_t * sem)	Schließen
int	sem_destroy	(sem_t * sem)	Invalidieren
int	sem_getvalue	(sem_t * sem, int * sval)	Abfragem
int	sem_init	(sem_t * sem, int pshared, unsigned value)	Initialisieren
int	sem_post	(sem_t * sem)	Inkrementieren
int	sem_wait	(sem_t * sem)	Blockieren
int	sem_trywait	(sem_t * sem)	…mit `EAGAIN`
int	sem_timedwait	(sem_t * sem, const struct timespec * timeout)	…und Wartezeit

`setjmp.h`

Sprünge auf dem Stack

typedef	jmp_buf
int	setjmp	(jmp_buf env)
void	longjmp	(jmp_buf env, int val)
typedef	sigjmp_buf
void	sigsetjmp	(sigjmp_buf env, int savesigs)
void	siglongjmp	(sigjmp_buf env, int val)
int	_setjmp	(jmp_buf env)
void	_longjmp	(jmp_buf env, int val)

`shadow.h`

Passwortdatenbank (nicht standartisiert)

struct	spwd
char *	sp_namp		Benutzername
char *	sp_pwdp		Streuwert des Passworts, siehe `crypt`
long	sp_lstchg		Änderungsdatum (Tage seit der Epoche)
long	sp_min		Minimum Tage bis zur nächsten Änderung
long	sp_max		Maximum Tage bis zur nächsten Änderung
long	sp_warn		Anzahl Tage bis zur Ablaufwarnung
long	sp_inact		Anzahl Tage bis zur Kontosperrung
long	sp_expire		Datum der Kontosperrung
unsigned long	sp_flag		Reserviert
void	setspent	(void)	Öffnet die Schattendatenbank
void	endspent	(void)	Schließt die Schattendatenbank
struct spwd *	getspent	(void)	Liest nächsten Eintrag
struct spwd *	fgetspent	(FILE * fp)	Liest nächsten Datensatz aus Datei
struct spwd *	sgetspent	(const char * s)	Liest Datensatz aus Zeichenkette
struct spwd *	getspnam	(const char * name)	Liefert Datensatz zum Benutzernamen
int	putspent	(const struct spwd * p, FILE * fp)	Schreibt Datensatz in Datei
int	lckpwdf	(void)	Sperrt die Schattendatenbank
int	ulckpwdf	(void)	Entsperrt die Schattendatenbank
int	getspent_r	( struct spwd * spbuf, char * buf, size_t buflen, struct spwd ** spbufp)
int	getspnam_r	(const char * name, struct spwd * spbuf, char * buf, size_t buflen, struct spwd ** spbufp)
int	fgetspent_r	(FILE * fp, struct spwd * spbuf, char * buf, size_t buflen, struct spwd ** spbufp)
int	sgetspent_r	(const char * s, struct spwd * spbuf, char * buf, size_t buflen, struct spwd ** spbufp)

`signal.h`

Signalverarbeitung

Zum Kontext eines Prozesses gehört eine Bitmaske mit ignorierten und anstehenden Signalen sowie eine Signalbehandlungsroutine für jede Signalnummer. Mit der folgenden Schnittstelle kann ein Prozess bestimmte Signale ignorieren und eigene Behandlungsroutinen festlegen.

union sigval
int	raise	( int sig)	Sendet Signal an den eigenen Prozess
int	kill	(pid_t pid, int sig)	Sendet Signal an einen anderen Prozess
int	killpg	(int pgrp, int sig)	Sendet Signal an die Prozessgruppe
int	pthread_kill	(pthread_t thread, int sig)	Sendet Signal an einen Thread im eigenen Prozess
int	sival_int
void *	sival_ptr
int	sigqueue	(pid_t pid, int sig, const union sigval v)	Sendet Signal und Wert an einen Prozess
typedef void	(*sighandler_t)	(int)
sighandler_t	signal	(int sig, sighandler_t handler)	Installiert Behandlungsroutine für ein Signal
sighandler_t	sigset	(int sig, sighandler_t handler)	Dito, verwende besser `sigaction`
int	sighold	(int sig)	Sperrt Signal in der Signalmaske; verwende `sigprocmask`
int	sigrelse	(int sig)	Entsperrt Signal in der Signalmaske
int	sigignore	(int sig)	Ersetz Behandlungsroutine durch `SIG_IGN`
int	sigpause	(int sig)	Wartet auf ein Signal; verwende `sigsuspend`
int	siginterrupt	(int sig, int flag)	Erlaubt Unterbrechung von Systemaufrufen; verwende `sigaction` mit `SA_RESTART`
typedef	sigset_t		Bitmaske für Signale
int	sigemptyset	( sigset_t * set)	Entfernt Bits für alle Signale
int	sigfillset	( sigset_t * set)	Setzt Bits für alle Signale
int	sigaddset	( sigset_t * set, int sig)	Setzt Bit für ein Signal
int	sigdelset	( sigset_t * set, int sig)	Entfernt Bit für ein Signal
int	sigismember	(const sigset_t * set, int sig)	Prüft, ob das Bit gesetzt ist
int	sigsuspend	(const sigset_t * set)	Wartet auf eines der gesetzten Signale
int	sigpending	( sigset_t * set)	Ermittelt anstehendes Signal
int	sigwait	(const sigset_t * set, int * sig)	Wartet bis eines der Signale in der Bitmaske auftritt
int	sigprocmask	(int how,	Sperrt Signale in der Signalmaske aus. (außer `SIGKILL` und `SIGSTOP`)
		const sigset_t * set,	Neue Signalmaske
		sigset_t * oldset)	Alte Signalmaske
struct	sigaction
void	(* saandler)	(int)	Behandlungsroutine, standardmäßig `SIG_DFL` bzw. `SIG_IGN`
void	(* sa_sigaction)	(int, siginfo_t , void )	Behandlungsroutine, wenn `sa_flags = SA_SIGINFO` gesetzt ist
sigset_t	sa_mask		Bitmaske für während der Behandlung zu blockierende Signale
int	sa_flags		Steuerung des Verhaltens
int	sigaction	(int sig,	Registriert Behandlungsroutine für ein Signal
		const struct sigaction * act,	Neue Funktion
		struct sigaction * oldact)	Alte Funktion
typedef	siginfo_t
int	si_signo		Signalummmer
int	si_code		Signalcode
int	si_errno		Fehlercode
pid_t	si_pid		Sendender Prozess
uid_t	si_uid		Realer Benutzer
void *	si_addr		Adresse oder fehlerhafte Instruktion
int	si_status		Rückgabewert oder Signal
long	si_band		Ereignis für `SIGPOLL`
union sigval	si_value		Signalwert
int	sigwaitinfo	(const sigset_t * set, siginfo_t * info)	Legt Thread bis zum Eintreffen eines Signals schlafen
int	sigtimedwait	(const sigset_t * set, siginfo_t * info,
		const struct timespec * timeout)
void	psignal	( int sig, const char * s)	Gibt die Beschreibung des Signals in Puffer aus
void	psiginfo	(const siginfo_t * info, const char * s)	Gibt Informationen zum Ursprung des Signals aus
typedef	stack_t
void *	ss_sp		Basisadresse
int	ss_flags		Flags
size_t	ss_size		Größe
int	sigaltstack	(const stack_t * ss, stack_t * oss)	Verwendet bei der Signalbehandlung einen anderen Stack

Signalverarbeitung in Multithread-Prozessen ist etwas komplexer, siehe pthread_sigmask.

Id	Name	Default	Aktion
1	`SIGHUP`	term	Terminal Hangup
2	`SIGINT`	term	Abbrechen (`Ctrl`-`C`)
3	`SIGQUIT`	core	Abwürgen (`Ctrl`-`\`)
4	`SIGILL`	core	Illegale Instruktion
6	`SIGABRT`	core	Prozess beenden (`abort()`)
8	`SIGFPE`	core	Gleitkomma-Ausnahme
9	`SIGKILL`	term	Abschießen (nicht abfangbar, `kill -9`)
11	`SIGSEGV`	core	Speicherzugriffsfehler
13	`SIGPIPE`	term	Schreibfehler in Pipe
15	`SIGTERM`	term	Beenden (`kill`)
17	`SIGSTOP`	stop	Pausieren (nicht abfangbar)
18	`SIGTSTP`	stop	Pausieren
19	`SIGCONT`	cont	Fortsetzen
20	`SIGCHLD`	–	Kindprozess
	`…`
28	`SIGWINCH`	–	Fenstergröße
29	`SIGPWR`	term	Stromverlust

`spawn.h`

`stdarg.h`

Variable Argumentlisten

typedef	va_list
void	va_start	(va_list ap, last)
type	va_arg	(va_list ap, type)
void	va_end	(va_list ap)
void	va_copy	(va_list dest, va_list src)
int	vprintf	( const char * format, va_list ap)
int	vfprintf	(FILE * fp, const char * format, va_list ap)
int	vsprintf	(char * str, const char * format, va_list ap)
int	vsnprintf	(char * str, size_t size, const char * format, va_list ap)
int	vscanf	( const char * format, va_list ap)
int	vsscanf	(const char * str, const char * format, va_list ap)
int	vfscanf	(FILE * fp, const char * format, va_list ap)

`stdatomic.h`

Atomare Operationen

typedef	atomic_flag
bool	atomic_flag_test_and_set	(volatile atomic_flag * obj)	Setzt ein Bit und liefert den Vorwert
void	atomic_flag_clear	(volatile atomic_flag * obj)	Löscht ein Bit
volatile A
void	atomic_init	(volatile A * obj, C desired)	Initialisiert ein Objekt
bool	atomic_is_lock_free	(const v. A * obj)	Zeigt an, ob ein Objekt lockfrei ist
void	atomic_store	(volatile A * obj, C desired)	Speichert einen Wert in einem Objekt
C	atomic_load	(volatile A * obj)	Liest einen Wert aus einem Objekt
C	atomic_exchange	(volatile A * obj)	Tauscht einen Wert mit dem Wert eines Objekts
bool	atomic_compare_exchange_strong	(volatile A * obj, C * expected, C desired)	Tauscht einen Wert, wenn er den Erwartungen entspricht
bool	atomic_compare_exchange_weak	(volatile A * obj, C * expected, C desired)
C	atomic_fetch_add	(volatile A * obj, M arg)	Addiert einen Wert
C	atomic_fetch_sub	(volatile A * obj, M arg)	Subtrahiert einen Wert
C	atomic_fetch_or	(volatile A * obj, M arg)	Logisches ODER
C	atomic_fetch_xor	(volatile A * obj, M arg)	Logisches XOR
C	atomic_fetch_and	(volatile A * obj, M arg)	Logisches UND
A	kill_dependency	( A y)
typedef	memory_order
void	atomic_thread_fence	(memory_order order)	Generische Trennungsprimitive
void	atomic_signal_fence	(memory_order order)	Trennung zwischen Thread und Signalverarbeitung

Die Funktionen für Flags und Objekte existieren noch in einer _explicit-Variante, die einen zusätzlichen memory_order-Parameter kennt.

`stddef.h`

Generische Standard-Typen

#define	NULL	((void *) 0)	Zeiger nach Nirgendwo
#define	offsetof	(type, member)	Position eines Felds in der Struktur
typedef	size_t	unsigned int	Größe von Objekten im Speicher
typedef	rsize_t	unsigned int	Dito aber mit garantierter Bereichsprüfung
typedef	ptrdiff_t		Abstand innerhalb eines Objekts
typedef	wchar_t	unsigned short	16 Bit Unicode
typedef	errno_t	int	Rückgabewert für Funktionen die `errno` liefern

`stdint.h`

Generische Ganzzahl-Typen

Weil die tatsächliche Größe der eingebauten Ganzzahltypen von der Architektur des Prozessors und dem verwendeten Übersetzer abhängen, verwendet man möglichst sinnvolle Aliase, die eine Mindestgröße für bestimmte Zwecke garantieren.

#define	SIZE_MAX	0 … 2⁶⁴-1	Größe von Arrays
#define	RSIZE_MAX		Größe von Arrays mit Bereichsprüfung
#define	PTRDIFF_MIN/MAX	- … 2⁶³-1	Entfernung von Zeigern
#define	SIG_ATOMIC_MIN/MAX	- … 2³¹-1
#define	WCHAR_MIN/MAX	- … 2³¹-1
#define	WINT_MIN/MAX	0 … 2³²-1
#define	INT8_MIN/MAX	-128 … 127
…
typedef	[u]int8_t	char	8 Bit, 1 Oktett
typedef	[u]int16_t	short int	16 Bit, 2 Oktette, Wort
typedef	[u]int32_t	long int	32 Bit, 4 Oktette, Quad, Doppelwort
typedef	[u]int64_t	long long int	64 Bit, 8 Oktette, Octa, Quadrupelwort
typedef	[u]intmin_t	char	Kleinster Ganzzahltyp
typedef	[u]intmax_t	long long int	Größter Ganzzahltyp

`stdio.h`

Gepufferte Ein-/Ausgabe

ANSI C definiert die Datenstruktur FILE als plattformunabhängige Schnittstelle für den Dateizugriff. Intern werden Dateideskriptoren und die Grundoperationen open, read, write, close verwendet.

typedef	FILE		Datenstruktur mit Schreib-/Lesepuffer
#define	EOF	-1	Symbol für Dateiende
#define	BUFSIZ	8192	Optimale Puffergröße
#define	FILENAME_MAX	4096	Maximale Pfadlänge
#define	FOPEN_MAX	8	Offene Dateien
#define	TMP_MAX	25	Temporäre Dateien (POSIX) bzw. 10000 (XSI) temporäre Dateien
extern FILE *	stdin		Standardeingabe
extern FILE *	stdout		Standardausgabe
extern FILE *	stderr		Standardfehlerausgabe
Datenstrom
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 *	tmpfile	(void)	Erzeugt eine temporäre Datei und löscht diese beim Schließen
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
Wahlfreier Zugriff
void	rewind	(FILE * stream)	Setzt Position auf den Dateianfang
long	ftell	(FILE * stream)	Liefert aktuelle Position, siehe `ftello`
int	fseek	(FILE * stream, long offset, int whence)	Setzt aktuelle Position
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	fgetc	( FILE * stream)	Liest nächstes Zeichen aus Datenstrom
int	putc	(int c, FILE * stream)	Schreibt Zeichen 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
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	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

Datenstrom
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
int	pclose	(FILE * stream)	Schließt eine Pipe
Wahlfreier Zugriff
off_t	ftello	(FILE * stream)	Liefert aktuelle Position für große Dateien, siehe `ftell`
int	fseeko	(FILE * stream, off_t offset, int whence)	Setzt aktuelle Position für große Dateien
Lese- und Schreiboperationen
int	getw	( FILE * stream)	Liest Integer aus Datenstrom
int	putw	(int w, FILE * stream)	Schreibt Integer 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
Formatierte Ein-/Ausgabe
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
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
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
…

`stdlib.h`

Gemischter Beutel Buntes

Gleitpunkt-Arithmetik
double	atof	(const char * nptr)
int	atoi	(const char * nptr)
long	atol	(const char * nptr)
long long	atoll	(const char * nptr)
double	strtod	(const char * nptr, char ** endptr)
float	strtof	(const char * nptr, char ** endptr)
long double	strtold	(const char * nptr, char ** endptr)
long	strtol	(const char * nptr, char ** endptr, int base)
long long	strtoll	(const char * nptr, char ** endptr, int base)
unsigned long	strtoul	(const char * nptr, char ** endptr, int base)
unsigned long long	strtoull	(const char * nptr, char ** endptr, int base)
Ganzzahl-Arithmetik
int	abs	(int j)	Absolutwert
long int	labs	(long j)
long long int	llabs	(long long j)
typedef	div_t
int	quot		Quotient
int	rem		Rest
div_t	div	(int numerator, int denominator)	Division
ldiv_t	ldiv	(long numerator, long denominator)	mit Rest
lldiv_t	lldiv	(long long numerator, long long denominator)
Binärsuche
void	qsort	( void * base, size_t nmemb, size_t size, int (* compar) (const void , const void ))
void *	bsearch	(const void * key, const void * base, size_t nmemb, size_t size, int (* compar) (const void , const void ))
Dynamische Speicherverwaltung
void *	malloc	(size_t size)	Reservieren
void *	calloc	(size_t nmemb, size_t size)	Initialisieren
void *	realloc	(void * ptr, size_t size)	Vergrößern
void	free	(void * ptr)	Freigeben
void *	valloc	( size_t size)	Seitenanfang
void *	aligned_alloc	( size_t alignment, size_t size)	Zweierpotenz
UTF-8
int	mblen	(const char * mb, size_t n)	Anzahl Oktette
int	wctomb	( char * mb, wchar_t wc )	16-Bit – Multibyte
int	mbtowc	(wchar_t * wc, const char * mb, size_t n)	Multibyte – 16-Bit
size_t	mbstowcs	(wchar_t * wc, const char * mb, size_t n)	Multibyte – 16-Bit
size_t	wcstombs	( char * mb, const wchar_t * wc, size_t n)	16-Bit – Multibyte
Programm ausführen
int	system	(const char * command)	Kommando in Shell ausführen
void	abort	(void)	`SIGABRT` an sich selbst senden
int	atexit	(void (* function) (void))	Funktion für `exit` registrieren
_Noreturn void	exit	(int status)	`_exit` aufrufen
_Noreturn void	_Exit	(int status)	Direkt `_exit` aufrufen
int	at_quick_exit	(void (* function) (void))	Funktion für `quick_exit` registrieren
_Noreturn void	quick_exit	(int status)	`_exit` aufrufen
char *	getenv	(const char * name)	Wert der Umgebungsvariable liefern
Pseudo-Terminal
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
Pseudo-Zufallszahlen
int	rand_r	(unsigned int * seedp)	Sichere Variante von `rand`
void	srand	(unsigned int seed)	Initialisierung
void	srandom	(unsigned int seed)
long	random	(void)	Ganzzahl
char *	initstate	(unsigned int seed, char * state, size_t n)
char *	setstate	( char * state)
void	srand48	(long int seedval)
unsigned short *	seed48	(unsigned short seed16v[3])
void	lcong48	(unsigned short param[7])
double	drand48	(void)	Gleitpunktzahl
double	erand48	(unsigned short xsubi[3])	Gleitpunktzahl
long	lrand48	(void)	Nächste Positive
long	nrand48	(unsigned short xsubi[3])	Positive Zahl
long	mrand48	(void)	Vorzeichenbehaftet
long	jrand48	(unsigned short xsubi[3])	Vorzeichenbehaftet
void	setkey	(const char * key)	Schlüssel für `encrypt`
Radix-64
long	a64l	(const char * s)	Radix-64
char *	l64a	(long value)	Radix-64
Pfad
char *	realpath	(const char * path, char * resolved_path)	Absoluter Pfad
char *	mkdtemp	(char * template)	Temporäres Verzeichnis
int	mkstemp	(char * template)	Temporäre Datei
int	mkstemps	(char * template, int suffixlen)	… mit Suffix
int	mkostemp	(char * template, int flags)	… mit Optionen
int	mkostemps	(char * template, int suffixlen, int flags)	… mit Optionen und Suffix
Umgebung
int	putenv	( char * string)	Setzt Variable als `name=wert`
int	setenv	(const char * name, const char * value, int overwrite)
int	unsetenv	(const char * name)	Entfernt eine Variable aus der Umgebung
int	clearenv	(void)	Entfernt alle Variablen aus der Umgebung
Argument
int	getsubopt	(char ** optionp,	Kommaseparierte Unteroptionen; siehe `getopt`
		char * const * tokens,
		char ** valuep)

`stdnoreturn.h`

Schlüsselwort für Funktionen ohne Rücksprung (abort und exit)

#define

noreturn

_Noreturn

Definition für das Schlüsselwort

`string.h`

Zeichenketten

Eine Zeichenkette besteht aus einer Reihung von Oktetten, die durch ein NUL-Zeichen abgeschlossen wird. C kümmert sich nicht um den Zeichensatz.

size_t	strlen	(const char * s)	Länge der Zeichenkette
size_t	strxfrm	(char * dest, const char * src, size_t n)	Präfix lokalisieren
char *	strcpy	(char * dest, const char * src)	Unsicher kopieren
char *	strncpy	(char * dest, const char * src, size_t n)	Präfix kopieren
char *	strcat	(char * dest, const char * src)	Zeichnkette anhängen
char *	strncat	(char * dest, const char * src, size_t n)	Präfix anhängen
char *	strchr	(const char * s, int c)	Zeichen suchen
char *	strrchr	(const char * s, int c)	Rückwärts suchen
char *	strpbrk	(const char * s, const char * accept)	Zeichen aus Menge suchen
size_t	strspn	(const char * s, const char * accept)	Länge des Präfixes
size_t	strcspn	(const char * s, const char * reject)	…ohne diese Zeichen
char *	strstr	(const char * haystack, const char * needle)	Zeichenkette suchen
int	strcmp	(const char * s1, const char * s2)	Lexikographisch,
int	strncmp	(const char * s1, const char * s2, size_t n)	Ein Präfix,
int	strcoll	(const char * s1, const char * s2)	Lokalisiert oder
char *	strtok	(char * s, const char * delim)	Zeichenkette trennen, Verwende `strtok_r`
char *	strerror	(int errnum)	Fehlercode beschreiben, siehe `strerror_r`
void *	memset	(void * s, int c, size_t n)	Speicherbereich mit Zeichen füllen
void *	memfrob	(void * s, size_t n)	Speicherbereich mit XOR 42 behandeln
void *	memcpy	(void * dest, const void * src, size_t n)	Disjunkten Speicherbereich kopieren
void *	memccpy	(void * dest, const void * src, int c, size_t n)	Dito, aber bei einem bestimmten Zeichen stoppen
void *	mempcpy	(void * dest, const void * src, size_t n)	Dito, Zeiger auf das Ende des Zielspeichers liefern
void *	memmove	(void * dest, const void * src, size_t n)	Überlappenden Speicherbereich kopieren
void *	memchr	(const void * s, int c, size_t n)	Zeichen im Speicherbereich suchen
void *	memrchr	(const void * s, int c, size_t n)	Dito, von hinten her
void *	rawmemchr	(const void * s, int c)	Optimal, wenn das Zeichen garantiert vorkommt
int	memcmp	(const void * s1, const void * s2, size_t n)	Speicherbereiche vergleichen
void *	memmem	(const void * haystack, size_t haystacklen, const void * needle, size_t needlelen)
size_t	strnlen	(const char * s, size_t n)	Länge des Präfix
char *	stpcpy	(char * dest, const char * src)	Dito, Zeiger auf Ende
char *	stpncpy	(char * dest, const char * src, size_t n)	…Zeiger auf Ende
size_t	strlcpy	(char * dest, const char * src, size_t n)	Terminierung garantiert
size_t	strlcat	(char * dest, const char * src, size_t n)	Mit Terminierung anhängen
char *	strchrnul	(const char * s, int c)	Dito, aber nie `NULL`
char *	strrchrnul	(const char * s, int c)	…aber nie `NULL`
char *	strcasestr	(const char * haystack, const char * needle)	…ohne groß/klein
int	strverscmp	(const char * s1, const char * s2;	Numerisch sortieren
char *	strtok_r	(char * s, const char * delim, char ** save)	…Position in `save`
char *	strsep	(char ** s, const char * delim)	…Position in `s`
char *	strdup	(const char * s)	Zeichenkette auf Heap
char *	strdupa	(const char * s)	Zeichenkette auf Stack
char *	strndup	(const char * s, size_t n)	Präfix auf Heap kopieren
char *	strndupa	(const char * s, size_t n)	Präfix auf Stack kopieren
char *	strfry	(char * s)	Anagramm bilden
int	strerror_r	(int errnum, char * buf, size_t n)	Fehlercode im Puffer
char *	strsignal	(int signum)	Signal beschreiben

`strings.h`

Vergleich von Zeichenketten

int	strcasecmp	(const char * s1, const char * s2)	Zeichenkette vergleichen
int	strcasecmp_l	(const char * s1, const char * s2, locale_t locale)
int	strncasecmp	(const char * s1, const char * s2, size_t n)	Präfix vergleichen
int	strncasecmp_l	(const char * s1, const char * s2, size_t n, locale_t locale)
int	ffs	(int i)	Index des ersten Bits
int	ffsl	(long i)
int	ffsll	(long long i)

`sys/file.h`

BSD Sperr-Mechanismus

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

`sys/inotify.h`

Dateisystem-Ereignisse

Man fügt einem Überwacher-Objekt Pfade hinzu und liest mit read aufgetretene Ereignisse aus.

struct	inotify_event
int	wd		Pfad-Deskriptor
uint32_t	mask		Aufgetretene Ereignisse
uint32_t	cookie		Cookie für zusammen gehörende Ereignisse (`rename`)
uint32_t	len		Länge des zusätzlichen Speichers
char	name[]		Optionaler Speicherplatz für Pfadname
int	inotify_init	(void)	Liefert Deskriptor für einen neuen Überwacher
int	inotify_init1	(int flags)
int	inotify_add_watch	(int fd, const char * path, uint32_t mask)	Fügt einen Pfad hinzu
int	inotify_rm_watch	(int fd, int wd)	Entfernt einen Pfad

`sys/ioctl.h`

Spezialkommandos für die Ein/Ausgabe (nicht standartisiert)

int

ioctl

(int d, int request, ...)

`sys/ipc.h`

Interprozesskommunikation (System V)

struct	ipc_perm
key_t	__key		Schlüssel für `{sem\|msg\|shm}get`
uid_t	uid		Eigentümer
gid_t	gid		Eigentümergruppe
uid_t	cuid		Erzeuger
gid_t	cgid		Erzeugergruppe
unsigned short	mode		Zugriffsrechte
unsigned short	__seq		Fortlaufende Nummer
key_t	ftok	(const char * path, int salt)	Hashwert aus Pfad ableiten

`sys/mman.h`

Speicherverwaltung

Memory Mapping wird verwendet, um (Teile von) Dateien in den Adressraum des Prozesses einzublenden. Die Echtzeit-Erweiterungen erlauben es, Datei-Deskriptoren für die Verwendung mit mmap zu öffnen. Moderne Prozessoren unterstützen Memory Protection Keys, um Schreibzugriffe auf bestimmte Speicherbereiche zu unterbinden.

struct	posix_typed_mem_info
void *	mmap	( void * addr, size_t len, int prot, int flags,
		int fd, off_t offset)
int	munmap	( void * addr, size_t len)
int	mprotect	( void * addr, size_t len, int prot)
int	msync	( void * addr, size_t len, int flags)
int	mlock	(const void * addr, size_t len)
int	munlock	(const void * addr, size_t len)
int	mlockall	( int flags)
int	munlockall	(void)
int	mincore	( void * addr, size_t len, unsigned char * vec)
void *	mremap	( void * addr, size_t len, size_t new_len, int flags)
int	remap_file_pages	( void * addr, size_t len, int prot,
		ssize_t pgoff, int flags)
int	madvise	( void * addr, size_t len, int advice)
size_t	posix_tmi_length
int	posix_madvise	( void * addr, size_t len, int advice)
int	posix_mem_offset	(const void * addr, size_t len, off_t * off,
		size_t * contig_len, int * fd)
int	posix_typed_mem_open	(const char * name, int oflag, int tflag)
int	posix_typed_mem_get_info	(int fd, struct posix_typed_mem_info * info)
int	shm_open	(const char * name, int oflag, mode_t mode)
int	shm_unlink	(const char * name)
int	pkey_alloc	(unsigned long flags, unsigned long rights)
int	pkey_mprotect	(void * addr, size_t len, int prot, int pkey);
unsigned long	pkey_get	(int pkey);
int	pkey_set	(int pkey, unsigned long access_rights);
int	pkey_free	(int pkey);

`sys/msg.h`

Nachrichten-Warteschlangen (System V Message Queues)

struct	msqid_ds
struct ipc_perm	msg_perm		Zugriffsrechte
time_t	msg_stime		Sendezeit
time_t	msg_rtime		Empfangszeit
time_t	msg_ctime		Änderungszeit
msgqnum_t	msg_qnum		Nachrichten
msglen_t	msg_qbytes		Kapazität
pid_t	msg_lspid		Sender
pid_t	msg_lrpid		Empfänger
int	msgget	(key_t key, int flags)	Erzeugen
int	msgctl	(int id, int cmd, struct msqid_ds * buf)	Ändern
int	msgsnd	(int id, void * msg, size_t len, int msgflg)
int	msgrcv	(int id, void * msg, size_t len, long int type, int msgflg)

`sys/resource.h`

Zuteilung von Betriebsmitteln

struct	rlimit
int	getpriority	(int which, id_t id)
int	setpriority	(int which, id_t id, int priority)
rlim_t	rlim_cur		Aktuelle Grenze
rlim_t	rlim_max		Harte Grenze, Maximum für `rlim_cur`
int	getrlimit	(int what, struct rlimit * limits)
int	setrlimit	(int what, const struct rlimit * limits)
struct	rusage
struct timeval	ru_utime		Rechenheit des Besitzers
struct timeval	ru_stime		Rechenheit des Systems
long	ru_maxrss		Maximale RSS in Kilobyte
long	ru_ixrss		@todo integral shared memory size
long	ru_idrss		@todo integral unshared data size
long	ru_isrss		@todo integral unshared stack size
long	ru_minflt		Weiche Seitenfehler
long	ru_majflt		Harte Seitenfehler
long	ru_nswap		Swap-Operationen
long	ru_inblock		Lese-Operationen
long	ru_oublock		Schreib-Operationen
long	ru_msgsnd		Gesendete IPC-Nachrichten
long	ru_msgrcv		Empfangene IPC-Nachrichten
long	ru_nsignals		Empfangene Signale
long	ru_nvcsw		Freiwillige Kontextwechsel
long	ru_nivcsw		Unfreiwillige Kontextwechsel
int	getrusage	(int who, struct rusage * usage)	Liefert Statistik über verbrauchte Ressourcen

`sys/select.h`

Aktivität auf Dateideskriptoren (siehe poll)

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)

`sys/sem.h`

Wechselseitiger Ausschluss (System V Semaphore)

struct	semid_ds
struct ipc_perm	sem_perm
time_t	sem_otime
time_t	sem_ctime
unsigned short	sem_nsems
int	semget	(key_t key, int nsems, int flags)
union	semun
int	val		`SETVAL`
struct semid_ds *	buf		`IPC_{STAT,SET}`
unsigned short *	array		`{GET,SET}ALL`
int	semctl	(int semid, int semnum, int cmd, ...)
struct	sembuf
unsigned short	sem_num		Index
short	sem_op		-1, 0, 1
short	sem_flg
int	semop	(int semid, struct sembuf * sops, unsigned nsops)
int	semtimedop	(int semid, struct sembuf * sops, unsigned nsops, struct timespec * timeout)

`sys/shm.h`

Gemeinsamer Speicher (System V Shared Memory)

struct	shmid_ds
struct ipc_perm	shm_perm		Zugriffsrechte
size_t	shm_segsz		Größe in Oktetten
time_t	shm_atime		Einblenden
time_t	shm_dtime		Ausblenden
time_t	shm_ctime		Änderung
pid_t	shm_cpid		Erzeuger
pid_t	shm_lpid		Einblender
shmatt_t	shm_nattch		Anzahl
int	shmget	(key_t key, size_t size, int flags)	Erzeugen
int	shmctl	(int id, int cmd, struct shmid_ds * buf)	Ändern
void *	shmat	(int id, const void * addr, int shmflg)	Einblenden
int	shmdt	( const void * addr)	Ausblenden

`sys/socket.h`

Netzwerk-Sockel

struct	sockaddr
int	socket	(int domain, int type, int protocol)
int	socketpair	(int domain, int type, int protocol, int fd[2])
int	sockatmark	(int fd)
sa_family_t	sa_family
char	sa_data[14]
int	bind	(int fd, const struct sockaddr * addr, socklen_t len)
int	listen	(int fd, int backlog)
int	accept	(int fd, struct sockaddr * addr, socklen_t * len)
int	connect	(int fd, const struct sockaddr * addr, socklen_t len)
int	shutdown	(int fd, int how)
int	getsockname	(int fd, struct sockaddr * addr, socklen_t * len)
int	getpeername	(int fd, struct sockaddr * addr, socklen_t * len)
int	getsockopt	(int fd, int level, int optname, void * optval, socklen_t * optlen)
int	setsockopt	(int fd, int level, int optname, const void * optval, socklen_t optlen)
ssize_t	send	(int fd, const void * buf, size_t len, int flags)
ssize_t	sendto	(int fd, const void * buf, size_t len, int flags, const struct sockaddr * to, socklen_t len)
ssize_t	recv	(int fd, void * buf, size_t len, int flags)
ssize_t	recvfrom	(int fd, void * buf, size_t len, int flags,
		struct sockaddr * from, socklen_t * len)
struct	msghdr
void *	msg_name
socklen_t	msg_namelen
struct iovec *	msg_iov
size_t	msg_iovlen
void *	msg_control
socklen_t	msg_controllen
int	msg_flags
ssize_t	sendmsg	(int fd, const struct msghdr * msg, int flags)
ssize_t	recvmsg	(int fd, struct msghdr * msg, int flags)

`sys/stat.h`

Metadaten von Dateien

struct	stat
#define	S_ISLNK	(mode)	Symbolischer Verweis
#define	S_ISREG	(mode)	Reguläre Datei
#define	S_ISDIR	(mode)	Verzeichnis
#define	S_ISCHR	(mode)	Zeichengerät
#define	S_ISBLK	(mode)	Blockgerät
#define	S_ISFIFO	(mode)	FIFO
#define	S_ISSOCK	(mode)	Sockel
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		Anzahl Oktette
blksize_t	st_blksize		Anzahl 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
int	stat	(const char * path, struct stat * buf)	Ermittelt Status einer Datei
int	lstat	(const char * path, struct stat * buf)	Ermittelt Status eines Symlinks
int	chmod	(const char * path, mode_t mode)	Ändert Zugriffsrechte einer Datei
int	mkdir	(const char * path, mode_t mode)	Erzeugt ein Verzeichnis
int	mkfifo	(const char * path, mode_t mode)	Erzeugt eine FIFO
int	mknod	(const char * path, mode_t mode, dev_t dev)	Erzeugt einen Dateisystem-Knoten
int	mkdirat	(int fd, const char * path, mode_t mode)	Erzeugt Verzeichnis relativ zu einem anderen Verzeichnis
int	mkfifoat	(int fd, const char * path, mode_t mode)	Erzeugt FIFO relativ zum Verzeichnis
int	mknodat	(int fd, const char * path, mode_t mode, dev_t dev)	Erzeugt Dateisystem-Knoten relativ zum Verzeichnis
int	fstat	(int fd, struct stat * buf)	Ermittelt Status einer geöffneten Datei
int	fchmod	(int fd, mode_t mode)	Ändert Zugriffsrechte einer geöffneten Datei
mode_t	getumask	(void)	Liefert Maske für Zugriffrechte
mode_t	umask	(mode_t mode)	Setzt Maske für Zugriffrechte

`sys/statvfs.h`

Füllstand des Dateisystems

struct	statvfs
unsigned long	f_bsize		Blockgröße
unsigned long	f_frsize		Fragmentgröße
fsblkcnt_t	f_blocks		Anzahl Fragmente im Dateisystem
fsblkcnt_t	f_bfree		Anzahl freier Blöcke
fsblkcnt_t	f_bavail		Anzahl freier Blöcke für unprivilegierte Benutzer
fsfilcnt_t	f_files		Anzahl Inodes
fsfilcnt_t	f_ffree		Anzahl freier Inodes
fsfilcnt_t	f_favail		Anzahl freier Inodes für unprivilegierte Benutzer
unsigned long	f_fsid		Identifikationsnummer
unsigned long	f_flag		Bitmaske für Flags
unsigned long	f_namemax		Maximale Länge für Dateinamen
int	fstatvfs	(int fd, struct statvfs * buf)
int	statvfs	(const char * path, struct statvfs * buf)

`sys/time.h`

Zugriffszeiten von Dateien (Siehe select, getrusage und utmpx)

struct	timeval
typedef	suseconds_t	long	Mikrosekunden
time_t	tv_sec		Sekunden
suseconds_t	tv_usec		Mikrosekunden
int	utimes	(const char * path, const struct timeval times[2])	Änderungs- und Zugriffszeit
struct	timezone
int	tz_minuteswest		GMT-Versatz
int	tz_dsttime		Sommerzeit
int	gettimeofday	( struct timeval * tv,	Aktuelle Uhrzeit
		struct timezone * tz)	`clock_gettime`
struct	itimerval
struct timeval	it_interval		Zeitspanne
struct timeval	it_value		Aktueller Wert
int	setitimer	(int type,	Signal senden
		const struct itimerval * new_value,	`timer_settime`
		struct itimerval * old_value)
int	getitimer	(int type,	Zählerstand
		struct itimerval * current)	`timer_gettime`

`sys/times.h`

Rechenzeit des Prozesses

struct	tms
clock_t	tms_utime		Eigene Prozesszeit
clock_t	tms_stime		Eigene Systemzeit
clock_t	tms_cutime		Prozesszeit beendeter Kindprozesse
clock_t	tms_cstime		Systemzeit beendeter Kindprozesse
clock_t	times	(struct tms * buf)	Verbrauchte Rechenzeit ermitteln

`sys/uio.h`

Vektorisierte Ein-/Ausgabe

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)

`sys/un.h`

Unix Domain Sockets

struct	sockaddr_un
sa_family_t	sun_family		`AF_LOCAL`
char	sun_path[100]		Pfad

`sys/utsname.h`

Namensgebung des Betriebssystems (uname(1))

struct	utsname
char	sysname[]	"Linux"	Kernelname
char	nodename[]	"debian"	Hostname
char	release[]	"3.16.0-4-amd64"	Kernelversion
char	version[]	"#1 SMP … (2015-07-17)"	Kerneldatum
char	machine[]	"x86_64"	Systemarchitektur
int	uname	(struct utsname * buf)	Betriebssystem identifizieren

`sys/wait.h`

Warten auf Kindprozesse

pid_t	wait	( int * status)	Wartet auf `SIGCHLD` von einem Kindprozess
pid_t	wait3	( int * status, int options, struct rusage * rusage)	… und liest dessen Ressourcenverbrauch
pid_t	waitpid	(pid_t pid, int * status, int options)	Wartet auf einen bestimmten Prozess
pid_t	wait4	(pid_t pid, int * status, int options, struct rusage * rusage)	… und liest dessen Ressourcenverbrauch
int	waitid	(idtype_t idtype, id_t id, siginfo_t * info, int options)	Wartet auf ein bestimmtes Ereignis

`syslog.h`

Meldungen per Syslog (Siehe fmtmsg)

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

`tar.h`

`termios.h`

Terminal-Steuerung

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)

`tgmath.h`

`threads.h`

Nebenläufigkeit

typedef	thrd_t
int	thrd_create	(thrd_t * thr, thrd_start_t func, void * arg)
thrd_t	thrd_current	(void)
int	thrd_detach	(thrd_t thr)
int	thrd_equal	(thrd_t thr0, thrd_t thr1)
noreturn void	thrd_exit	( int res)
int	thrd_join	(thrd_t thr, int * res)
int	thrd_sleep	(const struct timespec * duration,
		( struct timespec * remaining)
void	thrd_yield	(void)
typedef	mtx_t
void	mtx_destroy	(mtx_t * mtx)
int	mtx_init	(mtx_t * mtx, int type)
int	mtx_lock	(mtx_t * mtx)
int	mtx_timedlock	(mtx_t * mtx, const struct timespec * timeout)
int	mtx_trylock	(mtx_t * mtx)
int	mtx_unlock	(mtx_t * mtx)
typedef	cnd_t
void	call_once	(once_flag * flag, void (* func)(void))
void	cnd_broadcast	(cnd_t * cond)
void	cnd_destroy	(cnd_t * cond)
void	cnd_init	(cnd_t * cond)
void	cnd_signal	(cnd_t * cond)
void	cnd_timedwait	(cnd_t * cond, mtx_t * mtx,
		const struct timespec * timeout)
void	cnd_wait	(cnd_t * cond, mtx_t * mtx)
typedef	tss_t
int	tss_create	(tss_t * key, tss_dtor_t dtor)
void	tss_delete	(tss_t key)
void *	tss_get	(tss_t key)
int	tss_set	(tss_t key, void * val)

`time.h`

Darstellung und Umrechnung von Zeitpunkten

typedef	time_t		Sekunden seit Beginn der Unix-Epoche
#define	CLOCKS_PER_SEC	1000000
time_t	time	( time_t * t)	0
double	difftime	( time_t t1, time_t t0)	Differenz
struct	tm		Kalenderzeit
int	tm_sec	0–59	Sekunde
int	tm_min	0–59	Minute
int	tm_hour	0–23	Stunde
int	tm_mday	1–31	Tag des Monats
int	tm_mon	0–11	Januar…Dezember
int	tm_year	0–200	Jahre seit 1900
int	tm_wday	0–6	Sonntag…Samstag
int	tm_yday	0–365	Jahrestag
int	tm_isdst	0–1	1=Sommerzeit
struct tm *	localtime	(const time_t * t)	Mit Zeitzone, Verwende `localtime_r`
struct tm *	gmtime	(const time_t * t)	UTC, Verwende `gmtime_r`
time_t	mktime	(struct tm * tm)	Normalisierung
size_t	strftime	( char * str, size_t max, const char * format, const struct tm * tm)	Schablone
char *	ctime	(const time_t * t)	RFC-822, Verwende `ctime_r`
char *	asctime	(const struct tm * tm)	Verwende `asctime_r`
extern char *	tzname[2]		Zeitzone
extern long	timezone
extern int	daylight
void	tzset	(void)	`tzname` aus `$TZ`
struct tm *	localtime_r	(const time_t * t, struct tm * result)	Sichere Version von `localtime` mit Zeitzone
struct tm *	gmtime_r	(const time_t * t, struct tm * result)	Sichere Version von `gmtime`, liefert UTC
struct tm *	getdate	(const char * str)	`DATEMSK`
struct tm *	getdate_r	(const char * str, struct tm * result)
char *	strptime	(const char * str, const char * format, struct tm * tm)	Schablone
char *	ctime_r	(const time_t * t, char * buf)	Sichere Version von `ctime`
char *	asctime_r	(const struct tm * tm, char * buf)	Sichere Version von `asctime`
typedef	clock_t	long int	Prozessor-Ticks seit Start des Prozesse
clock_t	clock	(void)
struct	timespec
time_t	tv_sec
long int	tv_nsec
int	clock_getcpuclockid	(pid_t pid, clockid_t * id)
int	clock_getres	(clockid_t id, struct timespec * tp)
int	clock_gettime	(clockid_t id, struct timespec * tp)
int	clock_settime	(clockid_t id, const struct timespec * tp)
int	clock_nanosleep	(clockid_t id, int flags, const struct timespec * request, struct timespec * remain)
int	nanosleep	( const struct timespec * request, struct timespec * remain)
Zeitgeber für Intervalle
typedef	timer_t
int	timer_create	(clockid_t id, struct sigevent * event
		timer_t * timer)
int	timer_delete	(timer_t timer)
int	timer_getoverrun	(timer_t timer)
struct	itimerspec
struct timespec	it_interval
struct timespec	it_value
int	timer_gettime	(timer_t timer, struct itimerspec * current)
int	timer_settime	(timer_t timer, int flags, const struct itimerspec * oldval, struct itimerspec * newval)

`trace.h`

`ulimit.h`

Maximale Dateigrößen

long

ulimit

(int cmd, long newlimit)

Maximale Dateigröße, verwende getrlimit bzw. setrlimit

`unistd.h`

Diverse Unix Funktionen

Umgebung
extern char **	environ		Null-terminierte Liste aller Umgebungsvariablen
Argumente
extern char *	optarg		Parameter der aktuellen Option
extern int	optind	0 < `optind` < argc	Index der nächsten Option
extern int	opterr	1	Fehlerausgabe unterdrücken mit 0
extern int	optopt		Falscher Buchstabe, wenn `getopt` ein `'?'` liefert
int	getopt	(int argc, char * const argv[],	Buchstabe der nächsten Option in der Argumentliste,
		const char * optstring)	inkrementiert `optind` und setzt `optarg`
Ein/Ausgabe
#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
Terminal
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
Benutzer
char *	getlogin	(void)	Besitzer des Terminals
int	getlogin_r	(char * buf, size_t size)	Benutzernamen in Puffer schreiben
typedef	uid_t	int	Benutzernummer
uid_t	getuid	(void)	Besitzer des Prozesses
uid_t	geteuid	(void)	Effektiver Benutzer
int	getresuid	(uid_t * ruid, uid_t * euid, uid_t * suid)	Liefert alle relevanten Benutzer
int	setuid	(uid_t uid)	Ändert effektiven und (wenn root) realen Benutzer
int	seteuid	(uid_t euid)	Ändert nur den effektiven Benutzer
int	setreuid	(uid_t ruid, uid_t euid)	Ändert realen und effektiven Benutzer
int	setresuid	(uid_t ruid, uid_t euid, uid_t suid)	Ändert alle Benutzer auf einmal
typedef	gid_t	int	Gruppennummer
gid_t	getgid	(void)	Gruppe des Prozesses
gid_t	getegid	(void)	Effektive Gruppe
int	getresgid	(gid_t * rgid, gid_t * egid, gid_t * sgid)	Liefert alle relevanten Gruppen
int	setgid	(gid_t gid)	Ändert effektive und (wenn root) reale Gruppe
int	setegid	(gid_t egid)	Ändert nur die effektive Gruppe
int	setregid	(gid_t rgid, gid_t egid)	Ändert reale und effektive Gruppe
int	setresgid	(gid_t rgid, gid_t egid, gid_t sgid)	Ändert alle Gruppen auf einmal
Verschlüsselung
void	encrypt	(char block[64], int edflag)	Daten mit `setkey` verschlüsseln
char *	crypt	(const char * key, const char * salt	Streuwert über Passwort bilden
char *	crypt_r	(const char * key, const char * salt, struct crypt_data * data)
Netzwerk
int	gethostname	( char * name, size_t len)	Eigener Hostname
int	sethostname	(const char * name, size_t len)
int	getdomainname	( char * name, size_t len)	Eigene Domäne
int	setdomainname	(const char * name, size_t len)
long	gethostid	(void)	Identifikation
int	sethostid	(long hostid)
Prozess ausführen
pid_t	fork	(void)	Kindprozess abspalten; oft gefolgt von `exec`
int	execl	(const char * path, const char * arg, ...)	Programm mit Argumenten starten
int	execlp	(const char * path, const char * arg, ...)	… und Programm im `PATH` suchen
int	execle	(const char * path, const char * arg, ...,	… und Umgebung vorbesetzen
		char * const envp[])
int	execv	(const char * path, char * const argv[])	Programm mit Argumenten starten
int	execvp	(const char * path, char * const argv[])	… und Programm im `PATH` suchen
int	execve	(const char * path, char * const argv[]	… und Umgebung vorbesetzen
		char * const envp[])
int	execvpe	(const char * path, char * const argv[]	Alle Varianten kombiniert
		char * const envp[])
int	fexecve	(int fd, char * const argv[],	Geöffnete Binärdatei ausführen
		char * const envp[])
Prozess gruppieren
typedef	pid_t		Prozessnummer
pid_t	getpid	(void)	Eigene Prozessnummer
pid_t	getppid	(void)	Prozessnummer des Elternprozesses
pid_t	getsid	(pid_t process)	Sitzungsnummer des Prozesses
pid_t	getpgid	(pid_t process)	Prozessgruppe eines anderen Prozesses
pid_t	getpgrp	(void)	Eigene Prozessgruppe
pid_t	setsid	(void)	Neue Prozessgruppe erzeugen
int	setpgid	(pid_t process, pid_t group)	Prozess einer Prozessgruppe zuweisen
pid_t	tcgetpgrp	(int fd)	Prozessnummer der Vordergrundgruppe
int	tcsetpgrp	(int fd, pid_t group)	Prozessgruppe in den Vordergrund bringen
int	setpgrp	(void)	Entspricht `setpgid (0, 0)`
Prozess steuern
int	nice	(int inc)	Priorität senken
int	pause	(void)	Auf Signal warten
unsigned	alarm	(unsigned int seconds)	`SIGALRM` auslösen
unsigned	sleep	(unsigned int seconds)	Prozess pausieren
typedef	useconds_t	long	Mikrosekunden
int	usleep	(useconds_t usec)	Obsolet, verwende `nanosleep`
_Noreturn	_exit	(int status)	Wird von `exit` aufgerufen, schließt offene Dateien und sendet `SIGCHLD` an Elternprozess

2 Zeichen aus der Menge [a-zA-Z0-9./] für DES in 4096 Variationen

`utime.h`

Zugriffszeit von Dateien (obsolet)

struct	utimbuf
time_t	actime		Zeitpunkt des letzten Zugriffs
time_t	modtime		Zeitpunkt der letzten Änderung
int	utime	(const char * path,	Setzt Zeitstempel einer Datei
		const struct utimbuf * buf)	Obsolet, verwende `utimes`

`utmpx.h`

Anmelde-Protokoll (/var/log/wtmp)

struct	utmpx
char	ut_user[]		Benutzername
char	ut_id[]		Initialisierungsprozess
char	ut_line[]		Gerätename
pid_t	ut_pid		Prozessnummer
short	ut_type		Typ
struct timeval	ut_tv		Zeitpunkt des Eintrags
void	setutxent	(void)
void	endutxent	(void)
struct utmpx *	getutxent	(void)
struct utmpx *	getutxid	(const struct utmpx * ut)
struct utmpx *	getutxline	(const struct utmpx * ut)
struct utmpx *	pututxline	(const struct utmpx * ut)

`uchar.h`

Konversion von UTF-8-Zeichen

typedef	mbstate_t		Zwischenstand
typedef	char16_t		16-Bit Unicode
typedef	char32_t		32-Bit Unicode
size_t	c16rtomb	(char * mb, char16_t c16, mbstate_t * s)	16-Bit – Multibyte
size_t	c32rtomb	(char * mb, char32_t c32, mbstate_t * s)	32-Bit – Multibyte
size_t	mbrtoc16	(char16_t * c16, const char * mb, size_t max, mbstate_t * s)	Multibyte – 16-Bit
size_t	mbrtoc32	(char32_t * c32, const char * mb, size_t max, mbstate_t * s)	Multibyte – 32-Bit

`wchar.h`

Verarbeitung von Multibyte-Zeichen

Konversion
typedef	wint_t		Quadrupelbyte
typedef	wchar_t		Doppelbyte
wint_t	btowc	(int c)	Konvertiert Oktett in Quadrupel
int	wctob	(wint_t c)	Konvertiert Quadrupel in Oktett oder liefert `EOF`
Datenstrom
wint_t	fgetwc	( FILE * fp)
wint_t	fputwc	(wchar_t c, FILE * fp)
wchar_t *	fgetws	(wchar_t * s, int n, FILE * fp)
int	fputws	(const wchar_t * s, FILE * fp)
int	fwide	( FILE * fp, int mode)
wint_t	getwc	( FILE * fp)
wint_t	getwchar	(void)
wint_t	putwc	(wchar_t c, FILE * fp)
wint_t	putwchar	(wchar_t c)
wint_t	ungetwc	(wint_t c, FILE * fp)
Formatierung
int	fwscanf	( FILE * fp, const wchar_t * format, ...)
int	fwprintf	( FILE * fp, const wchar_t * format, ...)
int	vfwscanf	( FILE * fp, const wchar_t * format, va_list arg)
int	vfwprintf	( FILE * fp, const wchar_t * format, va_list arg)
int	wscanf	( const wchar_t * format, ...)
int	wprintf	( const wchar_t * format, ...)
int	vwscanf	( const wchar_t * format, va_list arg)	Standardeingabe
int	vwprintf	( const wchar_t * format, va_list arg)	Standardausgabe
int	swscanf	(const wchar_t * s, const wchar_t * format, ...)
int	swprintf	( wchar_t * s, size_t n, const wchar_t * format, ...)
int	vswscanf	(const wchar_t * s, size_t n, const wchar_t * format, va_list arg)
int	vswprintf	( wchar_t * s, size_t n, const wchar_t * format, va_list arg)
size_t	wcsftime	( wchar_t * s, size_t n, const wchar_t * format, const struct tm * tm)
Multibyte
int	mbsinit	(const mbstate_t * ps)	Setzt Zustand auf Anfang
size_t	mbrlen	( const char * s, size_t n, mbstate_t * ps)	Liefert Oktettzahl des nächsten Zeichens
size_t	mbrtowc	(wchar_t * pwc, const char * s, size_t n, mbstate_t * ps)	Extrahiert ein Multibyte-Zeichen
size_t	mbsrtowcs	(wchar_t * dst, const char ** src, size_t len, mbstate_t * ps)	Konvertiert Multibyte nach Wide
size_t	wcrtomb	(char * s, wchar_t wc, mbstate_t * ps)	Konvertiert 16-Bit in Multibyte
size_t	wcsrtombs	(char * dst, const wchar_t ** src, size_t len, mbstate_t * ps)	Konvertiert 16-Bit nach Multibyte
Zahlen
double	wcstod	(const wchar_t * nptr, wchar_t ** endptr)
float	wcstof	(const wchar_t * nptr, wchar_t ** endptr)
long double	wcstold	(const wchar_t * nptr, wchar_t ** endptr)
long long	wcstoll	(const wchar_t * nptr, wchar_t ** endptr, int base)
unsigned long long	wcstoull	(const wchar_t * nptr, wchar_t ** endptr, int base)
long	wcstol	(const wchar_t * nptr, wchar_t ** endptr, int base)
unsigned long	wcstoul	(const wchar_t * nptr, wchar_t ** endptr, int base)
Zeichenketten
wchar_t *	wcscat	( wchar_t * s1, const wchar_t * s2)
int	wcscmp	(const wchar_t * s1, const wchar_t * s2)
int	wcscoll	(const wchar_t * s1, const wchar_t * s2)
wchar_t *	wcscpy	( wchar_t * s1, const wchar_t * s2)
size_t	wcscspn	(const wchar_t * s1, const wchar_t * s2)
size_t	wcslen	(const wchar_t * s)
wchar_t *	wcsncat	( wchar_t * s1, const wchar_t * s2, size_t n)
int	wcsncmp	(const wchar_t * s1, const wchar_t * s2, size_t n)
wchar_t *	wcsncpy	( wchar_t * s1, const wchar_t * s2, size_t n)
size_t	wcsspn	(const wchar_t * s1, const wchar_t * s2)
wchar_t *	wcsstr	(const wchar_t * s1, const wchar_t * s2)
wchar_t *	wcstok	( wchar_t * s1, const wchar_t * s2, wchar_t ** ptr)
size_t *	wcsxfrm	( wchar_t s1, const wchar_t * s2, size_t n)
Speicherbereiche
int *	wmemcmp	(const wchar_t s1, const wchar_t * s2, size_t n)
wchar_t *	wmemcpy	( wchar_t * s1, const wchar_t * s2, size_t n)
wchar_t *	wmemmove	( wchar_t * s1, const wchar_t * s2, size_t n)
wchar_t *	wmemset	( wchar_t * s, wchar_t c, size_t n)
wchar_t *	wcschr	(const wchar_t * s, wchar_t c)
wchar_t *	wcspbrk	(const wchar_t * s1, const wchar_t * s2)
wchar_t *	wcsrchr	(const wchar_t * s, wchar_t c)
wchar_t *	wcsstr	(const wchar_t * s1, const wchar_t * s2)
wchar_t *	wmemchr	(const wchar_t * s, wchar_t c, size_t n)
int	wcwidth	(wchar_t c)	Liefert Spaltenbreite eines Zeichens
int	wcswidth	(const wchar_t * s, size_t n)	Berechnet Spaltenbreite für Zeichenkette
Datenstrom
FILE *	open_wmemstream	(wchar_t ** ptr, size_t * sizeloc)	Operiert auf einem dynamisch wachsenden Puffer
Zeichenketten
wchar_t *	wcsdup	(const wchar_t * s)
int	wcscasecmp	(const wchar_t * s1, const wchar_t * s2)
int	wcsncasecmp	(const wchar_t * s1, const wchar_t * s2, size_t n)
size_t	wcsnlen	(const wchar_t * s, size_t maxlen)
wctrans_t	wctrans	(const char * name)
Speicherbereiche
wchar_t *	wcpcpy	(wchar_t * dest, const wchar_t * src)
wchar_t *	wcpncpy	(wchar_t * dest, const wchar_t * src, size_t n)
int	iswctype_l	(wint_t c, wctype_t category, locale_t locale)
int	iswalnum_l	(wint_t c, locale_t locale)
int	iswalpha_l	(wint_t c, locale_t locale)
int	iswblank_l	(wint_t c, locale_t locale)
int	iswcntrl_l	(wint_t c, locale_t locale)
int	iswdigit_l	(wint_t c, locale_t locale)
int	iswgraph_l	(wint_t c, locale_t locale)
int	iswlower_l	(wint_t c, locale_t locale)
int	iswprint_l	(wint_t c, locale_t locale)
int	iswpunct_l	(wint_t c, locale_t locale)
int	iswspace_l	(wint_t c, locale_t locale)
int	iswupper_l	(wint_t c, locale_t locale)
int	iswxdigit_l	(wint_t c, locale_t locale)
int	iswblank_l	(wint_t c, locale_t locale)
wint_t	towctrans_l	(wint_t c, wctrans_t category, locale_t locale)
wint_t	towlower_l	(wint_t c, locale_t locale)
wint_t	towupper_l	(wint_t c, locale_t locale)

`wctype.h`

Multibyte-Zeichen klassifizieren.

typedef	wctype_t
int	iswctype	(wint_t c, wctype_t category)
int	iswalnum	(wint_t c)
int	iswalpha	(wint_t c)
int	iswblank	(wint_t c)
int	iswcntrl	(wint_t c)
int	iswdigit	(wint_t c)
int	iswgraph	(wint_t c)
int	iswlower	(wint_t c)
int	iswprint	(wint_t c)
int	iswpunct	(wint_t c)
int	iswspace	(wint_t c)
int	iswupper	(wint_t c)
int	iswxdigit	(wint_t c)
int	iswblank	(wint_t c)
typedef	wctrans_t
wint_t	towctrans	(wint_t c, wctrans_t category)
wint_t	towlower	(wint_t c)
wint_t	towupper	(wint_t c)

`wordexp.h`

Wortlisten expandieren.

typedef	wordexp_t
size_t	we_wordc
char **	we_wordv
size_t	we_offs
int	wordexp	(const char * words, wordexp_t * pwordexp, int flags)
void	wordfree	( wordexp_t * pwordexp)

Literatur

The Open Group: Portable Operating System Interface
Stevens, Rago: Advanced Programming in the Unix Environment
Michael Kerrisk: The Linux Programming Interface
Brian Hall: Beej's Guide to Network Programming
Jonathan Corbet: System calls for memory protection keys, 2. Juni 2016, LWN

`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.

`E2BIG`	Argumentliste zu lang
`EACCESS`	Zugriff verweigert
`EAGAIN`	Ressource vorübergehend nicht verfügbar
…
`EWOULDBLOCK`	Operation würde blockieren
`EXDEV`	Improper link
`EXFULL`	Exchange full

`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.

`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

MM_OK	Okay
MM_NOTOK	Fehler
MM_NOMSG	Fehler beim Schreiben auf die Standardfehlerausgabe (`stderr`)
MM_NOCON	Fehler beim Schreiben auf die Systemkonsole

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

0	Zeichenkette passt auf das Muster.
FNM_NOMATCH	Zeichenkette passt nicht auf das Muster.

FNM_PATHNAME	Schrägstriche in der Zeichenkette passen nur auf Schrägstriche im Muster
FNM_PERIOD	Führende Punkte in der Zeichenkette müssen genau auf das Muster passen.
FNM_NOESCAPE	Backslash nicht als Fluchtsymbol interpretieren.

FTW_F	Datei
FTW_D	Verzeichnis
FTW_DNR	Verzeichnis ohne Leserechte
FTW_DP	Verzeichnis mit besuchten Unterverzeichnissen
FTW_NS	Unbekannter Typ (`stat` ist fehlgeschlagen)
FTW_SL	Symlink
FTW_SLN	Symlink auf fehlende Datei

FTW_PHYS	Folgt keinen Symlinks.
FTW_MOUNT	Überquert keine Dateisystemgrenzen.
FTW_DEPTH	Besucht Unterverzeichnisse zuerst.
FTW_CHDIR	Wechselt vorher das aktuelle Arbeitsverzeichnis.

FTS_D	Normales Verzeichnis in Preorder
FTS_DC	Zyklisches Verzeichnis, siehe `fts_cycle`
FTS_DEFAULT	Keine der anderen Optionen
FTS_DNR	Nicht lesbares Verzeichnis, siehe `fts_errno`
FTS_DOT	`.` oder `..` Verzeichnis
FTS_DP	Normales Verzeichnis in Postorder
FTS_ERR	Unspezifische Fehler, siehe `fts_errno`
FTS_F	Normale Datei
FTS_NS	Metadaten nicht lesbar `fts_statp` ist leer, siehe `fts_errno`
FTS_NSOK	Metadaten nicht vorhanden `fts_statp` ist leer
FTS_SL	Symbolische Verknüpfung
FTS_SLNONE	Tote symbolische Verknüpfung

FTS_LOGICAL	Symbolische Links dereferenzieren
FTS_PHYSICAL	Symbolische Links als solche liefern
FTS_COMFOLLOW	Symbolischen Links sofort folgen
FTS_NOCHDIR	Arbeitsverzeichnis nicht wechseln
FTS_NOSTAT	Keine Metadaten lesen (`fts_info=FTS_NSOK`)
FTS_SEEDOT	Verzeichnisse `.` und `..` nicht ignorieren.
FTS_XDEV	Dateisystem nicht verlassen

FTS_AGAIN	Eintrag noch einmal besuchen
FTS_FOLLOW	Symbolischem Link folgen
FTS_SKIP	Unterverzeichnis nicht besuchen

GDBM_REPLACE	Eventuell vorhandenen Wert ersetzen
GDBM_INSERT	Fehler bei bereits vorhandenem Wert

GDBM_META_MASK_MODE	Zugriffsrechte nicht wiederherstellen
GDBM_META_MASK_OWNER	Besitzer nicht wiederherstellen

GDBM_NO_ERROR	Kein Fehler
GDBM_MALLOC_ERROR	Nicht genügend Heap-Speicher
GDBM_BLOCK_SIZE_ERROR	Ungültige Blockgröße
GDBM_FILE_OPEN_ERROR	Öffnen der Datei fehlgeschlagen
GDBM_FILE_WRITE_ERROR	Schreiben der Datei fehlgeschlagen
GDBM_FILE_SEEK_ERROR	Positionierung innerhalb der Datei fehlgeschlagen
GDBM_FILE_READ_ERROR	Lesen der Datei fehlgeschlagen
GDBM_BAD_MAGIC_NUMBER	Keine GDBM-Datei
GDBM_EMPTY_DATABASE	Leere Datei
GDBM_CANT_BE_READER	Keine Lesesperre
GDBM_CANT_BE_WRITER	Keine Schreibsperre
GDBM_READER_CANT_DELETE	Nur Lesezugrff
GDBM_READER_CANT_STORE	Kein Schreibzugriff
GDBM_READER_CANT_REORGANIZE	Kein Schreibzugriff
GDBM_UNKNOWN_UPDATE	Reserviert
GDBM_ITEM_NOT_FOUND	Schlüssel nicht gefunden
GDBM_REORGANIZE_FAILED	Kann keine temporäre Datenbank erzeugen
GDBM_CANNOT_REPLACE	Schlüssel nicht ersetzbar
GDBM_ILLEGAL_DATA	Fehlerhaftes Datum
GDBM_OPT_ALREADY_SET	Option wurde bereits gesetzt
GDBM_OPT_ILLEGAL	Ungültige Option
GDBM_BYTE_SWAPPED	Falsche Oktektt-Anordnung
GDBM_BAD_FILE_OFFSET	Ungültige Dateikennung
GDBM_BAD_OPEN_FLAGS	Ungültiger Parameter
GDBM_FILE_STAT_ERROR	Kann Dateiinformation nicht lesen
GDBM_FILE_EOF	Vorzeitiges Dateiende
GDBM_NO_DBNAME	Keine Ausgabedatei
GDBM_ERR_FILE_OWNER	Kann Besitzer nicht wiederherstellen
GDBM_ERR_FILE_MODE	Kann Zugriffsrechte nicht wiederherstellen

*	Joker für beliebig viele Zeichen.
?	Joker für ein einzelnes Zeichen.
[…]	Joker für ein Zeichen aus einer Menge.

GLOB_APPEND	Pfade hinten an eine vorhandene Liste in `gl_pathv` anhängen.
GLOB_DOOFFS	`gl_offs` freie Plätze am Beginn der Liste reservieren.
GLOB_ERR	Abbruch beim ersten Lesefehler.
GLOB_MARK	Pfadtrenner an Verzeichnisnamen hängen.
GLOB_NOCHECK	Das Muster selbst liefern, wenn kein Pfad auf das Muster passt.
GLOB_NOESCAPE	Backslash nicht als Fluchtsymbol interpretieren.
GLOB_NOSORT	Pfade nicht alphabetisch sortieren.

GLOB_ABORTED	Abbruch wegen Fehler (`GLOB_ERR` gesetzt oder `errfunc` liefert Fehlercode).
GLOB_NOMATCH	Das Muster passt auf keinen Pfad (`GLOB_NOCHECK` nicht gesetzt).
GLOB_NOSPACE	Fehler beim Reservieren von Speicher.

CODESET	Name des verwendeten Zeichensatzes
YESEXPR	Regulärer Ausdruck für Varianten von Ja
NOEXPR	Regulärer Ausdruck für Varianten von Nein
D_T_FMT	Formatstring für `strftime` für Datum und Uhrzeit
D_FMT	Formatstring für `strftime` für Datum
T_FMT	Formatstring für `strftime` für Uhrzeit
DAY_1…7	Name des Wochentags beginnend bei Sonntag
MON_1…12	Name des Monats beginnend bei Januar
ABDAY_1…7	Abgekürzter Wochentag
ABMON_1…12	Abgekürzter Monatsname
RADIXCHAR	Dezimaltrennzeichen
THOUSEP	Trennzeichen für Tausend
CRNCYSTR	Währungssymbol

LC_CTYPE_MASK
LC_NUMERIC_MASK
LC_TIME_MASK
LC_COLLATE_MASK
LC_MONETARY_MASK
LC_MESSAGES_MASK
LC_PAPER_MASK
LC_NAME_MASK
LC_ADDRESS_MASK
LC_TELEPHONE_MASK
LC_MEASUREMENT_MASK
LC_IDENTIFICATION_MASK

FP_NAN	Nicht darstellbar
FP_INFINITE	Positiv oder negativ unendlich
FP_ZERO	Null
FP_SUBNORMAL	Zu klein zum Normalisieren
FP_NORMAL	Nichts von den genannten

AI_CANONNAME
AI_PASSIVE
AI_V4MAPPED
AI_ALL
AI_NOFQDN	Nur den Hostnamen ermitteln
AI_NUMERICHOST	Numerische Adresse statt Hostname ermitteln
AI_NAMEREQD	Fehlermeldung statt Numerische Adresse
AI_NUMERICSERV	Kanalnummer statt Dienstname zurückliefern
AI_DGRAM	Datagrammdienst UDP statt Stromdienst TCP liefern, meistens gleich

AF_UNSPEC	Unbekannt
AF_LOCAL	Unix Domain Socket
AF_INET	IPv4 Adresse (32 Bit)
AF_INET6	IPv6 Adresse (128 Bit)

SOCK_DGRAM	Verbindungslos und unsicher
SOCK_STREAM	Verbindungsorientiert und sicher

UDP	Verbindungslos (`SOCK_DGRAM`)
TCP	Verbindungsorientiert (`SOCK_STREAM`)

NL_SETD	Used by gencat when no $set directive is specified in a message text source file. This constant can be passed as the value of set_id on subsequent calls to catgets() (that is, to retrieve messages from the default message set). The value of NL_SETD is implementation-defined.
NL_CAT_LOCALE	Value that must be passed as the oflag argument to catopen() to ensure that message catalog selection depends on the `LC_MESSAGES` locale category, rather than directly on the LANG environment variable.

`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

REG_EXTENDED	Verwende erweiterte reguläre Ausdrücke
REG_ICASE	Ignoriere Groß-/Kleinschreibung
REG_NOSUB	Werte keine geklammerten Ausdrücke aus
REG_NEWLINE	Spezialbehandlung von Zeilenumbrüchen

REG_NOTBOL	Das Symbol `^` nicht auf den Anfang der Zeichenkette anwenden
REG_NOTEOL	Das Symbol `$` nicht auf das Ende der Zeichenkette anwenden