#!/usr/bin/perl
#
# Funkruf-Client fuer die DP-BOX und die BCM
# Und die Shell! (Hallo Marc-Andre!)
# (Start:  rpp <call> )
#
# Script by DG1KWA / Andreas 24.4.2000
# V0.05 vom 3.5.2000
#
# Modifizierungen von DH6BB / Jens  08.09.2000
# V0.07f vom 05.11.2000
# Es gilt die ALAS !
# Letzte Aenderung am: 05.11.2000
#

require 5.002;

#####################################################################
# Definitionen der Verzeichnisse fuer die weitere Verwendung        #
#####################################################################
$CONFIGFILE = "/var/lib/funkruf/config.rpp";
&config();
$VERSION   = "0.07g";                                 # Versionsnummer


#####################################################################
# Programm-Beginn                                                   #
#####################################################################

&read_spool_dirs();                 # Anzahl und Name der SPOOL-Dirs ermitteln

$call  = $ENV{"CALLSIGN"};          # User-Call ermitteln
$sysop = $ENV{"DPBOXSYSOP"};        # Ist der User Sysop ? 0 = no 1 = ja
if ($call eq "") {$call=uc ($ARGV[0]);}   # Fuer Commandozeilenstart

$Aktivierung=0;
&send_ctext ();                     # Connect-Text senden

#####################################################################
# Hauptmenue                                                        #
#####################################################################

while (1) {                                     # Beginn der Hauptschleife
   $taddr=0;
   &prompt();                                   # Prompt ausgeben
   $eingabe = <STDIN>;                          # wurde etwas eingegeben ?
   chop ($eingabe);                             # RETURN abschneiden

  open (LOG ,">>$LOGFILE");
  &Zeit();
  printf (LOG "\n%02d:%02d %02d/%02d/%02d:",$Hour,$Minute,$Day,$Month,$Year);
  if ($sysop==1){ printf (LOG "*");}            #Sysop im Log kennzeichnen
  printf (LOG "$call command: $eingabe");
  close (LOG);

   $eingabe=&umconvert($eingabe);               # Umlautkonvertierung   
   @line = split (/ /,$eingabe);                # Eingabe beim SPACE aufspalten

   if    ($line[0] =~ /\b(q|qu|qui|quit)\b/i)
          { send_exit (0) } # QUIT

   elsif ($line[0] =~ /\b(h|he|hel|help)\b/i)
          { &send_help() }  # HILFE

   elsif ($line[0] =~ /\b(i|in|inf|info)\b/i)
          { &send_info() }  # INFO-Text

   elsif ($line[0] =~ /\b(p|pa|pag|page)\b/i)
          { &page() }       # Funkruf senden

   elsif ($line[0] =~ /\b(u|us|use|user)\b/i)
          { &findUser () }  # User finden

   elsif ($line[0] =~ /\b(g|gr|gru|grup|grupp|gruppe)\b/i)
          { &gruppen_ruf() } # Gruppen-Ruf Senden

   elsif ($line[0] =~ /\b(l|li|lis|list)\b/i)
          { &read_gruppen_dirs() } # Gruppen-Ruf Rubriken auflisten

   elsif ($line[0] =~ /\b(r|ru|rub|rubr|rubri|rubrik)\b/i)
          { if ($sysop == 1) { &write_rubrik ()} } # Rubrik beschreiben (Sysop)

   elsif ($line[0] eq "+")
          { if ($sysop == 1) { &addUser ()} }      # User in Database eintragen (Sysop)

   elsif ($line[0] eq "-")
          { if ($sysop == 1) {&delUser ()} }      # User aus Database austragen (Sysop)

   elsif (uc($line[0]) eq "DATABASE") { &show_database() } # Database ausgeben

   elsif (uc($line[0]) eq "+GRP") { if ($sysop == 1) { &addGruppe() } }   # Gruppe hinzufuegen (Sysop)
   elsif (uc($line[0]) eq "-GRP") { if ($sysop == 1) { &delGruppe() } }  # Gruppe loeschen (Sysop)
   elsif (uc($line[0]) eq "+USRGRP") { if ($sysop == 1) { &addUserGruppe() } }# User zur Gruppe hinzuf|gen (Sysop)
   elsif (uc($line[0]) eq "-USRGRP") { if ($sysop == 1) { &delUserGruppe() } }# User aus Gruppe loeschen (Sysop)
   elsif (uc($line[0]) eq "ACT") { if ($sysop == 1) { &actSkyp() } } # Funkrufempfaenger aktivieren
   else { printf("\nUngueltiger Befehl! Moegliche Befehle: Help Info Page Gruppe User Quit"); }
}

