/***************************************************************************
                          file.c  -  description                              
                             -------------------                                         
    begin                : Fri Dec 10 1999                                           
    copyright            : (C) 1999 by Thomas Marquardt                         
    email                : th.marquardt@t-online.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 <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "gesko.h"


#define LINIE "#------------------------------------------------------------------------------\n"
#define ABSATZ "\n\n\n"


/* --- Globale Variablen --- */
int Ctr = 0;


/********************************************************************************/
/* Funktion zum Schreiben eines Files, das die Strukturen der Datenbloecke zeigt */
/* ---------------------------------------------------------------------------- */
/* Autor: Thomas Marquardt                                                      */
/********************************************************************************/
void PrintSize (FILE * StructFilePtr, int pos, size_t size, unsigned char * text)
{
  char   HilfsString[512];
  
  sprintf (HilfsString,"ByteLen=%4d   Pos=%4d   StructLen=%4d   StructName=%s\n", Ctr, pos, size, text);
  fputs (HilfsString, StructFilePtr);

  Ctr += size;
}



/*****************************************************************************/
/* Funktion zum Schreiben eines Files, das den L7_Einr_Block darstellt       */
/* ------------------------------------------------------------------------- */
/* Autor: Thomas Marquardt                                                   */
/* letzte Aenderung : Steffen Hildebrandt, 11.11.2002                        */
/*****************************************************************************/
int MakeCfgFile( EINRICHT_BLOCK L7_Einr_Block )
{
  FILE * CfgFilePtr;
  FILE * StructFilePtr;
  char   HilfsString[512];
  char   TempString[512];
  int pos, i, tfe, taste, IntPort, ExtS0, ddi, Ber, prio, Reserve;
  unsigned char *x;
  unsigned char *y;


  Ctr = 0;

  strcpy (HilfsString, "config_data/daten.cfg");
  if ( (CfgFilePtr=fopen(HilfsString, "w") ) == NULL )
  {
    printf ("FEHLER : Verzeichnis < config_data > ist nicht vorhanden! Bitte manuell anlegen!\n\n");
	  exit (0);
  }
  printf ("Schreibe File: %s\n", HilfsString);

  strcpy (HilfsString, "config_data/struct.cfg");
  if ( (StructFilePtr=fopen(HilfsString, "w") ) == NULL )
  {
    printf ("FEHLER : Verzeichnis < config_data > ist nicht vorhanden! Bitte manuell anlegen!\n\n");
	  exit (0);
  }
  fputs (LINIE, StructFilePtr);
  fputs ("# File fuer Datenblock L7_Einr_Block / Befehl: EINR\n", StructFilePtr);
  fputs (LINIE, StructFilePtr);
  printf ("Schreibe File: %s\n", HilfsString);

  #ifdef MARQ
  i = 0;
  while ( i < sizeof (L7_Einr_Block) )
  {
	sprintf (HilfsString,"%4d  %02X\n", i++, *x++);
	fputs (HilfsString, StructFilePtr);
  }
  #endif
  
  x = (void *)&L7_Einr_Block;

  fputs (LINIE, CfgFilePtr);
  fputs ("# Dieses File wurde beim Auslesen einer GESKO ISDN-Anlage erzeugt\n", CfgFilePtr);
  fputs (LINIE, CfgFilePtr);


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# TFE-TAGSCHALTUNG fuer beide TFE's und jeweils zwei Taster\n", CfgFilePtr);
  fputs ("# Definition fuer L7_Einr_Block.tfe_tag_schltg\n", CfgFilePtr);
  for ( tfe = 0; tfe < 2; tfe++ ) 
  {
	for ( taste = 0; taste < 2; taste++ )
	{
	  sprintf (HilfsString,"%d.TFE TASTE%d :  %08lX\n", tfe+1, taste, L7_Einr_Block.tfe_tag_schltg[tfe][taste]);
	  fputs (HilfsString, CfgFilePtr);
	}
  }
  y = (void *)&L7_Einr_Block.tfe_tag_schltg;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.tfe_tag_schltg), "tfe_tag_schltg");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# TFE-NACHTSCHALTUNG fuer beide TFE's und jeweils zwei Taster\n", CfgFilePtr);
  fputs ("# Definition fuer L7_Einr_Block.tfe_nacht_schltg\n", CfgFilePtr);
  for ( tfe = 0; tfe < 2; tfe++ ) 
  {
	for ( taste = 0; taste < 2; taste++ )
	{
	  sprintf (HilfsString,"%d.TFE TASTE%d :  %08lX\n", tfe+1, taste, L7_Einr_Block.tfe_nacht_schltg[tfe][taste]);
	  fputs (HilfsString, CfgFilePtr);
	}
  }
  y = (void *)&L7_Einr_Block.tfe_nacht_schltg;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.tfe_nacht_schltg), "tfe_nacht_schltg" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# TEILNEHMERTYP fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.typtln\n", CfgFilePtr);
  fputs ("# Die Zaehlung beginnt bei Port 3\n", CfgFilePtr);
  fputs ("# TYPINTAB      00\n", CfgFilePtr);
  fputs ("# TYPKOMBI      01\n", CfgFilePtr);
  fputs ("# TYPANRB       02\n", CfgFilePtr);
  fputs ("# TYPFAX        03\n", CfgFilePtr);
  fputs ("# TYPMODEM      04\n", CfgFilePtr);
  fputs ("# TYPTFE        05\n", CfgFilePtr);
  fputs ("# TYPAUDIO      06\n", CfgFilePtr);
  fputs ("# TYPALARM      07\n", CfgFilePtr);
  fputs ("# TYPINTISDN    08\n", CfgFilePtr);
  fputs ("# TYPDEFAULT    09\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Einr_Block.typtln[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.typtln;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.typtln), "typtln" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# AMTSRUFRHYTHMUS fuer alle externen Ports und DDI's bzw. MSN's\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.typamtsruf\n", CfgFilePtr);
  fputs ("# K_AMT_R1      00\n", CfgFilePtr);
  fputs ("# K_AMT_R2      01\n", CfgFilePtr);
  fputs ("# K_AMT_R3      02\n", CfgFilePtr);
  for ( ExtS0 = 0; ExtS0 < ANZ_EXT_S0_PORT; ExtS0++ )
  {
	for ( ddi = 0; ddi < DDI_MAX_ANZ; ddi++ )
	{
	  sprintf (HilfsString, "%d.EXTS0  %02d.DDI : %02X\n", ExtS0+1, ddi+1, L7_Einr_Block.typamtsruf[ExtS0][ddi]);
	  fputs (HilfsString, CfgFilePtr);
	}
  }
  y = (void *)&L7_Einr_Block.typamtsruf;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.typamtsruf), "typamtsruf" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# AMTSHOLUNG fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.typamtshol\n", CfgFilePtr);
  fputs ("# Die Zaehlung beginnt bei Port 3\n", CfgFilePtr);
  fputs ("# K_L7_OFF      00\n", CfgFilePtr);
  fputs ("# K_L7_ON       01\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Einr_Block.typamtshol[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.typamtshol;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.typamtshol), "typamtshol" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# BERECHTIGUNG fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.ber\n", CfgFilePtr);
  fputs ("# Die Zaehlung beginnt bei Port 3\n", CfgFilePtr);
  fputs ("# NICHT_AMT     00\n", CfgFilePtr);
  fputs ("# HALB_AMT      01\n", CfgFilePtr);
  fputs ("# NAH_AMT       02\n", CfgFilePtr);
  fputs ("# INLAND_AMT    03\n", CfgFilePtr);
  fputs ("# VOLL_AMT      04\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Einr_Block.ber[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.ber;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.ber), "ber" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# KURZWAHLZIELNUMMERN fuer die gesamte Anlage\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.kwz\n", CfgFilePtr);
  for ( i = 0; i < L7_ANZ_KWZ; i++ )
  {
	sprintf (HilfsString, "%3d.KWZ : %s\n", i, L7_Einr_Block.kwz[i]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.kwz;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.kwz), "kwz");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# KURZWAHLZIELNAMEN fuer die gesamte Anlage\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.kwz_name\n", CfgFilePtr);
  for ( i = 0; i < L7_ANZ_KWZ; i++ )
  {
	sprintf (HilfsString, "%3d.KWZNAME : %s\n", i, L7_Einr_Block.kwz_name[i]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.kwz_name;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.kwz_name), "kwz_name");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# HOTLINE/BABYRUF fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.hotline\n", CfgFilePtr);
  fputs ("# Diese Rufnummer gilt fuer alle Ports, wenn dort aktiviert ist\n", CfgFilePtr);
  sprintf (HilfsString,"NUMMER : %s\n", L7_Einr_Block.hotline);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.hotline;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.hotline), "hotline" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# ANLAGENRUFNUMMER fuer alle externen Ports im Anlagenanschluß\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.anlrufnr\n", CfgFilePtr);
  for ( ExtS0 = 0; ExtS0 < ANZ_EXT_S0_PORT; ExtS0++ )
  {
	sprintf (HilfsString, "%d.EXTS0 : %s\n", ExtS0+1, L7_Einr_Block.anlrufnr[ExtS0]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.anlrufnr;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.anlrufnr), "anlrufnr");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# LAENGE DER DURCHWAHL fuer alle externen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.ddianz\n", CfgFilePtr);
  for ( ExtS0 = 0; ExtS0 < ANZ_EXT_S0_PORT; ExtS0++ )
  {
	sprintf (HilfsString, "%d.EXTS0 : %d\n", ExtS0+1, L7_Einr_Block.ddianz[ExtS0]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.ddianz;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.ddianz), "ddianz");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# NAHBEREICHSNUMMERN fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.nahber\n", CfgFilePtr);
  for ( Ber = 0; Ber < L7_ANZ_NAHBER; Ber++ )
  {
	sprintf (HilfsString, "%02d.NUMMER : %s\n", Ber+1, L7_Einr_Block.nahber[Ber]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.nahber;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.nahber), "nahber");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# SPERRBEREICHSNUMMERN fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.nahber\n", CfgFilePtr);
  for ( Ber = 0; Ber < L7_ANZ_SPERRBER; Ber++ )
  {
	sprintf (HilfsString, "%02d.NUMMER : %s\n", Ber+1, L7_Einr_Block.sperrber[Ber]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.sperrber;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.sperrber), "sperrber");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# CODENUMMER (nicht benutzt\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.cod_nr\n", CfgFilePtr);
  sprintf (HilfsString,"NUMMER : %s\n", L7_Einr_Block.cod_nr);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.cod_nr;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.cod_nr), "cod_nr");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# TAGSCHALTUNG je Externport fuer alle Internports\n", CfgFilePtr);
  fputs ("# Definition fuer L7_Einr_Block.tag_schltg\n", CfgFilePtr);
  for ( ExtS0 = 0; ExtS0 < ANZ_EXT_S0_PORT; ExtS0++ ) 
  {
	for ( ddi = 0; ddi < DDI_MAX_ANZ; ddi++ )
	{
	  sprintf (HilfsString,"%d.EXTS0   %02d.DDI :  %08lX\n", 
			   ExtS0+1, ddi+1, L7_Einr_Block.tag_schltg[ExtS0][ddi]);
	  fputs (HilfsString, CfgFilePtr);
	}
  }
  y = (void *)&L7_Einr_Block.tag_schltg;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.tag_schltg), "tag_schltg");

  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# NACHTSCHALTUNG je Externport fuer alle Internports\n", CfgFilePtr);
  fputs ("# Definition fuer L7_Einr_Block.nacht_schltg\n", CfgFilePtr);
  for ( ExtS0 = 0; ExtS0 < ANZ_EXT_S0_PORT; ExtS0++ ) 
  {
	for ( ddi = 0; ddi < DDI_MAX_ANZ; ddi++ )
	{
	  sprintf (HilfsString,"%d.EXTS0   %02d.DDI :  %08lX\n", 
			   ExtS0+1, ddi+1, L7_Einr_Block.nacht_schltg[ExtS0][ddi]);
	  fputs (HilfsString, CfgFilePtr);
	}
  }
  y = (void *)&L7_Einr_Block.nacht_schltg;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.nacht_schltg), "nacht_schltg");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# RUFWEITERSCHALTUNG je Externport fuer alle Internports\n", CfgFilePtr);
  fputs ("# Definition fuer L7_Einr_Block.rws_schltg\n", CfgFilePtr);
  for ( ExtS0 = 0; ExtS0 < ANZ_EXT_S0_PORT; ExtS0++ ) 
  {
	for ( ddi = 0; ddi < DDI_MAX_ANZ; ddi++ )
	{
	  sprintf (HilfsString,"%d.EXTS0   %02d.DDI :  %08lX\n", 
			   ExtS0+1, ddi+1, L7_Einr_Block.rws_schltg[ExtS0][ddi]);
	  fputs (HilfsString, CfgFilePtr);
	}
  }
  y = (void *)&L7_Einr_Block.rws_schltg;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.rws_schltg), "rws_schltg");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# GEBUEHRENFAKTOR_TELEKOM ALT fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.OldGrundFaktor\n", CfgFilePtr);
  fputs ("# Dieser Gebuehrenfaktor wurde fuer alte Versionen vor V4.15 verwendet\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.OldGrundFaktor);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.OldGrundFaktor;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.OldGrundFaktor), "OldGrundFaktor");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# GEBUEHRENFAKTOR_ANLAGE ALT fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.OldUserFaktor\n", CfgFilePtr);
  fputs ("# Dieser Gebuehrenfaktor wurde fuer alte Versionen vor V4.15 verwendet\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.OldUserFaktor);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.OldUserFaktor;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.OldUserFaktor), "OldUserFaktor");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# DRUCKERMODE fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.PrnKonfig\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Einr_Block.PrnKonfig[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.PrnKonfig;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.PrnKonfig), "PrnKonfig");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# DRUCKER fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.Drucker\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Einr_Block.Drucker[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.Drucker;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.Drucker), "Drucker");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# RUFWEITERSCHALTZEIT fuer Umschaltung von Tag- auf Rufweiterschaltung\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.rwsz\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.rwsz);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.rwsz;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.rwsz), "rwsz");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# FREIGABE zur Programmierung versteckter Leistungsmerkmale\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.freigabe\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.freigabe);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.freigabe;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.freigabe), "freigabe");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# TFE-RUFUMLEITUNGSZIEL fuer alle TFE's wenn dort aktiviert\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.tfe_ext_nr\n", CfgFilePtr);
  for ( tfe = 0; tfe < ANZ_TFE_PORT; tfe++ )
  {
	sprintf (HilfsString, "%02d.TFE NUMMER : %s\n", Ber+1, L7_Einr_Block.tfe_ext_nr[Ber]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.tfe_ext_nr;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.tfe_ext_nr), "tfe_ext_nr");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# ANRUFVARIANTE fuer gesamte Anlage\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.AVA\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.AVA);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.AVA;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.AVA), "AVA");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# RUFKONFIG\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.RufKonfig\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.RufKonfig);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.RufKonfig;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.RufKonfig), "RufKonfig");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# ANRUFBEANTWORTER-BESETZTZEICHEN fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.ab_mode\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Einr_Block.ab_mode[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.ab_mode;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.ab_mode), "ab_mode");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# GEBUEHRENIMPULS fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.geb_mode\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Einr_Block.geb_mode[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.geb_mode;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.geb_mode), "geb_mode");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# TAG/NACHTUMSCHALTUNG fuer gesamte Anlage\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.ava_aktiv\n", CfgFilePtr);
  sprintf (HilfsString,"VARIANTE : %02X\n", L7_Einr_Block.ava_aktiv);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.ava_aktiv;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.ava_aktiv), "ava_aktiv");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# NACHTSCHALTUNG_EIN_STUNDE fuer gesamte Anlage\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.ava_ein_std\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.ava_ein_std);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.ava_ein_std;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.ava_ein_std), "ava_ein_std");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# NACHTSCHALTUNG_EIN_MINUTE fuer gesamte Anlage\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.ava_ein_min\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.ava_ein_min);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.ava_ein_min;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.ava_ein_min), "ava_ein_min");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# NACHTSCHALTUNG_AUS_STUNDE fuer gesamte Anlage\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.ava_aus_std\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.ava_aus_std);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.ava_aus_std;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.ava_aus_std), "ava_aus_std");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# NACHTSCHALTUNG_AUS_MINUTE fuer gesamte Anlage\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.ava_aus_min\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.ava_aus_min);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.ava_aus_min;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.ava_aus_min), "ava_aus_min");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# TELEFONTYP fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.typtel\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Einr_Block.typtel[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.typtel;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.typtel), "typtel");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# VORWAHLNUMMER fuer gesamte Anlage\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.vorwahl\n", CfgFilePtr);
  sprintf (HilfsString, "WERT : %s\n", L7_Einr_Block.vorwahl);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.vorwahl;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.vorwahl), "vorwahl");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# MSN-ZUORDNUNG\n", CfgFilePtr);
  fputs ("# Definition fuer L7_Einr_Block.msn_zuordnung\n", CfgFilePtr);
  for ( prio = 0; prio < 2; prio++ ) 
  {
	for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
	{
	  sprintf (HilfsString,"%d.PRIO   %02d.INTPORT :  %02X  %02X\n", 
			   prio+1, IntPort+1, 
			   L7_Einr_Block.msn_zuordnung[prio][IntPort], 
			   L7_Einr_Block.msn_zuordnung[prio][IntPort]);
	  fputs (HilfsString, CfgFilePtr);
	}
  }
  y = (void *)&L7_Einr_Block.msn_zuordnung;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.msn_zuordnung), "msn_zuordnung");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# MSN-BERECHTIGUNG\n", CfgFilePtr);
  fputs ("# Definition fuer L7_Einr_Block.msn_berechtigung\n", CfgFilePtr);
  for ( ExtS0 = 0; ExtS0 < 2; ExtS0++ ) 
  {
	for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
	{
	  sprintf (HilfsString,"%d.EXTS0   %02d.INTPORT :  %08lX\n", 
			   ExtS0+1, IntPort+1, L7_Einr_Block.msn_berechtigung[ExtS0][IntPort]);
	  fputs (HilfsString, CfgFilePtr);
	}
  }
  y = (void *)&L7_Einr_Block.msn_berechtigung;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.msn_berechtigung), "msn_berechtigung");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# MSN-INDEX fuer Rufumleitungsaenderung\n", CfgFilePtr);
  fputs ("# Definition fuer L7_Einr_Block.ext_chg_idx\n", CfgFilePtr);
  for ( ExtS0 = 0; ExtS0 < 2; ExtS0++ ) 
  {
	sprintf (HilfsString,"%d.EXTS0 :  %02X\n", ExtS0+1, L7_Einr_Block.ext_chg_idx[ExtS0]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.ext_chg_idx;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.ext_chg_idx), "ext_chg_idx");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# GEBUEHRENKONTO fuer alle internen Teilnehmer\n", CfgFilePtr);
  fputs ("# Definition fuer L7_Einr_Block.geb_konto\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%02d.INTPORT :  ",IntPort+1);
	sprintf (TempString, "%02X  ", L7_Einr_Block.geb_konto[IntPort].mode);
	strcat (HilfsString, TempString);
	sprintf (TempString, "%04X\n", L7_Einr_Block.geb_konto[IntPort].dm);
	strcat (HilfsString, TempString);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.geb_konto;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.geb_konto), "geb_konto");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# PIN fuer gesamte Anlage\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.pin_nr\n", CfgFilePtr);
  sprintf (HilfsString, "WERT : %s\n", L7_Einr_Block.pin_nr);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.pin_nr;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.pin_nr), "pin_nr");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# LANDESKENNUNG fuer gesamte Anlage\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.land\n", CfgFilePtr);
  fputs ("# DEUTSCHLAND    00\n", CfgFilePtr);
  fputs ("# SCHWEIZ        01\n", CfgFilePtr);
  fputs ("# HOLLAND        02\n", CfgFilePtr);
  fputs ("# OESTERREICH    03\n", CfgFilePtr);
  fputs ("# RUSSLAND       04\n", CfgFilePtr);
  fputs ("# GROSSBRITANIEN 05\n", CfgFilePtr);
  fputs ("# SPANIEN        06\n", CfgFilePtr);
  fputs ("# BELGIEN        07\n", CfgFilePtr);
  fputs ("# DAENEMARK      08\n", CfgFilePtr);
  fputs ("# ITALIEN        09\n", CfgFilePtr);
  fputs ("# EURO           80\n", CfgFilePtr);
  sprintf (HilfsString, "WERT : %02X\n", L7_Einr_Block.land);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.land;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.land), "land");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# GEBUEHRENUEBERMITTLUNG fuer gesamte Anlage\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.geb_art\n", CfgFilePtr);
  fputs ("# FACILITY         00\n", CfgFilePtr);
  fputs ("# DISPLAY          01\n", CfgFilePtr);
  fputs ("# NATIONAL-CODESET 02\n", CfgFilePtr);
  sprintf (HilfsString, "WERT : %02X\n", L7_Einr_Block.geb_art);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.geb_art;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.geb_art), "geb_art");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# FLASHZEIT fuer gesamte Anlage\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.flash_time\n", CfgFilePtr);
  fputs ("# 50-110msec 00\n", CfgFilePtr);
  fputs ("# 50-350msec 01\n", CfgFilePtr);
  fputs ("# 50-750msec 02\n", CfgFilePtr);
  sprintf (HilfsString, "WERT : %02X\n", L7_Einr_Block.flash_time);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.flash_time;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.flash_time), "flash_time");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# ANRUFBEANTWORTER-PORT-RUFUMLEITUNGSAENDERUNG\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.ab_fern\n", CfgFilePtr);
  sprintf (HilfsString, "WERT : %02X\n", L7_Einr_Block.ab_fern);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.ab_fern;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.ab_fern), "ab_fern");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# BUFFERANZEIGE (nur fuer Debugging)\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.buffer_anz\n", CfgFilePtr);
  sprintf (HilfsString, "WERT : %02X\n", L7_Einr_Block.buffer_anz);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.buffer_anz;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.buffer_anz), "buffer_anz");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# MODE-fuer-GESPRAECHSDATENSPEICHERUNG fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.GespKonfig\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Einr_Block.GespKonfig[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.GespKonfig;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.GespKonfig), "GespKonfig");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# GESPRAECHSDATENSPEICHERUNG fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.GespMode\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Einr_Block.GespMode[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.GespMode;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.GespMode), "GespMode");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# GMODE-fuer-ANRUFDATENSPEICHERUNG\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.GespRufKonfig\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.GespRufKonfig);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.GespRufKonfig;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.GespRufKonfig), "GespRufKonfig");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# RUFABWEISUNG je Externport fuer alle Internports\n", CfgFilePtr);
  fputs ("# Definition fuer L7_Einr_Block.msn_rufabw\n", CfgFilePtr);
  for ( ExtS0 = 0; ExtS0 < 2; ExtS0++ ) 
  {
	for ( ddi = 0; ddi < DDI_MAX_ANZ; ddi++ )
	{
	  sprintf (HilfsString,"%d.EXTS0   %02d.DDI :  %08X\n", 
			   ExtS0+1, ddi+1, L7_Einr_Block.msn_rufabw[ExtS0][ddi]);
	  fputs (HilfsString, CfgFilePtr);
	}
  }
  y = (void *)&L7_Einr_Block.msn_rufabw;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.msn_rufabw), "msn_rufabw");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# MASTEREINSTELLUNG fuer interne a/b-Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.master_tln\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %04X\n", L7_Einr_Block.master_tln);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.master_tln;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.master_tln), "master_tln");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# ART-DES-INTERNEN-WAEHLTON fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.waehl_ton_art\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.waehl_ton_art);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.waehl_ton_art;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.waehl_ton_art), "waehl_ton_art");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# STERNTASTE ALS RUECKFRAGE fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.stern_tasten_funktion\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.stern_tasten_funktion);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.stern_tasten_funktion;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.stern_tasten_funktion), "stern_tasten_funktion");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# TFE-EXT-ZUSATZZEIT\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.tfe_ext_zusatzzeit\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.tfe_ext_zusatzzeit);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.tfe_ext_zusatzzeit;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.tfe_ext_zusatzzeit), "tfe_ext_zusatzzeit");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# GROSSBRITANIEN-AUSBAUSTUFE-2\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.isdn2_gb\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.isdn2_gb);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.isdn2_gb;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.isdn2_gb), "isdn2_gb");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# CLIP-BEI-NOTRUFZENTRALEN\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.notruf_clip\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.notruf_clip);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.notruf_clip;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.notruf_clip), "notruf_clip");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# IWV-RUECKFRAGE-ZIFFER\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.iwv_rfr_ziffer\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.iwv_rfr_ziffer);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.iwv_rfr_ziffer;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.iwv_rfr_ziffer), "iwv_rfr_ziffer");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# GEBUEHREN-FREQUENZ\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.geb_freq\n", CfgFilePtr);
  fputs ("# 1 16KHz\n", CfgFilePtr);
  fputs ("# 2 12KHz\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.geb_freq);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.geb_freq;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.geb_freq), "geb_freq");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# RUFNUMMER-fuer-CODELADUNG\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.code_lade_nr\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %s\n", L7_Einr_Block.code_lade_nr);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.code_lade_nr;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.code_lade_nr), "code_lade_nr");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# CODELADE-VERSUCHE\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.code_lade_max_ctr\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.code_lade_max_ctr);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.code_lade_max_ctr;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.code_lade_max_ctr), "code_lade_max_ctr");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# GLOBALNUMMER-fuer-OESTERREICH\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.glob_no\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.glob_no);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.glob_no;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.glob_no), "glob_no");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# CLIP-RUFMODIFIKATION\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.old_ruf_rhytmus\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.old_ruf_rhytmus);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.old_ruf_rhytmus;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.old_ruf_rhytmus), "old_ruf_rhytmus");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# IMPEDANZANPASSUNG\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.ImpAnpass\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.ImpAnpass);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.ImpAnpass;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.ImpAnpass), "ImpAnpass");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# GEBUEHRENFAKTOR_TELEKOM NEU fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.GrundFaktor\n", CfgFilePtr);
  fputs ("# Dieser Gebuehrenfaktor wird ab Versionen V4.16 verwendet\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %04X\n", L7_Einr_Block.GrundFaktor);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.GrundFaktor;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.GrundFaktor), "GrundFaktor");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# GEBUEHRENFAKTOR_ANLAGE fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.UserFaktor\n", CfgFilePtr);
  fputs ("# Dieser Gebuehrenfaktor wird ab Versionen V4.16 verwendet\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %04X\n", L7_Einr_Block.UserFaktor);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.UserFaktor;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.UserFaktor), "UserFaktor");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# KURZWAHL-MIT-NAMEN\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.kwz_mit_namen\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.kwz_mit_namen);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.kwz_mit_namen;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.kwz_mit_namen), "kwz_mit_namen");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# FSK-MIT-NAMEN\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.fsk_mit_namen\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.fsk_mit_namen);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.fsk_mit_namen;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.fsk_mit_namen), "fsk_mit_namen");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# GTV-SONDERWUNSCH\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.GtvSonderwunsch\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.GtvSonderwunsch);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.GtvSonderwunsch;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.GtvSonderwunsch), "GtvSonderwunsch");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# TFE-GESPRAECHSZEIT LIMITIEREN\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.tfe_gsp_limitieren\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.tfe_gsp_limitieren);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.tfe_gsp_limitieren;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.tfe_gsp_limitieren), "tfe_gsp_limitieren");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# TFE-GESPRAECHSZEITLIMIT\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.tfe_gsp_zeit\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.tfe_gsp_zeit);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.tfe_gsp_zeit;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.tfe_gsp_zeit), "tfe_gsp_zeit");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# MASTEREINSTELLUNG fuer interne ISDN-Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.master_isdn\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %04X\n", L7_Einr_Block.master_isdn);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.master_isdn;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.master_isdn), "master_isdn");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# TFE-RUFVERKUERZUNG\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.tfe_int_diffzeit\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.tfe_int_diffzeit);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.tfe_int_diffzeit;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.tfe_int_diffzeit), "tfe_int_diffzeit");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# DISPLAY-MESSAGE-MIT-NAMEN\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.isdn_mit_namen\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.isdn_mit_namen);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.isdn_mit_namen;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.isdn_mit_namen), "isdn_mit_namen");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# TFE-KAMERASTEUERUNG\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.TsForCamera\n", CfgFilePtr);
  sprintf (HilfsString,"WERT : %02X\n", L7_Einr_Block.TsForCamera);
  fputs (HilfsString, CfgFilePtr);
  y = (void *)&L7_Einr_Block.TsForCamera;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.TsForCamera), "TsForCamera");


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# RESERVEBYTES\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Einr_Block.Reserve\n", CfgFilePtr);
  for ( Reserve = 0; Reserve < sizeof (L7_Einr_Block.Reserve); Reserve++ )
  {
	sprintf (HilfsString,"%2d.RESERVE : %02X\n", Reserve+1, L7_Einr_Block.Reserve[Reserve]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Einr_Block.Reserve;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Einr_Block.Reserve), "Reserve");
	  
  fclose (StructFilePtr);
  fclose (CfgFilePtr);
  return (0);
}


