/***************************************************************************
                         zusatz.c     -  description
                             -------------------

    begin                : Wed Jul  18 MET 2001

    copyright            : (C) 1999-2001 by Th. Marquardt, Steffen Hildebrandt

    email                : th.marquardt@t-online.de
                           Steffen.Hildebrandt@web.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/time.h>
#include <signal.h>
#include <ctype.h>

#include "gesko.h"


#define MAX_ANLAGE_DATEN   52


/* Variablen  */
extern int timer;
extern int timeout_mode;
extern int timeout;
extern int logging;

/* Struktur für Anlage-Daten */
struct AnlageDaten
{
	char Kennung[3];
	char Testversion[2];
	char ErstPruef[6];
	char SerNr[10];
	char Pruefer[3];
	char TestFehler[2];
	char StartTest[2];
	char DatumPruef[6];
	char ZaehlPass[2];
	char ZaehlFail[2];
	char Ergebnis[1];
  char Pruefgeraet[1];
  char APGProgVersion[5];
  char ChangeFLASH[1];
	char RepaNr[6];
} ad;


/*****************************************************************************/
/* Funktion zum Auslesen und Anzeigen der Anlagedaten                        */
/* ----------------------------------------------------------------------    */
/* In:	                                                                     */
/* ---------------------------------------------------                       */
/* Out:	                                                                     */
/* ----------------------------------------------------                      */
/* Autor: Steffen Hildebrandt                                                */
/* letzte Aenderung: Steffen Hildebrandt 13.05.2002                          */
/*****************************************************************************/
void ReadPbxData(void)
{
  int k, error;
  int i = 0;
  int j = 0;
  unsigned char *puffer = malloc(512);
  unsigned char *text = malloc(512);
  cmdtype Cmd;


  /* Anlagedaten auslesen... */
  printf("Lese Anlagedaten...\n");

  Cmd.param_anz = 0;
  sprintf ( Cmd.befehl, "%s", "I209" );
  ConfPbxPutAndGet  ( Cmd, puffer, text, 0 );

  sprintf ( Cmd.befehl, "%s", "EEPR" );
  Cmd.param[0] = 1;
  Cmd.param[1] = 0;
  Cmd.param[2] = MAX_ANLAGE_DATEN;
  Cmd.param_anz = 3;

  k = 2;
  do
  {
    error = ConfPbxPutAndGet  ( Cmd, puffer, text, 0 );
   /* schauen, ob Anlagedaten ok sind... */
    if(memcmp(text, "G0", 2) == 0 || memcmp(text, "G1", 2) == 0 ||
       memcmp(text, "10", 2) == 0 || memcmp(text, "60", 2) == 0)
      error = NO_ERROR;
  }
  while(error != NO_ERROR && --k != 0);

  if(error == ERROR)
  {
    printf("FEHLER : Fehler bei Auslesen der Anlagedaten! -> ABBRUCH!\n");
    sprintf ( Cmd.befehl, "%s", "ENDE" );
    ConfPbxPutAndGet  ( Cmd, puffer, text, 1 );
    exit (0);
  }

  /* ...Füllen der Struktur... */
	for(i = 0; i < 3; i++, j++)
		ad.Kennung[i] = text[j];
	for(i = 0; i < 2; i++, j++)
		ad.Testversion[i] = text[j];
	for(i = 0; i < 6; i++, j++)
		ad.ErstPruef[i] = text[j];
	for(i = 0; i < 10; i++, j++)
		ad.SerNr[i] = text[j];
	for(i = 0; i < 3; i++, j++)
		ad.Pruefer[i] = text[j];
	for(i = 0; i < 2; i++, j++)
		ad.TestFehler[i] = text[j];
	for(i = 0; i < 2; i++, j++)
		ad.StartTest[i] = text[j];
	for(i = 0; i < 6; i++, j++)
		ad.DatumPruef[i] = text[j];
	for(i = 0; i < 2; i++, j++)
		ad.ZaehlPass[i] = text[j];
	for(i = 0; i < 2; i++, j++)
		ad.ZaehlFail[i] = text[j];
	for(i = 0; i < 1; i++, j++)
		ad.Ergebnis[i] = text[j];
	for(i = 0; i < 1; i++, j++)
		ad.Pruefgeraet[i] = text[j];
	for(i = 0; i < 5; i++, j++)
		ad.APGProgVersion[i] = text[j];
	for(i = 0; i < 1; i++, j++)
		ad.ChangeFLASH[i] = text[j];
	for(i = 0; i < 6; i++, j++)
		ad.RepaNr[i] = text[j];

  /* ...und anzeigen */
	printf("\n\n--- BEGIN --- ANLAGEDATEN\n\n");

	printf("Kennung              : %.3s\n", ad.Kennung);
	printf("Testversion          : %.2s\n", ad.Testversion);
	printf("Erstpruefung         : %.6s\n", ad.ErstPruef);
	printf("Seriennummer         : %.10s\n", ad.SerNr);
	printf("Pruefer              : %.3s\n", ad.Pruefer);
	printf("letzter Fehler       : %.2s\n", ad.TestFehler);
	printf("letzter Start        : %.2s\n", ad.StartTest);
	printf("Letzte Pruefung      : %.6s\n", ad.DatumPruef);
	printf("PASS Zaehler         : %.2s\n", ad.ZaehlPass);
	printf("FAIL Zaehler         : %.2s\n", ad.ZaehlFail);
	printf("letztes Ergebnis     : %.1s\n", ad.Ergebnis);
	printf("Pruefgeraet          : %.1s\n", ad.Pruefgeraet);
	printf("APG-Programmversion  : %.5s\n", ad.APGProgVersion);
  printf("FLASH-Wechsel        : %.1s\n", ad.ChangeFLASH);
  printf("Reparaturnummer      : %.6s\n", ad.RepaNr);

  printf("\n");

  /* neue Anlagen */
  if(strncmp(ad.Kennung, "G11", 3) == 0)
    printf("Anlage : family 104\n");
  if(strncmp(ad.Kennung, "G12", 3) == 0)
    printf("Anlage : family 108\n");
  if(strncmp(ad.Kennung, "G13", 3) == 0)
    printf("Anlage : family 115\n");
  if(strncmp(ad.Kennung, "G14", 3) == 0)
    printf("Anlage : family 105\n");
  if(strncmp(ad.Kennung, "G15", 3) == 0)
    printf("Anlage : family 116 (NEU)\n");
  if(strncmp(ad.Kennung, "G01", 3) == 0)
    printf("Anlage : office 2108 (NEU)\n");
  if(strncmp(ad.Kennung, "G02", 3) == 0)
    printf("Anlage : Overboard fuer office 1008/1106/1108/2108\n");
  if(strncmp(ad.Kennung, "G03", 3) == 0)
    printf("Anlage : office 1106 (NEU)\n");
  if(strncmp(ad.Kennung, "G04", 3) == 0)
    printf("Anlage : office 1108 NEU\n");
  if(strncmp(ad.Kennung, "G05", 3) == 0)
    printf("Anlage : office 1008 NEU\n");
  /* alte Anlagen */
  if(strncmp(ad.Kennung, "104", 3) == 0)
    printf("Anlage : family 4\n");
  if(strncmp(ad.Kennung, "108", 3) == 0)
    printf("Anlage : family 8\n");
  if(strncmp(ad.Kennung, "606", 3) == 0)
    printf("Anlage : office 206\n");
  if(strncmp(ad.Kennung, "609", 3) == 0)
    printf("Anlage : office 209\n");

	printf("\n--- END --- ANLAGEDATEN\n");

  Cmd.param_anz = 0;
  sprintf ( Cmd.befehl, "%s", "ENDE" );
  ConfPbxPutAndGet  ( Cmd, puffer, text, 0 );

  return;
}