#####################################################################
# Configuration und Verzeichnisse einlesen                          #
#####################################################################

sub config()
{
  open (config ,"$CONFIGFILE");
  while(defined ( $input = <config> ))
  {
    chop($input);
    @eingang = split (/=/,$input);
    if(uc($eingang[0]) eq "SERVERCALL")  {$SERVERCALL=$eingang[1];};
    if(uc($eingang[0]) eq "MAILBOXCALL") {$Mailbox   =$eingang[1];};
    if(uc($eingang[0]) eq "STANDORT")    {$STANDORT  =$eingang[1];};
    if(uc($eingang[0]) eq "CTEXT")       {$CTEXTFILE =$eingang[1];};
    if(uc($eingang[0]) eq "HELPFILE")    {$HELPFILE  =$eingang[1];};
    if(uc($eingang[0]) eq "INFOFILE")    {$INFOFILE  =$eingang[1];};
    if(uc($eingang[0]) eq "LIBDIR")      {$LIBDIR    =$eingang[1];};    
    if(uc($eingang[0]) eq "LOGFILE")     {$LOGFILE   =$eingang[1];};    
    if(uc($eingang[0]) eq "DATABASE")    {$DATABASE  =$eingang[1];};    
    if(uc($eingang[0]) eq "TEMPDATABASE"){$DATABASET =$eingang[1];};    
    if(uc($eingang[0]) eq "CHANGEDIR")   {$CHANGEDIR =$eingang[1];};    
    if(uc($eingang[0]) eq "SPOOLDIRS")   {$SPOOLDIRS =$eingang[1];};    
    if(uc($eingang[0]) eq "GROUPDIR")    {$GROUPDIRS =$eingang[1];};    
    if(uc($eingang[0]) eq "LOCATOR")     {$LOCATOR   =$eingang[1];};    
    if(uc($eingang[0]) eq "CHANGEFILE")  {$CHANGEDAT =$eingang[1];};        
    if(uc($eingang[0]) eq "GROUPTEMP")   {$GROUPTEMP =$eingang[1];};        
  }
  @eingang = split (/-/,$SERVERCALL);  
  $OWNCALL=$eingang[0];
  close (config);
}


#####################################################################
# Neue Gruppe fuer Gruppenruf hinzufuegen                           #
#####################################################################

sub addGruppe()
{

   $tgruppe = shift(@line);     # Befehl selber verwerfen
   $tgruppe = uc(shift(@line)); # Gruppe lesen

   if (length ($tgruppe) == 0) {
    print ("\nFehler: Sie haben keine Gruppe eingegeben!");
    return;
   }

   $vorhanden=open (GRUPPE, "$GROUPDIRS/$tgruppe");
   close (GRUPPE);
   if ($vorhanden==0)                # Gruppe bereits vorhanden?
   {
     open (GRUPPE, '>>' ."$GROUPDIRS/$tgruppe");
     close (GRUPPE);
     printf("\nGruppe %s wurde angelegt. Bitte jetzt User eintragen", $tgruppe);
   }
   else
   {
       printf("\nGruppe %s schon vorhanden oder kann nicht angelegt werden!",$tgruppe);
   }
}


#####################################################################
# Gruppe fuer Gruppenruf loeschen
#####################################################################

