/************************************************************************/
/*                                                                      */
/*    *****                       *****                                 */
/*      *****                   *****                                   */
/*        *****               *****                                     */
/*          *****           *****                                       */
/*  ***************       ***************                               */
/*  *****************   *****************                               */
/*  ***************       ***************                               */
/*          *****           *****           TheNetNode                  */
/*        *****               *****         Portable                    */
/*      *****                   *****       Network                     */
/*    *****                       *****     Software                    */
/*                                                                      */
/* File os/linux/ax25ip.c (maintained by: DG9OBU)                       */
/*                                                                      */
/* This file is part of "TheNetNode" - Software Package                 */
/*                                                                      */
/* Copyright (C) 1998 - 2008 NORD><LINK e.V. Braunschweig               */
/*                                                                      */
/* This program is free software; you can redistribute it and/or modify */
/* it under the terms of the NORD><LINK ALAS (Allgemeine Lizenz fuer    */
/* Amateurfunk Software) as published by Hans Georg Giese (DF2AU)       */
/* on 13/Oct/1992; either version 1, or (at your option) any later      */
/* version.                                                             */
/*                                                                      */
/* This program is distributed WITHOUT ANY WARRANTY only for further    */
/* development and learning purposes. See the ALAS (Allgemeine Lizenz   */
/* fuer Amateurfunk Software).                                          */
/*                                                                      */
/* You should have received a copy of the NORD><LINK ALAS (Allgemeine   */
/* Lizenz fuer Amateurfunk Software) along with this program; if not,   */
/* write to NORD><LINK e.V., Hinter dem Berge 5, D-38108 Braunschweig   */
/*                                                                      */
/* Dieses Programm ist PUBLIC DOMAIN, mit den Einschraenkungen durch    */
/* die ALAS (Allgemeine Lizenz fuer Amateurfunk Software), entweder     */
/* Version 1, veroeffentlicht von Hans Georg Giese (DF2AU),             */
/* am 13.Oct.1992, oder (wenn gewuenscht) jede spaetere Version.        */
/*                                                                      */
/* Dieses Programm wird unter Haftungsausschluss vertrieben, aus-       */
/* schliesslich fuer Weiterentwicklungs- und Lehrzwecke. Naeheres       */
/* koennen Sie der ALAS (Allgemeine Lizenz fuer Amateurfunk Software)   */
/* entnehmen.                                                           */
/*                                                                      */
/* Sollte dieser Software keine ALAS (Allgemeine Lizenz fuer Amateur-   */
/* funk Software) beigelegen haben, wenden Sie sich bitte an            */
/* NORD><LINK e.V., Hinter dem Berge 5, D-38108 Braunschweig            */
/*                                                                      */
/************************************************************************/

/************************************************************************/
/*                                                                      */
/* AX25IP.C V1.05 01.9.98 by DG1KWA / Andreas                           */
/*                        extended by DG9OBU / Marc                     */
/************************************************************************/

#include "tnn.h"

#ifdef AX25IP
#include "ax25ip.h"

/*************************************************************************/
/* AX25IP-Hausaufgaben : RX, TX und Routingtabellenpflege                */
/*************************************************************************/
void ax25ip(void)
{
  register UBYTE uEntry = 0;

  /* nur wenn Interface aktiv ist */
  if (!ax25ip_active)
    return;

  /* empfangene Frames abholen */
  ax25ip_recv();

  /* IP-Adressen der Routentabelle pflegen */
  if ((uNamesUpdate != 0) && (tic10 % uNamesUpdate == 0))
  {
    for (; uEntry <= TABLE_SIZE; ++uEntry)
      route_update(&route_tbl[uEntry]);

    route_update(&default_route);
  }

  /* ausstehende Frames senden wenn vorhanden */
  if (kick[ax25ip_port])
    ax25ip_send();
}

/*************************************************************************/
/* Einen Eintrag aus der Routingtabelle ausgeben                         */
/*************************************************************************/
void show_rt_entry(struct route_table_entry rp, MBHEAD *bufpoi)
{
  /* erst mal merken, wo wir sind */
  bufpoi->l4time = bufpoi->mbpc;

  /* Check auf Eintrag fuer die default-Route */
  if (rp.callsign[0] != 1)
    putprintf(bufpoi, "%s", call_to_a(&rp.callsign[0]));
  else
    putstr("default", bufpoi);

  putspa(11, bufpoi);

  /* IP-Adresse ausgeben */
  show_ip_addr(ntohl(rp.ip_addr), bufpoi);

  putspa(29, bufpoi);

  /* UDP-Port ausgeben wenn UDP-Port gesetzt */
  if (rp.udp_port != 0)
  {
    /* Eine UDP-Route */
    putstr("UDP", bufpoi);
    putspa(35, bufpoi);
    putnum(ntohs(rp.udp_port), bufpoi);
  }
  else
    /* Eine IP-Route */
    putstr("IP", bufpoi);

  /* Routen-Timeout anzeigen */
  if (rp.timeout != 0)
  {
    ULONG d = rp.timeout;
    ULONG h, m, s;                  /* Stunden, Minuten, Sekunden */

    s = d % 60L;
    d /= 60L;
    m = d % 60L;
    d /= 60L;
    h = d % 24L;

    putspa(40, bufpoi);
    putprintf(bufpoi, " %02lu:%02lu:%02lu", h, m, s); /* hh:mm:ss */
  }

  if (rp.hostname[0] != 0)
  {
    putspa(50, bufpoi);
    putprintf(bufpoi, "%s", rp.hostname);
  }

  putstr("\r", bufpoi);
}

/* Anzahl von IP- oder UDP-Routen in der Routingtabelle feststellen */
/* (IP-Routen haben keinen UDP-Port gesetzt) */
/* UDP = FALSE -> IP-Routen zaehlen, UDP = TRUE -> UDP-Routen zaehlen */
/* Default-Route wird beachtet */
unsigned int count_routes(BOOLEAN udp)
{
  register unsigned int i;
  register unsigned int j = 0;

  /* Gesamte Routingtabelle durchgehen */
  for (i = 0; i < (unsigned int)route_tbl_top; ++i)
  {
    if (   ((udp == TRUE) && (route_tbl[i].udp_port != 0))    /* UDP-Route */
        || ((udp == FALSE) && (route_tbl[i].udp_port == 0)))  /* IP-Route */
      ++j;
  }

  /* Default-Route */
  if (default_route.callsign[0] != 0)
  {
    if (   ((udp == TRUE) && (default_route.udp_port != 0))    /* UDP-Route */
        || ((udp == FALSE) && (default_route.udp_port == 0)))  /* IP-Route */
      ++j;
  }

  /* Anzahl Routen melden */
  return (j);
}

/* Timeout fuer gelernte Routen */
void route_age(void)
{
  register unsigned int i = 0;

#ifdef AXIPR_HTML
  /* htmlstatistik-timer. */
  h_timer();
#endif

  /* Gesamte Routingtabelle durchgehen */
  for (; i < (unsigned int)route_tbl_top; ++i)
  {
    /* Route mit laufendem Timer */
    if (route_tbl[i].timeout != 0)
    {
      /* Timer laeuft jetzt ab */
      if (--route_tbl[i].timeout == 0)
        /* Route loeschen */
        route_del(route_tbl[i].callsign);
    }
  }
}

/* Hostname -> IP-Adressen aufloesen */
void route_update(struct route_table_entry *rtentry)
{
  struct hostent *hstent;

  /* Kein Hostname, dann auch keine Umwandlung moeglich */
  if (rtentry->hostname[0] == 0)
    return;

  /* Hostname im IP-Adresse konvertieren */
  if ((hstent = gethostbyname((char*)&rtentry->hostname[0])) != NULL)
  {
    /* Bei Aenderung uebernehmen */
    if (memcmp(&rtentry->ip_addr, &hstent->h_addr_list[0][0], 4) != 0)
    {
      /* IP-Adresse hat sich geaendert */
      memcpy(&rtentry->ip_addr, &hstent->h_addr_list[0][0], 4);
      LOGL1("IP-adress for %s changed !", rtentry->hostname);
    }
  }

#ifdef AXIPR_UDP
  /* Original UDP-Port setzen. */
  rtentry->udp_port = rtentry->org_udp_port;
#endif /* AXIPR_UDP */
}

/* Partielle Frame-Analyse fuer dyn. Eintraege */
BOOLEAN route_canlearn(MBHEAD *fbp)
{
  char *p;                              /* Zeiger im Header             */
  register int n;
  UBYTE ctl;

  rwndmb(fbp);                          /* Frame von vorne              */

  for (p = rxfhdr, n = 1; n <= L2INUM + L2VNUM; ++n)
  {
    if (!getfid(p, fbp))                /* naechstes Call lesen         */
      return (FALSE);

    p += L2IDLEN;
    if (*(p - 1) & L2CEOA)
      break;                            /* Ende des Addressfeldes       */
  }
  *(p - 1) &= ~L2CEOA;
  *p = NUL;
  ctl = getchr(fbp);                    /* Control-Byte extrahieren     */
  ctl &= ~L2CPF;                        /* Poll-Flag loeschen           */
  /* Nur UI, UA und SABM/SABME erzeugen einen dynamischen Eintrag       */
  if (   ctl == L2CUI                   /* UI                           */
      || ctl == L2CUA                   /* UA                           */
      || ctl == L2CSABM                 /* SABM                         */
#ifdef EAX25
      || ctl == L2CSABME                /* SABME (EAX.25)               */
     )
#endif
    return (TRUE);

#ifndef AXIPR_UDP
  /* Alle anderen Kontrollcodes landen hier und bewirken keinen Eintrag */
  return (FALSE);
#else
  return (TRUE);
#endif
}

/*************************************************************************/
/* Kommandointerface fuer Operationen auf die AX25IP-Routentabelle       */
/*************************************************************************/

/* Eine Route anhand eines Calls loeschen, liefert TRUE wenn erfolgreich */
BOOLEAN route_del(unsigned char *call)
{
  register int i;
  register int j;

  /* Soll die Default-Route geloescht werden ? */
  if ((call == NULL) || (call[0] == NUL))
  {
    /* Als unbenutzt markieren */
    default_route.callsign[0] = NUL;

    /* Pruefen, ob Sockets noch notwendig */
    ax25ip_check_down();
    return (TRUE);
  }

  /* Uebergebenes Call in der Tabelle suchen */
  for (i = 0; i < route_tbl_top; ++i)
  {
    if (addrmatch(call, route_tbl[i].callsign))
    {
    /* BINGO ! */
    /* Problem: die Tabelle hat keinen Merker, ob ein Eintrag gueltig ist, */
    /*          die Eintraege haengen einfach hintereinander. Deshalb alle */
    /*          Eintraege oberhalb des gefundenen Eintrages einen nach     */
    /*          unten kopieren und den "table-top" einen herabsetzen.      */
      for (j = i; j < route_tbl_top; ++j)
        route_tbl[j] = route_tbl[j + 1];

      /* Ein Tabelleneintrag weniger */
      route_tbl_top--;

      /* Pruefen, ob Sockets noch notwendig */
      ax25ip_check_down();
      return(TRUE);
    }
  }

  return(FALSE);
}

static const char inv_mode[] = "Invalid Mode\r";
static const char inv_call[] = "Invalid Callsign\r";
static const char inv_ip[]   = "Invalid IP adress\r";
static const char inv_par[]  = "Invalid Parameter\r";