/*****************************************************************************/
/* Funktion zum Schreiben eines Files, das den L7_Msn_Block darstellt        */
/* ----------------------------------------------------------------------    */
/* Autor: Thomas Marquardt                                                   */
/* letzte Aenderung : Steffen Hildebrandt, 11.11.2002                        */
/*****************************************************************************/
int MakeMsnFile( MSN_BLOCK L7_Msn_Block )
{
  FILE * CfgFilePtr;
  FILE * StructFilePtr;
  char   HilfsString[512];
  int pos, index, ExtS0;
  unsigned char *x;
  unsigned char *y;


  Ctr = 0;

  strcpy (HilfsString, "config_data/daten.msn");
  if ( (CfgFilePtr=fopen(HilfsString, "w") ) == NULL )
  {
    printf ("FEHLER : Verzeichnis < config_data > ist nicht vorhanden! Bitte manuell anlegen!\n\n");
	  exit (0);
  }
  printf ("\nSchreibe File: %s\n", HilfsString);


  strcpy (HilfsString, "config_data/struct.msn");
  if ( (StructFilePtr=fopen(HilfsString, "w") ) == NULL )
  {
    printf ("FEHLER : Verzeichnis < config_data > ist nicht vorhanden! Bitte manuell anlegen!\n\n");
	  exit (0);
  }
  fputs (LINIE, StructFilePtr);
  fputs ("# File fuer Datenblock L7_Msn_Block / Befehl: MSNK\n", StructFilePtr);
  fputs (LINIE, StructFilePtr);
  printf ("Schreibe File: %s\n", HilfsString);

  #ifdef MARQ
  i = 0;
  while ( i < sizeof (L7_Msn_Block) )
  {
	sprintf (HilfsString,"%4d  %02X\n", i++, *x++);
	fputs (HilfsString, StructFilePtr);
  }
  #endif
  
  x = (void *)&L7_Msn_Block;


  fputs (LINIE, CfgFilePtr);
  fputs ("# Dieses File wurde beim Auslesen einer GESKO ISDN-Anlage erzeugt\n", CfgFilePtr);
  fputs (LINIE, CfgFilePtr);


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# MSN's fuer alle externen S0-Schnittstellen im Mehrgeraeteanschluss\n", CfgFilePtr);
  fputs ("# Definition fuer L7_Msn_Block.msn\n", CfgFilePtr);
  for ( ExtS0 = 0; ExtS0 < ANZ_EXT_S0_PORT; ExtS0++ ) 
  {
	for ( index = 0; index < MSN_MAX_ANZ; index++ )
	{
	  sprintf (HilfsString,"%d.EXTS0  %2d.INDEX :  %s\n", ExtS0+1, index+1, L7_Msn_Block.msn[ExtS0][index]);
	  fputs (HilfsString, CfgFilePtr);
	}
  }
  y = (void *)&L7_Msn_Block.msn;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Msn_Block.msn), "msn" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# DDI's fuer alle externen S0-Schnittstellen im Anlagenanschluss\n", CfgFilePtr);
  fputs ("# Definition fuer L7_Msn_Block.msn\n", CfgFilePtr);
  for ( ExtS0 = 0; ExtS0 < ANZ_EXT_S0_PORT; ExtS0++ ) 
  {
	for ( index = 0; index < DDI_MAX_ANZ; index++ )
	{
	  sprintf (HilfsString,"%d.EXTS0  %2d.INDEX :  %s\n", ExtS0+1, index+1, L7_Msn_Block.ddi[ExtS0][index]);
	  fputs (HilfsString, CfgFilePtr);
	}
  }
  y = (void *)&L7_Msn_Block.ddi;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Msn_Block.ddi), "ddi" );

  fclose (CfgFilePtr);
  return (0);
}