sub delGruppe()
{
   $tgruppe = shift(@line);     # Befehl selber verwerfen
   $tgruppe = uc(shift(@line)); # Gruppe lesen

   if (length ($tgruppe) == 0) {
    print ("\nFehler: Sie haben keine Gruppe eingegeben!");
    return;
   }

   $vorhanden=open (GRUPPE, "$GROUPDIRS/$tgruppe");
   close (GRUPPE);
   if ($vorhanden==0)
   {
    print ("\nFehler: Sie haben keine gueltige Gruppe gewaehlt!");
    return;
   }
   $users=0;
   open (IN, "$GROUPDIRS/$tgruppe");
   @lines = sort(<IN>);
   foreach $line (@lines) {
        # Gruppe leer?
     chop ($line);
     $users++;
    }

   close (IN);
   if ($users>0)
   {
      printf("\nGruppe nicht leer! Bitte vorher die User der Gruppe loeschen!");
   }
   else
   {
      system ("rm $GROUPDIRS/$tgruppe");
      printf ("\nGruppe %s wurde entfernt.", $tgruppe);
   }
}


#####################################################################
# User aus Gruppe loeschen
#####################################################################

sub delUserGruppe()
{
   $tgruppe = shift(@line);     # Befehl selber verwerfen
   $tgruppe = uc(shift(@line)); # Gruppe lesen
   $tcall   = uc(shift(@line)); # Call lesen

   if (length ($tcall) == 0) {
    print ("\nFehler: Sie haben kein Call eingegeben!");
    return;
   }

   if (length ($tgruppe) == 0) {
    print ("\nFehler: Sie haben keine Gruppe eingegeben!");
    return;
   }

   $vorhanden=open (GRUPPE, "$GROUPDIRS/$tgruppe");
   close (GRUPPE);
   if ($vorhanden==0)
   {
    print ("\nFehler: Sie haben keine gueltige Gruppe gewaehlt!");
    return;
   }

   open (IN, "$GROUPDIRS/$tgruppe");
   open (OUT, '>'."$GROUPTEMP");
   @lines = sort(<IN>);
   foreach $line (@lines) {
     chop ($line);
     if ($line eq $tcall) {
        print ("\nCall: $tcall wurde ausgetragen!");
     }
     else {
        printf (OUT "$line\n");
     }
   }
   close (IN);
   close (OUT);
   system ("mv $GROUPTEMP $GROUPDIRS/$tgruppe");
}


#####################################################################
# User in der Gruppe eintragen
#####################################################################

sub addUserGruppe()
{
   $tgruppe = shift(@line);     # Befehl selber verwerfen
   $tgruppe = uc(shift(@line)); # Gruppe lesen
   $tcall   = uc(shift(@line)); # Call lesen

   if (length ($tgruppe) == 0) {
    print ("\nFehler: Sie haben keine Gruppe eingegeben!");
    return;
   }

   if (length ($tcall) == 0) {
    print ("\nFehler: Sie haben kein Call eingegeben!");
    return;
   }

   $vorhanden=open (GRUPPE, "$GROUPDIRS/$tgruppe");
   close (GRUPPE);
   if ($vorhanden==0)
   {
    print ("\nFehler: Sie haben keine gueltige Gruppe gewaehlt!");
    return;
   }

   open (gruppen, '>>' ."$GROUPDIRS/$tgruppe");
   printf (gruppen "$tcall\n");
   close (gruppen);
   printf ("\n$tcall wurde in die Gruppe $tgruppe eingetragen!");
}


#####################################################################
# Moegliche Gruppen ausgeben                                        #
#####################################################################