/*****************************************************************************/
/* Funktion zum Ermitteln des Hardwaretyps                                   */
/* ----------------------------------------------------------------------    */
/* In:	                                                                     */
/* ---------------------------------------------------                       */
/* Out:	                                                                     */
/* ----------------------------------------------------                      */
/* Autor: Steffen Hildebrandt                                                */
/* letzte Aenderung: Steffen Hildebrandt 18.11.2002                          */
/*****************************************************************************/
void GetHardwareInfo(void)
{
	int hw = NO_TYP;
	int fam = NO_TYP;
	int ovb = FALSE;
	int off_old = FALSE;
	int io8, io8_d0;
	int io6, io6_d3, io6_d5;
  int p0, p2;
	int p0_d4, p0_d5;
	int p1;
	int p1_d7;
	int p2_d0, p2_d1, p2_d2, p2_d3;
  unsigned char *puffer = malloc(512);
  unsigned char *text = malloc(512);
	unsigned char *temp = (unsigned char*)calloc(512, 1);
  cmdtype Cmd;


  printf("\nHardwareerkennung...\n");

  Cmd.param_anz = 0;
  sprintf ( Cmd.befehl, "%s", "I209" );
  ConfPbxPutAndGet  ( Cmd, puffer, text, 0 );

	/* auf geeignete FW-Version pruefen -> Hardwareerkennung fuer FW-Version >= V4.23 */
  Cmd.param_anz = 0;
  sprintf ( Cmd.befehl, "%s", "VERS" );
  ConfPbxPutAndGet  ( Cmd, puffer, text, 0 );
	if (strncmp(text, "ERR", 3) == 0)
	{
		printf("FEHLER : Fehler bei Hardwareerkennung! -> ABBRUCH!\n");
		exit (0);
	}

	strncpy(temp, strpbrk(text, "V"), 5);
	if (strcmp(temp, "V4.22") <= 0)
	{
		printf("HINWEIS : Anlage muss Firmware-Version >= V 4.23 besitzen! -> Hardwareerkennung nicht moeglich!\n");
		exit (0);
	}	

	/* schauen, ob Family- oder Office-Anlage... */
	if (strncmp(text, "GESKO i416", 10) == 0)
		fam = OFFICE;
	if (strncmp(text, "GESKO A416", 10) == 0)
		fam = OFFICE;
	if (strncmp(text, "GESKO F108", 10) == 0)
		fam = FAMILY;
	if (strncmp(text, "GESKO A108", 10) == 0)
		fam = FAMILY;

	/****************************************/
	/* -> Pruefungen fuer OFFICE-Anlagen... */
	/****************************************/

	if (fam == OFFICE)
	{
		/* ist Overboard vorhanden? */
  	sprintf ( Cmd.befehl, "%s", "PORD" );
  	Cmd.param[0] = 1;
  	Cmd.param[1] = 0xFF;
  	Cmd.param[2] = 0;
  	Cmd.param_anz = 3;
  	ConfPbxPutAndGet  ( Cmd, puffer, text, 0 );

  	p1 = HexToWert(puffer);
  	p1_d7 = p1 & 0x80;	

		switch (p1_d7)
		{
			case 0x80 : ovb = FALSE;
		 	 break;
			case 0  	: ovb = TRUE;
		 	 break;
		}

/*****/

		/* ein paar Portwerte einlesen und merken... */
  	sprintf ( Cmd.befehl, "%s", "PORD" );
  	Cmd.param[0] = 2;
  	Cmd.param[1] = 0xFF;
  	Cmd.param[2] = 0;
  	Cmd.param_anz = 3;
  	ConfPbxPutAndGet  ( Cmd, puffer, text, 0 );

  	p2 = HexToWert(puffer);
		p2_d0 = p2 & 0x01;
		p2_d1 = p2 & 0x02;
		p2_d2 = p2 & 0x04;
		p2_d3 = p2 & 0x08;

		/* ... */
  	sprintf ( Cmd.befehl, "%s", "PORD" );
  	Cmd.param[0] = 0;
  	Cmd.param[1] = 0xFF;
  	Cmd.param[2] = 0;
  	Cmd.param_anz = 3;
  	ConfPbxPutAndGet  ( Cmd, puffer, text, 0 );

 		p0 = HexToWert(puffer);
		p0_d4 = p0 & 0x10;
		p0_d5 = p0 & 0x20;

/*****/

		/* schauen, ob es eine family 115/116 ist... */
		if (p2_d0 == 1 && p0_d4 == 0)
		{
			if (p0_d5 == 0)
			  hw = FAMILY_115;
			 else
				hw = FAMILY_116;
			goto m1;
		}

/*****/

		/* schauen, ob ALTE oder NEUE Hardware (Office-Reihe)... */
  	sprintf ( Cmd.befehl, "%s", "IORD" );
  	Cmd.param[0] = 0x0807;
  	Cmd.param[1] = 0;
  	Cmd.param[2] = 0;
  	Cmd.param_anz = 3;
  	ConfPbxPutAndGet  ( Cmd, puffer, text, 0 );

		io8 = HexToWert(puffer);
		io8_d0 = io8 & 0x01;

		switch (io8_d0)
		{
			case 1 : off_old = TRUE;
		 	 break;
			case 0 : off_old = FALSE;
		 	 break;
		}

/*****/

		/* ALTE Hardware - welche Anlage (office 2108/2116/1106/1114) */
		if (off_old == TRUE)
		{
			switch(p0_d5)
			{
				case 0 : 		if (ovb == TRUE)
											hw = OFFICE_1114;
										 else
											hw = OFFICE_1106;
				 break;
				case 0x20 : if (ovb == TRUE)
											hw = OFFICE_2116;
										 else
											hw = OFFICE_2108;
				 break;
			}
		}

/*****/

		/* NEUE Hardware - welche Anlage (office 2108/2116/1108/1116/1106/1114/1008/1016) */
		if (off_old == FALSE)
		{

			if (p0_d4 == 0)
			{
				if (ovb == TRUE)
					hw = OFFICE_1016;
				 else
					hw = OFFICE_1008;
			}

			if (p0_d4 == 0x10 && p0_d5 == 0x20)
			{
				if (ovb == TRUE)
					hw = OFFICE_2116;
				 else
					hw = OFFICE_2108;
			}

			if (p0_d4 == 0x10 && p0_d5 == 0 && p2_d1 == 0)
			{
				if (ovb == TRUE)
					hw = OFFICE_1116;
				 else
					hw = OFFICE_1108;
			}

			if (p0_d4 == 0x10 && p0_d5 == 0 && p2_d1 == 0x02)
			{
				if (ovb == TRUE)
					hw = OFFICE_1114;
				 else
					hw = OFFICE_1106;
			}
		}
	}

	/****************************************/
	/* -> Pruefungen fuer FAMILY-Anlagen... */
	/****************************************/

	if (fam == FAMILY)
	{
		/* welche Family?... */
  	sprintf ( Cmd.befehl, "%s", "IORD" );
  	Cmd.param[0] = 0x0600;
  	Cmd.param[1] = 0;
  	Cmd.param[2] = 0;
  	Cmd.param_anz = 3;
 		ConfPbxPutAndGet  ( Cmd, puffer, text, 0 );

		io6 = HexToWert(puffer);
		io6_d3 = io6 & 0x04;
		io6_d5 = io6 & 0x10;

		if (io6_d3 == 0)
			hw = FAMILY_104;
		 else
		{
			if (io6_d5 == 0)
				hw = FAMILY_105;
			 else
				hw = FAMILY_108;
		}
	}

/**********************************/

m1 :

	/* und Ende... */
  Cmd.param_anz = 0;
  sprintf ( Cmd.befehl, "%s", "ENDE" );
  ConfPbxPutAndGet  ( Cmd, puffer, text, 0 );

	/* Anzeige des Hardwaretyps... */
	switch (hw)
	{
		case FAMILY_104  : printf(" -> Anlage ist eine <family 104>!\n");
		 break;
		case FAMILY_105  : printf(" -> Anlage ist eine <family 105>!\n");
		 break;
		case FAMILY_108  : printf(" -> Anlage ist eine <family 108>!\n");
		 break;
		case FAMILY_115  : printf(" -> Anlage ist eine <family 115>!\n");
		 break;
		case FAMILY_116  : printf(" -> Anlage ist eine <family 116>!\n");
		 break;
		case OFFICE_1008 : printf(" -> Anlage ist eine <office 1008>!\n");
		 break;
		case OFFICE_1016 : printf(" -> Anlage ist eine <office 1016>!\n");
		 break;
		case OFFICE_1106 : printf(" -> Anlage ist eine <office 1106>!\n");
		 break;
		case OFFICE_1114 : printf(" -> Anlage ist eine <office 1114>!\n");
		 break;
		case OFFICE_1108 : printf(" -> Anlage ist eine <office 1108>!\n");
		 break;
		case OFFICE_1116 : printf(" -> Anlage ist eine <office 1116>!\n");
		 break;
		case OFFICE_2108 : printf(" -> Anlage ist eine <office 2108>!\n");
		 break;
		case OFFICE_2116 : printf(" -> Anlage ist eine <office 2116>!\n");
		 break;
		case NO_TYP      : printf("FEHLER : Keine Hardware erkannt!\n"); 
		 break;
	}

	return;
}