/*****************************************************************************/
/* Funktion zum Schreiben eines Files, das den L7_Einr_Block darstellt       */
/* ----------------------------------------------------------------------    */
/* Autor: Thomas Marquardt                                                   */
/* letzte Aenderung : Steffen Hildebrandt, 11.11.2002                        */
/*****************************************************************************/
int MakeTlnFile( TLN_BLOCK L7_Tln_Block )
{
  FILE * CfgFilePtr;
  FILE * StructFilePtr;
  char   HilfsString[512];
  int pos, IntPort, Reserve;
  unsigned char *x;
  unsigned char *y;


  Ctr = 0;

  strcpy (HilfsString, "config_data/daten.tln");
  if ( (CfgFilePtr=fopen(HilfsString, "w") ) == NULL )
  {
    printf ("FEHLER : Verzeichnis < config_data > ist nicht vorhanden! Bitte manuell anlegen!\n\n");
    exit (0);
  }
  printf ("\nSchreibe File: %s\n", HilfsString);

  strcpy (HilfsString, "config_data/struct.tln");
  if ( (StructFilePtr=fopen(HilfsString, "w") ) == NULL )
  {
    printf ("FEHLER : Verzeichnis < config_data > ist nicht vorhanden! Bitte manuell anlegen!\n\n");
    exit (0);
  }
  fputs (LINIE, StructFilePtr);
  fputs ("# File fuer Datenblock L7_Tln_Block / Befehl: TLND\n", StructFilePtr);
  fputs (LINIE, StructFilePtr);
  printf ("Schreibe File: %s\n", HilfsString);

  #ifdef MARQ
  i = 0;
  while ( i < sizeof (L7_Tln_Block) )
  {
	sprintf (HilfsString,"%4d  %02X\n", i++, *x++);
	fputs (HilfsString, StructFilePtr);
  }
  #endif
  
  x = (void *)&L7_Tln_Block;

  fputs (LINIE, CfgFilePtr);
  fputs ("# Dieses File wurde beim Auslesen einer GESKO ISDN-Anlage erzeugt\n", CfgFilePtr);
  fputs (LINIE, CfgFilePtr);


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# ANRUFSCHUTZ fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Tln_Block.anrufschutz\n", CfgFilePtr);
  fputs ("# Die Zaehlung beginnt bei Port 3\n", CfgFilePtr);
  fputs ("# K_L7_OFF   Anrufschutz AUS\n", CfgFilePtr);
  fputs ("# K_ARSI     Anrufschutz INTERN\n", CfgFilePtr);
  fputs ("# K_ARSE     Anrufschutz EXTERN\n", CfgFilePtr);
  fputs ("# K_ARSB     Anrufschutz BEIDE\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Tln_Block.anrufschutz[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Tln_Block.anrufschutz;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Tln_Block.anrufschutz), "anrufschutz" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# ANKLOPFSCHUTZ fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Tln_Block.anklopfschutz\n", CfgFilePtr);
  fputs ("# Die Zaehlung beginnt bei Port 3\n", CfgFilePtr);
  fputs ("# K_L7_OFF   Anklopfschutz AUS\n", CfgFilePtr);
  fputs ("# K_AKSI     Anklopfschutz INTERN\n", CfgFilePtr);
  fputs ("# K_AKSE     Anklopfschutz EXTERN\n", CfgFilePtr);
  fputs ("# K_AKSB     Anklopfschutz BEIDE\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Tln_Block.anklopfschutz[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Tln_Block.anklopfschutz;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Tln_Block.anklopfschutz), "anklopfschutz" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# RUFUMLEITUNG fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Tln_Block.rufumleitung\n", CfgFilePtr);
  fputs ("# Die Zaehlung beginnt bei Port 3\n", CfgFilePtr);
  fputs ("# K_L7_OFF    keine Rufumleitung\n", CfgFilePtr);
  fputs ("# andere Werte zeigen auf einen Teilnehmer\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Tln_Block.rufumleitung[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Tln_Block.rufumleitung;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Tln_Block.rufumleitung), "rufumleitung" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# FOLLOW-ME fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Tln_Block.follow_me\n", CfgFilePtr);
  fputs ("# Die Zaehlung beginnt bei Port 3\n", CfgFilePtr);
  fputs ("# K_L7_OFF    AUS\n", CfgFilePtr);
  fputs ("# K_L7_ON     EIN\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Tln_Block.follow_me[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Tln_Block.follow_me;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Tln_Block.follow_me), "follow_me" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# HOTLINE/BABYRUF fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Tln_Block.hotline\n", CfgFilePtr);
  fputs ("# Die Zaehlung beginnt bei Port 3\n", CfgFilePtr);
  fputs ("# K_L7_OFF     AUS\n", CfgFilePtr);
  fputs ("# K_L7_ON      EIN\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Tln_Block.hotline[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Tln_Block.hotline;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Tln_Block.hotline), "hotline" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# CLIP fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Tln_Block.CLIP_aktiv\n", CfgFilePtr);
  fputs ("# Die Zaehlung beginnt bei Port 3\n", CfgFilePtr);
  fputs ("# K_L7_OFF    AUS\n", CfgFilePtr);
  fputs ("# K_L7_ON     EIN\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Tln_Block.CLIP_aktiv[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Tln_Block.CLIP_aktiv;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Tln_Block.CLIP_aktiv), "CLIP_aktiv" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# COLP fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Tln_Block.COLP_aktiv\n", CfgFilePtr);
  fputs ("# Die Zaehlung beginnt bei Port 3\n", CfgFilePtr);
  fputs ("# K_L7_OFF    AUS\n", CfgFilePtr);
  fputs ("# K_L7_ON     EIN\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Tln_Block.COLP_aktiv[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Tln_Block.COLP_aktiv;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Tln_Block.COLP_aktiv), "COLP_aktiv" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# WECKZEIT fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Tln_Block.weckzeit\n", CfgFilePtr);
  fputs ("# Die Zaehlung beginnt bei Port 3\n", CfgFilePtr);
  fputs ("# K_L7_OFF    AUS\n", CfgFilePtr);
  fputs ("# K_L7_ON     EIN\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : MODE=%02X  STD=%02X  MIN=%02X\n", IntPort+1, 
			 L7_Tln_Block.weckzeit[IntPort].mode,
			 L7_Tln_Block.weckzeit[IntPort].stunde,
			 L7_Tln_Block.weckzeit[IntPort].minute);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Tln_Block.weckzeit;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Tln_Block.weckzeit), "weckzeit" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# RUFUMLEITUNGSZIEL-EXTERN fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Tln_Block.rul_nr\n", CfgFilePtr);
  fputs ("# Die Zaehlung beginnt bei Port 3\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %s\n", IntPort+1, (char *)L7_Tln_Block.rul_nr[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Tln_Block.rul_nr;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Tln_Block.rul_nr), "rul_nr" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# RUFUMLEITUNGSART fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Tln_Block.rul_art\n", CfgFilePtr);
  fputs ("# Die Zaehlung beginnt bei Port 3\n", CfgFilePtr);
  fputs ("# CF_CLR	Rufumleitung AUS\n", CfgFilePtr);
  fputs ("# CFU     STAENDIG\n", CfgFilePtr);
  fputs ("# CFNR    BEI NICHTMELDEN\n", CfgFilePtr);
  fputs ("# CFB	    BEI BESETZT\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Tln_Block.rul_art[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Tln_Block.rul_art;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Tln_Block.rul_art), "rul_art" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# WECKTAGE fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Tln_Block.weck_tage\n", CfgFilePtr);
  fputs ("# Die Zaehlung beginnt bei Port 3\n", CfgFilePtr);
  fputs ("# Jedes Bit repraesentiert einen Wochentag\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %02X\n", IntPort+1, L7_Tln_Block.weck_tage[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Tln_Block.weck_tage;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Tln_Block.weck_tage), "weck_tage" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# ZEILNEHMERNAME fuer alle internen Ports\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Tln_Block.tln_name\n", CfgFilePtr);
  fputs ("# Die Zaehlung beginnt bei Port 3\n", CfgFilePtr);
  for ( IntPort = 0; IntPort < MAX_ANZ_INT_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %s\n", IntPort+1, L7_Tln_Block.tln_name[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Tln_Block.tln_name;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Tln_Block.tln_name), "tln_name" );


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# RESERVEBYTES\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_Tln_Block.Reserve\n", CfgFilePtr);
  for ( Reserve = 0; Reserve < sizeof (L7_Tln_Block.Reserve); Reserve++ )
  {
	sprintf (HilfsString,"%3d.RESERVE : %02X\n", Reserve+1, L7_Tln_Block.Reserve[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_Tln_Block.Reserve;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_Tln_Block.Reserve), "Reserve");
	  
  fclose (StructFilePtr);
  fclose (CfgFilePtr);
  return (0);
}

/*****************************************************************************/
/* Funktion zum Schreiben eines Files, das die L7_IntPortTab darstellt       */
/* ----------------------------------------------------------------------    */
/* Autor: Thomas Marquardt                                                   */
/* letzte Aenderung : Steffen Hildebrandt, 11.11.2002                        */
/*****************************************************************************/
int MakeTabFile( INT_PORT_TAB L7_IntPortTab )
{
  FILE * CfgFilePtr;
  FILE * StructFilePtr;
  char   HilfsString[512];
  int pos, IntPort;
  unsigned char *x;
  unsigned char *y;


  Ctr = 0;
  strcpy (HilfsString, "config_data/daten.tab");
  if ( (CfgFilePtr=fopen(HilfsString, "w") ) == NULL )
  {
    printf ("FEHLER : Verzeichnis < config_data > ist nicht vorhanden! Bitte manuell anlegen!\n\n");
    exit (0);
  }
  printf ("\nSchreibe File: %s\n", HilfsString);

  strcpy (HilfsString, "config_data/struct.tab");
  if ( (StructFilePtr=fopen(HilfsString, "w") ) == NULL )
  {
    printf ("FEHLER : Verzeichnis < config_data > ist nicht vorhanden! Bitte manuell anlegen!\n\n");
    exit (0);
  }
  fputs (LINIE, StructFilePtr);
  fputs ("# File fuer Datenblock L7_IntPortTab / Befehl: IDAT\n", StructFilePtr);
  fputs (LINIE, StructFilePtr);
  printf ("Schreibe File: %s\n", HilfsString);

  x = (void *)&L7_IntPortTab;

  fputs (LINIE, CfgFilePtr);
  fputs ("# Dieses File wurde beim Auslesen einer GESKO ISDN-Anlage erzeugt\n", CfgFilePtr);
  fputs (LINIE, CfgFilePtr);


  fputs (ABSATZ, CfgFilePtr);
  fputs (LINIE, CfgFilePtr);
  fputs ("# INTERNE RUFNUMMER\n", CfgFilePtr);
  fputs ("# Definitionen fuer L7_IntPortTab\n", CfgFilePtr);
  fputs ("# Die Zaehlung beginnt bei Port 3\n", CfgFilePtr);
  for ( IntPort = 3; IntPort < MAX_ANZ_PORT; IntPort++ )
  {
	sprintf (HilfsString,"%2d.INTPORT : %s\n", IntPort-3+1, L7_IntPortTab.rufnr[IntPort]);
	fputs (HilfsString, CfgFilePtr);
  }
  y = (void *)&L7_IntPortTab.rufnr;
  pos = y - x;
  PrintSize (StructFilePtr, pos,  sizeof (L7_IntPortTab.rufnr), "rufnr" );

  fclose (StructFilePtr);
  fclose (CfgFilePtr);
  return (0);
}