sub read_gruppen_dirs()
{
 if (length($line[1]) >= 1)             # Eingetragene User ausgeben
 {
  $tgruppe = shift(@line);     # Befehl selber verwerfen
  $tgruppe = uc(shift(@line)); # Gruppe lesen
  $vorhanden=open (GRUPPE, "$GROUPDIRS/$tgruppe");

  if ($vorhanden == 1)
  {	  
   printf ("\nFolgende User sind in der Gruppe $tgruppe eingetragen:\n");
   print (<GRUPPE>);
   close (GRUPPE);
  }
  else
  {
   printf ("\nGruppe $tgruppe nicht vorhanden!");
  }
 }
 
 else
 {
 opendir (GROUPYS,"$GROUPDIRS");        # Nur Gruppennamen ausgeben
 $anz=-2;   # Eintaege .  und ..  muessen weg
 while (defined($file = readdir (GROUPYS)))
 {
   $anz++;
   if ($anz>0)
   {
     print($file);
     printf("\n");
   }
 }
 printf("\nAnzahl der Gruppen: %d", $anz);
 closedir (GROUPYS);
 }
}




#####################################################################
# Gruppen-Ruf senden
#####################################################################

sub gruppen_ruf ()
{
  $tgruppe = shift(@line);     # Befehl selber verwerfen
  $tgruppe = uc(shift(@line)); # Gruppe lesen
  if ((@line)=="")
  {
   printf("\nSie haben keinen Text eingegeben! Bsp: G WPRG Treffen nicht vergessen");
   return;
  }

  $vorhanden=open (GRUPPE, "$GROUPDIRS/$tgruppe");

  if ($vorhanden == 1)
  {
      printf("\nGruppenruf an die Gruppe $tgruppe");
      printf("\nFolgende User werden benachrichtigt:");
       while (defined ($tcall = <GRUPPE>))
      {
        chop ($tcall);
        &page_database();
      }
  }
  else
  {
      printf("\nGruppe nicht vorhanden!  Liste mit <grpdir>");
  }
  close (GRUPPE);
}



#####################################################################
# Page-Befehl ausfuehren
#####################################################################

sub page ()
{
  $tcall = shift(@line);     # Befehl selber verwerfen
  $tcall = uc(shift(@line)); # Call lesen
  if ((@line)=="")
  {
   printf("\nSie haben keinen Text eingegeben! Bsp: P DG9BHD Komm mal auf RW");
   return;
  }

  if (abs($tcall) >= 1) { &page_num () }
  else { &page_database () }
}


#####################################################################
# Funkruf senden
#####################################################################

sub page_num ()
{

  if ($sysop == 0) {  # Ist er Sysop ?
    printf ("\nDiese Funktion ist nur fuer Sysops zulaessig!!");
    return;           # Nein, dann darf er nicht ;(
  }

  foreach $SUBDIR (@SLAVES) {
      &neu_datei();

      if ($Versuche < 100)
      {
           open (FUNKRUF, ">".$FNAME);
                printf (FUNKRUF "$tcall\n$call:");
                foreach $i (@line) {
                  printf (FUNKRUF "$i ");
        }
     close (FUNKRUF);
     }


 else
 {
    printf("\nFunkruf konnte nicht richtig gesendet werden! ");
    printf("Bitte Sysop informieren! tnx.");
 }

}

 printf ("\nDer Funkruf an $tcall wird ausgesendet!");
}


#####################################################################
# Funkruf senden (Empfaenger aus DATABASE ermitteln)
#####################################################################

sub page_database ()
{

  if (length ($tcall) == 0) {
    print ("\nFehler: Sie haben kein Call eingegeben!");
    return;
  }

  &Zeit();

  open (DATAB, "$DATABASE");
  while (defined ($input = <DATAB>)) {
    chop ($input);
    @a = split (/ /,$input);
    $dbcall = $a[0];
    $dbaddr = $a[1];
    if ($tcall eq $dbcall) {
      print ("\nDer Funkruf an $dbcall ($dbaddr) wird gesendet");
      srand ();
      open (LOG ,">>$LOGFILE");
      printf (LOG "\n%02d:%02d %02d/%02d/%02d:",$Hour,$Minute,$Day,$Month,$Year);
      printf (LOG "$call to $dbcall($dbaddr) ");
      foreach $i (@line) {
        printf (LOG "$i ");
      }
      close (LOG);

      foreach $SUBDIR (@SLAVES) {
      &neu_datei();


       if ($Versuche <100)
       {
        open (FUNKRUF, ">".$FNAME);
        printf (FUNKRUF "$dbaddr\n$call:");
        foreach $i (@line) {
         printf (FUNKRUF "$i ");
         }
         close (FUNKRUF);
        }

        else
        {
            printf("\nFunkruf konnte nicht richtig gesendet werden! ");
            printf("Bitte Sysop informieren! tnx.");
        }

      }
      close (DATAB);
      return;
    }
  }
  close (DATAB);
  print ("\nFehler: User steht nicht in der Database!");
}