void
ccpaxipr(void)
{
  MBHEAD         *mbp;
  int             port = 0;
  register int    i;
  int             tmp_fd = -1;
  int             new_udp = 0;
  unsigned char   call[L2IDLEN];
  char            hostname[HNLEN + 1];
  struct          hostent *host = NULL;
  int             uNewTimeout;
#ifdef AXIPR_UDP
  char           *Hostname = hostname;
  int             NewLogLevel = FALSE;
#endif
#ifdef AXIPR_HTML
  char           *timeset  = set_time();
  int             NewHtmlStat = FALSE;
#endif
  char            cBuf[BUFLEN + 1];
  unsigned int    uCmd = OP_NONE;
  unsigned int    uMode = NO_MODE;

#ifdef AXIPR_HTML
#define OP_HTMLSTAT 10
#endif

  memset(hostname, 0, sizeof(hostname));

  /* AX25IP ueberhaupt aktiv ? */
  if (ax25ip_active == FALSE)
  {
    putmsg("No AX25IP-interface present, nothing to configure or show !\r");
    return;
  }

  /* neuen Parser verwenden ? */
  if (new_parser == TRUE)
  {

  /* Sysop will aendern und noch was in der Zeile da ? */
  if (issyso() && skipsp(&clicnt, &clipoi))
  {
    /* Frischer Buffer */
    memset(cBuf, 0, sizeof(cBuf));

    /* Operation lesen (add, delete) */
    for (i = 0; i < BUFLEN; ++i)
    {
      if ((!clicnt) || (*clipoi == ' '))
        break;
      clicnt--;
      cBuf[i] = toupper(*clipoi++);
    }

    /* Zum alten Parser zurueckschalten */
    if (   (strcmp(cBuf, "OLD") == 0)
        || (cBuf[0] == 'O')
       )
    {
      new_parser = FALSE;
      putmsg("Switched to old axipr-parser !!!\r");
      return;
    }

    /* Hinzufuegen (add oder +) */
    if (   (strcmp(cBuf, "ADD") == 0)
        || (cBuf[0] == '+')
       )
      uCmd = OP_ADD;

    /* Loeschen (delete, del oder -) */
    if (   (strcmp(cBuf, "DELETE") == 0)
        || (strcmp(cBuf, "DEL") == 0)
        || (cBuf[0] == '-')
       )
      uCmd = OP_DEL;

    /* eigenen UDP-Port aendern */
    if (strcmp(cBuf, "MYUDP") == 0)
      uCmd = OP_MYUDP;

    /* Namensaufloesungsintervall einstellen */
    if (strcmp(cBuf, "LOOKUP") == 0)
      uCmd = OP_HNUPD;

    /* Loglevel */
    if (   (strcmp(cBuf, "LOGLEVEL") == 0)
        || (strcmp(cBuf, "LOG") == 0)
       )
      uCmd = OP_LOG;

    /* Timeout fuer dynamische Routen */
    if (strcmp(cBuf, "TIMEOUT") == 0)
      uCmd = OP_TIMEOUT;

#ifdef AXIPR_HTML
    /* htmlstatistik */
    if (   (strcmp(cBuf, "HTMLSTAT") == 0)
        || (strcmp(cBuf, "H") == 0))

      uCmd = OP_HTMLSTAT;
#endif

    /* Fehler bei der Auswertung ? */
    if (uCmd == OP_NONE)
    {
      putmsg(inv_mode);
      return;
    }

    /* Hier rein, wenn der Timeout fuer dynamische Routen geaendert werden soll */
    if (uCmd == OP_TIMEOUT)
    {
      int uNewTimeout;

      /* Noch was da in der Kommandozeile ? */
      if (!skipsp(&clicnt, &clipoi))
      {
        mbp = getmbp();
        putprintf(mbp, "the actual timeout for dynamic routes is : %u\r", uDynTimeout);
        /* und ab die Post ... */
        prompt(mbp);
        seteom(mbp);
        return;
      }

      /* Timeout lesen */
      uNewTimeout = nxtlong(&clicnt, &clipoi);

      if (  (uNewTimeout < 0)
          ||(uNewTimeout > (86400)))  /* max. 1 Tag */
      {
        putmsg("error: timeout out of range (0 - 86400) !\r");
        return;
      }

      /* Wert uebernehmen */
      uDynTimeout = uNewTimeout;

      /* und ab die Post ... */
      mbp = getmbp();
      prompt(mbp);
      seteom(mbp);
      return;
    }

    /* Hier rein, wenn das Intervall der Namensaufloesung geaendert werden soll */
    if (uCmd == OP_HNUPD)
    {
      UWORD uNewInterval;

      /* Noch was da in der Kommandozeile ? */
      if (!skipsp(&clicnt, &clipoi))
      {
        mbp = getmbp();

        putprintf(mbp, "Hostname-update ");

        if (uNamesUpdate != 0)
          putprintf(mbp, "occurs every %u seconds.\r", uNamesUpdate / 100);
        else
          putprintf(mbp, "is disabled at the moment.\r");

        /* und ab die Post ... */
        prompt(mbp);
        seteom(mbp);
        return;
      }

      /* Timeout lesen */
      uNewInterval = nxtnum(&clicnt, &clipoi);

      if (uNewInterval > 3600)  /* max. eine Stunde */
      {
        putmsg("error: value out of range (0 - 3600 seconds) !\r");
        return;
      }

      /* Wert uebernehmen */
      uNamesUpdate = uNewInterval * 100;

      /* und ab die Post ... */
      mbp = getmbp();
      prompt(mbp);
      seteom(mbp);
      return;
    }

    /* Hier rein, wenn der Loglevel geaendert werden soll */
    if (uCmd == OP_LOG)
    {
      int new_loglevel;

      /* Noch was da in der Kommandozeile ? */
      if (!skipsp(&clicnt, &clipoi))
      {
        mbp = getmbp();
        putprintf(mbp, "my actual loglevel is : %u\r", loglevel);
        /* und ab die Post ...                                            */
        prompt(mbp);
        seteom(mbp);
        return;
      }

      /* neues Loglevel lesen */
      new_loglevel = nxtnum(&clicnt, &clipoi);

      if (  (new_loglevel < 0)
          ||(new_loglevel > 4))
      {
        putmsg("error: loglevel out of range (0 - 4) !!!\r");
        return;
      }

      /* Wert uebernehmen */
      loglevel = new_loglevel;

      /* und ab die Post ... */
      mbp = getmbp();
      prompt(mbp);
      seteom(mbp);
      return;
    }

#ifdef AXIPR_HTML
    if (uCmd == OP_HTMLSTAT)
    {
      /* Noch was da in der Kommandozeile ? */
      if (!skipsp(&clicnt, &clipoi))
      {
        mbp = getmbp();
#ifdef SPEECH
        putprintf(mbp, speech_message(347),HtmlStat);
#else
        putprintf(mbp, "HTML-Statistic is %d\r", HtmlStat);
#endif
        /* und ab die Post ... */
        prompt(mbp);
        seteom(mbp);
        return;
      }

      /* Timeout lesen */
      NewHtmlStat = nxtnum(&clicnt, &clipoi);

      if (  (NewHtmlStat < 0)
          ||(NewHtmlStat > 1))
      {
#ifdef SPEECH
        putmsg(speech_message(300));
#else
        putmsg("errors: Log level worth from 0 to 1!\r");
#endif
        return;
      }

      /* Wert uebernehmen */
      HtmlStat = NewHtmlStat;

      /* und ab die Post ... */
      mbp = getmbp();
      prompt(mbp);
      seteom(mbp);
      return;
    }
#endif /* AXIPR_HTML */

    /* Hier nur rein, wenn wir als naechstes eine UDP-Portnummer erwarten */
    if (uCmd == OP_MYUDP)
    {
      /* Noch was da in der Kommandozeile ? */
      if (!skipsp(&clicnt, &clipoi))
      {
        mbp = getmbp();
        putprintf(mbp, "my actual UDP-port is : %u\r", ntohs(my_udp));
        /* und ab die Post ...                                            */
        prompt(mbp);
        seteom(mbp);
        return;
      }

      /* neue UDP-Portnummer lesen */
      new_udp = nxtlong(&clicnt, &clipoi);

      if (  (new_udp <= 0)
          ||(new_udp > 65535))
      {
        putmsg("error: UDP-port number not valid (0 - 65535) !!!\r");
        return;
      }

#ifdef AXIPR_UDP
      /* Neuer UDP-Port gleich MY-UDP?   */
      /* Keine Aenderungen durchfuehren. */
      if (my_udp == htons((unsigned short)new_udp))
      {
        /* und ab die Post ...           */
        mbp = getmbp();
        prompt(mbp);
        seteom(mbp);
        return;
      }
#endif /* AXIPR_UDP */

#ifndef AXIPR_UDP
      /* Laufendes UDP aendern */
      if (fd_udp != -1)
      {
#endif
        /* Versuchen, neuen UDP-Port anzulegen */
        if ((tmp_fd = setup_udp(htons((unsigned short)new_udp))) != -1)
        {
#ifndef AXIPR_UDP
          /* Neuen Descriptor eintragen und alten schliessen */
          close(fd_udp);
#else
          /* Nur wenn alter Socket noch lebt,  */
          if (fd_udp != EOF)
            /* dann schliessen wir den Socket. */
            close(fd_udp);
#endif /* AXIPR_UDP */

          fd_udp = tmp_fd;
          /* Gibt es einen Eintrag. */
          if (l1pp)
            /* Check, ob neuer Filedescriptor groesser ist */    
            l1pp->kisslink = max(fd_ip, fd_udp);

          /* Neuen UDP-Port merken */
          my_udp = htons((unsigned short)new_udp);
        }
        else
        {
          putmsg("error: changing the UDP-port failed !!!\r");
          return;
        }
#ifndef AXIPR_UDP
      }
      else
      {
        /* neuen UDP-Port merken */
        my_udp = htons(new_udp);
      }
#endif
      /* und ab die Post ...                                                  */
      mbp = getmbp();
      prompt(mbp);
      seteom(mbp);
      return;
    }

    /* Noch was da in der Kommandozeile ? */
    if (!skipsp(&clicnt, &clipoi))
    {
      putmsg("syntax error: callsign missing\r");
      return;
    }

    /* Frischer Buffer */
    memset(cBuf, 0, sizeof(cBuf));

    /* Call lesen */
    for (i = 0; i < BUFLEN; ++i)
    {
      if ((!clicnt) || (*clipoi == ' '))
        break;

      clicnt--;
      cBuf[i] = toupper(*clipoi++);
    }

    /* Operation auf Default-Route ? */
    if (strcmp(cBuf, "DEFAULT") == 0)
      call[0] = NUL;    /* Leere Callstring als Indikator fuer Defaultroute */
    else
    {
      /* Call konvertieren und pruefen */
      if (a_to_call(cBuf, call) != 0)
      {
        putmsg(inv_call);
        return;
      }
    }

    /* Wenn wir loeschen wollen, brauchen wir nichts mehr */
    if (uCmd != OP_DEL)
    {
      /* Noch was da in der Kommandozeile ? */
      if (!skipsp(&clicnt, &clipoi))
      {
        putmsg("syntax error: IP-adress missing\r");
        return;
      }

      /* Frische Buffer */
      memset(hostname, 0, sizeof(hostname));

      /* Hostnamen / IP-Adresse lesen */
      for (i = 0; i < HNLEN; ++i)
      {
        if (!clicnt || *clipoi == ' ')
          break;

        clicnt--;
        hostname[i] = *clipoi++;
      }

      /* eventuellen Hostnamen aufloesen */
      if ((host = gethostbyname(hostname)) == NULL)
      {
        mbp = getmbp();
        putprintf(mbp, "Warning: can't resolve IP for host %s ! I keep trying ...\r", hostname);
        prompt(mbp);
        seteom(mbp);
      }
      else
      {
        strncpy(hostname, host->h_name, sizeof(hostname));
      }
    } /* if (uCmd != OP_DEL) */

    /* Optionale UDP-Parameter lesen */
    skipsp(&clicnt, &clipoi);

    /* Frischer Buffer */
    memset(cBuf, 0, sizeof(cBuf));

    /* Mode lesen (IP, UDP) */
    for (i = 0; i < BUFLEN; ++i)
    {
      if ((!clicnt) || (*clipoi == ' '))
        break;

      clicnt--;
      cBuf[i] = toupper(*clipoi++);
    }

    /* Mode bestimmen (UDP) */
    /* Bei der Initialisierung wurde bereits IP eingestellt */
    if (   (strcmp(cBuf, "UDP") == 0)
        || (cBuf[0] == 'U')
       )
      uMode = UDP_MODE;

    /* Noch was da in der Kommandozeile ? */
    if (!skipsp(&clicnt, &clipoi))
      port = DEFAULT_UDP_PORT;
    else
    {
      /* neue UDP-Portnummer lesen */
      port = nxtlong(&clicnt, &clipoi);

      if (  (port <= 0)
          ||(port > 65535))
      {
        putmsg("error: UDP-port number not valid\r");
        return;
      }
    }

    /* Operation ausfuehren */
    switch (uCmd)
    {
      /* Route hinzufuegen */
      case OP_ADD :
#ifndef AXIPR_UDP
        route_add((unsigned char*)&hostname, host, call, (uMode == UDP_MODE ? port : 0), (call[0] == 0 ? TRUE : FALSE)
        break;
#else
        if (route_add((unsigned char*)&hostname
                                 , host
                                 , call
                                 , (uMode == UDP_MODE ? (int)port : 0)
                                 , (call[0] == 0 ? TRUE : FALSE)
                                 , 0
                                 , hostname
#ifdef AXIPR_HTML
                                 , timeset
                                 , P_USER
#endif /* AXIPR_HTML */
                                 ))
                      putmsg("Call is registerd.\r");

                    return;
#endif /* AXIPR_UDP */

      /* Route loeschen */
      case OP_DEL :
#ifndef AXIPR_UDP
                    route_del(call);
                    break;
#else

                    if (route_del(call))
                      putmsg("Call is deleted!\r");
                    else
                      putmsg("Call no deleted!\r");

                    return;
#endif /* AXIPR_UDP. */


      default     : break;
    }

    mbp = getmbp();
    /* und ab die Post ... */
    prompt(mbp);
    seteom(mbp);
    return;
  }

  }
  else
  {
  /* ALTE SYNTAX */

  /* Sysop will aendern und noch was in der Zeile da ? */
  if (issyso() && skipsp(&clicnt, &clipoi))
  {
    clicnt--;

    switch (toupper(*clipoi++))
    {
      case 'P':                                 /* Parser aendern       */
        /* wir koennen nur in den neuen Parser umschalten */
        new_parser = TRUE;
        putmsg("Switched to new axipr-parser !!!\r");
        return;
        break;

      case 'R':                                 /* Routen-Eintrag       */
        /* Kommandozeile pruefen */
        if (!skipsp(&clicnt, &clipoi))
        {
          putmsg(inv_par);
          return;
        }

        clicnt--;

        switch (*clipoi++)
        {
          case '-':                             /* Route loeschen       */
            /* Call lesen */
            if (getcal(&clicnt, &clipoi, TRUE, (char *)call) != YES)
            {
              invcal();
              return;
            }

            /* Call konvertieren */
            for (i = 0; i < L2CALEN; ++i)
              call[i] = call[i] << 1;

#ifdef AXIPR_UDP
            /* und ab die Post ...                                                  */
            mbp = getmbp();

            if (route_del(call))
              putstr("Call is delete!\r", mbp);
            else
              putstr("Call no delete!\r", mbp);

            prompt(mbp);
            seteom(mbp);
            return;
#else
           /* Route loeschen */
            route_del(call);
            break;
#endif /* AXIPR_UDP. */

          case '+':                             /* Route hinzufuegen    */
            /* Call lesen */
            if (getcal(&clicnt, &clipoi, TRUE, (char *)call) != YES)
            {
              invcal();
              return;
            }

            /* Call linksschieben   */
            for (i = 0; i < L2CALEN; ++i)
              call[i] = call[i] << 1;

            /* Noch was da in der Kommandozeile ? */
            if (!skipsp(&clicnt, &clipoi))
            {
              putmsg("IP-Adress/Hostname missing\r");
              return;
            }

            /* Frische Buffer */
            memset(hostname, 0, sizeof(hostname));

            /* Hostnamen / IP-Adresse lesen */
            for (i = 0; i < HNLEN; ++i)
            {
              if (!clicnt || *clipoi == ' ')
                break;

              clicnt--;
              hostname[i] = *clipoi++;
            }

            /* Hostname / IP-Adresse aufloesen */
            if ((host = gethostbyname(hostname)) == NULL)
            {
              putmsg(inv_ip);
              return;
            }

            /* Mode-Parameter vorhanden ? */
            if (skipsp(&clicnt, &clipoi))
            {
              --clicnt;
              switch (toupper(*clipoi++))
              {
                case 'I':       /* IP: Port steht fest */
                  break;
                case 'U':       /* UDP: abweichenden Port lesen wenn vorhanden */
                  nextspace(&clicnt, &clipoi);
                  if (!skipsp(&clicnt, &clipoi))
                    port = DEFAULT_UDP_PORT;
                  else
                    {
                      port = nxtlong(&clicnt, &clipoi);

                      if (  (port <= 0)
                          ||(port > 65535))
                      {
                        putmsg("error: UDP-port number not valid\r");
                        return;
                      }
                    }
                  break;

                default:        /* unbekannter Modus */
                  putmsg(inv_mode);
                  return;
              }
            }
            /* Route hinzufuegen */
#ifndef AXIPR_UDP
            route_add((unsigned char*)&hostname, host, call, (int) port, FALSE, 0);
            break;
#else
            if (route_add((unsigned char*)&hostname
                         , host
                         , call
                         , (int) port
                         , FALSE
                         , 0
                         , hostname
#ifdef AXIPR_HTML
                         , timeset
                         , P_USER
#endif /* AXIPR_HTML */
                         ))
              putmsg("Call is registerd.\r");

            return;
#endif /* AXIPR_UDP */

        }
        break;

      case 'D':                         /* Default Route aendern        */

        nextspace(&clicnt, &clipoi);

        /* Noch Eingaben da ? */
        if (!skipsp(&clicnt, &clipoi))
        {
          putmsg(inv_mode);
          return;
        }

        clicnt--;

        /* Operation bestimmen */
        switch (*clipoi++)
        {
          case '-':                     /* Default Route loeschen       */
#ifdef AXIPR_UDP
            /* und ab die Post ...                                                  */
            mbp = getmbp();

            if (route_del((unsigned char *)""))
              putstr("Call is delete!\r", mbp);
            else
              putstr("Call no delete!\r", mbp);

            prompt(mbp);
            seteom(mbp);
            return;
#else
            route_del((unsigned char *)"");
            break;
#endif /* AXIPR_UDP. */

          case '+':                     /* Default Route eingeben       */

            /* IP-Adresse / Hostname lesen */
            if (!skipsp(&clicnt, &clipoi))
            {
              putmsg(inv_ip);
              return;
            }

            /* Frische Buffer */
            memset(hostname, 0, sizeof(hostname));

            /* IP-Adresse / Hostname kopieren */
            for (i = 0; i < HNLEN; ++i)
            {
              if (!clicnt || *clipoi == ' ')
                break;
              clicnt--;
              hostname[i] = *clipoi++;
            }

            /* aufloesen */
            if ((host = gethostbyname(hostname)) == NULL)
            {
              putmsg(inv_ip);
              return;
            }

            /* Modus-Kennzeichner lesen falls vorhanden */
            if (skipsp(&clicnt, &clipoi))
            {
              --clicnt;
              switch (toupper(*clipoi++))
              {
                case 'I':   /* IP: Port steht fest */
                  break;
                case 'U':   /* UDP: eventuell abweichenden Port lesen */
                  nextspace(&clicnt, &clipoi);

                  if (!skipsp(&clicnt, &clipoi))
                    port = DEFAULT_UDP_PORT;
                  else
                    {
                      port = nxtlong(&clicnt, &clipoi);

                      if (  (port <= 0)
                          ||(port > 65535))
                      {
                        putmsg("error: UDP-port number not valid\r");
                        return;
                      }
                    }
                  break;
                default:    /* unbekannter Modus */
                  putmsg(inv_mode);
                  return;
              }
            }
            /* Route eintragen */
#ifndef AXIPR_UDP
            route_add((unsigned char*)&hostname, host, NULL, (int) port, TRUE, 0);
            break;
#else
            if (route_add((unsigned char*)&hostname
                         , host
                         , NULL
                         , (int) port
                         , TRUE
                         , 0
                         , hostname
#ifdef AXIPR_HTML
                         , timeset
                         , P_USER
#endif /* AXIPR_HTML */
                         ))
              putmsg("Call is registerd.\r");

            return;
#endif /* AXIPR_UDP */

          default:
            putmsg(inv_mode);
            return;
        }
        break;

      /* Eigenen UDP-Port aendern */
      case 'U':
        /* neuer Port muss vorhanden sein */
        if (!skipsp(&clicnt, &clipoi))
        {
          putmsg(inv_par);
          return;
        }

        /* Port ermitteln. */
        new_udp = nxtlong(&clicnt, &clipoi);

        if (  (new_udp <= 0)
            ||(new_udp >= 65535))
        {
          putmsg("UDP-Port not valid, not changed !!!\r");
          return;
        }

#ifdef AXIPR_UDP
        /* Neuer UDP-Port gleich MY-UDP?   */
        /* Keine Aenderungen durchfuehren. */
        if (my_udp == htons((unsigned short)new_udp))
        {
          /* und ab die Post ...           */
          mbp = getmbp();
         prompt(mbp);
         seteom(mbp);
         return;
        }
#endif /* AXIPR_UDP */

#ifndef AXIPR_UDP
        /* Laufendes UDP aendern */
        if (fd_udp != -1)
        {
#endif
          /* Versuchen, neuen UDP-Port anzulegen */
          if ((tmp_fd = setup_udp(htons((unsigned short)new_udp))) != -1)
          {
#ifndef AXIPR_UDP
          /* Neuen Descriptor eintragen und alten schliessen */
          close(fd_udp);
#else
          /* Nur wenn alter Socket noch lebt,  */
          if (fd_udp != EOF)
            /* dann schliessen wir den Socket. */
            close(fd_udp);
#endif /* AXIPR_UDP */

            fd_udp = tmp_fd;
            /* Gibt es einen Eintrag. */
            if (l1pp)
              /* Check, ob neuer Filedescriptor groesser ist */
              l1pp->kisslink = max(fd_ip, fd_udp);

            /* Neuen UDP-Port merken */
            my_udp = htons((unsigned short)new_udp);
          }
          else
          {
            putmsg("ERROR: Changing UDP-Port failed, Port not changed !!!\r");
            return;
          }
#ifndef AXIPR_UDP
        }
        else
        {
          /* neuen UDP-Port merken */
          my_udp = htons(new_udp);
        }
#endif

        putmsg("UDP-Port successfully changed\r");
#ifdef AXIPR_UDP
        return;
#else
        break;
#endif /* AXIPR_UDP. */

      /* Timeout fuer dynamische Routen aendern. */
      case 'T':

      /* Noch was da in der Kommandozeile ? */
      if (!skipsp(&clicnt, &clipoi))
      {
        mbp = getmbp();
        putprintf(mbp, "the actual timeout for dynamic routes is : %u\r", uDynTimeout);
        /* und ab die Post ... */
        prompt(mbp);
        seteom(mbp);
        return;
      }

      /* Timeout lesen */
      uNewTimeout = nxtlong(&clicnt, &clipoi);

      if (  (uNewTimeout < 0)
          ||(uNewTimeout > (86400)))  /* max. 1 Tag */
      {
        putmsg("error: timeout out of range (0 - 86400) !\r");
        return;
      }

      /* Wert uebernehmen */
      uDynTimeout = uNewTimeout;

      /* und ab die Post ... */
      mbp = getmbp();
      prompt(mbp);
      seteom(mbp);
      return;

#ifdef AXIPR_UDP
      /* Loglevel aendern. */
      case 'L':

      /* Noch was da in der Kommandozeile ? */
      if (!skipsp(&clicnt, &clipoi))
      {
        mbp = getmbp();
#ifdef SPEECH
        putprintf(mbp, speech_message(299),loglevel);
#else
        putprintf(mbp, "My LogLevel: %d\r",loglevel);
#endif
        /* und ab die Post ... */
        prompt(mbp);
        seteom(mbp);
        return;
      }

      /* Loglevel lesen */
      NewLogLevel = nxtnum(&clicnt, &clipoi);

      if (  (NewLogLevel < 0)
          ||(NewLogLevel > 4))
      {
#ifdef SPEECH
         putmsg(speech_message(300));
#else
         putmsg("errors: Log level worth from 0 to 4!\r");
#endif
         return;
      }

      /* Wert uebernehmen */
      loglevel = NewLogLevel;

      /* und ab die Post ... */
      mbp = getmbp();
      prompt(mbp);
      seteom(mbp);
      return;
#endif /* AXIPR_UDP */

#ifdef AXIPR_HTML
      /* htmlstatistik aendern. */
      case 'H':

      /* Noch was da in der Kommandozeile ? */
      if (!skipsp(&clicnt, &clipoi))
      {
        mbp = getmbp();
#ifdef SPEECH
        putprintf(mbp, speech_message(347),HtmlStat);
#else
        putprintf(mbp, "HTML-Statistic is %d\r", HtmlStat);
#endif
        /* und ab die Post ... */
        prompt(mbp);
        seteom(mbp);
        return;
      }

      /* Loglevel lesen */
      NewHtmlStat = nxtnum(&clicnt, &clipoi);

      if (  (NewHtmlStat < 0)
          ||(NewHtmlStat > 1))
      {
#ifdef SPEECH
         putmsg(speech_message(348));
#else
         putmsg("Error: HTML-Statistic worth from 0 to 1!\r\r");
#endif
         return;
      }

      /* Wert uebernehmen */
      HtmlStat = NewHtmlStat;

      /* und ab die Post ... */
      mbp = getmbp();
      prompt(mbp);
      seteom(mbp);
      return;
#endif

      /* Unbekannte Kommandos */
      default:
        putmsg(inv_par);
        return;
    }
  }
  }

  mbp = putals("AXIP-Routes:\rCall-------IP----------------Mode--Port--Timeout--IP/Hostname----\r");

  /* Alle Routingtabelleneintraege durchgehen und ausgeben */
  for (i = 0; i < route_tbl_top; ++i)
    show_rt_entry(route_tbl[i], mbp);

  /* Default-Route ausgeben wenn vorhanden */
  if (default_route.callsign[0] == 1)
    show_rt_entry(default_route, mbp);

  putprintf(mbp, "-----------------------------------------------------------------\r");

  /* Eigenen UDP-Port ausgeben */
  putprintf(mbp, "UDP-port (%u): ", ntohs(my_udp));
  putprintf(mbp, "%s", (fd_udp != -1 ? "active" : "not active"));

  /* IP-Status ausgeben */
  putprintf(mbp, ", IP-protocol (family %u): ", IPPROTO_AX25);
  putprintf(mbp, "%s", (fd_ip != -1 ? "active" : "not active"));

  /* Timeout des dynamischen Routenlerners ausgeben */
  putprintf(mbp, "\rTimeout for dynamically learned routes is %u seconds.\r", uDynTimeout);

  /* Hostname -> IP-Adresse Aktualisierungsintervall ausgeben */
  putprintf(mbp, "Hostname-to-IP-adress conversion ");

  if (uNamesUpdate != 0)
    putprintf(mbp, "occurs every %u seconds.\r", uNamesUpdate / 100);
  else
    putprintf(mbp, "is disabled.\r");

#ifdef AXIPR_UDP
#ifdef SPEECH
  putprintf(mbp, speech_message(299), loglevel);
#else
  putprintf(mbp, "My LOGLevel is %u.\r", loglevel);
#endif /* SPEECH */
#endif /* AXIPR_UDP */

#ifdef AXIPR_HTML
#ifdef SPEECH
  putprintf(mbp, speech_message(347), HtmlStat);
#else
  putprintf(mbp, "My HTML-Statistic is %d.\r", HtmlStat);
#endif /* SPEECH */
#endif /* AXIPR_HTML */

  /* und ab die Post ... */
  prompt(mbp);
  seteom(mbp);
}

/* Routeneintraege fuer parms.tnb ausgeben */
void dump_ax25ip(MBHEAD* mbp)
{
  register int i;

  putstr(";\r; AX25IP Routes\r;\r", mbp);

  if (ax25ip_active == FALSE)
    return;

  if (new_parser == TRUE)
  {
    putstr("; WARNING: this section is written using the new syntax of the AXIPR-command,\r", mbp);
    putstr(";          DO NOT USE with older TNNs compiled only for old style syntax !!!\r;\r", mbp);

    /* Falls wir noch im alten Parser sind, dann umschalten */
    putprintf(mbp, "AXIPR P\r");
    /* eigenen UDP-Port ausgeben */
    putprintf(mbp, "AXIPR MYUDP %u\r", ntohs(my_udp));
    /* Timeout fuer dynamische Routen ausgeben */
    putprintf(mbp, "AXIPR TIMEOUT %u\r", uDynTimeout);
    /* Intervall fuer Hostnamen-Update ausgeben */
    putprintf(mbp, "AXIPR LOOKUP %u\r", uNamesUpdate);
  }

#ifdef AXIPR_UDP
  /* eigenen UDP-Port ausgeben */
  putprintf(mbp, "AXIPR U %u\r", ntohs(my_udp));
  /* Timeout fuer dynamische Routen ausgeben */
  putprintf(mbp, "AXIPR T %u\r", uDynTimeout);

  putprintf(mbp, "AXIPR L %d\r",loglevel);

#ifdef AXIPR_HTML
  putprintf(mbp, "AXIPR H %d\r",HtmlStat);
#endif /* AXIPR_HTML */
#endif /* AXIPR_UDP */

  /* alle Routingtabelleneintraege durchgehen und ausgeben */
  for (i = 0; i < route_tbl_top; ++i)
  {
    /* Dynamisch gelernte Routen werden inaktiv zur Information geschrieben ! */
    if (route_tbl[i].timeout != 0)
      continue;

/*    putprintf(mbp, "; ");*/

    /* Eintrag einer Route erzeugen */
    putprintf(mbp, (new_parser == FALSE ? "AXIPR R + %s " : "AXIPR ADD %s ")
                 , call_to_a(&route_tbl[i].callsign[0]));

    /* Den Hostnamen ausgeben */
    putprintf(mbp, "%s", route_tbl[i].hostname);

    /* Mode und ggf. Port ausgeben wenn UDP */
    if (route_tbl[i].udp_port != 0)
    {
      putstr((new_parser == FALSE ? " U " : " UDP "), mbp);
      putnum(ntohs(route_tbl[i].udp_port), mbp);
    }

    putstr("\r", mbp);
  }

  /* Die Defaultroute ausgeben wenn gesetzt */
  if (default_route.callsign[0] == 1)
  {
    /* Kommandokopf schreiben */
    putstr((new_parser == FALSE ? "AXIPR D + " : "AXIPR ADD DEFAULT "), mbp);

    /* Den Hostnamen ausgeben */
    putprintf(mbp, "%s", default_route.hostname);

    /* Mode und ggf. Port ausgeben wenn UDP */
    if (default_route.udp_port != 0)
    {
      putstr((new_parser == FALSE ? " U " : " UDP "), mbp);
      putnum(ntohs(default_route.udp_port), mbp);
    }
    putstr("\r", mbp);
  }
}

/************************************************************************/
/* AX25IP Initialisierung                                               */
/************************************************************************/
BOOLEAN ax25ip_l1init(int l2port)
{
  if (ax25ip_active == TRUE)
    return(TRUE);

  /* Socketstrukturen initialisieren */
  memset((char*)&to, 0, sizeof(to));
  memset((char*)&from, 0, sizeof(from));

  ax25ip_port = l2port;
  l1pp = &l1port[l1ptab[l2port]];
  l2flp = (LHEAD *) &txl2fl[l2port];

  /* Routingtabelle initialisieren */
  route_init();

  /* Konfiguration einlesen */
  if (config_read() == FALSE)
    return(FALSE);

  /* Notwendige Sockets anlegen */
#ifndef AXIPR_UDP
  ax25ip_check_up();
#endif

  /* Wir sind fertig */
  ax25ip_active = TRUE;
  return(TRUE);
}

/* Einen Filedescriptor fuer IP anlegen */
int setup_ip(void)
{
  /* Temporaerer Filedescriptor */
  int tmp_fd = -1;

  /* Adressstruktur loeschen */
  memset((char*)&ipbind, 0, sizeof(ipbind));

  /* Rohen IP-Socket anlegen */
  if ((tmp_fd = socket(AF_INET, SOCK_RAW, IPPROTO_AX25)) < 0)
  {
    xprintf("AX25IP : cannot create ip raw-socket: %s\n", strerror(errno));
    LOGL2("AX25IP : cannot create ip raw-socket: %s\n", strerror(errno));
    return(-1);
  }

  /* Nonblocking-IO */
  if (fcntl(tmp_fd, F_SETFL, FNDELAY) < 0)
  {
    xprintf("AX25IP : cannot set non-blocking I/O on ip raw-socket\n");
    LOGL2("AX25IP : cannot set non-blocking I/O on ip raw-socket\n");
    close(tmp_fd);
    return(-1);
  }

  /* Adressstruktur mit notwendigen Werten fuellen */
  ipbind.sin_family = AF_INET;
  ipbind.sin_addr.s_addr = htonl(INADDR_ANY);

  return (tmp_fd);
}

/* Einen Filedescriptor fuer UDP anlegen */
/* Es muss der UDP-Port angegeben werden, auf dem wir hoeren wollen */
/* (Achtung: UDP-Port in Network-Byteorder) */
int setup_udp(unsigned short udp_port)
{
  /* Temporaerer Filedescriptor */
  int tmp_fd = -1;

  /* Port-Check */
  if (udp_port == 0)
    return(-1);

  /* Adressstruktur loeschen */
  memset((char*)&udpbind, 0, sizeof(udpbind));

  /* UDP-Socket anlegen */
  if ((tmp_fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
  {
    xprintf("AX25IP : cannot create socket: %s\n", strerror(errno));
    LOGL2("AX25IP : cannot create socket: %s\n", strerror(errno));
    return(-1);
  }

  /* Nonblocking-IO */
  if (fcntl(tmp_fd, F_SETFL, FNDELAY) < 0)
  {
    xprintf("AX25IP : cannot set non-blocking I/O on udp socket\n");
    LOGL2("AX25IP : cannot set non-blocking I/O on udp socket\n");
    close(tmp_fd);
    return(-1);
  }

  /* Socket-Optionen fuer UDP einstellen */
  /* SO_KEEPALIVE einschalten */
  if (sockopt_keepalive == TRUE)
  {
    int iFlag = 1;

    if (setsockopt(tmp_fd, SOL_SOCKET, SO_KEEPALIVE, (const char *)&iFlag, sizeof(int)) < 0)
    {
      xprintf("AX25IP : cannot set SO_KEEPALIVE for udp : %s\n", strerror(errno));
      LOGL2("AX25IP : cannot set SO_KEEPALIVE for udp : %s\n", strerror(errno));
    }
  }

  /* Socket auf max. Durchsatz */
  if (sockopt_throughput == TRUE)
  {
    int iFlag = IPTOS_THROUGHPUT;

    if (setsockopt(tmp_fd, IPPROTO_IP, IP_TOS, (const char *)&iFlag, sizeof(IPTOS_THROUGHPUT)) < 0)
    {
      xprintf("AX25IP : cannot set IPTOS_THROUGHPUT for udp : %s\n", strerror(errno));
      LOGL2("AX25IP : cannot set IPTOS_THROUGHPUT for udp : %s\n", strerror(errno));
    }
  }

  /* Adressstruktur fuellen */
  udpbind.sin_addr.s_addr = htonl(INADDR_ANY);
  udpbind.sin_port = udp_port;
  udpbind.sin_family = AF_INET;

  /* Adresse und Port binden */
  if (bind(tmp_fd, (struct sockaddr *)&udpbind, sizeof(udpbind)) < 0)
  {
    xprintf("AX25IP : cannot bind udp socket: %s\n", strerror(errno));
    LOGL2("AX25IP : cannot bind udp socket: %s\n", strerror(errno));
    close(tmp_fd);
    return(-1);
  }

  return(tmp_fd);
}

/* Pruefen, ob schon Sockets angelegt sind, wenn nicht, dann notwendige */
/* Sockets oeffnen */
void ax25ip_check_up(void)
{
  /* IP notwendig ? */
  if ((count_routes(FALSE) != 0) && (fd_ip == -1))
    fd_ip = setup_ip(); /* IP starten */

  /* UDP notwendig ? */
  if ((count_routes(TRUE) != 0) && (fd_udp == -1))
    fd_udp = setup_udp(my_udp); /* UDP starten */

#ifdef AXIPR_UDP
  if (l1pp != NULL)
#endif
    /* Markieren, ob IP oder UDP laufen */
    l1pp->kisslink = max(fd_ip, fd_udp);
}

/* Pruefen, ob Sockets angelegt sind und diese noch benoetigt werden. */
/* Falls nicht, Sockets schliessen */
void ax25ip_check_down(void)
{
  /* IP notwendig ? */
  if ((count_routes(FALSE) == 0) && (fd_ip != -1))
  {
    close(fd_ip);
    fd_ip = -1;
  }

  /* UDP notwendig ? */
  if ((count_routes(TRUE) == 0) && (fd_udp != -1))
  {
    close(fd_udp);
    fd_udp = -1;
  }

  /* Gibt es einen Eintrag. */
  if (l1pp)
    /* Markieren, ob IP oder UDP laufen */
    l1pp->kisslink = max(fd_ip, fd_udp);
}

/*************************************************************************/
/* AX25IP Pakete empfangen                                               */
/*************************************************************************/
void ax25ip_recv(void)
{
  struct       iphdr *ipptr;
  struct       timeval tv;
  int          l = 0;
  int          iDescriptorsReady = 0;
  register int i = 0;
  register int max_fd = -1;
  socklen_t    fromlen = sizeof(from);
  int          hdr_len = 0;
  UBYTE        buf[MAX_FRAME+1];
  UBYTE        *bufptr;
  MBHEAD       *rxfhd;
  BOOLEAN      UDP_Frame = FALSE;
  fd_set       rmask;

#ifdef AXIPR_UDP
  if (LookAX25IP)
    return;
#endif /* AX25IP_UDP */

  FD_ZERO(&rmask);

  /* IP-Filedescriptor eintragen */
  if (fd_ip != -1)
  {
    FD_SET((unsigned int)fd_ip, &rmask);
    if (fd_ip > max_fd - 1)
      max_fd = fd_ip + 1;
  }

  /* UDP-Filedescriptor eintragen */
  if (fd_udp != -1)
  {
    FD_SET((unsigned int)fd_udp, &rmask);
    if (fd_udp > max_fd - 1)
      max_fd = fd_udp + 1;
  }

  /* ist was aktiv ? */
  if (max_fd == -1)
    return;

  tv.tv_usec = 0;
  tv.tv_sec = 0;

  iDescriptorsReady = select(max_fd, &rmask, NULL, NULL, &tv);

  /* nix da */
  if (iDescriptorsReady == 0)
    return;
 
  /* Fehler */
  if (iDescriptorsReady == -1)
  {
    LOGL2("select()-Error %i: %s", errno, strerror(errno));
    return;
  }

  /* RX fuer IP */
  if ((fd_ip != -1) && (FD_ISSET(fd_ip, &rmask)))
  {
    l = recvfrom(fd_ip, (UBYTE *)(bufptr = buf), MAX_FRAME, 0, (struct sockaddr *) &from, &fromlen);

    if (l > 0)
    {
      if (l > (signed)sizeof(struct iphdr*))
      {
        ipptr = (struct iphdr*)buf;
        hdr_len = 20;

        if (!ok_crc(buf + hdr_len, l - hdr_len))
        { /* stimmt die CRC ? */
          LOGL2("IP-RX: CRC-Error, frame dropped");
          return; /* Fehler */
        }
      }
      else
      {
        LOGL2("IP-RX: frame too short, frame dropped");
        return; /* Fehler */
      }
    }
    i = hdr_len;
  }

  /* RX fuer UDP, aber nur, wenn nicht schon TCP was empfangen hat */
  if ((fd_udp != -1) && (FD_ISSET(fd_udp, &rmask) && (l == 0)))
  {
    l = recvfrom(fd_udp, (UBYTE *)(bufptr = buf), MAX_FRAME, 0, (struct sockaddr *) &from, &fromlen);

    if (l > 0)
    {
      if (!ok_crc(buf, l))
      { /* stimmt die CRC ? */
        LOGL2("UDP-RX: CRC-Error, frame dropped");
        return; /* Fehler */
      }
    }
    UDP_Frame = TRUE;
  }

  /* Ab hier gemeinsame Behandlung */
  /* Erst mal gucken, ob was gekommen ist */
  if (l == 0)
    return; /* nix da */

  l -= 2; /* CRC abschneiden */

  if (l < 15)
  {
    LOGL2("AX25IP: RX frame dropped, length wrong, frame is too short !");
    return;
  }

  /* Hier angekommen haben wir (hoffentlich) ein gueltiges Frame. Die */
  /* weitere Behandlung ist fuer IP und UDP nahezu identisch.         */

  /* Frame in Buffer umkopieren und Empfangsport eintragen */
  rxfhd = cpyflatmb((char*)&buf[i], l - i);
  rxfhd->l2port = ax25ip_port;

  /* Frame in die L2-RX-Kette einhaengen */
  relink((LEHEAD *)rxfhd, (LEHEAD *)rxfl.tail);

  /* Jetzt noch das Frame an den Routenlerner zur Analyse */
  if (route_canlearn(rxfhd))
  {
    /* Frame kann zum Lernen benutzt werden */
    /* Absenderrufzeichen ermitteln und konvertieren      */
    /* Wir brauchen hier nicht den eigentlichen Absender, */
    /* sondern den, der als letztes gedigipeated hat.     */
    struct in_addr ipaddr;
#ifndef AXIPR_UDP
    struct route_table_entry* rtptr;
#endif /* AXIPR_UDP */
    unsigned char srccall[L2IDLEN + 1];

    cpyid((char *)srccall, dheardcall(rxfhdr));

    /* Call linksschieben */
    for (i = 0; i < L2CALEN; ++i)
      srccall[i] = srccall[i] << 1;

    /* Gibt es schon eine IP fuer dieses Call, dann kann sich die IP  */
    /* geaendert haben. Falls ja und es sich um einen dynamischen Eintrag */
    /* handelt, dann loeschen und neuen Eintrag anlegen. */
#ifndef AXIPR_UDP
    if ((rtptr = call_to_ip(srccall)) != NULL)
    {
      if ((   (rtptr->ip_addr != from.sin_addr.s_addr)
           || (rtptr->udp_port != (UDP_Frame == TRUE ? ntohs(from.sin_port) : 0)))
           && (rtptr->timeout != 0))
        route_del(srccall); /* Route loeschen */
      else
      {
        if (rtptr != &default_route)
          return;             /* Adresse unveraendert */
      }
    }
#endif /* AXIPR_UDP */

    ipaddr.s_addr = from.sin_addr.s_addr;

#ifndef AXIPR_UDP
    /* Route eintragen */
    route_add((unsigned char*)inet_ntoa(ipaddr), NULL, srccall,
              (UDP_Frame == TRUE ? ntohs(from.sin_port) : 0), FALSE, uDynTimeout);
#else
    route_analyse(ipaddr, srccall,
                  (UDP_Frame == TRUE ? ntohs(from.sin_port) : 0));
  }
#endif /* AXIPR_UDP */
}

/*************************************************************************/
/* AX25IP Pakete senden                                                  */
/*************************************************************************/
void ax25ip_send(void)
{
  unsigned char  buf[MAX_FRAME];
  int            len = 0;
  int            fd = -1;
  MBHEAD        *txfhdl;

  struct route_table_entry *rt;
  struct hostent *hstent;

  unsigned char *call;

  if (kick[ax25ip_port]) /* haben wir was zu senden ? */
  {
    /* Sicherheitsabfrage, da kick[] auch manipuliert werden kann */
    if (l2flp->head == l2flp)
    {
      kick[ax25ip_port] = FALSE;
      return;
    }

    ulink((LEHEAD *)(txfhdl = (MBHEAD *) l2flp->head));/*Zeiger holen*/

    /* Daten aus den internen Puffern in einen linearen Puffer uebertragen */
    len = cpymbflat((char*)&buf[0], txfhdl);

    relink((LEHEAD *)txfhdl,          /* als gesendet betrachten und in */
           (LEHEAD *)stfl.tail);      /* die gesendet Liste umhaengen   */

    kick[ax25ip_port] = ((LHEAD *)l2flp->head != l2flp);

    /* Naechstes Call der Digipeaterkette holen */
    call = next_addr(buf);

    /* IP-Adresse des naechsten Digipeaters ermitteln */
    rt = call_to_ip(call);

    if (rt == NULL) /* wir kennen das Ziel nicht */
    {
#ifdef AXIPR_UDP
       if ((rt = search_route(call)) == NULL)
       {
#endif
         LOGL2("no route for %s, can't send", call_to_a(call));
         return;
       }
#ifdef AXIPR_UDP
    }
#endif

    /* Ein Host, zu dem bisher keine IP-Adresse aufgeloest werden konnte */
    if (rt->ip_addr == 0L)
    {
      /* Versuchen, jetzt eine IP-Adresse zu bestimmen */
      if ((hstent = gethostbyname((char*)rt->hostname)) != NULL)
         memcpy((unsigned char*)&rt->hostname, (unsigned char *)&hstent->h_addr_list[0][0], 4);
    }

    /* Checksumme anhaengen */
    add_ax25crc(buf, len);
    /* CRC-Bytes sind dazugekommen */
    len += 2;
    /* Ziel-IP-Adresse in Sendestruktur eintragen */
    memcpy((char *) &to.sin_addr, (char *)&rt->ip_addr, 4);
    /* Ziel-Port nur bei UDP eintragen */
    if (rt->udp_port != 0)
      memcpy((char *) &to.sin_port, (char *)&rt->udp_port, 2);
    else
      to.sin_port = 0;  /* bei IP kein Port */

    to.sin_family = AF_INET;

    /* Unterscheidung IP oder UDP */
    if (to.sin_port == 0)
      fd = fd_ip;
    else
      fd = fd_udp;

    if (fd == -1)
    {
      LOGL2("error: no descriptor, can't send !!!");
      return;
    }

    if (sendto(fd, (char *)buf, len, 0, (struct sockaddr *)&to, sizeof(to)) < 0)
      LOGL2("error: sendto failed, fd=%u error=%s", fd, strerror(errno));
  }
}

/*************************************************************************/
/* AX25IP Deinitialisierung, Port und Sockets schliessen                 */
/*************************************************************************/
void ax25ip_l1exit(void)
{
  /* Nur wenn aktiv */
  if (ax25ip_active == FALSE)
    return;

  /* IP-Socket schliessen wenn offen */
  if (fd_ip != -1)
  {
    close(fd_ip);
    fd_ip = -1;
  }

  /* UDP-Socket schliessen wenn offen */
  if (fd_udp != -1)
  {
    close(fd_udp);
    fd_udp = -1;
  }

  /* AX25IP nicht mehr aktiv */
  ax25ip_active = FALSE;

  /* Gibt es einen Eintrag. */
  if (l1pp)
    l1pp->kisslink = -1;
}

void ax25ip_l1ctl(int req, int port)
{
  /* nur eigene Ports bearbeiten */
  if ((ax25ip_active == FALSE) || (kissmode(port) != KISS_AXIP))
    return;

  switch (req)
  {
    /* Testpattern auf dem Port senden (wird unterdrueckt) */
    case L1CTST : testflag[port] = FALSE;
                  kick[port] = FALSE;
                  break;

    default : break;
  }
}

void ax25ip_hwstr(int port, MBHEAD *mbp)
{
#ifdef AXIPR_UDP
    putstr(" ", mbp);
    /* My UDP-Port ausgeben. */
    putprintf(mbp,"%u", ntohs(my_udp));
#endif
}

BOOLEAN ax25ip_dcd(int port)
{
  return (FALSE);
}


/* routing.c    Routing table manipulation routines
 *
 * Copyright 1991, Michael Westerhof, Sun Microsystems, Inc.
 * This software may be freely used, distributed, or modified, providing
 * this header is not removed.
 *

 * Modified for use in TNN by DG1KWA & DG9OBU

 */



/* Initialize the routing table */
void route_init(void)
{
  /* Defaultroute initialisieren */
  memset(&default_route, 0 , sizeof(struct route_table_entry));

  /* Routen initialisieren */
  memset(&route_tbl, 0, (TABLE_SIZE * sizeof(struct route_table_entry)));
}

/* Add a new route entry */
#ifndef AXIPR_UDP
static void route_add(unsigned char* hostname, struct hostent *hstent, unsigned char *call, int udpport,
                      int default_rt, int timeout)
#else
static BOOLEAN route_add(unsigned char *host, struct hostent *hstent, unsigned char *call, int udpport,
                         int default_rt, int timeout, char *hostname
#ifdef AXIPR_HTML
                      , char *timeset, UWORD protokoll
#endif /* AXIPR_HTML */
                      )
#endif /* AXIPR_UDP */
{
   register unsigned int i = 0;
   struct route_table_entry *rtptr;
   struct hostent *hst;

   /* Eintrag soll Defaultroute sein */
   if (default_rt)
   {
      for (i = 1; i < 7 ;++i)
        default_route.callsign[i] = 0;

      if (hstent != NULL)
        memcpy(&default_route.ip_addr, (unsigned char *)&hstent->h_addr_list[0][0], 4);
      else
        memset(&default_route.ip_addr, 0, 4);

      default_route.udp_port = htons((unsigned short)udpport);
      default_route.timeout = 0;                /* Defaultroute ohne Timeout */

      if (hostname != NULL)
        strncpy((char*)&default_route.hostname, (char*)hostname, HNLEN);

      default_route.callsign[0] = 1;            /* mark valid */

      /* Socket ggf. installieren */
      ax25ip_check_up();

#ifndef AXIPR_UDP
      return;
#else
      return(TRUE);
#endif /* AXIPR_UDP */
   }

   /* Normale Routen nur wenn Call vorhanden */
   if (call == NULL)
#ifndef AXIPR_UDP
     return;
#else
     return(FALSE);
#endif /* AXIPR_UDP */

   /* Check auf doppelte Eintraege, Eintrag wird nur angenommen wenn */
   /* es noch noch keinen Eintrag unter diesem Call gibt. */
   if (((rtptr = call_to_ip(call)) != NULL) && (rtptr->ip_addr != default_route.ip_addr))
   {
#ifndef AXIPR_UDP
     putmsg("A route to this callsign is already set up, delete it first.\r");
     return;
#else
#ifndef AXIPR_HTML
     UpdateRoute(call, udpport, timeout, hostname);
#else
     UpdateRoute(call, udpport, timeout, hostname, timeset, protokoll);
#endif /* AXIPR_HTML */
     return(FALSE);
#endif /* AXIPR_UDP */
   }

   /* Passt noch ein Eintrag in die Tabelle ? */
   if (route_tbl_top >= TABLE_SIZE)
   {
     xprintf("Routing table is full; entry ignored.\n");
     LOGL2("Routing table is full; entry ignored");
     putmsg("Routing table is full, entry ignored\r");
#ifndef AXIPR_UDP
     return;
#else
     return(FALSE);
#endif /* AXIPR_UDP */
   }

   /* Call eintragen */
   for (i = 0; i < 6; ++i)
     route_tbl[route_tbl_top].callsign[i] = call[i] & 0xfe;

   /* SSID eintragen */
   route_tbl[route_tbl_top].callsign[6] = (call[6] & 0x1e) | 0x60;

   if (hstent != NULL && hstent->h_length != 0)
   {
     memcpy((unsigned char*)&route_tbl[route_tbl_top].ip_addr, (unsigned char *)&hstent->h_addr_list[0][0], 4);
   }
   else
     memset(&route_tbl[route_tbl_top].ip_addr, 0, sizeof(route_tbl[route_tbl_top].ip_addr));

   route_tbl[route_tbl_top].udp_port = htons((unsigned short)udpport);
   route_tbl[route_tbl_top].timeout = timeout;

   if (hostname != NULL)
   {
     memcpy(&route_tbl[route_tbl_top].hostname, hostname, strlen((char*)hostname));
     /* Keine Adressaufloesung bisher, dann probieren wir es noch einmal */
     if (hstent == NULL)
     {
       if ((hst = gethostbyname((char*)hostname)) != NULL)
         memcpy((unsigned char*)&route_tbl[route_tbl_top].ip_addr, &hst->h_addr_list[0][0], 4);
     }
   }

#ifdef AXIPR_UDP
   /* Original UDP-Port eintragen. */
   route_tbl[route_tbl_top].org_udp_port = htons((UWORD)udpport);
#endif

#ifdef AXIPR_HTML
   /* Hostname eintragen. */
   (void)memcpy(route_tbl[route_tbl_top].timeset, timeset, 17);
   /* Protokoll eintragen. */
   route_tbl[route_tbl_top].protokoll = P_USER;
   /* Route als offline markieren. */
   route_tbl[route_tbl_top].online = FALSE;
#endif

   /* Ein Routeneintrag mehr */
   route_tbl_top++;

   /* Socket ggf. installieren */
   ax25ip_check_up();

#ifndef AXIPR_UDP
   return;
#else
   return(TRUE);
#endif /* AXIPR_UDP */
}

/*
 * Return an IP address and port number given a callsign.
 * We return a pointer to the route structure for this callsign
 * or a NULL-pointer if no route was found.
 */

struct route_table_entry* call_to_ip(unsigned char *call)
{
   register int i;
   unsigned char mycall[7];

   /* Leere Calls koennen nicht verarbeitet werden */
   if (call == NULL)
     return (NULL);

   /* Call-Bytes kopieren, letztes Bit abschneiden (entspricht >> 1 & 7F) */
   for (i = 0; i < 6; ++i)
     mycall[i] = call[i] & 0xfe;

   /* SSID kopieren */
   mycall[6] = (call[6] & 0x1e) | 0x60;

   /* Routingtabelle durchsuchen */
   for (i = 0; i < route_tbl_top; ++i)
   {
     if (addrmatch(mycall , route_tbl[i].callsign))
     {
       /* Aktivitaet auf diesem Eintrag, dann Timeout erneuern */
       if (route_tbl[i].timeout)
         route_tbl[i].timeout = uDynTimeout;

       return (&route_tbl[i]); /* Eintrag gefunden */
     }
   }

   /* Kein Routingeintrag vorhanden, Default-Route melden wenn vorhanden */
   if (default_route.callsign[0])
      return (&default_route);

   /* Kein Routingeintrag gefunden, keine Defaultroute */
   return (NULL);
}

/*
 * tack on the CRC for the frame.  Note we assume the buffer is long
 * enough to have the two bytes tacked on.
 */
void add_ax25crc(unsigned char *buf, int l)
{
   unsigned short int u = compute_crc(buf, l);

   buf[l] = u & 0xff;              /* lsb first */
   buf[l + 1] = (u >> 8) & 0xff;   /* msb next */
}


/*
 **********************************************************************
 * The following code was taken from Appendix B of RFC 1171
 * (Point-to-Point Protocol)
 *
 * The RFC credits the following sources for this implementation:
 *
 *   Perez, "Byte-wise CRC Calculations", IEEE Micro, June, 1983.
 *
 *   Morse, G., "Calculating CRC's by Bits and Bytes", Byte,
 *   September 1986.
 *
 *   LeVan, J., "A Fast CRC", Byte, November 1987.
 *
 *
 * The HDLC polynomial: x**0 + x**5 + x**12 + x**16
 */

/*
 * u16 represents an unsigned 16-bit number.  Adjust the typedef for
 * your hardware.
 */
/*typedef unsigned short u16;*/


/*
 * FCS lookup table as calculated by the table generator in section 2.
 */
static UWORD fcstab[256] = {
   0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
   0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
   0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
   0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
   0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
   0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
   0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
   0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
   0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
   0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
   0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
   0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
   0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
   0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
   0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
   0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
   0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
   0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
   0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
   0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
   0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
   0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
   0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
   0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
   0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
   0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
   0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
   0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
   0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
   0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
   0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
   0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
};

#define PPPINITFCS      0xffff  /* Initial FCS value */
#define PPPGOODFCS      0xf0b8  /* Good final FCS value */

/*
 * Calculate a new fcs given the current fcs and the new data.
 */
UWORD pppfcs(register UWORD fcs, register unsigned char *cp, register int len)
{
    while (len--)
       fcs = (fcs >> 8) ^ fcstab[(fcs ^ *cp++) & 0xff];

    return(fcs);
}

/*
 * End code from Appendix B of RFC 1171
 **********************************************************************
 */

/*
 *  The following routines are simply convenience routines...
 *  I'll merge them into the mainline code when suitably debugged
 */

/* Return the computed CRC */
UWORD compute_crc(unsigned char *buf, int l)
{
   UWORD fcs = (pppfcs(PPPINITFCS, buf, l) ^ 0xFFFF);

   return (fcs);
}

/* Return true if the CRC is correct */
BOOLEAN ok_crc(unsigned char *buf, int l)
{
   UWORD fcs = pppfcs(PPPINITFCS, buf, l);

   return (fcs == PPPGOODFCS);
}

/* return true if the addresses supplied match */
int addrmatch(unsigned char *a, unsigned char *b)
{
   if ((*a == '\0') || (*b == '\0')) return(0);

   if ((*a++ ^ *b++) & 0xfe) return(0);   /* "K" */
   if ((*a++ ^ *b++) & 0xfe) return(0);   /* "A" */
   if ((*a++ ^ *b++) & 0xfe) return(0);   /* "9" */
   if ((*a++ ^ *b++) & 0xfe) return(0);   /* "W" */
   if ((*a++ ^ *b++) & 0xfe) return(0);   /* "S" */
   if ((*a++ ^ *b++) & 0xfe) return(0);   /* "B" */
   if ((*a++ ^ *b++) & 0x1e) return(0);   /* ssid */
   return(1);
}

/* return pointer to the next station to get this packet */
unsigned char *next_addr(unsigned char *f)
{
   unsigned char *a;

   /* If no digis, return the destination address */
   if (NO_DIGIS(f)) return(f);

   /* check each digi field.  The first one that hasn't seen it is the one */
   a = f + 7;
   do {
      a += 7;
      if (NOTREPEATED(a)) return(a);
   } while (NOT_LAST(a));

/* all the digis have seen it.  return the destination address */
   return(f);
}

/* Open and read the config file */
int config_read(void)
{
   FILE *cf;
   char buf[256], cbuf[256];
   int errflag = 0;
   int e = 0;
   int lineno = 0;
   char cfgfile[256];

   strcpy(cfgfile, confpath);
   strcat(cfgfile, CONFIG_FILE);

   if ((cf = fopen(cfgfile, "r")) == NULL)
   {
#ifdef INIPATH
     strcpy(cfgfile, INIPATH);
     strcat(cfgfile, CONFIG_FILE);

     if ((cf = fopen(cfgfile, "r")) == NULL)
     {
#endif
#ifdef AXIPR_UDP
       /* AX25IP.CFG ist nicht mehr noetig,   */
       /* kann aber weiterhin benutzt werden. */
       return(TRUE);
#endif
       xprintf("AX25IP: Config file %s not found or could not be opened\n", CONFIG_FILE);
       return(FALSE);
#ifdef INIPATH
     }
#endif
   }

   while (fgets(buf, 255, cf) != NULL)
   {
     (void)strcpy(cbuf, buf);
     ++lineno;

     if ((e = parse_line(buf)) < 0)
     {
       xprintf("Config error at line %d: ", lineno);

       switch (e)
       {
         case -1 : xprintf("Missing argument\n"); break;
         case -2 : xprintf("Bad callsign format\n"); break;
         case -3 : xprintf("Bad option - on/off\n"); break;
         case -4 : xprintf("Bad option - tnc/digi\n"); break;
         case -5 : xprintf("Host not known\n"); break;
         case -6 : xprintf("Unknown command\n"); break;
         case -7 : xprintf("Text string too long\n"); break;
         case -8 : xprintf("Bad option - every/after\n"); break;
         case -9 : xprintf("Bad option - ip/udp\n"); break;

         default: xprintf("Unknown error\n"); break;
       }
       xprintf("%s", cbuf);
       ++errflag;
     }
   }

   if (errflag)
     exit(1);

   if (mode == NO_MODE)
   {
     xprintf("Must specify ip and/or udp sockets\n");
     return(FALSE);
   }

   fclose(cf);

   return(TRUE);
}

/* Process each line from the config file.  The return value is encoded. */
int parse_line(char *buf)
{
   char *p;
   char *q;
   char hostname[HNLEN];
   unsigned char tcall[7];
   struct hostent hstent;
   struct hostent *he;
   int i = 0;
   int uport = 0;
   int dfalt = 0;
#ifdef AXIPR_HTML
   char *timeset = set_time();
#endif

   p = strtok(buf, " \t\n\r");

   memset(&hstent, 0, sizeof(hstent));

   /* Leere Zeilen */
   if (p == NULL)
     return(0);

   /* Kommentarzeilen nicht auswerten */
   if (*p == '#')
     return(0);

   if (strcmp(p, "socket") == 0)
   {
     q = strtok(NULL, " \t\n\r");

     if (q == NULL)
       return(-1);

     if (strcmp(q, "ip") == 0)
       mode = IP_MODE;
     else if (strcmp(q, "udp") == 0)
     {
        mode = UDP_MODE;
        my_udp = htons(DEFAULT_UDP_PORT);

        /* Bei UDP optionale Portnummer lesen */
        q = strtok(NULL, " \t\n\r");

        /* Nummer war vorhanden, auswerten */
        if (q != NULL)
        {
           i = atoi(q);
           /* Nummer ist gueltig, uebernehmen */
           if (i > 0)
             my_udp = htons((unsigned short)i);
        }
     }
     else
       return(-9);

     return(0);
   }
   else if (strcmp(p, "socketoption") == 0)
     {
       q = strtok(NULL, " \t\n\r");

       /* Pruefung auf leere Zeile */
       if (q == NULL)
         return(-1);

       if (strcmp(q, "SO_KEEPALIVE") == 0)
       {
          sockopt_keepalive = TRUE;
       }
       else if (strcmp(q, "IPTOS_THROUGHPUT") == 0)
       {
          sockopt_throughput = TRUE;
       }
       else return(-9);

     return(0);

    } else if (strcmp(p, "loglevel") == 0) {
      q = strtok(NULL, " \t\n\r");
      if (q == NULL) return(-1);
      loglevel = atoi(q);
      return(0);

   } else if (strcmp(p, "route") == 0) {
      uport = 0;
      dfalt = 0;

      q = strtok(NULL, " \t\n\r");

      /* Pruefung auf leere Zeile */
      if (q == NULL)
        return(-1);

      /* Pruefung auf default-Route */
      if (strcmp(q, "default") == 0)
        dfalt = 1;
      else
      {
         /* Ziel der Route pruefen */
         if (a_to_call(q, tcall) != 0)
           return(-2);
      }

      /* Hostnamen holen, dies kann auch eine IP-Adresse sein */
      q = strtok(NULL, " \t\n\r");
      if (q == NULL)
        return(-1);

      he = gethostbyname(q);

      /* Keine gueltige IP-Adresse ? */
      if (he == NULL)
      {
        /* Da route_add() eine hostent-Struktur braucht, bauen wir ihm eine. */
        /* Den Hostname sichern und den Zeiger auf den Puffer im hostent eintragen. */
        strncpy(hostname, q, HNLEN);

         he = &hstent;
         he->h_name = hostname;
      }

      q = strtok(NULL, " \t\n\r");

      if (q != NULL)
      {
        if (strcmp(q, "udp") == 0)
        {
          uport = DEFAULT_UDP_PORT;

          q = strtok(NULL, " \t\n\r");
          if (q != NULL)
          {
            i = atoi(q);
            if (i > 0)
               uport = i;
          }
        }
      }
#ifndef AXIPR_UDP
      route_add((unsigned char*)he->h_name, he, tcall, uport, dfalt, 0);
#else
      route_add((unsigned char*)he->h_name, he, tcall, uport, dfalt, 0, (char*)he->h_name
#ifdef AXIPR_HTML
               , timeset, P_USER
#endif /* AXIPR_HTML */
               );
#endif /* AXIPR_UDP */
      return(0);
   }
   return(-999);
}


/* Convert ascii callsign to internal format */
int a_to_call(char *text, unsigned char *tcall)
{
   register size_t  i = 0;
   int           ssid = 0;
   unsigned char c;

   if (strlen(text) == 0)
     return(-1);

   for (i = 0; i < 6; ++i)
     tcall[i] = (' ' << 1);

   tcall[6] = '\0';

   for (i = 0; i < strlen(text); ++i)
   {
     c = text[i];
     if (c == '-')
     {
       ssid = atoi(&text[i + 1]);
       if (ssid > 15)
         return(-1);
       tcall[6] = (ssid << 1);
       return(0);
     }

     if (islower(c))
       c = toupper(c);

     if (i > 5)
       return(-1);

     tcall[i] = (c << 1);
   }
   return(0);
}

/* Convert internal callsign to printable format */
char *call_to_a(unsigned char *tcall)
{
   int i = 0;
   int ssid = 0;
   char *tptr;
   static char t[10];

   for (i = 0, tptr = t; i < 6; ++i)
   {
     if (tcall[i] == (' ' << 1))
       break;
     *tptr = tcall[i] >> 1;
     tptr++;
   }

   ssid = (tcall[6] >> 1) & 0x0f;
   if (ssid > 0)
   {
     *tptr = '-';
     tptr++;

     if (ssid > 9)
     {
       *tptr = '1';
       tptr++;
       ssid -= 10;
     }
     *tptr = '0' + ssid;
     tptr++;
   }

   *tptr = '\0';
   return(&t[0]);
}

void write_log(const char *format, ...)
{
  FILE *fp;
  va_list arg_ptr;
  struct tm *lt;

  fp = fopen("ax25ip.log", "a+");

  if (fp != NULL)
  {
    lt = localtime(&sys_time);
    fprintf(fp, "%16.16s:", ctime(&sys_time));
    va_start(arg_ptr, format);
    vfprintf(fp, format, arg_ptr);
    va_end(arg_ptr);
    fprintf(fp, "\n");
    fclose(fp);
  }
  else
    loglevel = 0;   /* Logging aus da Fehler mit der Logdatei */
}

#ifdef AXIPR_UDP
/* AX25IP-Frame untersuchen, wenn Aenderungen     */
/* z.B. UDP-Port, IP-Adresse in TBL Aktualisieren.*/
void route_analyse(struct in_addr ip, unsigned char *call, int uport)
{
  register int   i;
  char           mycall[7];

#ifdef AXIPR_HTML
  char        *timeset = set_time();
#endif /* AXIPR_HTML */

  /* Leere Calls koennen nicht verarbeitet werden */
  if (call[0] == FALSE)
    return;

   /* Call-Bytes kopieren, letztes Bit abschneiden (entspricht >> 1 & 7F) */
   for (i = 0; i < 6; ++i)
     mycall[i] = call[i] & 0xfe;

   /* SSID kopieren */
   mycall[6] = (call[6] & 0x1e) | 0x60;

   /* Routingtabelle durchsuchen */
   for (i = 0; i < route_tbl_top; ++i)
   {
      if (addrmatch((unsigned char *)mycall , route_tbl[i].callsign))
      {
        /* Bei Aenderung uebernehmen */
        if (memcmp(&ip, &route_tbl[i].ip_addr, 4) != 0)
          /* IP-Adresse hat sich geaendert */
          memcpy(&route_tbl[i].ip_addr, &ip, 4);

        /* UDP-Port unterschiedlich? */
        if (route_tbl[i].udp_port != htons((UWORD)uport))
           /* UDP-Port updaten. */
           route_tbl[i].udp_port = htons((UWORD)uport);

#ifdef AXIPR_HTML
        /* Route ggf. auf online setzen. */
        if (!route_tbl[i].online)
          route_tbl[i].online = TRUE;
#endif
        /* Aktivitaet auf diesem Eintrag, dann Timeout erneuern */
        if (route_tbl[i].timeout)
          route_tbl[i].timeout = uDynTimeout;

        /* Aktualisierung beendet. */
        return;
      }
   }

#ifndef AXIPR_HTML
   /* Auto-Route eintragen */
   route_add((unsigned char*)inet_ntoa(ip), NULL, call,uport, FALSE, uDynTimeout, (char*)inet_ntoa(ip));
#else
   /* Auto-Route eintragen */
   route_add((unsigned char*)inet_ntoa(ip), NULL, call,uport, FALSE, uDynTimeout, (char*)inet_ntoa(ip), timeset, P_USER);
#endif /* AXIPR_HTML */
}

/* Per Rufzeichen, ohne die SSID zubeachten, einen */
/* Routeneintrag suchen. Gibt es keinen Eintrag,   */
/* wird sofort abgebrochen, ansonsten werden die   */
/* routeneintraege IP-Adresse und UDP-Port ueber-  */
/* nommen und das neue Rufzeichen wird eingetragen.*/
struct route_table_entry *search_route(unsigned char *call)
{
  register int i;
  char         srccall[10];
#ifdef AXIPR_HTML
  char        *timeset = set_time();
#endif /* AXIPR_HTML */

  /* Konvertiere Rufzeichen. */
  callss2str((char *)srccall, call_to_a(call));

  /* TB durchgehen. */
  for (i = 0; i < route_tbl_top; ++i)
  {
    /* Suche Rufzeichen. */
    if (cmpcal(srccall, call_to_a(&route_tbl[i].callsign[0])))
    {
#ifndef AXIPR_HTML
      /* Auto-Route eintragen */
      route_add((unsigned char *)&route_tbl[i].ip_addr, NULL, (unsigned char *)call, htons(route_tbl[i].org_udp_port), FALSE, uDynTimeout, (char *)route_tbl[i].hostname);
#else
      /* Auto-Route eintragen */
      route_add((unsigned char *)&route_tbl[i].ip_addr, NULL, (unsigned char *)call, htons(route_tbl[i].org_udp_port), FALSE, uDynTimeout, (char *)route_tbl[i].hostname, timeset, P_USER);
#endif /* AXIPR_HTML */
      /* Aktuellen Eintrag weiterreichen. */
       return (&route_tbl[i]); /* Eintrag gefunden */
    }
  }
 /* Kein Rufzeichen gefunden. */
 return (NULL);
}

/* Eine AX-Route Updaten. */
void UpdateRoute(unsigned char *srccall,
                  int           udpport,
                  int           timeout,
                  char         *hostname
#ifdef AXIPR_HTML
                , char          *timeset
                , UWORD          protokoll
#endif /* AXIPR_HTML */
)
{
  MBHEAD      *mbp;
  register int i;

  /* TB durchgehen. */
  for (i = 0; i < route_tbl_top; ++i)
  {
    /* Suche Rufzeichen. */
    if (addrmatch((unsigned char *)srccall , route_tbl[i].callsign))
    {
      route_tbl[i].org_udp_port = route_tbl[i].udp_port = htons((unsigned short)udpport);
      /* Hostname eintragen. */
      (void)memcpy(route_tbl[i].hostname, hostname, HNLEN);
      /* ggf. Timeout setzen. */
      route_tbl[i].timeout = timeout;

#ifdef AXIPR_HTML
      /* Hostname eintragen. */
      (void)memcpy(route_tbl[i].timeset, timeset, 17);
      /* Protokoll eintragen. */
      route_tbl[i].protokoll = P_USER;
#endif /* AXIPR_HTML */

      mbp = getmbp();

      /* und ab die Post ... */
      prompt(mbp);
      seteom(mbp);
      return;
    }
  }
}

#ifdef AXIPR_HTML

/* Protokoll fuer HTML-Ausgabe setzen. */
void SetHTML(int port, char *call, PEER *pp, BOOLEAN flag)
{
  register int  i;
  char          srccall[10 + 1];

  call2str(srccall, call);

  /* Routingtabelle durchsuchen */
  for (i = 0; i < route_tbl_top; ++i)
  {
    if (!strcmp(srccall , call_to_a(&route_tbl[i].callsign[0])))
    {
      /* Protokoll setzen. */
      set_status(i, port, pp);

      /* Route auf online/offline stellen. */
      route_tbl[i].online = flag;

      break;
    }
  }
}

/* Aktualisiere Loginzeit fuer TB */
char *set_time(void)
{
  time_t      go;
  struct tm  *zeit;
  static char c[17];
  char       *timeset = c;

  /* aktuelle Kalenderzeit */
  time(&go);
  /* konvertiert Datum und Uhrzeit. */
  zeit = localtime(&go);
  /* Formatiere eine Zeit-/Datumsangabe */
  strftime(c,17,"%d-%b-%H:%M:%S",zeit);

/* Aktuelle Login Date/Time */
return(timeset);
}

/* Protokoll setzen. */
void set_status(register int a, int port, PEER *pp)
{
  if (pp == NULL)                                  /* Route wird ausgetragen. */
  {
    route_tbl[a].protokoll = P_OFFLINE;          /* Route auf OFFLINE setzen. */
    route_tbl[a].online    = FALSE;
    return;
  }

  switch(pp->typ)                                            /* Protokol-TYP. */
  {
    case INP    :                                                 /* INP-TYP. */
     route_tbl[a].protokoll = P_INP;                       /* INP-TYP setzen. */
    break;

    case TNN    :                                                  /* TNN-TYP */
    case THENET :                                              /* THENET-TYP. */
      route_tbl[a].protokoll = P_THENET;            /* TNN/THENET-TYP setzen. */
     break;

    case FLEXNET:                                             /* FLEXNET-TYP. */
      route_tbl[a].protokoll = P_FLEXNET;              /* FLEXNET-TYP setzen. */
     break;

    default:
      route_tbl[a].protokoll = P_OFFLINE;        /* Route auf OFFLINE setzen. */
      route_tbl[a].online    = FALSE;
     return;
  }

  route_tbl[a].online    = TRUE;
}

/* Timer fuer htmlstatistik. */
void h_timer(void)
{
  static LONG h_Timer = 0L;

  /* Timer abgelaufen. */
  if (h_Timer <= 0L)
  {
    /* Timer neu setzen. */
    /* fest auf 60 sec.  */
    h_Timer = 60L;
    /* html auf Platte schreiben. */
    w_statistik();
  }
  /* Timer runter zaehlen. */
  h_Timer--;
}

/* Hiermit checken wir ob die rstat.css existiert. */
/* FALSE = keine rstat.css gefunden                */
/* TRUE  = es existiert eine rstat.css             */
static int check_css_file(void)
{
  char cssfile[255];

  /* Path kopieren. */
  strcpy(cssfile, htmlpath);
  /* CSS-Dateiname anhaengen.  */
  strcat(cssfile, CSS_RFILE);

  /* Pruefe ob Datei existiert.*/
  if (!access(cssfile,FALSE))
      /* Datei existiert. */
          return(TRUE);
  else
      /* Nix gefunden! */
          return(FALSE);
}

/* Eine default RSTAT.CSS schreiben */
static void rstat_css_default_file(void)
{
  FILE *fp;
  char cfgfile[255];

  if (HtmlStat == FALSE)
      return;

  strcpy(cfgfile, htmlpath);
  strcat(cfgfile, CSS_RFILE);
  if ((fp = fopen(cfgfile, "w+t")) == NULL)
      return;

  fprintf(fp,"BODY {\n"
             " BACKGROUND-IMAGE: url('bg.jpg');\n"
             " BACKGROUND-COLOR: #000080;\n"
             " COLOR: #FFFFFF;\n"
             " FONT-FAMILY: Verdana, Arial;\n"
             " FONT-SIZE: 12;\n"
             "}\n");

  fprintf(fp,"H1 {\n"
             " FONT-SIZE: 18; COLOR: #FFCC00;\n"
             "}\n");

  fprintf(fp,"H2 {\n"
             " FONT-SIZE: 12; COLOR: #FFFFFF;\n"
             "}\n");

  fprintf(fp,"a:link, a:visited {\n"
             " COLOR: #FFFFFF;\n"
             " text-weight: bold;\n"
             " text-decoration: none;\n"
             "}\n");

  fprintf(fp,"a:hover {\n"
             " COLOR: #FF6600;\n"
             " text-weight: bold;\n"
             " text-decoration: none;\n"
             "}\n"
             ".info {\n"
             " FONT-SIZE: 12; COLOR: #99CCFF;\n"
             "}\n");

  fprintf(fp,"table.box {\n"
             " background-color: #ffbb00;\n"
             " backcolor: #220000;\n"
             " backcolorlight: #00ff00;\n"
             " backcolordark: #000000;\n"
             " border-width: 0px;\n"
             " width: 95%%;\n"
             " border-style: outset;\n"
             " border-spacing: 2px;\n"
             " border-padding: 8px;\n"
             "}\n");
  
fprintf(fp,".status {\n"
             " FONT-SIZE: 10; BACKGROUND: #000000; COLOR: #FFCC00; TEXT-ALIGN: center;\n"
             "}\n");

  fprintf(fp,".off {\n"
             " FONT-SIZE: 10; BACKGROUND: #000000; COLOR: #ffffff;\n"
             "}");

  fprintf(fp,".offline {\n"
             " FONT-SIZE: 10; BACKGROUND: #9f00FF; COLOR: #ffffff;\n"
             "}");

  fprintf(fp,".user {\n"
             " FONT-SIZE: 10; BACKGROUND: #E06060; COLOR: #ffffff;\n"
             "}\n");

  fprintf(fp,".thenet {\n"
             " FONT-SIZE: 10; BACKGROUND: #E00060; COLOR: #ffffff;\n"
             "}\n");

  fprintf(fp,".inp {\n"
             " FONT-SIZE: 10; BACKGROUND: #0070C0; COLOR: #ffffff;\n"
             "}\n");

  fprintf(fp,".Flexnet {\n"
             " FONT-SIZE: 10; BACKGROUND: #006060; COLOR: #ffffff;\n"
             "}\n");

  fprintf(fp,".about {\n"
             " FONT-SIZE: 13; COLOR: #ffffff;\n"
             "}\n");

  fclose(fp);
}

/* Wie viel Ports sind nich frei ? */
static int free_ports(void)
{
  int free = FALSE;

  return(free = TABLE_SIZE - route_tbl_top);
}

/* Wie viel L2-Links (USER) - sind aktiv ? */
static int activ_user(void)
{
  register int a;
  int          user = FALSE;

  /* TB durchgehen */
  for (a = 0; a < route_tbl_top; a++)
    /* nur die als User markiert sind */
    if (   route_tbl[a].protokoll == P_USER
        /* und online sind !!!        */
        && route_tbl[a].online > 0)
        /* Alle USER zaehlen */
        user++;

  return(user);
}

/* Wie viel L2/L4_links sind aktiv ? */
static int activ_links(void)
{
  register int a;
  int          links = FALSE;

  /* TB durchgehen */
  for (a = 0; a < route_tbl_top; a++)
    /* L2/L4-Link online ?      */
    if (   route_tbl[a].online > 0
    /* wir zaehlen alle Protokolle, ausser USER */
        && route_tbl[a].protokoll != 1)
        links++;

  return(links);
}

/* Die Aktuelle Uhrzeit fuer HTML ausgeben */
static char *puttim_stat(void)
{
  struct      tm *p;
  static char tim[20];
  time_t      timet;
  char       *atime = tim;

  time(&timet);

  p = localtime(&timet);
  sprintf(tim,"%02i.%02i.%02i %02i:%02i:%02i",
              p->tm_mday,  p->tm_mon+1, p->tm_year % 100,
              p->tm_hour, p->tm_min, p->tm_sec);

  return(atime);
}

static char *set_class(UWORD flag, register int a)
{
  static char    o[8];
  char *protokoll = o;

  switch(flag)
  {
    case P_OFFLINE :
     if (!route_tbl[a].online)
       strcpy(o, "offline");

    break;

    case P_USER :
    if (route_tbl[a].online)
       strcpy(o, "user");
     else
       strcpy(o, "offline");
     break;

    case P_THENET :
    if (route_tbl[a].online)
       strcpy(o, "thenet");
     else
       strcpy(o, "offline");
     break;

    case P_INP :
     if (route_tbl[a].online)
       strcpy(o, "inp");
     else
       strcpy(o, "offline");

     break;

    case P_FLEXNET :
     if (route_tbl[a].online)
       strcpy(o, "flexnet");
     else
       strcpy(o, "offline");

     break;

    default:
      strcpy(o, "unknown");
     break;
  }

 return(protokoll);
}

static char *set_pname(register int a)
{
  static char p[8];
  char *protokoll = p;

  switch(route_tbl[a].protokoll)
  {
    case P_USER :
      strcpy(p, "L2");
     break;

    case P_THENET :
      strcpy(p, "THENET");
     break;

    case P_INP :
      strcpy(p, "INP");
     break;

    case P_FLEXNET :
      strcpy(p, "FLEXNET");
     break;

    default:
      strcpy(p, "UNKNOWN");
     break;
  }

return(protokoll);
}

static void all_route(FILE *fp, UWORD flag, register int a)
{
  char *pclass = set_class(flag, a);
  char *protokoll = set_pname(a);

  /* Nummer einer Route. */
  fprintf(fp,"  <td class=\"%s\"><center>%d</td>\n"
            , pclass, a);

  /* Rufzeichen. */
  fprintf(fp,"  <td class=\"%s\">%s</td>\n"
            , pclass
            , call_to_a(&route_tbl[a].callsign[0]));

  /* IP-Adresse. */
  fprintf(fp,"  <td class=\"%s\">"
             "  <a href=\"http://%s\" target=\"_http\">%s</a></td>\n"
            , pclass
            , route_tbl[a].hostname
            , route_tbl[a].hostname);

  /* Hostname/IP-Adresse. */
  fprintf(fp,"  <td class=\"%s\"><center>%s</td>\n"
            , pclass
            , route_tbl[a].hostname);

  /* UDP-Port */
  fprintf(fp,"  <td class=\"%s\"><center>%d</td>\n"
            , pclass
            , htons(route_tbl[a].udp_port));

  /* Loginzeit */
  fprintf(fp,"  <td class=\"%s\"><center>%s</td>\n"
            , pclass
            , route_tbl[a].timeset);

  if (route_tbl[a].timeout)
    /* Timeout */
    fprintf(fp,"  <td class=\"%s\"><center>%d</td>\n"
              , pclass
              , route_tbl[a].timeout);
  else
    /* Statische Route */
    fprintf(fp,"  <td class=\"%s\"><center>Statisch</td>\n"
              , pclass);

  /* Protokoll */
  fprintf(fp,"  <td class=\"%s\"><center>%s</td></tr>\n"
            , pclass
            , protokoll);
}

static void show_route(FILE *fp, UWORD flag, register int a)
{
  switch(flag)
  {
    case P_OFFLINE :
      if (!route_tbl[a].online)
         fprintf(fp," <tr class=\"offline\">\n");

      break;

    case P_USER :
      if (   route_tbl[a].protokoll == flag
          && route_tbl[a].online)
         fprintf(fp," <tr class=\"user\">\n");
      else
         fprintf(fp," <tr class=\"offline\">\n");

      break;

    case P_THENET :
      if (   route_tbl[a].protokoll == flag
          && route_tbl[a].online)
         fprintf(fp," <tr class=\"thenet\">\n");
      else
         fprintf(fp," <tr class=\"offline\">\n");

      break;


    case P_INP :
      if (   route_tbl[a].protokoll == flag
          && route_tbl[a].online)
         fprintf(fp," <tr class=\"inp\">\n");
      else
         fprintf(fp," <tr class=\"offline\">\n");

      break;

    case P_FLEXNET :
      if (   route_tbl[a].protokoll == flag
          && route_tbl[a].online)
         fprintf(fp," <tr class=\"flexnet\">\n");
      else
         fprintf(fp," <tr class=\"offline\">\n");

      break;


    default:
      if (   route_tbl[a].protokoll == flag
          && route_tbl[a].online)
         fprintf(fp," <tr class=\"unknow\">\n");
      else
         fprintf(fp," <tr class=\"offline\">\n");

     break;
  }
  all_route(fp, flag, a);
}

/* Schreibe htmlstatistik auf Platte. */
void w_statistik(void)
{
  FILE         *fp;
  char          cfgfile[255],mycall[10];
  char         *atime = puttim_stat();
  register int  a;
  char          runtime[8 + 1];
#ifndef CONNECTTIME
  unsigned long upt,
                upd,
                uph;
#endif /* CONNECTTIME */

  /* Pruefe, ob htmlstatistik eingeschaltet ist. */
  if (HtmlStat == FALSE)
      /* Ist nicht eingeschaltet, abbruch. */
      return;
  else
  {
    /* Pruefe ob CSS-Datei exisiert. */
    if (!check_css_file())
       /* Nein, dann neuschreiben.  */
       rstat_css_default_file();

  }

  strcpy(cfgfile,htmlpath );
  strcat(cfgfile, HTML_RFILE);
  if ((fp = fopen(cfgfile,"w+t")) == NULL)
      return;

  call2str(mycall,myid);

#ifndef CONNECTTIME
  upt = sys_time - start_time;                 /* Uptime in seconds     */
  upd = upt / SECONDS_PER_DAY;                 /* Uptime days           */
  upt %= SECONDS_PER_DAY;
  uph = upt / SECONDS_PER_HOUR;                /* Uptime hours          */
  upt %= SECONDS_PER_HOUR;

  if (upd > 0)
    sprintf(runtime, "%2lud,%2luh", upd, uph);
  else
    if (uph > 0)
      sprintf(runtime, "%2luh,%2lus", uph, upt);
    else
      if (upt > 0)
        sprintf(runtime, "    %2lus", upt);
      else
        sprintf(runtime, "       ");
#else
  sprintf(runtime, "%s", ConnectTime(tic10 / 100));
#endif /* CONNECTTIME */

  fprintf(fp,"<html>"
             "<head>\n"
             "<meta http-equiv=\"refresh\" content=\"%d\">\n"
             "<title>AXIPR-Statistik</title>\n"
             "<link rel=stylesheet type=text/css href=rstat.css>\n"
             "</head>\n<body>\n",HTML_INV);

  fprintf(fp,"<DIV ALIGN=\"CENTER\"><CENTER>\n"
             "<H1><U>%s%s)</U></H1>\n",signon,mycall);

  fprintf(fp,"<H2>Date/Time: %s Runtime: %s, %d Frei</H2>\n\n",atime, runtime, free_ports());
  fprintf(fp,"<FONT class=\"info\"><B> %d L2/L4-LINKS</b></FONT>\n",activ_links());
  fprintf(fp,"<table class=\"box\" cellspacing=\"2\" cellpadding=\"2\" style=\"border-collapse: collapse\">\n");
  fprintf(fp," <tr class=\"status\">\n"
             "  <td class=\"status\">Nr.</td>\n"
             "  <td class=\"status\">Rufzeichen</td>\n"
             "  <td class=\"status\">IP-Adresse</td>\n"
             "  <td class=\"status\">DYNDNS</td>\n"
             "  <td class=\"status\">UDP</td>\n"
             "  <td class=\"status\">Login</td>\n"
             "  <td class=\"status\">Timeout</td>\n"
             "  <td class=\"status\">Protokoll</td>\n"
             " </tr>\n");

   /* TB durchgehen. */
   for (a = 0; a < route_tbl_top; a++)
   {
     /* Nur aktive Routen zeigen. */
     if (route_tbl[a].online == FALSE)
       /* zum naechsten Eintrag. */
       continue;

     /* Nur INP- oder FLEXNET-Routen bearbeiten */
     if (route_tbl[a].protokoll > P_USER)
       /* und anzeigen. */
       show_route(fp, route_tbl[a].protokoll, a);
   }

   fprintf(fp,"</table><br><br>\n");

   fprintf(fp,"<FONT class=\"info\"><B>%d USER</B></FONT>\n",activ_user());
   fprintf(fp,"<table class=\"box\" cellspacing=\"2\" cellpadding=\"2\" style=\"border-collapse: collapse\">\n");
   fprintf(fp," <tr class=\"status\">\n"
              "  <td class=\"status\">Nr.</td>\n"
              "  <td class=\"status\">Rufzeichen</td>\n"
              "  <td class=\"status\">IP-Adresse</td>\n"
              "  <td class=\"status\">DYNDNS</td>\n"
              "  <td class=\"status\">UDP</td>\n"
              "  <td class=\"status\">Login</td>\n"
              "  <td class=\"status\">Timeout</td>\n"
              "  <td class=\"status\">Protokoll</td>\n"
              " </tr>\n");

   /* TB durchgehen */
   for (a = 0; a < route_tbl_top; a++)
   {
     /* Nur aktive Routen zeigen. */
     if (route_tbl[a].online == FALSE)
       /* zum naechsten Eintrag. */
       continue;

     /* Nur USER-Routen bearbeiten */
     if (route_tbl[a].protokoll == P_USER)
       /* und anzeigen. */
       show_route(fp, route_tbl[a].protokoll, a);
   }

   fprintf(fp,"</table>\n\n");
   fprintf(fp,"<BR><FONT class=\"info\"><B>My UDP-Port: %u</B></FONT>\n",htons(my_udp));
   fprintf(fp,"</body></html>\n");
   fclose(fp);
}

#endif /* AXIPR_HTML */
#endif /* AXIPR_UDP */

#endif

/* End of os/win32/ax25ip.c */