/*****************************************************************************/
/* Funktion zum Ermitteln ob alte oder neue Anlagen                          */
/* ----------------------------------------------------------------------    */
/* In:	                                                                     */
/* ---------------------------------------------------                       */
/* Out:	Anlagetyp oder ERROR                                                 */
/* ----------------------------------------------------                      */
/* Autor: Steffen Hildebrandt                                                */
/* letzte Aenderung: Steffen Hildebrandt 21.01.2003                          */
/*****************************************************************************/
int GetAnlageTyp(void)
{
  int ret = ERROR; 
  unsigned char *puffer = malloc(512);
  unsigned char *text = malloc(512);
  cmdtype Cmd;


  printf("\nAnlagetyp ermitteln...\n");

  Cmd.param_anz = 0;
  sprintf ( Cmd.befehl, "%s", "I209" );
  ConfPbxPutAndGet  ( Cmd, puffer, text, 0 );

  Cmd.param_anz = 0;
  sprintf ( Cmd.befehl, "%s", "VERS" );
  ConfPbxPutAndGet  ( Cmd, puffer, text, 0 );
	if (strncmp(text, "ERR", 3) == 0)
	{
		printf("FEHLER : Fehler bei Ermitteln des Anlagetyps! -> ABBRUCH!\n");
		exit (0);
	}

  /* Anlagetyp ermitteln und ausgeben... */
	if(strstr(text, "F108") != 0 || strstr(text, "A108") != 0)
  {
	  ret = FAMILY;
 	  printf("Anlagetyp <F108/A108>-> family 104/105/108.\n\n");
  }

	if(strstr(text, "i416") != 0 || strstr(text, "A416") != 0)
  {
    ret = OFFICE;
		printf("Anlagetyp <i416/A416> -> family 115/116 oder office 1008/1106/1108/2108.\n\n");
  }

	if(strstr(text, "fam4") != 0 || strstr(text, "fam8") != 0)
  {
	  ret = FAMILY_OLD;
 	  printf("Anlagetyp <fam4/8> -> family 4/8.\n\n");
  }

	if(strstr(text, "off6") != 0 || strstr(text, "off9") != 0)
  {
    ret = OFFICE_OLD;
		printf("Anlagetyp <off6/9> -> office 206/209.\n\n");
  }

  return ret;
}