#####################################################################
# Quit-Text senden
#####################################################################

sub send_exit ()
{
  print ("\n Sie werden wieder mit der Box verbunden!");
  print ("\n Tschuess .... \n");

# Erstmal ausloggen ins Log schreiben
  open (LOG ,">>$LOGFILE");
  &Zeit();
  printf (LOG "\n%02d:%02d %02d/%02d/%02d:",$Hour,$Minute,$Day,$Month,$Year);
  printf (LOG "$call Logout from $OWNCALL RPP-Server");
  close (LOG);
  exit (0);
}


#####################################################################
# Ctext senden
#####################################################################

sub send_ctext ()
{
  # Erstmal einloggen ins Log schreiben
  open (LOG ,">>$LOGFILE");
  &Zeit();
  printf (LOG "\n%02d:%02d %02d/%02d/%02d:",$Hour,$Minute,$Day,$Month,$Year);
  printf (LOG "$call Login to $OWNCALL RPP-Server");
  close (LOG);

  printf("\nRPP Funkrufserver $OWNCALL in $STANDORT - $LOCATOR   Version $VERSION\n");
  open (CTEXT, "$CTEXTFILE");
  print (<CTEXT>);
  close (CTEXT);
}


#####################################################################
# Info senden
#####################################################################

sub send_info ()
{
  open (INFO, "$INFOFILE");
  print (<INFO>);
  close (INFO);
}

#####################################################################
# Ausgabe des Prompt
#####################################################################

sub prompt ()
{
 if ($sysop==1)
 {
    print ("\n\n$call* de $SERVERCALL >");
  # Ein `*` als Sysop
 }
 else
 {
     print ("\n\n$call de $SERVERCALL >");
  # Normaler User
 }
}


#####################################################################
# Hilfe senden
#####################################################################

sub send_help ()
{
  open (HELP, "$HELPFILE");
  print (<HELP>);
  close (HELP);
}

#####################################################################
# Eine Rubrik beschreiben
#####################################################################

sub write_rubrik ()
{

  print ("\nIn welche Rubrik (Nummer) moechten Sie schreiben: ");
  $rubrik = <STDIN>;
  chop ($rubrik);
  print ("\nIn welchen Slot (Nummer) moechten Sie schreiben: ");
  $slot = <STDIN>;
  chop ($slot);
  print ("\nNun bitte den Text (max. 80 Zeichen): ");
  $text = <STDIN>;
  chop ($text);
  $text=&umconvert($text);                # Umlautkonvertierung
  print ("\nBitte ueberpruefen Sie die Angaben:\n");
  print ("Rubrik:$rubrik Slot:$slot Text:\n$text\n\n");
  print ("Wollen Sie dieses senden lassen <j/n>:");
  $frage = <STDIN>;
  chop ($frage);
  if ($frage eq 'j') {
    &enqueue_skyper();
    print ("\nText wird ausgesendet!");
  }
  else {
    print ("\nFunktion abgebrochen");
  }
}


#####################################################################
# Daten fuer Skyper-Rubriken aufbereiten
#####################################################################

