JK-Wiki edv:prg:c:example

edv:prg:c:example:aktuellen_timestamp_erfassen

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:08+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Aktuellen Timestamp erfassen ======

	+	Als Beispiel eine Funktion, die die aktuelle Zeit erfaßt und über Parameter formatiert zurück gibt:
	+
	+	<code c>
	+	void getCurrentDateAndTime (char currentDate, const char formatDate, char currentTime, const char formatTime)
	+	{
	+	// ----- Achtung! Mehrere returns innerhalb der Funktion ------------------------------
	+
	+	time_t aktSekunden;
	+	struct tm *aktZeit;
	+
	+	if (!currentDate) return;
	+	if (!formatDate) return;
	+	if (!currentTime) return;
	+	if (!formatTime) return;
	+
	+	time(&aktSekunden); // aktuelle Zeit ermitteln
	+
	+	aktZeit = localtime(&aktSekunden); // auf Komponenten zerlegen
	+
	+	sprintf(currentTime, formatTime, aktZeit->tm_hour, aktZeit->tm_min, aktZeit->tm_sec); // Uhrzeit
	+	sprintf(currentDate, formatDate, aktZeit->tm_year + 1900, aktZeit->tm_mon + 1, aktZeit->tm_mday); // Datum
	+	} // getCurrentDateAndTime()
	+	</code>
	+
	+	:!: Alternativ kann die Formatierung des Strings mit Hilfe der Funktion strftime() (aus time.h) erfolgen. (Es ist wahrscheinlich sogar etwas eleganter. Das Beispiel oben dient eher dazu, den Umgang mit der Funktion time() zu erläutern.)
	+
	+	:!: Hier sind weitere Infos zu den [[EDV:PRG:C:Tipp:Zeit-Funktionen]] zu finden.
	+
	+	Die o.g. Funktion kann z.B. in einer Logging-Funktion genutzt werden um jede trace-Zeile mit dem Timestamp versehen:
	+
	+	<code c>
	+	void logIt (char functName, char text)
	+	{
	+	char strZeit [16];
	+	char strDatum [16];
	+
	+	memset(strZeit, '\0', sizeof(strZeit));
	+	memset(strDatum, '\0', sizeof(strDatum));
	+
	+	getCurrentDateAndTime(strDatum, "%04d-%02d-%02d", strZeit, "%02d:%02d:%02d");
	+
	+	fprintf(stdout, "%s/%s %s(): %s\n", strDatum, strZeit, functName ? functName : "NONAME(NULL-POINTER)", text ? text : "NOTEXT(NULL-POINTER)");
	+	fflush(stdout);
	+	} // logIt()
	+	</code>
	+
	+	Die Erfassung des Timestamps kann dazu verwendet werden, um die Laufzeit eines Programms oder einer Funktion zu messen. Man ruft die Funktion time() vor dem und nach dem zu messenden Abschnitt auf. Ein Beispiel dafür ist unter [[EDV:PRG:C:Example:Zeitabstände messen]] zu finden.
	+
	+	----
	+	Stand: 05.07.2016\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:array_of_messages

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:09+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Array of Messages ======

	+	Zweck: alle Messages, die ein Programm ausgibt, an einer Stelle zusammen halten.
	+
	+	Auf diese Weise lassen sich relativ einfach mehrsprachige Anwendungen erstellen.
	+
	+	msgs.h:
	+
	+	<code c>
	+	typedef struct
	+	{
	+	int msgType;
	+	int msgCode;
	+	char *msgText;
	+	} SMsgArray;
	+	</code>
	+
	+	msgs.c:
	+
	+	<code c>
	+	SMsgArray msgArray[] =
	+	{
	+	/* 0 */ {1, 1, "Message Typ 1 Code 1"},
	+	/* 1 */ {1, 2, "Message Typ 1 Code 2"},
	+	/* 2 */ {1, 3, "Message Typ 1 Code 3"},
	+	// und so weiter...
	+	/* N */ {5, 8, "Message Typ 5 Code 8"},
	+	// und so weiter...
	+	{0, 0, NULL},
	+	}; // msgArray[]
	+	</code>
	+
	+	----
	+	Stand: 27.03.2012\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:aus_mehreren_files_blockweise_lesen

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:07+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Aus mehreren Files blockweise lesen ======

	+	Ein vereinfachtes Beispiel um die Daten aus mehreren Files blockweise zu lesen und zu bearbeiten.
	+
	+	Buffer um die Daten aus dem File zu lesen:
	+
	+	<code c>
	+	typedef struct
	+	{
	+	// Wir nehmen an, unsere Daten haben folgende Struktur:
	+	char F1n_SatzLaenge [4]; // Satzlänge, z.B. "0128"
	+	char F2a_SatzArt [1]; // Satzart, z.B. 'A', 'C' oder 'E'
	+	char x_Rest [123]; // Damit die Gesamtgröße immer 128 Byte bleibt
	+	} FILE_SATZ_BUFFER;
	+	</code>
	+
	+	Aus diesen Files soll gelesen werden (globale Variablen):
	+
	+	<code c>
	+	FILE * file1 = NULL; // Das 1. File
	+	FILE * file2 = NULL; // Das 2. File
	+	</code>
	+
	+	Eine Beispielsfunktion, die versucht, mehrere Files (auf einheitliche Weise) zu bearbeiten:
	+
	+	<code c>
	+	int app_Run (int rc_Init)
	+	{
	+	int rc = RC_OK;
	+
	+	// Beide Eingangsdateien sollen bearbeitet werden.
	+	if (rc == RC_OK) rc = auswertenFile(&file1); // Das 1. File
	+	if (rc == RC_OK) rc = auswertenFile(&file2); // Das 2. File
	+
	+	return rc;
	+	} // app_Run()
	+	</code>
	+
	+	Die Funktion ruft für jedes einzelne File eine weitere Funktion auf, die nur für die Bearbeitung eines einzelnes Files zuständig ist.
	+
	+	Folgende (Beispiel-)Funktion bearbeitet ein (als Parameter übergebene) File:
	+
	+	<code c>
	+	int auswertenFile (const FILE ** fileZumAuswerten)
	+	{
	+	int rc = RC_OK;
	+	FILE_SATZ_BUFFER satzBuffer;
	+
	+	memset(&satzBuffer, '\0', sizeof(satzBuffer));
	+
	+	// Validierung: Vorhandensein von Variablen (darf kein NULL sein)
	+	if (!fileZumAuswerten) rc = RC_ERROR;
	+	// Validierung: Pointer-Variablen: Werte nur im definierten Bereich
	+	if (fileZumAuswerten) if (!(*fileZumAuswerten)) rc = RC_ERROR; // File MUSS bereits geöffnet sein
	+
	+	if (rc) fprintf(stderr, "auswertenFile(): Validierungsfehler.\n");
	+
	+	if (rc == RC_OK)
	+	{
	+	while (!feof(*fileZumAuswerten) && !rc) // Solange das File das EOF noch nicht erreicht hat, in der Schlefe lesen.
	+	{
	+	rc = getDataBlock(*fileZumAuswerten, &satzBuffer); // Einen Block aus dem File lesen und im Buffer speichern.
	+
	+	// TODO: Weitere Aktivitäten mit den Daten.
	+	// TODO: Weitere Aktivitäten mit den Daten.
	+	} // while()
	+	} // if
	+
	+	return rc;
	+	} // auswertenFile(..)
	+	</code>
	+
	+	Da das File zu groß sein kann, als der zur Verfügung stehende Speicher, und weil seine Struktur nicht zwangsläufig homogen sein sollte, macht es oft Sinn, das File nicht auf einmal, sondern blockweise (evtl. sogar mit verschiedenen Lesefunktionen) zu lesen. Das schafft Flexibilität beim Lesen.
	+
	+	Folgende (Beispiel-)Funktion liest einen Block und gibt ihn im Buffer zurück:
	+
	+	<code c>
	+	int getDataBlock (const FILE * fileZumLesen, FILE_SATZ_BUFFER * satzBuffer)
	+	{
	+	int rc = RC_OK;
	+	int blkGelesen = 0;
	+
	+	blkGelesen = fread(satzBuffer, sizeof(FILE_SATZ_BUFFER), 1, fileZumLesen); // 1 Block lesen
	+	if (blkGelesen != 1) rc = RC_ERROR;
	+
	+	// TODO: Weitere Aktivitäten mit den Daten, bevor sie zurückgegeben werden.
	+
	+	return rc;
	+	} // getDataBlock(..)
	+	</code>
	+
	+	:!: Achtung: Die Funktionen fread() und fwrite() sind plattformabhängig und nicht portabel! Man soll darauf achten, daß der schreibende und der lesende Prozesse binär zu einander kompatibel sind. Das heißt, sie haben das gleiche Alignment (plattform- und compilerabhängig) und die selbe Architektur (Byte-Reihenfolge im Sinne von Big- und Little-Endian).
	+
	+	----
	+	Stand: 04.03.2010\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:backslash2slash.sh

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:09+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== backslash2slash.sh ======

	+	Das Skript ersetzt alle Back-Slashes in den "#include"-Direktiven (.c- und .h-Files) durch Slashes:
	+
	+	<code bash>
	+	DATUM=`date +%Y%m%d`
	+
	+	for datei in `find . -name ".h" -o -name ".c"`
	+	do
	+	grep include $datei \| grep '\\' >/dev/null
	+	if [ $? -eq 0 ]
	+	then
	+	echo $datei
	+	cp $datei ${datei}.$DATUM
	+	sed '/#include/s/\\/\//g' $datei > ${datei}.changed
	+	mv ${datei}.changed $datei
	+	fi
	+	done
	+	</code>
	+
	+	----
	+	Stand: 10.12.2015\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:beispiel_cpu-time_funktionen

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:11+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Beispiel CPU-Time Funktionen ======

	+	Relevante manpages:
	+	* GETRLIMIT(2): [[http://man7.org/linux/man-pages/man2/getrlimit.2.html]]
	+	* GETRUSAGE(2): [[http://man7.org/linux/man-pages/man2/getrusage.2.html]]
	+	* CLOCK(3): [[http://man7.org/linux/man-pages/man3/clock.3.html]]
	+
	+	Mit folgendem Beispiel wird die Funktionsweise von getrlimit() und setrlimit() gezeigt.
	+
	+	<code c>
	+	#include <stdio.h>
	+	#include <string.h>
	+	#include <sys/time.h>
	+	#include <sys/resource.h>
	+
	+
	+	/*
	+	* Zur Info: "struct rusage" hat folgende Definition:
	+	*
	+	struct rusage
	+	{
	+	struct timeval ru_utime; // user CPU time used
	+	struct timeval ru_stime; // system CPU time used
	+	long ru_maxrss; // maximum resident set size
	+	long ru_ixrss; // integral shared memory size
	+	long ru_idrss; // integral unshared data size
	+	long ru_isrss; // integral unshared stack size
	+	long ru_minflt; // page reclaims (soft page faults)
	+	long ru_majflt; // page faults (hard page faults)
	+	long ru_nswap; // swaps
	+	long ru_inblock; // block input operations
	+	long ru_oublock; // block output operations
	+	long ru_msgsnd; // IPC messages sent
	+	long ru_msgrcv; // IPC messages received
	+	long ru_nsignals; // signals received
	+	long ru_nvcsw; // voluntary context switches
	+	long ru_nivcsw; // involuntary context switches
	+	};
	+	*/
	+
	+	/*
	+	* Zur Info: "struct timeval" hat folgende Definition:
	+	*
	+	struct timeval
	+	{
	+	long int tv_sec; // Number of seconds since the epoch. It is equivalent to a normal time_t value.
	+	long int tv_usec; // Fractional second value, represented as the number of microseconds.
	+	};
	+	*/
	+
	+	/*
	+	* Zur Info: "struct rlimit" hat folgende Definition:
	+	*
	+	struct rlimit
	+	{
	+	rlim_t rlim_cur; // Soft limit.
	+	rlim_t rlim_max; // Hard limit (ceiling for rlim_cur).
	+	};
	+	*/
	+
	+	/*
	+	* Zur Info: "rlim_t" hat folgende Definition:
	+	*
	+	* The rlim_t type is an arithmetic data type to which you can cast objects of
	+	* type int, size_t, and off_t without loss of information.
	+	*/
	+
	+
	+	// Anzahl an Arbeitzyklen:
	+	#define i_MAX_AZ 3000 // Aussere Schleife
	+	#define j_MAX_AZ 3000 // Innere Schleife
	+
	+	// CPU-Limits in Sekunden
	+	#define CPU_LIMIT_SOFT 5
	+	#define CPU_LIMIT_HARD 9
	+
	+
	+	int main (void)
	+	{
	+	int rc_main = 0;
	+	int rc_getrusage = 0;
	+	int rc_getrlimit = 0;
	+	int rc_setrlimit = 0;
	+	long int i, j, s;
	+
	+	struct rusage cpu_usage_self;
	+	struct rusage cpu_usage_children;
	+	struct rusage cpu_usage_thread;
	+
	+	struct rlimit cpu_timelimit_rlimit;
	+
	+	time_t aktSekunden1, aktSekunden2;
	+
	+
	+
	+	printf("\nTest von CPU-Time Funktionen\n\n");
	+
	+	printf("\n======================================================================\n");
	+
	+	printf("\nInitialisierung:\n\n");
	+
	+	memset(&cpu_usage_self, 0, sizeof(cpu_usage_self));
	+	memset(&cpu_usage_children, 0, sizeof(cpu_usage_children));
	+	memset(&cpu_usage_thread, 0, sizeof(cpu_usage_thread));
	+	memset(&cpu_timelimit_rlimit, 0, sizeof(cpu_timelimit_rlimit));
	+
	+	printf("\n======================================================================\n");
	+	// Timestamp am Anfang merken um spaeter die Laufzeit (nicht die CPU-Zeit!)
	+	// des Programms zu berechnen.
	+
	+	printf("aktSekunden1 = time(NULL);\n");
	+	aktSekunden1 = time(NULL);
	+	printf("time(): RC = %d\n", (int) aktSekunden1);
	+
	+	printf("\n======================================================================\n");
	+	// Aktuelle Soft- und Hard-CPU-Limits lesen.
	+
	+	printf("\nTest der Funktion: %s\n", "getrlimit()");
	+	printf("Syntax: %s\n", "int getrlimit(int resource, struct rlimit *rlim);");
	+
	+	printf("resource = [%s]\n", "RLIMIT_CPU");
	+	rc_getrlimit = getrlimit(RLIMIT_CPU, &cpu_timelimit_rlimit);
	+	printf("getrlimit(): RC = %d\n", rc_getrlimit);
	+
	+	printf("\nErgebnisse:\n\n");
	+
	+	printf("Response von getrlimit() - RLIMIT_CPU:\n");
	+	printf("\tCPU SoftLimit: rlim_cur = %u\n", (unsigned int) cpu_timelimit_rlimit.rlim_cur);
	+	printf("\tCPU HardLimit: rlim_max = %u\n", (unsigned int) cpu_timelimit_rlimit.rlim_max);
	+
	+	printf("\n======================================================================\n");
	+	// Neue Soft- und Hard-CPU-Limits setzen.
	+
	+	printf("\nTest der Funktion: %s\n", "setrlimit()");
	+	printf("Syntax: %s\n", "int setrlimit(int resource, const struct rlimit *rlim);");
	+
	+	cpu_timelimit_rlimit.rlim_cur = CPU_LIMIT_SOFT;
	+	cpu_timelimit_rlimit.rlim_max = CPU_LIMIT_HARD;
	+
	+	printf("CPU-Limits werden auf folgende Werte gesetzt:\n");
	+	printf("\tCPU SoftLimit: rlim_cur = %u\n", (unsigned int) cpu_timelimit_rlimit.rlim_cur);
	+	printf("\tCPU HardLimit: rlim_max = %u\n", (unsigned int) cpu_timelimit_rlimit.rlim_max);
	+
	+	printf("resource = [%s]\n", "RLIMIT_CPU");
	+	rc_setrlimit = setrlimit(RLIMIT_CPU, &cpu_timelimit_rlimit);
	+	printf("setrlimit(): RC = %d\n", rc_setrlimit);
	+
	+	printf("\n======================================================================\n");
	+	// Aktuelle Soft- und Hard-CPU-Limits nochmals lesen um zu pruefen, ob
	+	// die oben gesetzte Werte tatsaechlich uebernommen wurden.
	+
	+	printf("\nTest der Funktion: %s\n", "getrlimit()");
	+	printf("Syntax: %s\n", "int getrlimit(int resource, struct rlimit *rlim);");
	+
	+	printf("resource = [%s]\n", "RLIMIT_CPU");
	+	rc_getrlimit = getrlimit(RLIMIT_CPU, &cpu_timelimit_rlimit);
	+	printf("getrlimit(): RC = %d\n", rc_getrlimit);
	+
	+	printf("\nErgebnisse:\n\n");
	+
	+	printf("Response von getrlimit() - RLIMIT_CPU:\n");
	+	printf("\tCPU SoftLimit: rlim_cur = %u\n", (unsigned int) cpu_timelimit_rlimit.rlim_cur);
	+	printf("\tCPU HardLimit: rlim_max = %u\n", (unsigned int) cpu_timelimit_rlimit.rlim_max);
	+
	+	printf("\n======================================================================\n");
	+	// Etwas Last erzeugen und anschliessend die verbrauchte CPU-Zeit auslesen.
	+	//
	+	// Hier kann es, wenn das CPU-Limit ueberschritten wird, zum Abbruch kommen.
	+
	+	printf("\nCPU-Last erzeugen - durch Arbeitzyklen:\n\n");
	+
	+	printf("Aussere Schleife = %ld Zyklen\n", (long int) i_MAX_AZ);
	+	printf("Innere Schleife = %ld Zyklen\n", (long int) j_MAX_AZ);
	+	printf("Insgesamt = %ld Schleifenzyklen...\n", s = i_MAX_AZ * j_MAX_AZ);
	+	for (i = 0; i < i_MAX_AZ; i++) for (j = 0; j < j_MAX_AZ; j++) printf("%ld\r", s = i * j);
	+	printf("\n");
	+
	+
	+
	+	printf("\nTest der Funktion: %s\n", "getrusage()");
	+	printf("Syntax: %s\n", "int getrusage(int who, struct rusage *usage);");
	+
	+	printf("who = [%s]\n", "RUSAGE_SELF");
	+	rc_getrusage = getrusage(RUSAGE_SELF, &cpu_usage_self);
	+	printf("getrusage(): RC = %d\n", rc_getrusage);
	+
	+	printf("who = [%s]\n", "RUSAGE_CHILDREN");
	+	rc_getrusage = getrusage(RUSAGE_CHILDREN, &cpu_usage_children);
	+	printf("getrusage(): RC = %d\n", rc_getrusage);
	+
	+	// printf("who = [%s]\n", "RUSAGE_THREAD");
	+	// rc_getrusage = getrusage(RUSAGE_THREAD, &cpu_usage_thread);
	+	// printf("getrusage(): RC = %d\n", rc_getrusage);
	+
	+
	+
	+	printf("\nErgebnisse:\n\n");
	+
	+	printf("Response von getrusage() - RUSAGE_SELF:\n");
	+	printf("\tCPU utime: tv_sec = %ld\n", cpu_usage_self.ru_utime.tv_sec);
	+	printf("\tCPU utime: tv_usec = %ld\n", cpu_usage_self.ru_utime.tv_usec);
	+	printf("\tCPU stime: tv_sec = %ld\n", cpu_usage_self.ru_stime.tv_sec);
	+	printf("\tCPU stime: tv_usec = %ld\n", cpu_usage_self.ru_stime.tv_usec);
	+
	+	printf("Response von getrusage() - RUSAGE_CHILDREN:\n");
	+	printf("\tCPU utime: tv_sec = %ld\n", cpu_usage_children.ru_utime.tv_sec);
	+	printf("\tCPU utime: tv_usec = %ld\n", cpu_usage_children.ru_utime.tv_usec);
	+	printf("\tCPU stime: tv_sec = %ld\n", cpu_usage_children.ru_stime.tv_sec);
	+	printf("\tCPU stime: tv_usec = %ld\n", cpu_usage_children.ru_stime.tv_usec);
	+
	+	// printf("Response von getrusage() - RUSAGE_THREAD:\n");
	+	// printf("\tCPU utime: tv_sec = %ld\n", cpu_usage_thread.ru_utime.tv_sec);
	+	// printf("\tCPU utime: tv_usec = %ld\n", cpu_usage_thread.ru_utime.tv_usec);
	+	// printf("\tCPU stime: tv_sec = %ld\n", cpu_usage_thread.ru_stime.tv_sec);
	+	// printf("\tCPU stime: tv_usec = %ld\n", cpu_usage_thread.ru_stime.tv_usec);
	+
	+	printf("\n======================================================================\n");
	+	// Aktuelle Soft- und Hard-CPU-Limits nochmals lesen um zu pruefen, ob
	+	// der CPU-Verbrauch diese beeinfluesst hat.
	+
	+	printf("\nTest der Funktion: %s\n", "getrlimit()");
	+	printf("Syntax: %s\n", "int getrlimit(int resource, struct rlimit *rlim);");
	+
	+	printf("resource = [%s]\n", "RLIMIT_CPU");
	+	rc_getrlimit = getrlimit(RLIMIT_CPU, &cpu_timelimit_rlimit);
	+	printf("getrlimit(): RC = %d\n", rc_getrlimit);
	+
	+	printf("\nErgebnisse:\n\n");
	+
	+	printf("Response von getrlimit() - RLIMIT_CPU:\n");
	+	printf("\tCPU SoftLimit: rlim_cur = %u\n", (unsigned int) cpu_timelimit_rlimit.rlim_cur);
	+	printf("\tCPU HardLimit: rlim_max = %u\n", (unsigned int) cpu_timelimit_rlimit.rlim_max);
	+
	+	printf("\n======================================================================\n");
	+	// Timestamp am Ende merken.
	+
	+	printf("aktSekunden2 = time(NULL);\n");
	+	aktSekunden2 = time(NULL);
	+	printf("time(): RC = %d\n", (int) aktSekunden2);
	+
	+	if ((aktSekunden1 != -1) && (aktSekunden2 != -1)) printf("\nLaufzeit = %ld Sekunden\n", (long) (aktSekunden2 - aktSekunden1));
	+	else printf("\nWARNING: Laufzeit kann nicht berechnet werden\n");
	+
	+	printf("\n======================================================================\n");
	+
	+	return rc_main;
	+	} // main()
	+	</code>
	+
	+	----
	+	Stand: 11.10.2013
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:bit-operatoren

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:08+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Bit-Operatoren ======

	+	:!: Nur bei ganzzahligen Datentypen.
	+
	+	^Schreibweise ^Operator ^
	+	\|%%&%%, %%&=%% \|AND \|
	+	\|%%\|%%, %%\|=%% \|OR \|
	+	\|%%^%%, %%^=%% \|XOR \|
	+	\|%%~%% \|Komplement \|
	+	\|%%>>%%, %%>>=%%\|Rechtsverschiebung\|
	+	\|%%<<%%, %%<<=%%\|Linksverschiebung\|
	+
	+	:!: Nicht mit boolischen Operationen verwechseln!
	+
	+	----
	+	Stand: 15.07.2013\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:debug-makros

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:08+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Debug-Makros ======

	+	Einige nützliche Beispiele, die sich beim "Debuggen" als hilfreich erwiesen haben.
	+
	+	DEBUG_MAKROS_TRACE_AKTIV aktiviert DEBUG-Makros für die zusätzlichen Trace-Ausgaben auf stderr:
	+
	+	<code c>
	+	#ifdef DEBUG_MAKROS_TRACE_AKTIV
	+	#define DEBUG_FUNC_ENTRY() fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: --> ENTRY\n", __FILE__, __func__, __LINE__)
	+	#define DEBUG_FUNC_RC_VOID() fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: <-- EXIT; RC: (void)\n", __FILE__, __func__, __LINE__)
	+	#define DEBUG_FUNC_RC_INT(rc_name,rc_int) fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: <-- EXIT; RC: [%s]=[%d]\n", __FILE__, __func__, __LINE__, rc_name, rc_int)
	+	#define DEBUG_FUNC_RC_STR(rc_name,rc_str) fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: <-- EXIT; RC: [%s]=[%s]\n", __FILE__, __func__, __LINE__, rc_name, rc_str)
	+	#define DEBUG_VAR_STR(var_name,var_str) fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: Var: [%s]=[%s]\n", __FILE__, __func__, __LINE__, var_name, var_str ? var_str : "NULL")
	+	#define DEBUG_VAR_INT(var_name,var_int) fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: Var: [%s]=[%d]\n", __FILE__, __func__, __LINE__, var_name, var_int)
	+	#define DEBUG_INFO(info) fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: INF: [%s]\n", __FILE__, __func__, __LINE__, info)
	+	#define DEBUG_ERROR(info) fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: ERR: [%s]\n", __FILE__, __func__, __LINE__, info)
	+	#define DEBUG_MARK() fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: ---------- MARK ----------\n", __FILE__, __func__, __LINE__)
	+	#else
	+	#define DEBUG_FUNC_ENTRY()
	+	#define DEBUG_FUNC_RC_VOID()
	+	#define DEBUG_FUNC_RC_INT(rc_name,rc_int)
	+	#define DEBUG_FUNC_RC_STR(rc_name,rc_str)
	+	#define DEBUG_VAR_STR(var_name,var_str)
	+	#define DEBUG_VAR_INT(var_name,var_int)
	+	#define DEBUG_INFO(info)
	+	#define DEBUG_ERROR(info)
	+	#define DEBUG_MARK()
	+	#endif
	+	</code>
	+
	+	Das gleiche, aber etwas fortgeschrittener (mit Verwendung von [[http://jk-wiki.kreick.de/doku.php?id=edv:prg:c:tipp:vordefinierte_praeprozessor-direktiven#string-literal-operator\|String-Literal-Operator]]) kann wie folgt definiert werden:
	+
	+	<code c>
	+	#ifdef DEBUG_MAKROS_TRACE_AKTIV
	+	#define DEBUG_FUNC_ENTRY() fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: --> ENTRY\n", __FILE__, __func__, __LINE__)
	+	#define DEBUG_FUNC_RC_VOID() fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: <-- EXIT; RC: (void)\n", __FILE__, __func__, __LINE__)
	+	#define DEBUG_FUNC_RC_INT(rc_int) fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: <-- EXIT; RC: [" #rc_int "]=[%d]\n", __FILE__, __func__, __LINE__, rc_int)
	+	#define DEBUG_FUNC_RC_STR(rc_str) fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: <-- EXIT; RC: [" #rc_str "]=[%s]\n", __FILE__, __func__, __LINE__, rc_str)
	+	#define DEBUG_VAR_STR(var_str) fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: Var: [" #var_str "]=[%s]\n", __FILE__, __func__, __LINE__, var_str ? var_str : "NULL")
	+	#define DEBUG_VAR_INT(var_int) fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: Var: [" #var_int "]=[%d]\n", __FILE__, __func__, __LINE__, var_int)
	+	#define DEBUG_INFO(info) fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: INF: [%s]\n", __FILE__, __func__, __LINE__, info)
	+	#define DEBUG_ERROR(info) fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: ERR: [%s]\n", __FILE__, __func__, __LINE__, info)
	+	#define DEBUG_MARK() fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: ---------- MARK ----------\n", __FILE__, __func__, __LINE__)
	+	#else
	+	#define DEBUG_FUNC_ENTRY()
	+	#define DEBUG_FUNC_RC_VOID()
	+	#define DEBUG_FUNC_RC_INT(rc_int)
	+	#define DEBUG_FUNC_RC_STR(rc_str)
	+	#define DEBUG_VAR_STR(var_str)
	+	#define DEBUG_VAR_INT(var_int)
	+	#define DEBUG_INFO(info)
	+	#define DEBUG_ERROR(info)
	+	#define DEBUG_MARK()
	+	#endif
	+	</code>
	+
	+	DEBUG_MAKROS_STEP_AKTIV aktiviert DEBUG-Makros für die Unterbrechungen in Ablauf. Fortsetzen mit der <Enter>-Taste.
	+
	+	<code c>
	+	#ifdef DEBUG_MAKROS_STEP_AKTIV
	+	#define DEBUG_PAUSE_PRESS_ENTER() { char getsStr [16]; fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d]: Weiter mit <ENTER>-Taste ", __FILE__, __func__, __LINE__); gets(getsStr); fprintf(stderr, "----------------------------------------------------------------------\n"); }
	+	#define DEBUG_FORCE_EXIT(rc) { fprintf(stderr, "DEBUG: FILE=[%s] func=[%s] LINE=[%d] DEBUG_FORCE_EXIT: Das Programm wird zwangsweise beendet, EXIT-Code=[%d].\n\n", __FILE__, __func__, __LINE__, rc); exit(rc); }
	+	#else
	+	#define DEBUG_PAUSE_PRESS_ENTER()
	+	#define DEBUG_FORCE_EXIT(rc)
	+	#endif
	+	</code>
	+
	+
	+	===== Vordefinierte Debug-Makros =====
	+
	+	==== NDEBUG ====
	+
	+	If %%NDEBUG%% is defined as a macro name at the point in the source code where <assert.h> is included, then assert does nothing:\\ [[https://en.cppreference.com/w/c/error/assert]]
	+
	+	==== _DEBUG ====
	+
	+	Dieses Makro ist MS- bzw. VisualStudio-spezifisch.
	+
	+	%%_DEBUG%% is defined as 1 when the /LDd, /MDd, or /MTd compiler option is set. Otherwise, undefined.\\ [[https://msdn.microsoft.com/en-us/library/b0084kay.aspx]]
	+
	+	----
	+	Stand: 31.07.2018
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:environment_lesen

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:10+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Environment lesen ======

	+	Verschiedene Wege, die Environment-Variablen zu lesen.
	+
	+	===== main() =====
	+
	+	Auf POSIX-Systemen ist es möglich, die main()-Funktion mit 3 Parameter zu verwenden:
	+
	+	<code c>
	+	int main(int argc, char argv[], char envp[])
	+	{
	+	} // main()
	+	</code>
	+
	+	Das dritte Argument envp referenziert die Environment des Programms. Es ist ein String-Array.
	+
	+	===== environ =====
	+
	+	Das gleiche kann man über die Variable %%char environ%% erreichen. Die Environment wird als Array of Strings organisiert. Jeder String liegt in der Form name=value** vor. Das letzte Element des Arrays ist ein NULL.
	+
	+	Diese Variable ist im Header-File unistd.h deklariert.
	+
	+	===== getenv() =====
	+
	+	Die bessere Variante ist die Funktion getenv() bzw. secure_getenv(), deklariert in <stdlib.h>.
	+
	+	<code c>
	+	char* getenv(const char* name);
	+	char* secure_getenv(const char *name);
	+	</code>
	+
	+	Wenn der Parameter "name" nicht definiert ist, ist das Ergebnis ist NULL.
	+
	+	:!: Die Funktion secure_getenv() ist der getenv() ähnlich, gibt aber auch dann NULL zurück, wenn die Environment "unsicher" ist. Das ist der Fall, wenn bei dem Programm das Flag SUID oder SGID gesetzt ist. Auch allgemeine Libraries sollten immer die Funktion secure_getenv() nutzen anstelle von getenv(), um möglicher Verwundbarkeit vorzubeugen, wenn die Library von einem SUID/SGID-Programm verlinkt wird.
	+
	+	===== getenv_s() =====
	+
	+	Seit C11 steht auch folgende Funktion zur Verfügung:
	+
	+	<code c>
	+	errno_t getenv_s(size_t restrict len, char restrict value, rsize_t valuesz, const char *restrict name);
	+	</code>
	+
	+	Vorteil dieser Funktion ist, dass der Inhalt der Environment-Variable nicht als Pointer, sondern als Kopie über das Argument value zurückgegeben wird.
	+
	+	Detailliertere Beschreibung auf: [[http://en.cppreference.com/w/c/program/getenv]]
	+
	+	----
	+	Stand: 18.01.2016\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:get_currentexecutable

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:10+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== get_CurrentExecutable() ======

	+	Filename des gerade ausgeführten Moduls herausfinden
	+
	+	Hier soll man zwischen (mindestens) zwei Situationen unterscheiden, da die Vorgehensweise etwas unterschiedlich ist:
	+	* Das Programm selbst (wie z.B. ein EXE bzw. PE-Modul unter Windows)
	+	* Dynamische Library / Shared Object (wie z.B. ein SO-Modul unter Unix bzw. DLL unter Windows)
	+
	+	===== Im Fall "Das Programm selbst" =====
	+
	+	Man nimmt am Anfang der main() den Parameter argv[0] und speichert den dort enthaltenen Wert in einer lokalen/globalen Variable ab:
	+
	+	Schritt 1: in einem separaten Modul definiert man die Zugriffsfunktionen:
	+
	+	<code c>
	+	char current_executable[PATH_MAX] = { 0 };
	+
	+	string get_current_executable()
	+	{
	+	return current_executable;
	+	}
	+
	+	void set_current_executable(char *executable_fq_path)
	+	{
	+	if (current_executable[0] == '\0' && strlen(executable_fq_path) > 0)
	+	{
	+	strncpy(current_executable, executable_fq_path, sizeof(current_executable));
	+	current_executable[sizeof(current_executable) - 1] = '\0';
	+	}
	+	} // set_current_executable()
	+	</code>
	+
	+	Schritt 2: innerhalb von main() findet die Initialisierung statt:
	+
	+	<code c>
	+	int main(int argc, char* argv[])
	+	{
	+	char current_executable_fqPath[PATH_MAX] = { 0 };
	+
	+	if (realpath(argv[0], current_executable_fqPath) == NULL) current_executable_fqPath[0] = '\0';
	+
	+	set_current_executable(current_executable_fqPath);
	+	} // main()
	+	</code>
	+
	+	:!: Unter Windows kann man den Schritt 2 ersparen (und den Setter auch), weil das API eine passende Funktion zur Verfügung stellt:
	+
	+	<code c>
	+	string get_current_executable()
	+	{
	+	char path[MAX_PATH];
	+	HMODULE hModule = GetModuleHandle(NULL);
	+	if (hModule != NULL)
	+	{
	+	GetModuleFileName(hModule, path, (sizeof(path)));
	+	return path;
	+	}
	+	return "";
	+	}
	+	</code>
	+
	+	:!: Die Makros PATH_MAX (Unix) und MAX_PATH (Windows) in den jeweiligen APIs vordefiniert.
	+
	+	===== Im Fall "Dynamische Library" =====
	+
	+	Unter Windows die gleiche Vorgehensweise wie oben.
	+
	+	Für Unix wird der Modulname innerhalb der Initialisierungsroutine (wird durch %%void __attribute__ ((constructor))%% festgelegt) ermittelt:
	+
	+	<code c>
	+	#define _GNU_SOURCE
	+	#include <dlfcn.h>
	+	#include <stdio.h>
	+
	+	void __attribute__ ((constructor)) lib_initialize(void);
	+	void __attribute__ ((destructor)) lib_finalize(void);
	+
	+	// Called when the library is loaded and before dlopen() returns.
	+	void lib_initialize(void)
	+	{
	+	Dl_info dl_info;
	+	dladdr((void *) lib_initialize, &dl_info);
	+	set_current_executable(dl_info.dli_fname);
	+	} // lib_initialize()
	+
	+	// Called when the library is unloaded and before dlclose() returns.
	+	void lib_finalize(void)
	+	{
	+	}
	+	</code>
	+
	+	Quelle: [[http://stackoverflow.com/questions/1681060/library-path-when-dynamically-loaded]]
	+
	+	----
	+	Stand: 05.09.2016\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:kommunikation_ueber_named_pipes

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:07+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Kommunikation über Named Pipes ======

	+	Es gibt Aufgaben, daß die Ausgabe eines Programms (sagen wir //Prg1//) direkt als Eingabe eines anderen Programms (//Prg2//) verwendet und nicht als File gespeichert werden soll. Ein Beispiel: //Prg1// generiert Daten, die als geheim eingestuft sind (z.B. Paßwörter, PINs, etc.) und leitet sie nach stdout. //Prg2// empfängt diese Daten über stdin und bearbeitet weiter (z.B. verschlüsselt). Beide Prozesse sind über eine Pipe verbunden.
	+
	+	1) Der Aufruf würde dann etwa so aussehen:
	+
	+	<code bash>
	+	Prg1 \| Prg2
	+	</code>
	+
	+	2) Eine andere Möglichkeit wäre, beide Prozesse über eine Named Pipe kommunizieren zu lassen:
	+
	+	<code bash>
	+	# Eine Named Pipe anlegen (der Name spielt keine Rolle).
	+	mkfifo /Pfad/Prg1.to.Prg2.fifo
	+
	+	# Den schreibenden Prozeß im Hintergrund starten, die Pipe wird zum Schreiben geöffnet.
	+	Prg1 > /Pfad/Prg1.to.Prg2.fifo &
	+
	+	# Der schreibende Prozeß wird solange angehalten, bis die Pipe durch den lesenden Prozeß zum Lesen geöffnet wird.
	+	Prg2 < /Pfad/Prg1.to.Prg2.fifo
	+
	+	# Jetzt laufen beide Prozesse, die Daten werden über die Pipe geschaufelt.
	+
	+	# Als die Kommunikation abgeschlossen ist, soll die Pipe wieder gelöscht werden.
	+	rm /Pfad/Prg1.to.Prg2.fifo
	+	</code>
	+
	+	3) Es gibt aber Situationen, daß es sinnvoller erscheint, alle in der 2. Möglichkeit erwähnten Schritte direkt in das //Prg1// zu kapseln. Das hat Vorteil, daß:\\
	+	* Keine manuellen Schritte erforderlich sind, die fehleranfällig und manipulierbar sein könnten.
	+	* Da der Name und die Position im Filesystem der Named Pipe durch den //Prg1//-Prozeß bestimmt werden, sind sie für einen Angreifer nicht mehr so leicht abgreifbar.
	+	* Der Prozeß //Prg1// kümmert sich um den gesamten Ablauf selbst, so, daß die Prozeß-Leichen wegen den einseitig geöffneten Pipes einfacher vermieden werden können.
	+	* Der Prozeß //Prg1// löscht am Ende die Pipe, so, daß kein Müll im Filesystem liegen bleibt.
	+
	+	Ein Programmbeispiel für die 3. Variante könnte so aussehen:
	+
	+	<code c>
	+	{
	+	int rc = 0; // ReturnCode
	+	FILE *pipeFIFO = NULL;
	+	char pipeName [] = "/tmp/eineTestPipe.fifo";
	+	char runStr [1024];
	+
	+	memset(runStr, '\0', sizeof(runStr));
	+
	+	// Teil 1: Vorbereitung
	+
	+	if (!rc) remove(pipeName); // Evtl. bereits vorhandene Named Pipe wird vorsorglich entfernt.
	+
	+	if (!rc)
	+	{
	+	if ((rc = mkfifo(pipeName, 0666)) == 0) printf("Named Pipe %s wurde angelegt.\n", pipeName); // Named Pipe anlegen.
	+	else printf("Named Pipe %s konnte nicht angelegt werden.\n", pipeName);
	+	} // if
	+
	+	if (!rc)
	+	{
	+	sprintf(runStr, "cat %s &", pipeName); // Aufruf des Lese-Programms (im Text Prg2) vorbereiten.
	+	if ((rc = system(runStr)) != 0) printf("Prg2: Fehler beim Aufruf vom %s: %s\n", runStr, strerror(errno));
	+	else printf("Prg2: submitted.\n");
	+	} // if
	+
	+	// Ab dieser Stelle hat das Leseprogramm die Pipe zum Lesen geöffnet und läuft im Hintergrund.
	+
	+	if (!rc) pipeFIFO = fopen(pipeName, "w"); // Pipe zum Schreiben öffnen
	+	if (!pipeFIFO) printf("Named Pipe %s konnte nicht geöffnet werden.\n", pipeName); // Fehlermeldung.
	+	else printf("Named Pipe %s wurde geöffnet.\n", pipeName);
	+
	+	// Teil 2: Datenausgabe in die Pipe
	+
	+	if (pipeFIFO) fprintf(pipeFIFO, "Testausgabe:\nNamed Pipe = [%s], Aufruf von Prg2 = [%s]\n", pipeName, runStr);
	+
	+	// Teil 3: Aufräumen
	+
	+	if (pipeFIFO)
	+	{
	+	fflush(pipeFIFO);
	+	fclose(pipeFIFO); // Die Pipe schließen.
	+	pipeFIFO = NULL;
	+	sleep(1); // Vor dem Löschen evtl. kurz abwarten bis der Leseprozeß fertig ist (besser mit wait()).
	+	if ((rc = remove(pipeName)) != 0) printf("Named Pipe %s konnte nicht gelöscht werden.\n", pipeName); // Fehlermeldung.
	+	} // if
	+
	+	return rc;
	+	}
	+	</code>
	+
	+	----
	+	Stand: 30.10.2009\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:logging_ext

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:08+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== logging_ext ======

	+	FIXME: Da sich viele Teile der Funktionssignatur wiederholen und aus den Makros/Konstanten bestehen, ist es sinnvoll für die DebugLevel %%LOG_DEBUG%%, %%LOG_INFO%%, %%LOG_WARNING%% und %%LOG_ERR%% Makros um die Funktionen logLog(), logLogRC(), logLogRC_SQL(), logEntry(), logExit() und logExitRC() zu definieren.\\ Diese Makros sollen die Parameter %%logLevel%% (%%LOG_DEBUG%%/%%LOG_INFO%%/%%LOG_WARNING%%/%%LOG_ERR%%), %%modulName%% (%%__FILE__%%), %%lineNumber%% (%%__LINE__%%) und %%functName%% (%%__func__%%) kapseln.\\ Als Namen für diese Makros könnte man z.B. %%LOG_LOG_DEBUG()%%/%%LOG_LOG_INFO()%%/%%LOG_LOG_WARNING()%%/%%LOG_LOG_ERR()%% verwenden.
	+
	+	Logging-Modul - nützliche Log-Funktionen.
	+
	+	logging_ext.h:
	+
	+	<code c>
	+	/*********************************************************************
	+	*
	+	* Autor: Jürgen Kreick
	+	* Version: 1.0.0 vom 10.09.2010
	+	*
	+	**********************************************************************
	+	*
	+	* Achtung! Dieses Modul (in der aktuellen Version) ist nicht reenterable!
	+	*
	+	* Für MultiThreaded Betrieb nur bedingt geeignet!
	+	*
	+	**********************************************************************
	+	*
	+	* Hinweise zum Modul/Quelltext: Keine aktuellen Hinweise.
	+	*
	+	**********************************************************************
	+	*
	+	* Release Notes:
	+	*
	+	* Ver 1.0.0 (vom 10.09.2010):
	+	* Die erste Version des Moduls. Umfasst (nach außen) folgende Funktionen:
	+	* logInit(), logDone(), logLog(), logLogRC(), logLogRC_SQL(),
	+	* logEntry(), logExit(), logExitRC(), logErrorMsgFatal().
	+	*
	+	**********************************************************************/
	+
	+	#ifndef logging_ext_h_H
	+	#define logging_ext_h_H
	+
	+	// Wegen LogLevel (soll einheitlich zu Syslog bleiben)
	+	#include <syslog.h>
	+	// Typ "FILE"
	+	#include <stdio.h>
	+
	+	// Standard-LogLevel:
	+	#define LOGLEVEL_STD 5
	+	// Zur Abgrenzung (und Plausibilitätspruefung): der gleiche Wert wie der min./max. LogLevel
	+	#define LOGLEVEL_MIN 0
	+	#define LOGLEVEL_MAX 7
	+
	+	// Rückgabewerte:
	+	#define RC_OK 0
	+	#define RC_ERR -1
	+	// Status zum LogFile (Extension für den FileNamen) dranhängen
	+	#define LOGSTATUS_RUN "RUN"
	+	#define LOGSTATUS_CLOSE "CLOSED"
	+	// Vordefinierte (ungültige) LogFile-IDs:
	+	#define LOGFILE_NOFILE 0
	+	#define LOGFILE_ERROR -2
	+	// Vordefinierte LogFile-Texte:
	+	#define LOGTXT_FUNCTION_ENTRY "FUNCTION ENTRY"
	+	#define LOGTXT_FUNCTION_EXIT "FUNCTION EXIT"
	+
	+	// Datums- und Zeitformat:
	+	// Achtung!
	+	// Makros LOG_?????_FORMAT_MEM sollen genauen Speicherbedarf (in Zeichen) für
	+	// die entsprechenden LOG_?????_FORMAT widerspiegeln! Sie werden für die
	+	// Deklaration von String-Buffern genutzt.
	+	// Das ist nicht etwa die Länge des LOG_?????_FORMAT-Strings, sondern die Länge
	+	// des Strings, der durch das sprintf(LOG_?????_FORMAT, ...) erzeugt wird.
	+	// Wird hier ein zu kleiner Wert derfiniert, führt es zum BufferOverflow.
	+	// Datum JJJJ-MM-TT
	+	#define LOG_DATUM_FORMAT "%04d-%02d-%02d"
	+	#define LOG_DATUM_FORMAT_MEM 10
	+	// Zeit SS-MM-ss
	+	#define LOG_ZEIT_FORMAT "%02d-%02d-%02d"
	+	#define LOG_ZEIT_FORMAT_MEM 8
	+
	+
	+	// ****************** Prototypen **************************************
	+
	+	// logInit() wird ein Mal pro LogFile aufgerufen und legt dabei das LogFile an.
	+	// (Beim allerersten Aufruf wird zusätzlich das gesamte Log-Modul initialisiert.)
	+	//
	+	// Parameter:
	+	//
	+	// Es gibt 2 Varianten des Aufrufs:
	+	//
	+	// 1) Die logInit() generiert den FileNamen des LogFiles automatisch aus dem
	+	// Namen des Programms (char *progName), des aktuellen Datums und der
	+	// aktuellen Uhrzeit und legt es im angegebenen Ordner (char *loggingPath)
	+	// an. Der Parameter "char *logPathFileName" soll dabei NULL bleiben.
	+	//
	+	// 2) Die logInit() übernimmt den FileNamen des LogFiles samt Pfad aus dem
	+	// Parameter "char *logPathFileName" und fügt lediglich die Endung
	+	// beispielsweise ".RUN" bzw. ".CLOSED" hinzu.
	+	//
	+	// In beiden Fällen wird die Endung über den Parameter "char *extRun" und
	+	// "char *extClosed" bestimmt.
	+	//
	+	// char *loggingPath : Verzeichnis, in dem das LogFile angelegt werden soll
	+	// char *progName : Anfang des Dateinamens
	+	// char *logPathFileName : Entweder NULL (Kein konkretes File),
	+	// oder kompletter (mit Pfad) FileName
	+	// char *extRun : Entweder NULL (Keine Erweiterung des FileNamens),
	+	// oder eine Erweiterung, z.B. "RUN".
	+	// Diese wird am Ende des FileNamens angehängt.
	+	// char *extClosed : Entweder NULL (Keine Erweiterung des FileNamens),
	+	// oder eine Erweiterung, z.B. "CLOSED".
	+	// Diese bekommt das File nachdem die logDone(logFileID)
	+	// aufgerufen wird (normalerweise beim Programmende).
	+	// int threadNum : Falls mehrere Thread in separate LogFiles schreiben sollen,
	+	// hier die Thread-Nummer, sonst 0
	+	// int logLevelMax : Bis zu welchem LogLevel die Ausgabe erfolgen soll. (Alle
	+	// niedrigeren LogLevel werden mitgeloggt.)
	+	// Dateiname wird nach dem Schema "progName.JJJJ-MM-TT.SS-MM-ss.PID.ThreadNr.log.Status" gebildet.
	+	//
	+	// Rückgabewert: die "int logFileID" - sie wird bei allen Logging Funktionen
	+	// (innerhalb dieses Moduls) als Bezug auf das konkrete LogFile verwendet.
	+	// Bei Fehlern wird LOGFILE_ERROR als Rückgabewert zurück gegeben.
	+	int logInit (const char loggingPath, const char progName, const char logPathFileName, const char extRun, const char *extClosed, int threadNum, int logLevelMax);
	+
	+
	+	// logDone() schließt das über die logFileID referenziertes LogFile und ändert
	+	// dessen Status (den letzten Teil des Namen von ".RUN" auf ".CLOSED").
	+	// Mit dem Parameter 0 aufgerufen schließt sie alle LogFiles.
	+	void logDone (int logFileID);
	+
	+
	+	// Allgemeine Logging-Funktion.
	+	//
	+	// Parameter:
	+	// int logLevel : Unter welchem LogLevel soll die Ausgabe erfolgen. Falls
	+	// "logLevel" den "logLevelMax" beim Aufruf von logInit()
	+	// überschreitet, erfolgt keine Ausgabe.
	+	// int logFileID : Die LogFile-Referenz - das Ergebniss von logInit()
	+	// char *modulName : Modul-Name, das die Ausgabe produziert. In meisten Fällen
	+	// wird als Makro __FILE__ übergeben.
	+	// int lineNumber : Zeilennummer, die die Ausgabe produziert. In meisten Fällen
	+	// wird als Makro __LINE__ übergeben.
	+	// char *functName : Name der Funktion, die die Ausgabe produziert. In meisten
	+	// Fällen wird als Makro __func__ übergeben.
	+	// char *text : Die eigentliche Log-Ausgabe.
	+	//
	+	// Rückgabewert: Erfolg (Ausgabe erfolgreich) / Misserfolg (Ausgabe nicht erfolgrei oder LogLevel zu niedrig).
	+	int logLog (int logLevel, int logFileID, const char modulName, int lineNumber, const char functName, const char *text);
	+	//
	+	// Das gleiche wie oben, nur mit Angabe von RC (ReturnCode)
	+	//
	+	// Parameter: wie oben, jedoch ein Parameter zusätzlich:
	+	// int rc : ReturnCode, wird hinter dem "text" ausgegeben.
	+	int logLogRC (int logLevel, int logFileID, const char modulName, int lineNumber, const char functName, const char *text, int rc);
	+	//
	+	// Das gleiche wie oben, nur für SQL
	+	//
	+	// Diese Funktion kann nach jeder DB-Operation aufgerufen werden
	+	// (insbesondere falls der SQL-Code nicht RC_DB_OK ist).
	+	//
	+	// Parameter: wie oben, jedoch ein Parameter zusätzlich:
	+	// const char *sql : Der SQL selbst.
	+	int logLogRC_SQL (int logLevel, int logFileID, const char modulName, int lineNumber, const char functName, const char text, const char sql, int rc_SQL);
	+
	+
	+
	+	// Logging-Funktionen zum Markieren der Ein- und Ausstiegsstelle in den Funktionen.
	+	//
	+	// Parameter: wie oben.
	+	int logEntry (int logLevel, int logFileID, const char modulName, const char functName);
	+	int logExit (int logLevel, int logFileID, const char modulName, const char functName);
	+	// ...und für Exit mit ReturnCode
	+	int logExitRC (int logLevel, int logFileID, const char modulName, const char functName, int rc);
	+
	+
	+
	+	// Bei Fatalfehler wird eine Fehlermeldung auf "stderr" ausgegeben und die gesamte Anwendung mit exit(exitCode) unterbrochen.
	+	//
	+	// Parameter: wie oben.
	+	void logErrorMsgFatal (int exitCode, const char modulName, int lineNumber, const char functName, const char * fehlermeldung);
	+
	+
	+	/* Everything else goes here */
	+
	+	#endif
	+	// EOF
	+	</code>
	+
	+	logging_ext.c:
	+
	+	<code c>
	+	#include "logging_ext.h"
	+	// Makro ASSERT()
	+	#include <sys/debug.h>
	+	// Zeit-Funktionen und Strukturen
	+	#include <time.h>
	+	// Wegen der Funktion "max(int int1, int int2)":
	+	#include <sys/ddi.h>
	+
	+	////////////////////////////////////////////////////////////////////////////////
	+	//
	+	// Zur Info: LogLevel aus syslog.h
	+	// LOG_EMERG 0 /* system is unusable */
	+	// LOG_ALERT 1 /* action must be taken immediately */
	+	// LOG_CRIT 2 /* critical conditions */
	+	// LOG_ERR 3 /* error conditions */
	+	// LOG_WARNING 4 /* warning conditions */
	+	// LOG_NOTICE 5 /* normal but signification condition */
	+	// LOG_INFO 6 /* informational */
	+	// LOG_DEBUG 7 /* debug-level messages */
	+	//
	+	////////////////////////////////////////////////////////////////////////////////
	+
	+
	+	// LogLevel als String für die Ausgabe im LogFile:
	+	#define LOG_STR_EMERG "EMERGENCY"
	+	#define LOG_STR_ALERT "ALERT"
	+	#define LOG_STR_CRIT "CRITICAL"
	+	#define LOG_STR_ERR "ERROR"
	+	#define LOG_STR_WARNING "WARNING"
	+	#define LOG_STR_NOTICE "NOTICE"
	+	#define LOG_STR_INFO "INFO"
	+	#define LOG_STR_DEBUG "DEBUG"
	+
	+	// Restliche Konstanten:
	+	#define TMP_STR_LEN_MAX 8191
	+	#define FILENAME_LEN_MAX 8191
	+
	+	// So viele LogFiles parallel kann dieses Modul verwalten
	+	#define AKTIVE_LOGFILES_MAX 64
	+
	+	// Status
	+	#define LOGFILE_AKTIVE 1
	+	#define LOGFILE_FREE 0
	+
	+	// Ausgabeformat in der Funktion logLogRC()
	+	#define LOG_RC_FORMAT "%s (RC = %d)"
	+	// Ausgabeformat in der Funktion logExitRC()
	+	#define LOG_EXIT_RC_FORMAT "%s (RC = %d)"
	+	// Ausgabeformat in der Funktion logLogRC_SQL()
	+	#define LOG_RC_SQL_FORMAT "SQL: '%s;' %s (SQL-CODE = %d)"
	+
	+	// Vordefinierte LogFile-Meldungen:
	+	#define LOGTXT_TEXT_TOO_LONG "Log-Ausgabe ist zu lang"
	+
	+
	+	// ****************** lokale Strukturen **************************************
	+
	+	// Steuerstruktur für alle LogFiles
	+	typedef struct
	+	{
	+	int id; // logische Nummer eines Log-Files
	+	int active; // 1 = aktiv, 0 = frei
	+	int logLevel; // bis zu welchem LogLevel loggen
	+	int thread; // falls mehrere Thread aktiv sind, Thread-Nummer, sonst 0
	+	FILE *logFile; // FileDescriptor
	+	char fileNameRun [FILENAME_LEN_MAX + 1]; // FileName im aktiven Zustand (mit .RUN am Ende)
	+	char fileNameClose [FILENAME_LEN_MAX + 1]; // FileName im inaktiven Zustand (mit .CLOSED am Ende)
	+	} LOGFILE_CONTROL;
	+
	+
	+	// ****************** lokale Variablen **************************************
	+
	+	// Zähler für momentan aktive LogFiles.
	+	// Solange die "initLogFileCtl(0)" nicht aufgerufen wurde (anfängliche Initialisierung),
	+	// bleibt "countAktiveLogFiles" im Fehlerzustand und hindert jegliche weitere Funktion
	+	// des Moduls.
	+	int countAktiveLogFiles = LOGFILE_ERROR;
	+	int myPID = -1; // eigene Prozess-ID (Bestandteil des Namens des LogFiles)
	+	int threaded = 0; // Soviele Ausgaben erfolgen in den Threads (parallel).
	+
	+	LOGFILE_CONTROL logFileCtl [AKTIVE_LOGFILES_MAX + 1]; // Steuerstrukturen für alle LogFiles (Element 0 unbenutzt)
	+
	+	char *logLevel2String [] =
	+	{
	+	LOG_STR_EMERG, // 0 "EMERGENCY"
	+	LOG_STR_ALERT, // 1 "ALERT"
	+	LOG_STR_CRIT, // 2 "CRITICAL"
	+	LOG_STR_ERR, // 3 "ERROR"
	+	LOG_STR_WARNING, // 4 "WARNING"
	+	LOG_STR_NOTICE, // 5 "NOTICE"
	+	LOG_STR_INFO, // 6 "INFO"
	+	LOG_STR_DEBUG // 7 "DEBUG"
	+	};
	+
	+
	+	// ****************** interne Funktionen **************************************
	+
	+	void initLogFileCtl (int id) // initialisiert eine logFileCtl[id], falls id = 0 - gesamte Struktur
	+	{
	+	// Die ID darf nur zwischen 0 und AKTIVE_LOGFILES_MAX bewegen (beide einschließlich)
	+	ASSERT((id >= 0) && (id <= AKTIVE_LOGFILES_MAX));
	+
	+	if (id == 0) // Gesamte Struktur initialisieren
	+	{
	+	// Diese Initialisierung findet nur ein Mal statt - beim Start der Anwendung
	+	ASSERT(countAktiveLogFiles == LOGFILE_ERROR); // Die Struktur darf noch nicht initialisiert sein
	+	memset(&logFileCtl, 0x00, sizeof(logFileCtl));
	+	countAktiveLogFiles = 0;
	+	threaded = 0;
	+	myPID = getpid(); // eigene Prozess-ID
	+	}
	+	else // Eine einzelne Komponente initialisieren
	+	{
	+	ASSERT(countAktiveLogFiles >= 0); // Die Struktur muss bereits initialisiert sein
	+	memset(&(logFileCtl[id]), 0x00, sizeof(logFileCtl[0])); // nur eine logFileCtl[id] initialisieren
	+	} // if
	+	} // initLogFileCtl()
	+
	+
	+	int getNewLogFileCtl ()
	+	{
	+	int rc = LOGFILE_ERROR;
	+	register int i;
	+
	+	for (i = 1; i <= AKTIVE_LOGFILES_MAX; i++) // durch die ganze Tabelle
	+	{
	+	if (!(logFileCtl[i].active)) // Noch nicht aktiv?
	+	{
	+	rc = i; // ID merken
	+	break; // Keine weitere Suche
	+	} // if
	+	} // for
	+
	+	if ((rc <= 0) \|\| (rc > AKTIVE_LOGFILES_MAX)) rc = LOGFILE_ERROR;
	+	if (rc > 0) initLogFileCtl(rc); // ID initialisieren
	+
	+	return rc; // ID zurueck, oder -2 (LOGFILE_ERROR) wenn nichts passendes gefunden
	+	} // getNewLogFileCtl()
	+
	+
	+	void getCurrentDateAndTime (char currentDate, const char formatDate, char currentTime, const char formatTime)
	+	{
	+	// ----- Achtung! Mehrere returns innerhalb der Funktion ------------------------------
	+
	+	time_t aktSekunden;
	+	struct tm *aktZeit;
	+
	+	if (!currentDate) return;
	+	if (!formatDate) return;
	+	if (!currentTime) return;
	+	if (!formatTime) return;
	+
	+	time(&aktSekunden); // aktuelle Zeit holen
	+	aktZeit = localtime(&aktSekunden); // auf Komponenten zerlegen
	+	// Achtung! sprintf() ist unsicher!
	+	// Es findet hier keine Prüfung statt, ob in "currentTime" und "currentDate" genug Platz vorhanden ist!
	+	sprintf(currentTime, formatTime, aktZeit->tm_hour, aktZeit->tm_min, aktZeit->tm_sec); // Uhrzeit
	+	sprintf(currentDate, formatDate, aktZeit->tm_year + 1900, aktZeit->tm_mon + 1, aktZeit->tm_mday); // Datum
	+	} // getCurrentDateAndTime()
	+
	+
	+	// Diese Funktion berechnet wieviele Stellen (samt '-' bei negativen) eine Ganzzahl im String-Format belegt.
	+	int intlen (int zahl)
	+	{
	+	int len = 0;
	+
	+	// Initialisierungswert
	+	if (zahl < 1) len = 1; // Bei 0 wird nicht gezählt, bei negativen eine Stelle dazu wegen Vorzeichen.
	+	else len = 0;
	+
	+	zahl = abs(zahl);
	+	while (zahl > 0)
	+	{
	+	zahl = zahl / 10; // Um eine Stelle kürzen
	+	len++; // Eine Stelle dazu zählen
	+	} // while
	+
	+	return len;
	+	} // intlen()
	+
	+
	+	// ****************** export-Funktionen **************************************
	+
	+	int logInit (const char loggingPath, const char progName, const char logPathFileName, const char extRun, const char *extClosed, int threadNum, int logLevelMax)
	+	{
	+	int rc = RC_OK;
	+	int logFileID = LOGFILE_ERROR;
	+	FILE *logFile = NULL;
	+	char fileName [FILENAME_LEN_MAX + 1];
	+	char strZeit [LOG_ZEIT_FORMAT_MEM + 1];
	+	char strDatum [LOG_DATUM_FORMAT_MEM + 1];
	+	int logFileNameReserve = 0;
	+
	+	memset(fileName, '\0', sizeof(fileName));
	+	memset(strZeit, '\0', sizeof(strZeit));
	+	memset(strDatum, '\0', sizeof(strDatum));
	+
	+	if (countAktiveLogFiles == LOGFILE_ERROR) initLogFileCtl(0); // D.h. nur beim ersten Aufruf initialisieren.
	+
	+	if ((logFileID = getNewLogFileCtl()) > 0) rc = RC_OK; // wenn eine neue ID erteilt wurde
	+	else rc = RC_ERR; // keine neue ID verfügbar
	+
	+	if (!rc)
	+	{
	+	if (logLevelMax < LOGLEVEL_MIN) logLevelMax = LOGLEVEL_MIN;
	+	if (logLevelMax > LOGLEVEL_MAX) logLevelMax = LOGLEVEL_MAX;
	+
	+	logFileCtl[logFileID].id = logFileID; // Struktur ausfüllen
	+
	+	if (logPathFileName) // Falls ein konkreter FileName vorgegeben wurde, diesen als Basis verwenden.
	+	{
	+	// Die Verlängerung des FileNamens (logFileNameReserve) berechnen.
	+	if (extRun && extClosed) logFileNameReserve = max(strlen(extRun), strlen(extClosed)) + 1; // 1 für das '.'-Zeichen
	+	else if (extRun) logFileNameReserve = strlen(extRun) + 1;
	+	else if (extClosed) logFileNameReserve = strlen(extClosed) + 1;
	+	else logFileNameReserve = 0; // Keine Endungen
	+
	+	strlcpy(fileName, logPathFileName, sizeof(fileName) - logFileNameReserve); // Den FileNamen übernehmen
	+	}
	+	else // Den FileNamen selbstständig generieren.
	+	{
	+	getCurrentDateAndTime(strDatum, LOG_DATUM_FORMAT, strZeit, LOG_ZEIT_FORMAT);
	+
	+	snprintf(fileName, sizeof(fileName), "%s/%s.%s.%s.%d.%d.log", loggingPath, progName, strDatum, strZeit, myPID, threadNum); // StammName
	+	} // if
	+
	+	// Den kompletten FileNamen bilden - für den RUN-Zustand.
	+	if (extRun) snprintf(logFileCtl[logFileID].fileNameRun, sizeof(logFileCtl[0].fileNameRun), "%s.%s", fileName, extRun);
	+	else strlcpy(logFileCtl[logFileID].fileNameRun, fileName, sizeof(logFileCtl[0].fileNameRun));
	+
	+	// Den kompletten FileNamen bilden - für den CLOSED-Zustand.
	+	if (extClosed) snprintf(logFileCtl[logFileID].fileNameClose, sizeof(logFileCtl[0].fileNameClose), "%s.%s", fileName, extClosed);
	+	else strlcpy(logFileCtl[logFileID].fileNameClose, fileName, sizeof(logFileCtl[0].fileNameClose));
	+
	+	logFile = fopen(logFileCtl[logFileID].fileNameRun, "w"); // zum Schreiben öffnen
	+	if (logFile)
	+	{
	+	if (setvbuf(logFile, NULL, _IOLBF, TMP_STR_LEN_MAX + 1) != 0) // Zeilenbuffer anlegen
	+	{
	+	fclose(logFile); // Bei mißerfolg.
	+	logFile = NULL;
	+	} // if
	+	} // if
	+	if (logFile) logFileCtl[logFileID].logFile = logFile; // Falls geöffnet, den FileHandle zuweisen...
	+	else logFileCtl[logFileID].logFile = stderr; // ...sonst "stderr"-Handle
	+	logFileCtl[logFileID].logLevel = logLevelMax; // Den "persönlichen" LogLevel merken.
	+	logFileCtl[logFileID].thread = threadNum; // Thread-Nummer merken.
	+
	+	if (logFile) logFileCtl[logFileID].active = LOGFILE_AKTIVE; // auf aktiv setzen
	+	else rc = RC_ERR;
	+
	+	if (logFileCtl[logFileID].active == LOGFILE_AKTIVE) // Falls ein aktives LogFile dazu gekommen...
	+	{
	+	countAktiveLogFiles++; // ... eins dazu zählen.
	+
	+	if (logFileCtl[logFileID].thread > 0) threaded++; // Es ist also mit paralleler Ausgabe zu rechnen.
	+	} // if
	+	} // if
	+
	+	if (!rc) rc = logFileID;
	+	else rc = LOGFILE_ERROR;
	+
	+	return rc; // LogFile-ID
	+	} // logInit()
	+
	+
	+	void logDone (int logFileID)
	+	{
	+	// ----- Achtung! Mehrere returns innerhalb der Funktion ------------------------------
	+
	+	if (logFileID == 0)
	+	{
	+	int i;
	+
	+	for (i = 1; i <= AKTIVE_LOGFILES_MAX; i++) logDone(i); // Alle LogFiles schließen
	+
	+	return;
	+	} // if
	+
	+	if ((logFileID < 1) \|\| (logFileID > AKTIVE_LOGFILES_MAX)) return; // ID ist nicht plausibel
	+
	+	if (logFileCtl[logFileID].active != LOGFILE_AKTIVE) return; // ID ist nicht aktiv
	+
	+	// Ab hier Files schließen und die ID deaktivieren.
	+
	+	if (logFileCtl[logFileID].logFile) fflush(logFileCtl[logFileID].logFile);
	+	if (logFileCtl[logFileID].logFile == stderr) logFileCtl[logFileID].logFile = NULL; // Bei "stderr" keine weiteren Aktivitäten.
	+	if (logFileCtl[logFileID].logFile) fclose(logFileCtl[logFileID].logFile);
	+	logFileCtl[logFileID].logFile = NULL;
	+
	+	// Wechsel vom RUN- zum CLOSED-Zustand.
	+	rename(logFileCtl[logFileID].fileNameRun, logFileCtl[logFileID].fileNameClose); // Log-File umbenennen
	+
	+	logFileCtl[logFileID].active = LOGFILE_FREE; // nicht mehr aktiv
	+	if (logFileCtl[logFileID].thread) threaded--; // Um einen Thread weniger.
	+	if (threaded < 0) threaded = 0; // Darf nicht negativ sein (dürfte eigentlich nicht vorkommen).
	+	logFileCtl[logFileID].thread = 0;
	+	countAktiveLogFiles--;
	+	if (countAktiveLogFiles < 0) countAktiveLogFiles = 0; // Darf nicht negativ sein (dürfte eigentlich nicht vorkommen).
	+	} // logDone()
	+
	+
	+	int logLog (int logLevel, int logFileID, const char modulName, int lineNumber, const char functName, const char *text)
	+	{
	+	int rc = RC_OK;
	+	int logFileIdLogLevel = 0;
	+	char strZeit [LOG_ZEIT_FORMAT_MEM + 1];
	+	char strDatum [LOG_DATUM_FORMAT_MEM + 1];
	+
	+	memset(strZeit, '\0', sizeof(strZeit));
	+	memset(strDatum, '\0', sizeof(strDatum));
	+
	+	// Ist die logFileID plausibel?
	+	if ((logFileID < 1) \|\| (logFileID > AKTIVE_LOGFILES_MAX)) rc = RC_ERR; // ID ist nicht plausibel
	+	if ((logLevel < LOGLEVEL_MIN) \|\| (logLevel > LOGLEVEL_MAX)) rc = RC_ERR; // LogLevel ist nicht plausibel
	+	if (rc) logFileID = 0; // damit durch fehlerhafte logFileID kein Segmentation Fault ausgelöst wird
	+
	+	// ist die logFileID aktiv?
	+	if (!rc) if (logFileCtl[logFileID].active != LOGFILE_AKTIVE) rc = RC_ERR; // ID ist nicht plausibel
	+
	+	logFileIdLogLevel = logFileCtl[logFileID].logLevel;
	+	if (!rc && (logLevel <= logFileIdLogLevel)) // Ausgabe in LogFile nur wenn der LogLevel passt.
	+	{
	+	getCurrentDateAndTime(strDatum, LOG_DATUM_FORMAT, strZeit, LOG_ZEIT_FORMAT);
	+
	+	// Die Ausgabe ins LogFile abhängig vom zur logFileID gehörenden logLevel schreiben:
	+	// Log-Ausgabe für logEntry() / logExit() / logExitRC() (mit "modulName" und "functName")
	+	if (lineNumber == -1) fprintf(logFileCtl[logFileID].logFile, "%s %s %s: %s:%s(): %s\n", strDatum, strZeit, logLevel2String[logLevel], modulName ? modulName : "NOMODUL(NULL-POINTER)", functName ? functName : "NOFUNKT(NULL-POINTER)", text ? text : "NOTEXT(NULL-POINTER)");
	+	// Log-Ausgabe für logLevel = LOG_DEBUG (und evtl. höher) erfolgt mit "modulName", "lineNumber", und "functName" (alle Angaben)
	+	else if (logFileIdLogLevel >= LOG_DEBUG) fprintf(logFileCtl[logFileID].logFile, "%s %s %s: %s[%d]:%s(): %s\n", strDatum, strZeit, logLevel2String[logLevel], modulName ? modulName : "NOMODUL(NULL-POINTER)", lineNumber, functName ? functName : "NOFUNKT(NULL-POINTER)", text ? text : "NOTEXT(NULL-POINTER)");
	+	// Log-Ausgabe für logLevel = LOG_INFO (und evtl. höher) erfolgt nur mit "functName"
	+	else if (logFileIdLogLevel >= LOG_INFO) fprintf(logFileCtl[logFileID].logFile, "%s %s %s: %s(): %s\n", strDatum, strZeit, logLevel2String[logLevel], functName ? functName : "NOFUNKT(NULL-POINTER)", text ? text : "NOTEXT(NULL-POINTER)");
	+	// allgemeine Log-Ausgabe (nur mit Zeitstempel)
	+	else fprintf(logFileCtl[logFileID].logFile, "%s %s %s: %s\n", strDatum, strZeit, logLevel2String[logLevel], text ? text : "NOTEXT(NULL-POINTER)");
	+
	+	if (threaded) fflush(logFileCtl[logFileID].logFile); // Bei mehreren Threads sofort wegschreiben.
	+	} // if
	+
	+	return rc;
	+	} // logLog()
	+
	+	int logLogRC (int logLevel, int logFileID, const char modulName, int lineNumber, const char functName, const char *text, int rc)
	+	{
	+	char logStr [TMP_STR_LEN_MAX + 1];
	+
	+	memset(logStr, '\0', sizeof(logStr));
	+
	+	if ((strlen(text) + intlen(rc) + strlen(LOG_RC_FORMAT)) > TMP_STR_LEN_MAX) strcpy(logStr, LOGTXT_TEXT_TOO_LONG); // Ausgabe-String zu lang.
	+	else sprintf(logStr, LOG_RC_FORMAT, text, rc); // Achtung! sprintf() ist unsicher!
	+
	+	return logLog(logLevel, logFileID, modulName, lineNumber, functName, logStr);
	+	} // logLogRC()
	+
	+	int logLogRC_SQL (int logLevel, int logFileID, const char modulName, int lineNumber, const char functName, const char text, const char sql, int rc_SQL)
	+	{
	+	char logStr [TMP_STR_LEN_MAX + 1];
	+
	+	memset(logStr, '\0', sizeof(logStr));
	+
	+	if ((strlen(sql) + strlen(text) + intlen(rc_SQL) + strlen(LOG_RC_SQL_FORMAT)) > TMP_STR_LEN_MAX) strcpy(logStr, LOGTXT_TEXT_TOO_LONG); // Ausgabe-String zu lang.
	+	else sprintf(logStr, LOG_RC_SQL_FORMAT, sql, text, rc_SQL); // Achtung! sprintf() ist unsicher!
	+
	+	return logLog(logLevel, logFileID, modulName, lineNumber, functName, logStr);
	+	} // logLogRC_SQL()
	+
	+
	+	int logEntry (int logLevel, int logFileID, const char modulName, const char functName)
	+	{
	+	return logLog(logLevel, logFileID, modulName, -1, functName, LOGTXT_FUNCTION_ENTRY);
	+	} // logEntry()
	+
	+	int logExit (int logLevel, int logFileID, const char modulName, const char functName)
	+	{
	+	return logLog(logLevel, logFileID, modulName, -1, functName, LOGTXT_FUNCTION_EXIT);
	+	} // logExit()
	+
	+	int logExitRC (int logLevel, int logFileID, const char modulName, const char functName, int rc)
	+	{
	+	char logStr [TMP_STR_LEN_MAX + 1];
	+
	+	memset(logStr, '\0', sizeof(logStr));
	+
	+	sprintf(logStr, LOG_EXIT_RC_FORMAT, LOGTXT_FUNCTION_EXIT, rc); // Achtung! sprintf() ist unsicher!
	+	// Unbedingt darauf achten, daß "logStr" für die Ausgabe groß genug ist!
	+
	+	return logLog(logLevel, logFileID, modulName, -1, functName, logStr);
	+	} // logExitRC()
	+
	+
	+	void logErrorMsgFatal (int exitCode, const char modulName, int lineNumber, const char functName, const char * fehlermeldung)
	+	{
	+	fprintf(stderr, "\n%%s[%d]:%s(): FATAL ERROR: [%s]\n", modulName ? modulName : "NOMODUL(NULL-POINTER)", lineNumber, functName ? functName : "NOFUNKT(NULL-POINTER)", fehlermeldung ? fehlermeldung : "(undefinierte Fehlermeldung)");
	+	fprintf(stderr, "Die Ausfuehrung wird mit ExitCode = [%d] abgebrochen.\n\n", exitCode);
	+
	+	fflush(stderr);
	+	fflush(stdout);
	+
	+	exit(exitCode);
	+	} // errorMsgFatal()
	+
	+	// EOF
	+	</code>
	+
	+	----
	+	Stand: 10.09.2010\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:operationen_mit_strings

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:10+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Operationen mit Strings ======

	+	Zwei Strings vergleichen, ohne dabei die Groß-/Kleinbuchstaben zu unterscheiden (lexikographisch).
	+
	+	Posix:
	+	<code c>
	+	#include <strings.h>
	+	int strcasecmp (const char s1, const char s2);
	+	int strncasecmp(const char s1, const char s2, size_t n);
	+	</code>
	+
	+	Quelle: [[http://linux.die.net/man/3/strcasecmp]]
	+
	+	Windows/VS:
	+	<code c>
	+	#include <string.h>
	+	int _stricmp(const char string1, const char string2);
	+
	+	#include <string.h> // oder #include <wchar.h>
	+	int _wcsicmp(const wchar_t string1, const wchar_t string2);
	+
	+	#include <mbstring.h>
	+	int _mbsicmp(const unsigned char string1, const unsigned char_t string2);
	+	</code>
	+
	+	Quelle: [[https://msdn.microsoft.com/en-us/library/aa273371.aspx]]
	+
	+	FIXME
	+
	+	----
	+	Stand: 15.04.2016\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:signalbehandlung

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:09+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Code-Beispiele für die Signalbehandlung in C-/C++-Programmen ======

	+	===== Ein Beispiel (C-Programm) =====
	+
	+	Im Text (am Anfang):
	+
	+	<code c>
	+	#include <signal.h>
	+
	+	static int Signal = FALSE; // aktuelles Signal global speichern
	+
	+	// Semaphoren, die während Signalbehandlung beachtet werden sollen
	+	static int switchTraceFile = FALSE;
	+	static int switchTerminate = FALSE;
	+	</code>
	+
	+	In main() (irgendwo am Anfang) den SignalHandler einrichten/zuweisen:
	+
	+	<code c>
	+	signal(SIGTERM, SigHandler); // Signal SIGTERM durch SigHandler() abfangen
	+	signal(USER1, SigHandler); // Signal USER1 durch SigHandler() abfangen
	+	signal(SIGCHLD, SIG_IGN); // Signal SIGCHLD ignorieren
	+	</code>
	+
	+	Danach an mehreren Stellen im Text (vorzugsweise in den Schleifen) auf Vorhandensein eines Signals überprüfen und Bearbeitung des Signals vornehmen:
	+
	+	<code c>
	+	if (Signal)
	+	{
	+	rc = SigBehandlung(ec);
	+	}
	+	</code>
	+
	+	Bearbeitung des Signals selbst (darf etwas umfangreicher sein):
	+
	+	<code c>
	+	static int SigBehandlung (int *ec)
	+	{
	+	int rc = RC_OK;
	+
	+	ASSERT((ec != NULL));
	+	*ec = EC_OK;
	+
	+	if (rc == RC_OK)
	+	{
	+	Signal = FALSE; // vor Doppelverarbeitung schützen
	+	}
	+
	+	if (rc == RC_OK)
	+	{
	+	if (switchTraceFile)
	+	{
	+	// Hier wird was gemacht...
	+
	+	switchTraceFile = FALSE; // Semaphore zurücksetzen
	+
	+	rc = RC_OK;
	+	}
	+	}
	+
	+	if (rc == RC_OK)
	+	{
	+	if (switchTerminate) // Hier wird das Programm zwangsweise beendet...
	+	{
	+	// Funktion anmelden, die beim Beenden das Aufräumen vornimmt
	+	atexit(ExitServerEnde);
	+	exit(0);
	+	}
	+	}
	+
	+	return rc;
	+	} // SigBehandlung()
	+	</code>
	+
	+	SignalHandler selbst (zeitkritisch - darf nicht zu umfangreich sein) wird durch das Betriebssystem aufgerufen:
	+
	+	<code c>
	+	static void SigHandler(int sig)
	+	{
	+	fflush(stdout);
	+	fflush(stderr);
	+	LOG("SigHandler Enter");
	+
	+	fprintf(stderr, "Signal [%d] empfangen\n", sig);
	+
	+	Signal = sig; // global speichern: es gab einen Interrupt Request
	+
	+	switch (sig) // Aktivitäten während des SignalHandlers
	+	{
	+	case SIGTERM:
	+	fprintf(stderr, "SIGTERM: Prozeß soll demnächst beendet werden\n");
	+	break;
	+	default: break;
	+	}
	+
	+	fflush(stderr);
	+	LOG("SigHandler Exit");
	+	} // SigHandler()
	+	</code>
	+
	+	===== Weitere Beispiele =====
	+
	+	* C++ Signal Handling: [[http://www.tutorialspoint.com/cplusplus/cpp_signal_handling.htm]] (Mit Kurzbeschreibung der signal() und raise() Funktionen.)
	+	* Signal-Handler + die Klasse "SignalException": [[http://www.yolinux.com/TUTORIALS/C++Signals.html]]
	+
	+	Hier geht es zur Beschreibung einzelne [[EDV:OS:UNIX:Signale]] (nur UNIX/Linux).
	+
	+	----
	+	Stand: 04.08.2016\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:textfile_lesen_01

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:10+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Textfile lesen ======

	+	Folgende Funktion kann als einfache Vorlage genutzt werden um Textfiles zu lesen.
	+
	+	<code c>
	+	int theFunction()
	+	{
	+	FILE *pFile = NULL;
	+	char *pcFileBuffer = NULL;
	+	long lFileSize = 0;
	+
	+	// ...
	+	// Code-Zeilen...
	+	// ...
	+
	+
	+	// File zuerst öffnen
	+	if ((pFile = fopen(szFileName, "rb")) == NULL)
	+	{
	+	printf("File [%s] kann nichr geöffnet werden\n", szFileName);
	+	return (-1);
	+	} // if
	+
	+	// Größe des Files "messen"
	+	if (rc = fseek(pFile, 0, SEEK_END))
	+	{
	+	printf("IO Error\n");
	+	return (-1);
	+	} // if
	+	lFileSize = ftell(pFile);
	+
	+	// Speicher zuteilen
	+	if ((pcFileBuffer = calloc(1, lFileSize + 1)) == NULL)
	+	{
	+	printf("Out of Memory\n");
	+	return (-1);
	+	} // if
	+
	+	// File in den Buffer lesen
	+	if (rc = fseek(pFile, 0, SEEK_SET))
	+	{
	+	printf("IO Error\n");
	+	return (-1);
	+	} // if
	+	if ((rc = fread(pcFileBuffer, lFileSize, 1, pFile)) != 1)
	+	{
	+	printf("File [%s] kann nicht gelesen werden\n", szFileName);
	+	return (-1);
	+	}
	+
	+	pcFileBuffer[lFileSize] = '\0'; // Buffer abschließen
	+
	+	// ...
	+	// ...weitere Code-Zeilen...
	+	// ...
	+
	+	free(pcFileBuffer); // Am Ende Buffer freigeben
	+	pcFileBuffer = NULL;
	+
	+	// ...
	+	// ...weitere Code-Zeilen...
	+	// ...
	+	} // theFunction()
	+	</code>
	+
	+	----
	+	Stand: 06.08.2012\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:textfile_oeffnen_-_mit_versuchszaehler

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:09+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Textfile öffnen - mit Versuchszähler ======

	+	Folgende Funktion kann als einfache Vorlage genutzt werden um Textfiles zum Lesen oder Schreiben zu öffnen.
	+
	+	^Parameter ^Beschreibung ^
	+	\|%%const FILE ** fileToOpen%% \|Adresse der FILE-Variable \|
	+	\|%%const char * fileNameToOpen%%\|FQ Filename, das geöffnet werden soll \|
	+	\|%%int modus%% \|Zum Lesen / zum Schreiben \|
	+	\|%%int maxRetry%% \|Maximale Zahl der Versuche, File zu öffnen \|
	+	\|%%int retryDelay%% \|Pause in Sekunden zwischen den Versuchen \|
	+
	+	:!: Alle im Quelltext festkodierte Konstanten sind nur Beispielswerte. Bei konkreter Umsetzung sollen die Werte verwendet werden, die für die jeweilige Anwendung für sinnvoll erscheinen. Noch sinnvoller wäre anstelle von festkodierten Konstanten globale Variablen oder Makros einzusetzen, damit solche Werte auf einfache Weise anwendungsweit angepaßt werden könnten.
	+
	+	<code c>
	+	int init_EinAusFile (const FILE ** fileToOpen, const char * fileNameToOpen, int modus, int maxRetry, int retryDelay)
	+	{
	+	int rc = RC_OK;
	+	int retry;
	+
	+	// Validierung: Vorhandensein von Variablen (darf kein NULL sein)
	+	if (!fileToOpen) rc = RC_ERROR;
	+	if (!fileNameToOpen) rc = RC_ERROR;
	+	// Validierung: Werte dürfen sich nur im definierten Bereich bewegen
	+	if (!(modus == FILE_READ \|\| modus == FILE_WRITE)) rc = RC_ERROR; // Darf 1 oder 2 sein
	+	if ((maxRetry < 1) \|\| (maxRetry > 32767)) rc = RC_ERROR; // 1 bis 15^2-1 mal
	+	if ((retryDelay < 0) \|\| (retryDelay > 86400)) rc = RC_ERROR; // 24 Std x 60 Min x 60 Sek
	+	// Validierung: Pointer-Variablen: Werte nur im definierten Bereich
	+	if (fileNameToOpen) if (strlen(fileNameToOpen) == 0 \|\| strlen(fileNameToOpen) > FILENAME_LAENGE) rc = RC_ERROR; // Länge des Filenames
	+	if (fileToOpen) if ((*fileToOpen)) rc = RC_ERROR; // File darf nicht bereits geöffnet sein
	+
	+	if (rc) fprintf(stderr, "init_EinAusFile(): Validierungsfehler.\n");
	+
	+	if (!rc) // File öffnen
	+	{
	+	fprintf(stdout, "init_EinAusFile(): File [%s] wird geöffnet...\n", fileNameToOpen);
	+
	+	for (retry = maxRetry; (retry > 0) && (!(*fileToOpen)); retry--) // Evtl. mehrere Versuche
	+	{
	+	if (modus == FILE_READ) *fileToOpen = fopen(fileNameToOpen, "r"); // zum Lesen öffnen
	+	if (modus == FILE_WRITE) *fileToOpen = fopen(fileNameToOpen, "w"); // zum Schreiben öffnen
	+
	+	if ((retry > 1) && !(*fileToOpen)) sleep(retryDelay); // Falls Mißerfolg - kurze Pause einlegen (außer nach dem letzten Versuch).
	+	} // for (retry)
	+
	+	if ((*fileToOpen)) fprintf(stdout, "init_EinAusFile(): ...erfolgreich\n");
	+	else rc = RC_ERROR;
	+
	+	if (rc) fprintf(stderr, "init_EinAusFile(): Fehler beim Öffnen des Files [%s] aufgetreten.\n", fileNameToOpen);
	+	} // if
	+
	+	return rc;
	+	} // init_EinAusFile(..)
	+	</code>
	+
	+	wobei:\\
	+	RC_OK und RC_ERROR, FILE_READ und FILE_WRITE, FILENAME_LAENGE sind die vom Benutzer definierten Makros.
	+
	+	Beispiel eines Aufrufs:
	+
	+	<code c>
	+	#define FILENAME_LAENGE 8191
	+
	+	// TextFile öffnen zum Lesen
	+	#define FILE_READ 1
	+	// TextFile öffnen zum Schreiben
	+	#define FILE_WRITE 2
	+	// Beim Öffnen maximal so viele Versuchen unternehmen:
	+	#define FILE_RETRY 3
	+	// Zwischen den Wiederholungen so viele Sekunden warten:
	+	#define FILE_DELAY 1
	+
	+	FILE * fileInputDatei = NULL; // Input-Datei
	+	FILE * fileOutputDatei = NULL; // Output-Datei
	+
	+	char parFileNameInputDatei [FILENAME_LAENGE + 1]; // FileName für die Input-Datei
	+	char parFileNameOutputDatei [FILENAME_LAENGE + 1]; // FileName für die Output-Datei
	+
	+
	+
	+	int app_Init (void) // Initialisierung für die gesamte Anwendung
	+	{
	+	int rc = RC_OK;
	+
	+	fprintf(stdout, "app_Init(): Ein-/Ausgabe-Files werden geöffnet/erstellt.\n");
	+
	+	// Die Input-Datei zum Lesen öffnen
	+	if (rc == RC_OK) rc = init_EinAusFile(&fileInputDatei, parFileNameInputDatei, FILE_READ, FILE_RETRY, FILE_DELAY);
	+
	+	// Die Output-Datei zum Schreiben öffnen
	+	if (rc == RC_OK) rc = init_EinAusFile(&fileOutputDatei, parFileNameOutputDatei, FILE_WRITE, FILE_RETRY, FILE_DELAY);
	+
	+	if (rc == RC_OK) fprintf(stdout, "app_Init(): Alle Ein-/Ausgabe-Files wurden erfolgreich geöffnet/erstellt.\n");
	+	else fprintf(stdout, "app_Init(): ERROR: Das öffnen/erstellen von Ein-/Ausgabe-Files war nicht erfolgreich.\n");
	+
	+	return rc;
	+	} // app_Init()
	+	</code>
	+
	+	Und ab und zu fflush(stderr); bzw. fflush(stdout); auch nicht vergessen.
	+
	+	----
	+	Stand: 24.02.2010\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:textfile_schliessen_loeschen_-_mit_versuchszaehler

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:06+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Textfile schließen/löschen - mit Versuchszähler ======

	+	Folgende Funktion kann als einfache Vorlage genutzt werden um geöffnete Textfiles zu schließen und eventuell anschließend zu löschen.
	+
	+	^Parameter ^Beschreibung ^
	+	\|%%const FILE ** fileToClose%% \|Adresse der FILE-Variable \|
	+	\|%%const char * fileNameToDelete%%\|FQ Filename, das gelöscht werden soll \|
	+	\|%%int modus%% \|Zum Schließen / zum Schließen+Löschen \|
	+	\|%%int maxRetry%% \|Maximale Zahl der Versuche, File zu schließen/löschen \|
	+	\|%%int retryDelay%% \|Pause in Sekunden zwischen den Versuchen \|
	+
	+	:!: Alle im Quelltext festkodierte Konstanten sind nur Beispielswerte. Bei konkreter Umsetzung sollen die Werte verwendet werden, die für die jeweilige Anwendung für sinnvoll erscheinen. Noch sinnvoller wäre anstelle von festkodierten Konstanten globale Variablen oder Makros einzusetzen, damit solche Werte auf einfache Weise anwendungsweit angepaßt werden könnten.
	+
	+	<code c>
	+	int done_EinAusFile (const FILE ** fileToClose, const char * fileNameToDelete, int modus, int maxRetry, int retryDelay)
	+	{
	+	int rc = RC_OK;
	+	int retry;
	+	int notDeleted;
	+
	+	// Validierung: Vorhandensein von Variablen (darf kein NULL sein)
	+	if (!fileToClose) rc = RC_ERROR;
	+	// Validierung: Werte dürfen sich nur im definierten Bereich bewegen
	+	if (!(modus == FILE_CLOSE \|\| modus == FILE_DELETE)) rc = RC_ERROR; // Darf 3 oder 4 sein
	+	if ((maxRetry < 1) \|\| (maxRetry > 32767)) rc = RC_ERROR; // 1 bis 15^2-1 mal
	+	if ((retryDelay < 0) \|\| (retryDelay > 86400)) rc = RC_ERROR; // 24 Std x 60 Min x 60 Sek
	+	// Validierung: Pointer-Variablen: Werte nur im definierten Bereich
	+	if (fileNameToDelete) if (strlen(fileNameToDelete) == 0 \|\| strlen(fileNameToDelete) > FILENAME_LAENGE) rc = RC_ERROR; // Länge des Filenames
	+	if (fileToClose) if (!(*fileToClose)) rc = RC_ERROR; // File MUSS bereits geöffnet sein
	+	// Validierung: Kombination von Werten
	+	if (modus == FILE_DELETE) if (!fileNameToDelete) rc = RC_ERROR; // Beim Löschen muss der Filename angegeben werden
	+
	+	if (rc) fprintf(stderr, "done_EinAusFile(): Validierungsfehler.\n");
	+
	+	if (!rc) // File schließen
	+	{
	+	fprintf(stdout, "done_EinAusFile(): File [%s] wird geschlossen...\n", fileNameToDelete ? fileNameToDelete : "(FileName nicht angegeben)");
	+
	+	for (retry = maxRetry; (retry > 0) && (*fileToClose); retry--) // Evtl. mehrere Versuche
	+	{
	+	if (fclose(fileToClose) == 0) fileToClose = NULL; // Falls erfolgreich geschlossen, den Zeiger zurücksetzen
	+
	+	if ((retry > 1) && (*fileToClose)) sleep(retryDelay); // Falls Mißerfolg - kurze Pause einlegen (außer nach dem letzten Versuch).
	+	} // for (retry)
	+
	+	if (!(*fileToClose)) fprintf(stdout, "done_EinAusFile(): ...erfolgreich\n");
	+	else rc = RC_ERROR;
	+
	+	if (rc) fprintf(stderr, "done_EinAusFile(): Fehler beim Schließen des Files aufgetreten.\n");
	+	} // if
	+
	+	if ((!rc) && (modus == FILE_DELETE)) // File löschen
	+	{
	+	fprintf(stdout, "done_EinAusFile(): File [%s] wird gelöscht...\n", fileNameToDelete);
	+
	+	for (retry = maxRetry, notDeleted = 1; (retry > 0) && (notDeleted); retry--) // Evtl. mehrere Versuche
	+	{
	+	if (remove(fileNameToDelete) == 0) notDeleted = 0; // Falls erfolgreich gelöscht, den Flag zurücksetzen
	+
	+	if ((retry > 1) && (notDeleted)) sleep(retryDelay); // Falls Mißerfolg - kurze Pause einlegen (außer nach dem letzten Versuch).
	+	} // for (retry)
	+
	+	if (!notDeleted) fprintf(stdout, "done_EinAusFile(): ...erfolgreich\n");
	+	else rc = RC_ERROR;
	+
	+	if (rc) fprintf(stderr, "done_EinAusFile(): Fehler beim Löschen des Files [%s] aufgetreten.\n", fileNameToDelete);
	+	} // if
	+
	+	fflush(stderr);
	+	fflush(stdout);
	+
	+	return rc;
	+	} // done_EinAusFile(..)
	+	</code>
	+
	+	wobei:\\
	+	RC_OK und RC_ERROR, FILE_CLOSE und FILE_DELETE, FILENAME_LAENGE sind die vom Benutzer definierten Makros.
	+
	+	Beispiel eines Aufrufs:
	+
	+	<code c>
	+	#define FILENAME_LAENGE 8191
	+
	+	// TextFile schliessen
	+	#define FILE_CLOSE 3
	+	// TextFile schliessen und loeschen
	+	#define FILE_DELETE 4
	+	// Beim Öffnen maximal so viele Versuchen unternehmen:
	+	#define FILE_RETRY 3
	+	// Zwischen den Wiederholungen so viele Sekunden warten:
	+	#define FILE_DELAY 1
	+
	+
	+	FILE * fileInputDatei = NULL; // Input-Datei
	+	FILE * fileOutputDatei = NULL; // Output-Datei
	+
	+
	+	char parFileNameInputDatei [FILENAME_LAENGE + 1]; // FileName für die Input-Datei
	+	char parFileNameOutputDatei [FILENAME_LAENGE + 1]; // FileName für die Output-Datei
	+
	+
	+	int app_Done (int rc_Init, int rc_Run)
	+	{
	+	int rc = RC_OK;
	+	int rc_FileClose = RC_OK;
	+
	+	fprintf(stdout, "app_Done(): Ein-/Ausgabe-Files werden geschlossen.\n");
	+
	+	// Die Input-Datei schließen
	+	if (fileInputDatei)
	+	{
	+	rc = done_EinAusFile(&fileInputDatei, parFileNameInputDatei, FILE_CLOSE, FILE_RETRY, FILE_DELAY);
	+	if (rc) fprintf(stderr, "app_Done(): ERROR (unkritisch): Das Schließen des Files [%s] ist fehlgeschlagen.\n", parFileNameInputDatei);
	+	} // if
	+
	+	// Die Output-Datei schließen und löschen
	+	if (fileOutputDatei)
	+	{
	+	rc = done_EinAusFile(&fileOutputDatei, parFileNameOutputDatei, FILE_DELETE, FILE_RETRY, FILE_DELAY);
	+	if (rc) fprintf(stderr, "app_Done(): ERROR (kritisch): Das Schließen des Files [%s] ist fehlgeschlagen.\n", parFileNameAbkDatei);
	+	} // if
	+
	+	if (rc_FileClose) errorMsgFatal(TODO_KEINABBRUCH, "app_Done(): Eine der Dateien konnte nicht geschlossen werden. Sie ist möglicherweise beschädigt und kann nicht verwendet werden.");
	+
	+	fflush(stderr);
	+
	+	return rc;
	+	} // app_Done()
	+	</code>
	+
	+	wobei:\\
	+	errorMsgFatal() - eine Funktion, die kritische Meldungen ausgibt (und z.B. im Syslog protokolliert) und je nach Parameter, falls nötig, den Prozess zwangsweise abbricht.
	+
	+	Und ab und zu fflush(stderr); bzw. fflush(stdout); auch nicht vergessen.
	+
	+	----
	+	Stand: 24.02.2010\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:trim_ext

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:10+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== trim_ext ======

	+
	+	Trim-Modul - Funktionen um die Leerzeichen vorne und hinten bei einem String wegschneiden.
	+
	+	trim_ext.c:
	+
	+	<code c>
	+	/*********************************************************************
	+	*
	+	* Autor: Jürgen Kreick
	+	* Version: 1.1.1 vom 17.11.2011
	+	*
	+	**********************************************************************
	+	*
	+	* Hinweise zum Modul/Quelltext: Keine aktuellen Hinweise.
	+	*
	+	**********************************************************************
	+	*
	+	* Release Notes:
	+	*
	+	* Ver 1.0.0 (vom 10.08.2006):
	+	* Die erste Version des Moduls. Umfasst folgende Funktionen:
	+	* trimL(), trimR(), trimAll().
	+	*
	+	* Ver 1.1.0 (vom 30.11.2010):
	+	* In der ersten Version, wenn einer der Strings kein '\0'-Zeichen am Ende hat,
	+	* ist ein BufferOverflow möglich. Diese Sicherheitslücke ist hier durch Angabe
	+	* der maximalen Buffer-Länge (ein zusätzlicher Parameter) geschlossen.
	+	*
	+	* Ver 1.1.1 (vom 17.11.2011):
	+	* BugFix: Plausibilitätsprüfung in trimL(), trimR() und trimAll():
	+	* Prüfung "if (maxLen == 0)" durch "if (maxLen <= 0)" ersetzt.
	+	*
	+	**********************************************************************
	+	*
	+	* Funktionsbeschreibung:
	+	*
	+	* trimL() - schneidet Leerstellen in einem String links ab
	+	* trimR() - schneidet Leerstellen in einem String rechts ab
	+	* trimAll() - schneidet Leerstellen in einem String links und rechts ab
	+	*
	+	**********************************************************************/
	+
	+
	+	// Wegen NULL
	+	#include <stdio.h>
	+
	+	#define RC_TRIM_MODIFY 1
	+	#define RC_TRIM_NOMODIFY 0
	+	#define RC_TRIM_ERR -1
	+
	+	// Schneidet Leerstellen in einem String links ab
	+	// Parameter:
	+	// char *ziel : Hier steht am Ende der Bearbeitung das Ergebnis
	+	// char *quelle : Der zu bearbeitende String oder NULL
	+	// int maxLen : Längenbegrenzung für den String
	+	// Rückgabewert:
	+	// 1 : Der String wurde modifiziert
	+	// 0 : Der String ist unverändert geblieben
	+	// -1 : Fehler (z.B. bei der Plausibilitätsprüfung)
	+	int trimL (char ziel, const char quelle, const int maxLen)
	+	// Es sind zwei Varianten möglich:
	+	// Variante 1: dabei sind Quell- und Ziel-Strings unterschiedliche Variablen
	+	// Variante 2: dabei wird keine zweite Variable benötigt: dann "*quelle" ist gleich NULL
	+	{
	+	char *pZiel;
	+	char *pQuelle;
	+	int position = 0;
	+	int rc = RC_TRIM_NOMODIFY;
	+
	+	// Plausibilitätsprüfung:
	+	if (!ziel) return RC_TRIM_ERR; // Ziel-String kann nicht gespeichert werden
	+	if (maxLen <= 0) return RC_TRIM_ERR; // Kein Platz im Buffer
	+
	+	// Anfang des Quellstrings
	+	if (quelle != NULL) pQuelle = quelle; // Variante 1 - mit zwei Variablen
	+	else pQuelle = ziel; // Variante 2 - mit einer einzigen Variable
	+
	+	pZiel = ziel; // Anfang des Zielstrings
	+
	+	ziel[maxLen - 1] = '\0'; // Sicherheitsmaßnahme
	+
	+	if ((*pQuelle) == '\0') // Wenn der (Quell-/einzige) String leer ist, keine Bearbeitung nötig
	+	{
	+	ziel[0] = '\0'; // Sicherheitsmaßnahme
	+	return RC_TRIM_NOMODIFY;
	+	} // if
	+
	+	if (quelle != NULL) // Variante 1 - mit zwei Variablen
	+	{
	+	if ((*pQuelle) != ' ') rc = RC_TRIM_NOMODIFY; // Wenn der (Quell-)String keine Leerstelle vorne hat - keine Bearbeitung, nur der Kopiervorhang
	+	}
	+	else // Variante 2 - mit einer einzigen Variable
	+	{
	+	if ((*pQuelle) != ' ') return RC_TRIM_NOMODIFY; // Wenn der (einzige) String keine Leerstelle vorne hat, fertig - keine Bearbeitung
	+	} // if
	+
	+	if ((*pQuelle) == ' ') rc = RC_TRIM_MODIFY; // Der String wird modifiziert werden
	+
	+	position = 0;
	+	while ((*pQuelle) == ' ' && position < maxLen) // Leerstellen links berücksichtigen
	+	{
	+	pQuelle++;
	+	position++;
	+	} // while
	+	if (position >= maxLen) rc = RC_TRIM_ERR; // String hat kein '\0' (möglich nur wenn der Quell-String nicht NULL ist)
	+
	+	while ((*pQuelle) != '\0' && position < maxLen) // Kopiervorgang
	+	{
	+	(pZiel) = (pQuelle);
	+	pZiel++;
	+	pQuelle++;
	+	position++;
	+	} // while
	+	if (position >= maxLen) rc = RC_TRIM_ERR; // String hat kein '\0'
	+
	+	(*pZiel) = '\0'; // Neues Zeilenende
	+	ziel[maxLen - 1] = '\0'; // Sicherheitsmaßnahme
	+
	+	return rc;
	+	} // trimL()
	+
	+
	+	// Schneidet Leerstellen in einem String rechts ab
	+	// Parameter:
	+	// char *s : Der zu bearbeitende String
	+	// int maxLen : Längenbegrenzung für den String
	+	// Rückgabewert:
	+	// 1 : Der String wurde modifiziert
	+	// 0 : Der String ist unverändert geblieben
	+	// -1 : Fehler (z.B. bei der Plausibilitätsprüfung)
	+	int trimR (char *s, const int maxLen)
	+	{
	+	char *pS;
	+	int rc = RC_TRIM_NOMODIFY;
	+
	+	// Plausibilitätsprüfung: Prüfung auf NULL-Pointer und auf leeren String
	+	if (!s) return RC_TRIM_ERR; // Kein String angegeben - keine Bearbeitung
	+	if ((*s) == '\0') return RC_TRIM_NOMODIFY; // Der String ist leer
	+	if (maxLen <= 0) return RC_TRIM_ERR; // Kein Platz im Buffer
	+
	+	s[maxLen - 1] = '\0'; // Sicherheitsmaßnahme
	+
	+	pS = s; // Anfang des Strings
	+	while ((*pS) != '\0') pS++; // Nach Ende des Strings suchen
	+	pS--; // Eine Stelle zurück
	+	while ((*pS) == ' ') // Leerstellen rechts entdeckt
	+	{
	+	(*pS) = '\0'; // Neues Zeilenende
	+	rc = RC_TRIM_MODIFY;
	+	pS--; // Eine Stelle zurück
	+	} // while
	+
	+	return rc;
	+	} // trimR()
	+
	+
	+	// Schneidet Leerstellen in einem String links und rechts ab
	+	// Parameter:
	+	// char *ziel : Hier steht am Ende der Bearbeitung das Ergebnis
	+	// char *quelle : Der zu bearbeitende String oder NULL
	+	// int maxLen : Längenbegrenzung für den String
	+	// Rückgabewert:
	+	// 1 : Der String wurde modifiziert
	+	// 0 : Der String ist unverändert geblieben
	+	// -1 : Fehler (z.B. bei der Plausibilitätsprüfung)
	+	int trimAll (char ziel, const char quelle, const int maxLen)
	+	// Es sind zwei Varianten möglich:
	+	// Variante 1: dabei sind Quell- und Ziel-Strings unterschiedliche Variablen
	+	// Variante 2: dabei wird keine zweite Variable benötigt: dann "*quelle" ist gleich NULL
	+	{
	+	int rc = RC_TRIM_NOMODIFY;
	+	int rcL = RC_TRIM_NOMODIFY;
	+	int rcR = RC_TRIM_NOMODIFY;
	+
	+	// Plausibilitätsprüfung:
	+	if (!ziel) return RC_TRIM_ERR;
	+	if (maxLen <= 0) return RC_TRIM_ERR; // Kein Platz im Buffer
	+
	+	rcL = trimL(ziel, quelle, maxLen); // Erst links abschneiden
	+	rcR = trimR(ziel, maxLen); // Dann rechts abschneiden
	+
	+	if (rcL == RC_TRIM_MODIFY \|\| rcR == RC_TRIM_MODIFY) rc = RC_TRIM_MODIFY;
	+	if (rcL == RC_TRIM_ERR \|\| rcR == RC_TRIM_ERR) rc = RC_TRIM_ERR;
	+
	+	return rc;
	+	} // trimAll()
	+
	+	// EOF
	+	</code>
	+
	+	----
	+	Stand: 17.11.2011\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:vorlage_c-programm

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:07+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Vorlage C-Programm ======

	+	Ein Gerüst für ein C-Programm
	+
	+	AppName.h:
	+
	+	<code c>
	+	/**********************************************************************
	+	*
	+	* $AppName: Application %
	+	* $FileName: AppName.h %
	+	* $Description:
	+	* $CreatedBy: Name %
	+	* $CreatedDate: 2000-01-01_00:00 %
	+	* $LastModifyBy: Name %
	+	* $LastModifyDate: 2000-01-01_00:00 %
	+	*
	+	**********************************************************************/
	+
	+	/* History ************************************************************
	+	*
	+	* 2000-01-01 User1234: XY wurde durch XZ ersetzt.
	+	*
	+	**********************************************************************/
	+
	+	#ifndef _AppName_h_H
	+	#define _AppName_h_H
	+
	+
	+	// ****************** #include **************************************
	+	#include <stdio.h> // "stdout", NULL
	+
	+
	+	// ****************** defines **************************************
	+
	+	// Konstanten bzw. Makros (global - für die gesamte Anwendung)
	+	#define PROGRAM_NAME "AppName"
	+	#define PROGRAM_VERSION "01.01.01"
	+	#define PROGRAM_STAND "31.12.2000"
	+
	+	#define TRACEDIR_DEFAULT "/trace"
	+
	+	// ExitCodes
	+	#define EC_OK 0
	+	#define EC_FALSCHE_PARAMETER -1
	+	#define EC_FALSCHE_ENVIRONMENT -2
	+
	+	// RC-Codes
	+	#define RC_OK 0
	+	#define RC_ERR -1
	+
	+	// DB
	+	#define RC_DB_OK 0
	+	#define RC_DB_NOTFOUND 100
	+	#define RC_DB_ERR -1
	+	#define TRANSACTION_COMMIT 1
	+	#define TRANSACTION_ROLLBACK 2
	+	#define TRANSACTION_OFF 0
	+	#define TRANSACTION_ON 1
	+
	+	// Umgebungsvariablen
	+	#define ENV_USER "USER"
	+	#define ENV_TRACEPATH "TRACEPATH"
	+	#define ENV_HOSTNAME "HOSTNAME"
	+	#define ENV_MAIL_ABSENDER "MAIL_ABSENDER"
	+	#define ENV_SHELL "SHELL"
	+
	+	// verschiedene Konstanten
	+	#define TMP_STR_LEN_MAX 8191
	+	#define TMP_STR_LEN_MAX_STR "8191"
	+	#define FILENAME_LEN_MAX 8191
	+
	+
	+	// ****************** Strukturen **************************************
	+
	+	// ****************** globale Variablen **************************************
	+
	+	int logLevel = 0;
	+	int logFileID = 0;
	+
	+	char pfadTrace [FILENAME_LEN_MAX + 1]; // Pfad zum Trace-Verzeichnis
	+
	+	// Environment
	+	char *envHostname = NULL; // Der aktuelle Hostname
	+	char *envTracePatch = NULL; // trace-Verzeichnis
	+	char *envEMailAbsender = NULL; // Dieser User soll als eMail-Absender dienen
	+	char *envUser = NULL; // $USER
	+	char *envShell = NULL; // Aktuelle SHELL
	+
	+	// Beispielsvariablen
	+	int modusParameterA = 0;
	+	int modusTestlauf = 0;
	+	int anzahlIrgendwas = 0;
	+
	+
	+	// Statistik:
	+
	+	/* Everything else goes here */
	+
	+	#endif
	+
	+	// EOF
	+	</code>
	+
	+	AppName.c:
	+
	+	<code c>
	+	/**********************************************************************
	+	*
	+	* $AppName: Application %
	+	* $FileName: AppName.c %
	+	* $Description:
	+	* $CreatedBy: Name %
	+	* $CreatedDate: 2000-01-01_00:00 %
	+	* $LastModifyBy: Name %
	+	* $LastModifyDate: 2000-01-01_00:00 %
	+	*
	+	**********************************************************************/
	+
	+
	+	/* History ************************************************************
	+	*
	+	* 2000-01-01 User1234: XY wurde durch XZ ersetzt.
	+	*
	+	**********************************************************************/
	+
	+
	+	// ****************** #include ************************************
	+	#include "AppName.h"
	+
	+
	+	// ****************** #define *************************************
	+	//#define DEBUGMODE
	+
	+	#define MODUL_NAME "AppName.c"
	+
	+
	+	// ****************** Global Variables ****************************
	+	char * modulName = MODUL_NAME;
	+
	+
	+	// ****************** exit-Function *******************************
	+
	+	// ****************** Signal-Handling *****************************
	+
	+	// ****************** Functions ***********************************
	+
	+	void printAbout () // Kurze Info über die Anwendung (über stderr) ausgeben.
	+	{
	+	} // printAbout()
	+
	+
	+	void printDescription () // Syntax (über stderr) ausgeben.
	+	{
	+	} // printDescription()
	+
	+
	+	void initGlobalVar () // Globale Variablen initialisieren (für die gesamte Anwendung).
	+	{
	+	logLevel = LOGLEVEL_STD;
	+	logFileID = LOGFILE_NOFILE;
	+
	+	memset(pfadTrace, '\0', sizeof(pfadTrace));
	+
	+	// Environment
	+	envHostname = NULL; // Der aktuelle Hostname
	+	envTracePatch = NULL; // trace-Verzeichnis
	+	envEMailAbsender = NULL; // Dieser User soll als eMail-Absender dienen
	+	envUser = NULL; // $USER
	+	envShell = NULL; // Aktuelle SHELL
	+
	+	modusParameterA = OFF;
	+	modusTestlauf = OFF;
	+	anzahlIrgendwas = 123;
	+	} // initGlobalVar()
	+
	+
	+	void initLocalVar () // Lokale Variablen initialisieren (nur für dieses Modul).
	+	{
	+	char * functionName = "initLocalVar"; // Ein Beispiel
	+	} // initLocalVar()
	+
	+
	+	int initRuntimeVar (void) // Einige Variablen mit Laufzeitwerten initialisieren.
	+	{
	+	int rc = RC_OK;
	+
	+	// Environment übernehmen
	+	envHostname = getenv(ENV_HOSTNAME);
	+	envTracePatch = getenv(ENV_TRACEPATH);
	+	envEMailAbsender = getenv(ENV_MAIL_ABSENDER);
	+	envUser = getenv(ENV_USER);
	+	envShell = getenv(ENV_SHELL);
	+
	+	// Den Namen des Trace-Verzeichnisses bilden
	+	if (envTracePatch) strlcpy(pfadTrace, envTracePatch, sizeof(pfadTrace)); // Allgemeiner Trace-Pfad
	+	else strlcpy(pfadTrace, TRACEDIR_DEFAULT, sizeof(pfadTrace)); // Default Trace-Pfad
	+
	+	if (pfadTrace[strlen(pfadTrace)] != '/') strlcat(pfadTrace, "/", sizeof(pfadTrace)); // Falls '/'-Zeichen am Ende fehlt - hinzufügen
	+
	+	strlcat(pfadTrace, PROGRAM_NAME, sizeof(pfadTrace)); // Programmname an den Pfad anhängen
	+
	+	return rc;
	+	} // initRuntimeVar()
	+
	+
	+	int initLogging (void) // Initialisiert das Logging für die gesamte Anwendung.
	+	{
	+	int rc = RC_OK;
	+
	+	// Logging initialisieren
	+	logFileID = logInit(pfadTrace, PROGRAM_NAME, NULL, LOGSTATUS_RUN, LOGSTATUS_CLOSE, 0, logLevel);
	+	if (logFileID == LOGFILE_ERROR \|\| logFileID == LOGFILE_NOFILE) rc = RC_ERR;
	+	else rc = logLog(LOG_DEBUG, logFileID, __FILE__, __LINE__, __func__, "Das LogFile wurde angelegt.");
	+
	+	return rc;
	+	} // initLogging()
	+
	+	int doneLogging (void) // Beendet das Logging für die gesamte Anwendung.
	+	{
	+	int rc = RC_OK;
	+
	+	rc = logLog(LOG_DEBUG, logFileID, __FILE__, __LINE__, __func__, "Das LogFile wird geschlossen.");
	+	logDone(logFileID);
	+	logFileID = LOGFILE_NOFILE;
	+
	+	return rc;
	+	} // doneLogging()
	+
	+
	+	// Parameter von "Application" (Beispiel):
	+	// -a : optionaler Parameter a
	+	// -l Zahl : LogLevel, default 5 (LOG_NOTICE)
	+	// -t Anzahl : Testlauf: es werden nur <Anzahl> von Irgendwas bearbeitet
	+	int checkParameter (int argc, char *argv []) // Aufruf-Parameter auswerten.
	+	{
	+	int rc = RC_OK;
	+	int param;
	+	register int i;
	+	char strParameter [TMP_STR_LEN_MAX + 1]; // Ausgabe der gesamten Parameter-Zeile vor dem Parsen
	+	char logStr [TMP_STR_LEN_MAX + 1]; // u.a. Ausgabe der ermittelten Parameter nach dem Parsen
	+
	+	memset(logStr, '\0', sizeof(logStr));
	+
	+	strcpy(strParameter, "CALL:"); // Achtung! strcpy() ist unsicher!
	+	for (i = 0; i < argc; i++)
	+	{
	+	if ((strlen(strParameter) + 1 + strlen(argv[i])) > TMP_STR_LEN_MAX) logErrorMsgFatal(EC_FALSCHE_PARAMETER, __FILE__, __LINE__, __func__, "Parameterzeile zu lang. Es sind maximal " TMP_STR_LEN_MAX_STR " Zeichen zulässig.");
	+
	+	strlcat(strParameter, " ", sizeof(strParameter));
	+	strlcat(strParameter, argv[i], sizeof(strParameter));
	+	} // for i
	+	logLog(LOG_NOTICE, logFileID, __FILE__, __LINE__, __func__, strParameter);
	+
	+	while ((param = getopt(argc, argv, "al:t:")) != -1) // Parameter parsen
	+	{
	+	switch (param)
	+	{
	+	case 'a': modusParameterA = ON; break; // ON = Parameter a aktiv
	+	case 'l': logLevel = atoi(optarg); break; // LogLevel
	+	case 't': modusTestlauf = ON; anzahlIrgendwas = atoi(optarg); break;
	+
	+	default: // falsche Parameter
	+	snprintf(logStr, sizeof(logStr), "Fehler: '-%c' - falscher Parameter\n", param);
	+	logLog(LOG_ERR, logFileID, __FILE__, __LINE__, __func__, logStr);
	+	rc = RC_ERR;
	+	} // switch (param)
	+	} // while
	+
	+	// Environment-Übersicht ausgeben:
	+	logLog(LOG_NOTICE, logFileID, __FILE__, __LINE__, __func__, PROGRAM_NAME " wird mit folgendem Environment ausgeführt:");
	+	snprintf(logStr, sizeof(logStr), "%s: [%s]", ENV_HOSTNAME, envHostname ? envHostname : "NULL"); logLog(LOG_NOTICE, logFileID, __FILE__, __LINE__, __func__, logStr);
	+	snprintf(logStr, sizeof(logStr), "%s: [%s]", ENV_TRACEPATH, envTracePatch ? envTracePatch : "NULL"); logLog(LOG_NOTICE, logFileID, __FILE__, __LINE__, __func__, logStr);
	+	snprintf(logStr, sizeof(logStr), "%s: [%s]", ENV_MAIL_ABSENDER, envEMailAbsender ? envEMailAbsender : "NULL"); logLog(LOG_NOTICE, logFileID, __FILE__, __LINE__, __func__, logStr);
	+	snprintf(logStr, sizeof(logStr), "%s: [%s]", ENV_USER, envUser ? envUser : "NULL"); logLog(LOG_NOTICE, logFileID, __FILE__, __LINE__, __func__, logStr);
	+	snprintf(logStr, sizeof(logStr), "%s: [%s]", ENV_SHELL, envShell ? envShell : "NULL"); logLog(LOG_NOTICE, logFileID, __FILE__, __LINE__, __func__, logStr);
	+
	+	// Plausibilitätsprüfung:
	+	if ((logLevel < LOGLEVEL_MIN) \|\| (logLevel > LOGLEVEL_MAX)) // Falscher LogLevel
	+	{
	+	snprintf(logStr, sizeof(logStr), "Falscher LogLevel [%i] als Parameter angegeben. Es dürfen nur Werte zwischen [%i] (LOG_EMERG) und [%i] (LOG_DEBUG) genutzt werden.\n", logLevel, LOGLEVEL_MIN, LOGLEVEL_MAX);
	+	logLog(LOG_ERR, logFileID, __FILE__, __LINE__, __func__, logStr);
	+	logLevel = LOGLEVEL_STD;
	+	snprintf(logStr, sizeof(logStr), "Es wird default-LogLevel [%i] genutzt.\n", logLevel);
	+	logLog(LOG_NOTICE, logFileID, __FILE__, __LINE__, __func__, logStr);
	+	} // if
	+	if (!envHostname \|\| !envEMailAbsender \|\| !envTracePatch)
	+	{
	+	rc = RC_ERR;
	+	snprintf(logStr, sizeof(logStr), "Nicht alle Umgebungsvariablen definiert. Folgende sind erforderlich: [%s], [%s] und [%s]\n", ENV_HOSTNAME, ENV_MAIL_ABSENDER, ENV_TRACEPATH);
	+	logErrorMsgFatal(EC_FALSCHE_ENVIRONMENT, __FILE__, __LINE__, __func__, logStr);
	+	} // if
	+
	+	// Parameteruebersicht ausgeben:
	+	logLog(LOG_NOTICE, logFileID, __FILE__, __LINE__, __func__, PROGRAM_NAME " wird mit folgenden Parameter ausgeführt:");
	+	snprintf(logStr, sizeof(logStr), "Log-Level: [%i]", logLevel); logLog(LOG_NOTICE, logFileID, __FILE__, __LINE__, __func__, logStr);
	+	snprintf(logStr, sizeof(logStr), "Trace-Pfad: [%s]", pfadTrace); logLog(LOG_NOTICE, logFileID, __FILE__, __LINE__, __func__, logStr);
	+	snprintf(logStr, sizeof(logStr), "Parameter a: [%s]", modusParameterA ? "a aktiv" : "a inaktiv"); logLog(LOG_NOTICE, logFileID, __FILE__, __LINE__, __func__, logStr);
	+	snprintf(logStr, sizeof(logStr), "TestLauf: [%s]", modusTestlauf ? "EIN" : "AUS"); logLog(LOG_NOTICE, logFileID, __FILE__, __LINE__, __func__, logStr);
	+	if (modusTestlauf)
	+	{
	+	snprintf(logStr, sizeof(logStr), "Anzahl von Irgendwas im TestLauf: [%i]", anzahlIrgendwas); logLog(LOG_NOTICE, logFileID, __FILE__, __LINE__, __func__, logStr);
	+	} // if
	+
	+	return rc;
	+	} // checkParameter()
	+
	+
	+	int app_Init (int maxAttempt, int timeOut) // Die gesamte Anwendung initialisieren.
	+	{
	+	int rc = RC_OK;
	+
	+	rc = init_Part_1(maxAttempt, timeOut); // Funktionalität 1 initialisieren.
	+	rc = init_Part_2(maxAttempt, timeOut); // Funktionalität 2 initialisieren.
	+	rc = init_Part_3(maxAttempt, timeOut); // Funktionalität 3 initialisieren.
	+
	+	return rc;
	+	} // app_Init()
	+
	+
	+	int app_Done (int rc_Init, int rc_Run) // Die gesamte Anwendung deinitialisieren.
	+	{
	+	int rc = RC_OK;
	+
	+	rc = done_Part_3(); // Funktionalität 3 deinitialisieren.
	+	rc = done_Part_2(); // Funktionalität 2 deinitialisieren.
	+	rc = done_Part_1(); // Funktionalität 1 deinitialisieren.
	+
	+	return rc;
	+	} // app_Done()
	+
	+
	+	int re_Init (int partName, int maxAttempt, int timeOut) // Bei temporären Problemen.
	+	// z.B. DB-Connect verloren, die Session neu initialisieren.
	+	{
	+	int rc = RC_OK;
	+
	+	switch (partName)
	+	{
	+	case Part_1:
	+	rc = done_Part_1(); // Funktionalität 1 deinitialisieren.
	+	rc = init_Part_1(maxAttempt, timeOut); // Funktionalität 1 initialisieren.
	+	break;
	+	case Part_2:
	+	rc = done_Part_2(); // Funktionalität 2 deinitialisieren.
	+	rc = init_Part_2(maxAttempt, timeOut); // Funktionalität 2 initialisieren.
	+	break;
	+	case Part_3:
	+	rc = done_Part_3(); // Funktionalität 3 deinitialisieren.
	+	rc = init_Part_3(maxAttempt, timeOut); // Funktionalität 3 initialisieren.
	+	break;
	+	default:
	+	rc = RC_ERR; // Interner Fehler
	+	} // switch
	+
	+	return rc;
	+	} // re_Init()
	+
	+
	+	int app_Run (int rc_Init) // Der Hauptteil der Anwendung.
	+	{
	+	int rc = RC_OK;
	+
	+	switch (...)
	+	{
	+	case part1:
	+	rc = run_Part_1_1(); // Funktionalität 1.1 ausführen.
	+	rc = run_Part_1_2(); // Funktionalität 1.2 ausführen.
	+	break;
	+	case part2:
	+	rc = run_Part_2_1(); // Funktionalität 2.1 ausführen.
	+	rc = run_Part_2_2(); // Funktionalität 2.2 ausführen.
	+	rc = run_Part_2_3(); // Funktionalität 2.3 ausführen.
	+	break;
	+	case part3:
	+	rc = run_Part_3(); // Funktionalität 3 ausführen.
	+	break;
	+	default:
	+	rc = RC_ERR; // Interner Fehler.
	+	} // switch
	+
	+	return rc;
	+	} // app_Run()
	+
	+
	+	// ****************** main() **************************************
	+
	+	int main (int argc, char *argv [])
	+	{
	+	int rc = RC_OK;
	+	int rc_init = RC_OK;
	+	int rc_run = RC_OK;
	+	int rc_done = RC_OK;
	+	int maxAttempt = 0;
	+	int timeOut = 0;
	+
	+	#ifdef DEBUGMODE
	+	fprintf(stderr, "\n=== DEBUGMODE is ON ===\n");
	+	#endif
	+
	+	initGlobalVar();
	+	initLocalVar();
	+	rc = initRuntimeVar();
	+	rc = initLogging();
	+
	+	rc = checkParameter(argc, argv);
	+
	+	if (!rc) // Falls die Vorbereitung erfolgreich war...
	+	{
	+	rc_init = app_Init(maxAttempt, timeOut); // Initialisierung.
	+	rc_run = app_Run(rc_init); // Hauptlauf.
	+	rc_done = app_Done(rc_init, rc_run); // Aufräumen.
	+	} // if
	+
	+	rc = doneLogging();
	+
	+	if ((rc_init) \|\| (rc_run) \|\| (rc_done)) rc = RC_ERR;
	+	return rc;
	+	} // main()
	+
	+	// EOF
	+	</code>
	+
	+	----
	+	Stand: 04.11.2010
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:zeitabstaende_messen

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:08+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Zeitabstände messen ======

	+	...bzw. Laufzeit eines Programms / einer Funktion berechnen.
	+
	+	:!: Diese Zeit-Messung darf nicht mit der verbrauchten CPU-Zeit verwechselt werden!
	+
	+	<code c>
	+	void irgendEineFunktion (void)
	+	{
	+	time_t aktSekunden1, aktSekunden2;
	+
	+	// [...]
	+
	+	aktSekunden1 = time(NULL);; // Vor dem zu messenden Abschnitt - aktuelle Zeit ermitteln
	+
	+	// Hier tut das Programm etwas sinnvolles ;-)
	+
	+	aktSekunden2 = time(NULL); // Nach dem zu messenden Abschnitt - aktuelle Zeit ermitteln
	+
	+	printf("Laufzeit = %d Sekunden\n", aktSekunden2 - aktSekunden1); // Zeitdifferenz in Sekunden
	+
	+	return;
	+	} // irgendEineFunktion()
	+	</code>
	+
	+	----
	+	Stand: 11.10.2013\\
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF

edv:prg:c:example:zufaellige_int-zahl

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:07+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Zufällige int-Zahl ======

	+	<code c>
	+	int intMax;
	+	int intRandom;
	+
	+	srand((unsigned int) time(0L)); // Sequenz initialisieren
	+	intRandom = rand() % intMax; // Ergebnis: 0 < intRandom < intMax
	+	</code>
	+
	+	:!: Wichtiger Hinweis:\\
	+	When compiling multithreaded applications, the _REENTRANT
	+	flag must be defined on the compile line. This flag should
	+	only be used in multithreaded applications.
	+
	+	EOF

edv:prg:c:example:zweidimensionale_dynamische_arrays

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:09+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Zweidimensionale dynamische Arrays ======

	+	Auf der Web-Seite [[http://pronix.linuxdelta.de/C/standard_C/c_programmierung_17_1.shtml]] von [[http://pronix.linuxdelta.de/impressum/index.shtml\|Jürgen Wolf]] habe ich ein sehr interessantes Beispiel für zweidimensionale dynamische Arrays entdeckt.
	+
	+	Hier ist ein kleiner Ausschnitt (Kapitel 17.8) aus dem Artikel:
	+
	+	//(Zitat Anfang)//
	+
	+	Um also für ein zweidimensionales Array mit beliebig vielen Zeilen und Spalten Speicher zu reservieren, benötigen Sie zuerst Platz für die Zeile. Und für jede dieser Zeilen wird nochmals Platz für die Spalte benötigt. Beim Freigeben des Speichers muss dies in umgekehrter Reihenfolge vorgenommen werden.
	+
	+	Hierzu das vollständige Listing:
	+
	+	<code c>
	+	#include <stdio.h>
	+	#include <stdlib.h>
	+	#define BUF 255
	+
	+	int main ()
	+	{
	+	int i, j, zeile, spalte;
	+	// Matrix ist Zeiger auf int-Zeiger
	+	int ** matrix;
	+
	+	printf("Wie viele Zeilen : ");
	+	scanf("%d", &zeile);
	+	printf("Wie viele Spalten: ");
	+	scanf("%d", &spalte);
	+
	+	// Speicher reservieren für die int-Zeiger (=zeile)
	+	matrix = (int *) malloc(zeile sizeof(int *));
	+	if (NULL == matrix)
	+	{
	+	printf("Kein Speicher fuer die Zeilen...\n");
	+	exit(0);
	+	} // if
	+	// Jetzt noch Speicher reservieren für die einzelnen Spalten der i-ten Zeile
	+	for (i=0; i < zeile; i++)
	+	{
	+	matrix[i] = (int ) malloc(spalte sizeof(int));
	+	if (NULL == matrix[i])
	+	{
	+	printf("Kein Speicher fuer Zeile %d\n", i);
	+	exit(0);
	+	} // if
	+	} // for (i)
	+	// Mit beliebigen Werten initialisieren
	+	for (i = 0; i < zeile; i++) for (j = 0; j < spalte; j++) matrix[i][j] = i+j; // matrix[zeile][spalte]
	+	// Inhalt der Matrix entsprechend ausgeben
	+	for (i = 0; i < zeile; i++)
	+	{
	+	for (j = 0; j < spalte; j++) printf("%d ", matrix[i][j]);
	+	printf("\n");
	+	} // for (i)
	+
	+	// Speicherplatz wieder freigeben
	+	// Wichtig! In umgekehrter Reihenfolge!
	+	// Spalten der i-ten Zeile freigeben
	+	for (i = 0; i < zeile; i++) free(matrix[i]);
	+	// Jetzt können die leeren Zeilen freigegeben werden
	+	free(matrix);
	+
	+	return 0;
	+	} // main()
	+	</code>
	+
	+	//(Zitat Ende)//
	+
	+	Und weiter...
	+
	+	//(Zitat Anfang)//
	+
	+	Hierzu eine Tabelle:
	+
	+	^ Zugriff auf … ^ Möglichkeit 1 ^ Möglichkeit 2 ^ Möglichkeit 3 ^
	+	\|1.Zeile, 1.Spalte \|%%*matrix%% \|%%matrix[0]%% \|%%matrix[0][0]%% \|
	+	\|i.Zeile, 1.Spalte \|%%*(matrix+i)%% \|%%matrix[i]%% \|%%matrix[i][0]%% \|
	+	\|1.Zeile, i.Spalte \|%%(matrix+i)%% \|%%*(matrix[0]+i)%% \|%%matrix[0][i]%% \|
	+	\|i.Zeile, j.Spalte \|%%((matrix+i)+j)%% \|%%*(matrix[i]+j)%% \|%%matrix[i][j]%% \|
	+
	+	//(Zitat Ende)//
	+
	+	:!: Quellenangabe:\\ Den kompletten Artikel findet man auf der Web-Seite [[http://pronix.linuxdelta.de/C/standard_C/c_programmierung_17_1.shtml]] des Authors [[http://pronix.linuxdelta.de/impressum/index.shtml\|Jürgen Wolf]].
	+
	+	----
	+	Stand: 28.10.2011
	+	--- //[[feedback.jk-wiki@kreick.de\|: Jürgen Kreick]]//
	+
	+	EOF