/*****************************************************************************/
/* Funktion zum Test, ob geskoctrl schon gestartet wurde                     */
/* ----------------------------------------------------------------------    */
/* In:	                                                                     */
/* ---------------------------------------------------                       */
/* Out:	                                                                     */
/* ----------------------------------------------------                      */
/* Autor: Steffen Hildebrandt                                                */
/* letzte Aenderung: Steffen Hildebrandt 17.08.2001                          */
/*****************************************************************************/
int CheckStartProgram ( void )
{
  int i = 0;
  char zeile[80];
  FILE *fp;


 #ifndef SOLARIS 
  system("ps ax > /tmp/psax.tmp");
 #endif
 #ifdef SOLARIS
  system("ps -A > /tmp/psax.tmp");
 #endif

 #ifdef DEBUG
	printf("Ueberpruefe, ob geskoctrl schon gestartet wurde...\n");
 #endif

	fp = fopen("/tmp/psax.tmp", "r");	
	while((fgets(zeile, 80, fp)) != NULL)
	{
		if(strstr(zeile, "./geskoctrl") != 0)
      i++;
	   else
			continue;
	}		
  fclose(fp); 

	system ("rm /tmp/psax.tmp");

  if(i == 2)
  {
    printf("FEHLER : geskoctrl wurde schon gestartet! -> ABBRUCH!\n");
		exit(0);
  }

 #ifdef DEBUG
	printf("geskoctrl wurde noch nicht gestartet!\n");
 #endif

  return NO_ERROR;
}