sub enqueue_skyper()
{
  $rubrik += 0x1f;
  $slot   += 0x20;
  srand ();
  foreach $SUBDIR (@SLAVES) {

   &neu_datei();
   if ($Versuche <100)
   {
   open (funkruf, ">".$FNAME);   # Spool-Datei erstellen
   printf (funkruf "4520.3\r");  # Empfangsadresse setzen
   $a = chr($rubrik);            # ASCII-Zeichen erzeugen
   printf (funkruf "$a");        # und ausgeben in Datei
   $a = chr($slot);
   printf (funkruf "$a");
   while ($text =~ /[ -z]/g) {   # Text Zeichen fuer Zeichen durchgehen
    $a = chr(ord($&)+1);         # ASCII-Code +1
    printf (funkruf "$a");       # und in Datei schreiben
   }
   close (funkruf);              # fertig, Datei schliessen
  }
 else
 {
    printf("\nFunkruf konnte nicht richtig gesendet werden! ");
    printf("Bitte Sysop informieren! tnx.");
 }
 }
}


#####################################################################
# Einen User-Eintrag finden
#####################################################################

sub findUser()
{
   if (length($line[1]) >= 1)
   {
     printf ("\nFolgende Eintraege wurden gefunden:\n");
     if ($line[2] eq '+') {$moreinfo=1;}
     else {$moreinfo=0;}
     if ($line[1] eq '*' | $line[1] eq '+' |$line[1] eq '?') {$search='';}
      else { $search = uc($line[1]);
 }

     open (database , $DATABASE);
     $i = 0;
     while (defined ($line = <database>))
     {
       chop ($line);
       if ($line =~ m/$search/)
       {
        @a = split (/ /,$line);
        @b = split (/-/,@a[0]);

        if ($moreinfo==0)
        {
            printf ("%-6s",@b[0]);
            if (defined(@b[1])) { printf ("-%-2s",@b[1]) }
            else { printf ("   ") }
            $i++;
            if ($i >= 8) {
               printf ("\n");
               $i = 0;
             }
                else {}

         }
        else
        {

            printf ("%-6s",@b[0]);
            if (defined(@b[1])) { printf ("-%-2s" ,@b[1]) }
            else { printf ("  "); }
           printf ("\t%s  \t      ",@a[1]);
            $i++;
            if ($i >= 2) {
               printf ("\n");
               $i = 0;
             }
                else {}
        }
       }
     }
     close (database);
   }
   else { listallUser () }
}


#####################################################################
# Ausgabe der kompletten User-Liste
#####################################################################

sub listallUser()
{
   printf ("\nFolgende User sind bei $OWNCALL bekannt:\n");
   $Anzahl = 0;
   open (database , $DATABASE);
   $i = 0;
   while (defined ($line = <database>)) {
    chop ($line);

    $Anzahl=$Anzahl+1;

    @a = split (/ /,$line);
    @b = split (/-/,@a[0]);
    printf ("%-6s",@b[0]);
    if (defined(@b[1])) { printf ("-%-2s",@b[1]) }
    else { printf ("   ") }
    $i++;
    if ($i >= 8) {
       printf ("\n");
       $i = 0;
       }
    }
   printf ("\n\nBei $OWNCALL sind derzeit %d User eingetragen", $Anzahl);
   close (database);
}


#####################################################################
# Database ausgeben
#####################################################################

sub show_database
{
     open (database , $DATABASE);
     while (defined ($line = <database>))
     {
       chop ($line);
       printf ("$line\n");
     }
     close (database);
     return;
}


#####################################################################
# User in den Database loeschen
#####################################################################

