Ein Gerüst für ein C-Programm

AppName.h:

/**********************************************************************
*
*	$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

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

Stand: 04.11.2010 — : Jürgen Kreick

EOF