/*****************************************************************************/
/* Funktion fuer Timerende                                                   */
/* ----------------------------------------------------------------------    */
/* In: signr - Signalnummer (SIGALRM)                                        */
/* ---------------------------------------------------                       */
/* Out:	                                                                     */
/* ----------------------------------------------------                      */
/* Autor: Steffen Hildebrandt                                                */
/* letzte Aenderung: Steffen Hildebrandt, 09.01.2003                         */
/*****************************************************************************/
void TimerEnd(int signr)
{

	/* Timeout eingetreten -> Variable setzen */
	timeout = TRUE;

  /* Timerablauf signalisieren */
  timer = TIMER_DOWN;

 #ifdef DEBUG_TIMEOUT 
	printf("TIMER abgelaufen!\n");
 #endif

  /* Timer definiert zuruecksetzen */
	StartTimer(0, 0);

  switch(timeout_mode)
  {
    case SERIAL_IN  :
		 #ifdef DEBUG_TIMEOUT
			printf("\nFEHLER : Ablauf Timer! Timeout serielle Schnittstelle (SERIAL_IN)!\n");
		 #endif
     break;

    case SERIAL_OUT :
		 #ifdef DEBUG_TIMEOUT
			printf("\nFEHLER : Ablauf Timer! Timeout serielle Schnittstelle (SERIAL_OUT)!\n");
		 #endif
     break;

    case SERIAL_BLOCK_IN  :
		 #ifdef DEBUG_TIMEOUT
			printf("\nFEHLER : Ablauf Timer! Timeout serielle Schnittstelle (SERIAL_BLOCK_IN)!\n");
		 #endif
     break;

    case SERIAL_BLOCK_OUT  :
		 #ifdef DEBUG_TIMEOUT
			printf("\nFEHLER : Ablauf Timer! Timeout serielle Schnittstelle (SERIAL_BLOCK_OUT)!\n");
		 #endif
     break;

    default :
     break;
  }
}