sub delUser()
{
   $tcall = shift(@line);     # Befehl selber verwerfen
   $tcall = uc(shift(@line)); # Call lesen
   $taddr = shift(@line);     # Adresse lesen

   if (length ($tcall) == 0) {
    print ("\nFehler: Sie haben kein Call eingegeben!");
    return;
   }

   if (length ($taddr) == 0) {
    print ("\nFehler: Sie haben keine Adresse eingegeben!");
    return;
   }

   open (IN, $DATABASE);
   open (OUT, '>'.$DATABASET);
   @lines = sort(<IN>);
   $ausgetragen=0;
   foreach $line (@lines) {
     chop ($line);
     @a = split (/ /,$line);           # Geht so auch mit Eintraege von Namen und QTH
     if (@a[0]." ".@a[1] eq $tcall." ".$taddr) {
        print ("\nCall: $tcall mit Adresse $taddr wurde ausgetragen!");    # Ausgabe an User
        &changer("-");
        $ausgetragen=1;
     }
     else {
        printf (OUT "$line\n");
     }
   }
   if ($ausgetragen==0) {print("\nCall: $tcall mit Adresse $taddr nicht in der Datenbank!")}
   close (IN);
   close (OUT);
   system ("mv $DATABASET $DATABASE");
}


#####################################################################
# User in der Database eintragen
#####################################################################

sub addUser()
{
   $tcall = shift(@line);     # Befehl selber verwerfen
   $tcall = uc(shift(@line)); # Call lesen
   $taddr = shift(@line);     # Adresse lesen
   $tname = shift(@line);     # Name lesen
   $tqth  = shift(@line);     # QTH lesen

   if (length ($tcall) == 0) {
    print ("\nFehler: Sie haben kein Call eingegeben!");
    return;
   }

   if (abs($taddr) < 1 | length ($taddr) == 0)
   {
    print ("\nFehler: Sie haben keine Adresse eingegeben!");
    return;
   }

     open (database , $DATABASE);
     while (defined ($line = <database>))
     {
      chop ($line);
      @a = split (/ /,$line);
      if (uc($a[0]) eq $tcall)
      {
       printf("\nUser bereits in Database eingetragen: $a[0] ($a[1])");
       close (database);
       return;
      }
     }
   
   open (database, '>>'.$DATABASE);
   printf (database "$tcall $taddr $tname $tqth\n");
   close (database);

   # erstmal sortieren wir die Liste
   open (IN, $DATABASE);
   open (OUT, ">".$DATABASET);
   @lines = sort(<IN>);
   foreach $line (@lines) {
    printf (OUT "$line");
   }
   close (OUT);
   close (IN);
   system ("mv $DATABASET $DATABASE");
   system ("sync");
   &changer("+");
   &skyperact();
   print "\nTrage neuen User $tcall mit POCSAG-Adresse $taddr ein\n";
   print "und sende eine Aktivierungssequenz";


   foreach $SUBDIR (@SLAVES) {

    &neu_datei();

   if ($Versuche <100)
   {
     open (FUNKRUF, ">".$FNAME);
     printf (FUNKRUF "$taddr\nHallo $tcall Dein POCSAG-RX wurde eingetragen");
     close (FUNKRUF);
    }
    else
    {
        printf("\nFunkruf konnte nicht richtig gesendet werden! ");
        printf("Bitte Sysop informieren! tnx.");
    }
   }
}

#####################################################################
# Skyper-Aktivierung an Call senden
#####################################################################
sub actSkyp()
{
    $tcall = shift(@line);     # Befehl selber verwerfen
    $tcall = uc(shift(@line)); # Call lesen

    if (length ($tcall) == 0) {
     print ("\nFehler: Sie haben kein Call eingegeben!");
     return;
    }

    open (DATAB, "$DATABASE");
    while (defined($input=<DATAB>)){
     chop ($input);
     @a=split(/ /,$input);
     $dbcall=$a[0];
     $taddr =$a[1];
     if ($tcall eq $dbcall) {
     &skyperact();
     printf ("Sende User $tcall ($taddr) eine Aktivierungssequenz!\n");


     foreach $SUBDIR (@SLAVES) {

     &neu_datei();

     if ($Versuche <100)
     {
       open (FUNKRUF, ">".$FNAME);
       printf (FUNKRUF "$taddr\nHallo $tcall Dein Skyper wurde aktiviert");
       close (FUNKRUF);
     }
     else
     {
        printf("\nFunkruf konnte nicht richtig gesendet werden! ");
        printf("Bitte Sysop informieren! tnx.");
     }
    }
    close (DATAB);
    return
    }
  }
  close (DATAB);
  print ("\nFehler: User steht nicht in der Database!\n");
}




#####################################################################
# Skyper-Aktivierung an Adresse senden
#####################################################################

sub skyperact()
{
   @pocaddr = int($taddr);
   $shift = ($pocaddr[0] % 8) + 2;
   srand();
   foreach $SUBDIR (@SLAVES) {
   $Aktivierung=1;
   &neu_datei();
   $Aktivierung=0;
   if ($Versuche < 100)
   {
     open (funkruf, ">".$FNAME);
     printf (funkruf $pocaddr[0].".2\r");
     printf (funkruf chr(ord("0")+$shift));
     printf (funkruf chr(0x20+$shift));
     printf (funkruf chr(ord("3")+$shift));
     printf (funkruf chr(ord("1")+$shift));
     printf (funkruf chr(ord("1")+$shift));
     printf (funkruf chr(ord("2")+$shift));
     printf (funkruf chr(ord("1")+$shift));
     printf (funkruf chr(ord("1")+$shift));
     close (funkruf);
    }

    else
    {
        printf("\nFunkruf konnte nicht richtig gesendet werden! ");
        printf("Bitte Sysop informieren! tnx.");
    }
   }
}


#####################################################################
# Die Namen der SPOOL-Dirs lesen
#####################################################################

sub read_spool_dirs()
{
 opendir (HERE,"$SPOOLDIRS");
 @AllDirs = readdir (HERE);
 foreach $DirName (@AllDirs) {
  if (-d ($SPOOLDIRS.'/'.$DirName)) {
   if ($DirName ne '.' && $DirName ne '..') {
    push (@SLAVES, $DirName);
   }
  }
 }
 closedir (HERE);
}


#####################################################################
# Neue Datei fuer Funkruf generieren mit check ob schon vorhanden
#####################################################################

sub neu_datei()
{
      $Versuche=0;
      do {
       $Versuche++;

       if ($Aktivierung==1)
       {
          $FNAME = "$SPOOLDIRS/$SUBDIR/FUNKRUF.SK.".int(rand(65535));
          $vorhanden=open (FUNKRUF, $FNAME);
          close (FUNKRUF);
        }

        else
        {
            $FNAME = "$SPOOLDIRS/$SUBDIR/FUNKRUF.".int(rand(65535));
            $vorhanden=open (FUNKRUF, $FNAME);
            close (FUNKRUF);
        }


      }
      while ($vorhanden==1 && $Versuche < 100);
}

#####################################################################
# Aktuelles Datum und Uhrzeit einlesen
#####################################################################

sub Zeit()
{
  ($Second, $Minute, $Hour, $Day, $Month, $Year,
   $WeekDay, $DayOfYear, $IsDst) = localtime (time);
   $Year = $Year - 100;
   $Month = $Month + 1;
}


#####################################################################
# Protokolliert die Aenderungen an der Database
#####################################################################

sub changer()
{
 $changes=shift(@_);
 open (change, ">>$CHANGEDAT");
 &Zeit();
 printf (change "\n%02d:%02d %02d/%02d/%02d:",$Hour,$Minute,$Day,$Month,$Year);
 printf (change " $changes $tcall $taddr von $call an $OWNCALL");
 close (change);
}

#####################################################################
# Umlautkonvertierung
#####################################################################

sub umconvert
{
 my($konvertiert)=@_;
 $konvertiert=~ s/ä/ae/g;
 $konvertiert=~ s/ö/oe/g;
 $konvertiert=~ s/ü/ue/g;
 $konvertiert=~ s/Ä/Ae/g;
 $konvertiert=~ s/Ö/Oe/g;
 $konvertiert=~ s/Ü/Ue/g;
 $konvertiert=~ s/ß/ss/g;
 return($konvertiert)
}