/*****************************************************************************/
/* Funktion fuer Starten eines Timers                                        */
/* ----------------------------------------------------------------------    */
/* In:	                                                                     */
/* ---------------------------------------------------                       */
/* Out:	                                                                     */
/* ----------------------------------------------------                      */
/* Autor: Steffen Hildebrandt                                                */
/* letzte Aenderung: Steffen Hildebrandt, 09.01.2003                         */
/*****************************************************************************/
void StartTimer(long sec, long msec )
{
	struct itimerval timer_zeit;


	/* Timer auf NULL setzen und zurueck */
	if(sec == 0 && msec == 0)
	{
 	 #ifdef DEBUG_TIMEOUT
		printf("TIMER zurueckgesetzt!\n");
 	 #endif
		timer = TIMER_DOWN;
		return;
	}

	/* Timerwerte einstellen */
	timer_zeit.it_interval.tv_sec = 0;
	timer_zeit.it_interval.tv_usec = 0;
	timer_zeit.it_value.tv_sec = sec;
	timer_zeit.it_value.tv_usec = (msec / 100) * 100000;

  timer = TIMER_UP;

  /* Timer starten - zaehlt die reale Zeit */
	setitimer(ITIMER_REAL, &timer_zeit, NULL);

 #ifdef DEBUG_TIMEOUT
	printf("TIMER gestartet!\n");
 #endif

	return;
}

/*****************************************************************************/
/* Funktion für Delay/Pause - z.Zt. nicht genutzt !                          */
/* ----------------------------------------------------------------------    */
/* In:	                                                                     */
/* ---------------------------------------------------                       */
/* Out:	                                                                     */
/* ----------------------------------------------------                      */
/* Autor: Steffen Hildebrandt                                                */
/* letzte Aenderung: Steffen Hildebrandt 08.08.2001                          */
/*****************************************************************************/
void Pause(int sec, int msec)
{

	StartTimer(sec, msec);
	pause();

	return;
}

/*****************************************************************************/
/* Funktion fuer Beenden des Programm durch SIGNAL                           */
/* ----------------------------------------------------------------------    */
/* In:	                                                                     */
/* ---------------------------------------------------                       */
/* Out:	                                                                     */
/* ----------------------------------------------------                      */
/* Autor: Steffen Hildebrandt                                                */
/* letzte Aenderung: Steffen Hildebrandt, 14.05.2002                         */
/*****************************************************************************/
void EndeProgrammSignal ( int signr )
{
  unsigned char *text = malloc(512);
  cmdtype Cmd;


	if(logging == TRUE)
	{
 		/* Stop Logging... */
  	printf("\nStop Logging...\n");

  	Cmd.param_anz = 0;
  	sprintf ( Cmd.befehl, "%s", "GTZ0" );
  	GTPbxPutAndGet  ( Cmd, text, 1 );
	 }

  switch(signr)
  {
	  case SIGABRT : printf("\nSignal SIGABRT!\n");
     break;
    case SIGKILL : printf("\nSignal SIGKILL!\n");
     break;
    case SIGSEGV : printf("\nSignal SIGSEGV!\n");
     break;
    case SIGINT  : printf("\nSignal SIGINT!\n");
     break;
    case SIGTERM : printf("\nSignal SIGTERM!\n");
     break;
    default      :
     break;
  }
	printf("\nPROGRAMM-ENDE per Signal (Signal %d)!\n", signr);

	exit(0);
}

