Logo Search packages:      
Sourcecode: fbb version File versions  Download package

serv.c

   /****************************************************************
    Copyright (C) 1986-2000 by

    F6FBB - Jean-Paul ROUBELAT
    6, rue George Sand
    31120 - Roquettes - France
      jpr@f6fbb.org

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

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Parts of code have been taken from many other softwares.
    Thanks for the help.
    ****************************************************************/

/*
 *
 *      SERV.C : Programme principal
 */

#define FBB_MAIN
#define MAIN

#ifdef __MSDOS__
#define PUBLIC
#endif

#include <serv.h>
#include <yapp.h>

char *os (void)
{
#ifdef __FBBDOS__
      static char *my_os = "MsDos";

#endif
#ifdef __WINDOWS__
      static char *my_os = "Windows";

#endif
#ifdef __LINUX__
      static char *my_os = "Linux";

#endif
      return (my_os);
}

#if defined(__WINDOWS__) || defined(__LINUX__)

tp_ems t_ems[NB_EMS] =
{
      {"MSG", EMS_MSG},
      {"BID", EMS_BID},
      {"HIE", EMS_HRT},
      {"FWD", EMS_FWD},
      {"REJ", EMS_REJ},
      {"WPG", EMS_WPG},
      {"SCR", 0},
};

static int out_file (int, char *);

unsigned short xendien ( unsigned short xe1 )
{
      unsigned short xe2;

      xe2 = ( xe1 & 0x00FF ) << 8 ;
      xe2 |= ( xe1 & 0xFF00 ) >> 8 ;

      return xe2 ;
}

unsigned long xendienl ( unsigned long xe1 )
{
      unsigned long xe2;

      xe2 = ( xe1 & 0x000000FF ) << 24 ;
      xe2 |= ( xe1 & 0x0000FF00 ) << 8 ;
      xe2 |= ( xe1 & 0x00FF0000 ) >> 8 ;
      xe2 |= ( xe1 & 0xFF000000 ) >> 24 ;

      return xe2 ;
}

void sortie_prg (void)
{
      static int done = 0;

      if (done)
            return;

      done = 1;

      if (*BBS_DW)
      {
#if defined(__WINDOWS__) || defined(__FBBDOS__)
            send_dos (5, BBS_DW, NULL);
#endif
#ifdef __LINUX__
            char *pptr = BBS_DW;

            call_nbdos (&pptr, 1, NO_REPORT_MODE, NULL, TOOLDIR, NULL);
#endif
      }

      write_heard ();
/*
   #ifdef __WIN32__
   EndThread();
   #endif
 */
      if (operationnel >= 0)
      {
            operationnel = FALSE;
            flush_wp_cache ();
            dde_wp_serv = 0;
            ferme_log ();
#ifdef TRACE
            close_trace ();
#endif
      }

      /* Dealloue les listes chainees */
      end_pg ();                          /* Dealloue la chaine des PG */
      end_watchdog ();
      end_messages ();
      end_admin ();
      end_textes ();
      /*  end_ports (); */
      end_arbre ();
      end_bbs ();
      end_parts ();
      end_hold ();
      end_themes ();
      end_swap ();
      end_beacon ();
      end_wp ();
      end_lzhuf ();
      end_fwd ();
      /*  end_voies (); */
      end_modem ();
      end_exms ();
}

#endif /* __WINDOWS__ */

#ifdef  __FBBDOS__
/********* Test overflow **********
long maxrec;
 ********** Fin du test ***********/

#define BREAK

tp_ems t_ems[NB_EMS] =
{
      {"MSG", EMS_MSG},
      {"BID", EMS_BID},
      {"HIE", EMS_HRT},
      {"FWD", EMS_FWD},
      {"REJ", EMS_REJ},
      {"WPG", EMS_WPG},
      {"SCR", EMS_SCR},
};

/* extern unsigned _stklen = 17408; / 16384 ; / 12000 */
extern unsigned _stklen = 32768;    /* 16384 ; / 12000 */

static char nom_programme[80];

static void init_mem (void);
static int out_file (int, char *);

/* Routine appelee avant le _exit -> directive pragma */

void sortie_prg (void)
{
      static int done = 0;

      if (done)
            return;

      done = 1;

      if (*BBS_DW)
            send_dos (5, BBS_DW, NULL);

      write_heard ();

      if (operationnel >= 0)
      {
            operationnel = FALSE;
            flush_wp_cache ();
            dde_wp_serv = 0;
            ferme_log ();
#ifdef TRACE
            close_trace ();
#endif
            libere_xems ();
            remet_vecteurs ();
      }
      cprintf ("Exiting %d ...", type_sortie);
      sleep (2);

      sleep (2);
      if (!EGA)                           /* outportb(0x3d9, 0x0) */
            ;
      else
            ega_close ();
      close_win (fen_dos);

      /* Dealloue les listes chainees */
      end_pg ();                          /* Dealloue la chaine des PG */

      end_watchdog ();
      end_messages ();
      end_admin ();
      end_textes ();
      end_ports ();
      end_arbre ();
      end_bbs ();
      end_parts ();
      end_hold ();
      end_themes ();
      end_swap ();
      end_beacon ();
      end_wp ();
      end_lzhuf ();
      end_fwd ();
      end_voies ();
      end_modem ();
      end_exms ();
      end_dll ();
      /*  remet_dos(); */

      /* Fortify_OutputAllMemory();
         Fortify_DumpAllMemory(0);

         Fortify_LeaveScope(); */
}

#ifdef __FBBDOS__
#pragma exit sortie_prg
#endif

main (int ac, char **av)
{
      int voie;

/*
   ind_noeud null_cur;

   daemon_mode = 0;
   strcpy(null_cur.indic, "NULL");
 */
      accept_connection = FALSE;
      Fortify_EnterScope ();
      Fortify_CheckAllMemory ();

      init_semaine ();

      /* #if FBB_DEBUG */
      init_debug (_CS);
      /* #endif */

      operationnel = -1;

      df ("main", 3);
      /*  debut_fonction("main", 3, MK_FP(_SS, _BP)); */

#ifdef BREAK
      break_stop ();
#endif
      strcpy (nom_programme, av[0]);
      vlang = -1;
      init_mem ();
      if ((ac < 2) || (strcmp (av[1], "-t") != 0))
            boot_prg ();
      initialisations ();
#ifndef BREAK
      dprintf ("Break off !\r\n");
#endif
      /* chmod(nom_programme, S_IREAD); */

      /*cprintf("Voie = %d\r\n", sizeof(Svoie)); */
      /*cprintf("Port = %d\r\n", sizeof(defport)); */
      /*cprintf("Fwd  = %d\r\n", sizeof(Forward)); */
      /*sleep_(5); */

      operationnel = 1;
      display_screen ();
      for (voie = 1; voie < NBVOIES; voie++)
            programm_indic (voie);
      accept_connection = TRUE;
      kernel ();
      ff ();
      return (0);
}

static void init_mem (void)
{
#ifndef __DPMI16__
      FILE *fp;
      int i;
      char ligne[256];
      char *ptr = ligne;
      char *scan;

      if ((fp = fopen ("INIT.SRV", "r")) == NULL)
      {
#ifdef ENGLISH
            cprintf ("Cannot open file INIT.SRV        \r\n\a");
#else
            cprintf ("Erreur ouverture fichier INIT.SRV\r\n\a");
#endif
            curon ();
            exit (0);
      }
      i = 0;

      while (fgets (ligne, 250, fp))
      {
            ptr = sup_ln (ligne);
            if (*ligne == '#')
                  continue;
            i++;
            if (i == 36)
            {
                  int ems = atoi (ptr);

                  /* in_exms = 0; */
                  if (ems < 0 || ems > 2)
                        ems = 0;
                  strtok (ptr, " ,\t");
                  if (ems == 2)
                  {
                        while (scan = strtok (NULL, " ,\t"))
                        {
                              strupr (scan);
                              if (strcmp ("OVR", scan) == 0)
                              {
                                    if (_OvrInitExt (0L, 0L) == 0)
                                    {
                                          cprintf ("XMS driver initialized\r\n");
                                          /* sleep(5); */
                                    }
                                    else
                                    {
                                          cprintf ("XMS driver not found\r\n");
                                          curon ();
                                          exit (1);
                                    }
                              }
                        }
                  }
                  break;
            }
      }
      ferme (fp, 57);
#endif
}

void break_stop (void)
{
      bdos (0x33, 0x00, 0x31);      /* Driver transparent */
      setcbrk (0);                        /* breaks inhibes */
}

void break_ok (void)
{
      bdos (0x33, 0x00, 0x30);      /* Driver non transparent */
      setcbrk (1);                        /* breaks valides */
}

#endif /* __FBBDOS__ */

void sleep_ (unsigned sec)
{
#ifdef __WINDOWS__
      WinSleep (sec);
#endif

#ifdef __FBBDOS__
      long temps;
      long tempo;

      temps = btime ();

      for (;;)
      {
            tempo = btime ();
            if (tempo < temps)
                  break;
            if (tempo > (temps + (long) (sec * 18)))
                  break;
      }
/*
   tempo = sec * 18 ;
   while (tempo) ;
 */
      /*  attend_caractere(sec); */
#endif
}


void clear_inbuf (int voie)
{
      lbuf *bptr;

      while (svoie[voie]->inbuf.tete)
      {
            bptr = svoie[voie]->inbuf.tete->suite;
            svoie[voie]->memoc -= svoie[voie]->inbuf.tete->lgbuf;
            m_libere ((char *) svoie[voie]->inbuf.tete->buffer, svoie[voie]->inbuf.tete->lgbuf);
            m_libere ((char *) svoie[voie]->inbuf.tete, sizeof (lbuf));
            svoie[voie]->inbuf.tete = bptr;
      }
      svoie[voie]->inbuf.nblig = svoie[voie]->inbuf.nbcar = svoie[voie]->inbuf.nocar = 0;
      svoie[voie]->inbuf.curr = NULL;
      svoie[voie]->inbuf.ptr = NULL;
}


void init_timout (int voie)
{
      time_att[voie] = svoie[voie]->timout;
}


void init_langue (int voie)
{
      int v, cpt, lutil, luse, lang;

      nlang = svoie[voie]->finf.lang;
      if (nlang >= maxlang)
            nlang = 0;

      vlang = -1;
      for (cpt = 0; cpt < NBLANG; cpt++)
      {
            if (langue[cpt]->numlang == nlang)
            {
                  vlang = cpt;
                  break;
            }
      }

      if (vlang == -1)
      {
            /* swapp de la langue la moins utilisee */
            lutil = MAXVOIES;
            for (lang = 0; lang < NBLANG; lang++)
            {
                  if (langue[lang]->numlang == -1)
                  {
                        vlang = lang;
                        break;
                  }
                  luse = 0;
                  for (v = 0; v < NBVOIES; v++)
                  {
                        if ((voie != v) && (svoie[v]->sta.connect) && (svoie[v]->finf.lang == lang))
                              ++luse;
                  }
                  if (luse < lutil)
                  {
                        lutil = luse;
                        vlang = lang;
                  }
            }
            swap_langue (vlang, nlang);
      }
      Oui = *(langue[vlang]->plang[OUI - 1]);
      Non = *(langue[vlang]->plang[NON - 1]);
}


int nbl_page (int voie)
{
      int lig;

      if (voie == CONSOLE)
#ifdef __WINDOWS__
            lig = get_win_lig (CONSOLE) - 1;
#elsif __FBBDOS__
            lig = (doub_fen) ? separe - (M_LIG + 2) : h_screen - console - (M_LIG + 1);
#else
            lig = svoie[voie]->finf.nbl - 1;
#endif
      else
            lig = svoie[voie]->finf.nbl - 1;
      return (lig);
}


void prog_more (int voie)
{
      if (!(PAG (svoie[voie]->finf.flags)) || (FOR (svoie[voie]->mode)) ||
            ((voie_forward (voie)) && (voie != CONSOLE)) ||
            ((voie == CONSOLE) && (print)) || (svoie[voie]->binary) ||
            (POP ( no_port(voie))))
      {
            svoie[voie]->lignes = -1;
      }
      else
      {
            svoie[voie]->lignes = nbl_page (voie);
      }
      svoie[voie]->stop = 0;
}


/* Substitue les variables : */
/*   mode = 1 : $W = \r */
/*   mode = 2 : $W = \n */
/*   mode = 3 : $W = \r\n */
static char *expand_txt (int mode, char *texte)       /* Fin de ligne = Return */
{
      static char sbuffer[600];
      char *ptr;
      char c;
      int var = 0;
      int nb = 0;

      ptr = NULL;
      while (1)
      {
            if (nb > 590)
                  break;
            if (var)
            {
                  if (*ptr)
                  {
                        sbuffer[nb] = *ptr++;
                        nb++;
                  }
                  else
                        var = 0;
            }
            else
            {
                  if ((c = *texte++) == '\0')
                        break;
                  if (c == '$')
                  {
                        if ((c = *texte++) == '\0')
                              break;
                        if (c == 'W')
                        {
                              /* Fin de ligne */
                              switch (mode)
                              {
                              case 1:
                                    sbuffer[nb++] = '\r';
                                    break;
                              case 2:
                                    sbuffer[nb++] = '\n';
                                    break;
                              case 3:
                                    sbuffer[nb++] = '\r';
                                    sbuffer[nb++] = '\n';
                                    break;
                              }
                        }
                        else
                        {
                              ptr = variable (c);
                              var = 1;
                        }
                  }
                  else if (c == '%')
                  {
                        if ((c = *texte++) == '\0')
                              break;
                        ptr = alt_variable (c);
                        var = 1;
                  }
                  else
                  {
                        sbuffer[nb] = c;
                        nb++;
                  }
            }
      }
      sbuffer[nb] = '\0';
      return (sbuffer);
}

char *expand (char *texte)          /* Fin de ligne = LF */
{
      return (expand_txt (2, texte));
}

char *var_txt (char *texte)         /* Fin de ligne = Return */
{
      return (expand_txt (1, texte));
}

char *var_crlf (char *texte)  /* Fin de ligne = Return/LineFeed */
{
      return (expand_txt (3, texte));
}

int outfich (char *nomfich)
{
      /* Sortie avec variables */
      return (out_file (1, nomfich));
}


int outfichs (char *nomfich)
{
      /* Sortie sans variables */
      return (out_file (0, nomfich));
}


int out_file (int var, char *nomfich)
{
      int nb;
      char sbuffer[300];
      FILE *fptr;

      if ((fptr = fopen (nomfich, "rt")) != NULL)
      {
            while (fgets (sbuffer, 255, fptr))
            {
                  nb = strlen (sbuffer);
                  if (var)
                        out (sbuffer, nb);
                  else
                        outs (sbuffer, nb);
            }
            ferme (fptr, 48);
            return (TRUE);
      }
      return (FALSE);
}


char *who (char *ptr)
{
      int i = 0, j;
      char s[80];
      char freq[80];

      for (i = 2; i < NBVOIES; i++)
      {
            if (svoie[i]->sta.connect)
            {
                  j = 0;
                  sprintf (freq, "(%s)", p_port[no_port (i)].freq);
                  sprintf (s, "Ch. %-2d %9s : %6s-%-2d - %s\r",
                               virt_canal (i), freq, svoie[i]->sta.indicatif.call,
                    svoie[i]->sta.indicatif.num, strdate (svoie[i]->debut));
                  if (ptr)
                  {
                        strcpy (ptr, s);
                        ptr += strlen (s);
                  }
                  else
                        outs (s, strlen (s));
                  if (*(svoie[i]->sta.relais[j].call))
                  {
                        sprintf (s, "   via : %6s-%-2d",
                                     svoie[i]->sta.relais[j].call, svoie[i]->sta.relais[j].num);
                        if (ptr)
                        {
                              strcpy (ptr, s);
                              ptr += strlen (s);
                        }
                        else
                              outs (s, strlen (s));
                        ++j;
                        while (*(svoie[i]->sta.relais[j].call))
                        {
                              if (j == 4)
                              {
                                    if (ptr)
                                    {
                                          strcpy (ptr, "\r        ");
                                          ptr += 9;
                                    }
                                    else
                                          outs ("\n        ", 9);
                              }
                              sprintf (s, " %6s-%-2d", svoie[i]->sta.relais[j].call, svoie[i]->sta.relais[j].num);
                              if (ptr)
                              {
                                    strcpy (ptr, s);
                                    ptr += strlen (s);
                              }
                              else
                                    outs (s, strlen (s));
                              ++j;
                        }
                        if (ptr)
                        {
                              *ptr++ = '\r';
                              *ptr = '\0';
                        }
                        else
                              outsln (" ", 1);
                  }
            }
      }
      return (ptr);
}

void maj_niv (int nivo1, int nivo2, int nivo3)
{
      long caltemps;

      if (pvoie->niv1 != nivo1)
      {
            stemps[pvoie->niv1] += (time (&caltemps) - pvoie->tstat);
            pvoie->tstat = caltemps;
      }
      pvoie->niv1 = nivo1;
      pvoie->niv2 = nivo2;
      pvoie->niv3 = nivo3;
      status (voiecur);
}


int num_voie (char *indic_recherche)
{
      int i;

      for (i = 0; i < NBVOIES; ++i)
            if (svoie[i]->sta.connect && indcmp (svoie[i]->sta.indicatif.call, indic_recherche))
                  return (i);
      return (-1);
}


int texte (int no)
{
      int nl = 0;
      char *ptr;

      if (langue == NULL)
            return (nl);

      ptr = langue[vlang]->plang[no - 1];
      /*  cprintf("Texte : <%s>\r\n", ptr) ; */
      if ((no > 0) && (no <= NBTEXT))
            out (ptr, strlen (ptr));
      while (*ptr)
      {
            if ((*ptr == '$') && (*(ptr + 1) == 'W'))
                  ++nl;
            ++ptr;
      }
      return (nl);
}


int incindd (void)
{
      if (*indd)
      {
            do
            {
                  ++indd;
            }
            while ((*indd) && (*indd != '\n') && (!ISGRAPH (*indd)));
      }
      return (*indd);
}


void selvoie (voie)
{
      /* static int    cv = -1; */
      /* static Svoie  curr; */


      df ("selvoie", 1);

      /*
         if (voie != CONSOLE)
         selcanal(no_port(voie)) ;
       */

      if (((voie >= 0) && (voie < NBVOIES)) || (voie == MWARNING))
      {
            pvoie = svoie[voie];
            voiecur = voie;
            ptmes = &(pvoie->entmes);
      }
      else
            fbb_error (ERR_CANAL, "Select channel", voie);

      ff ();
}

void deconnexion (int voie, int type)
{
      if (voie == CONSOLE)
      {
            /* dprintf("deconnexion console\n"); */

            if (pvoie->cross_connect != -1)
            {
                  int save_voie = voiecur;

                  pvoie->ch_mon = -1;
                  selvoie (pvoie->cross_connect);
                  dec (voiecur, 1);
                  selvoie (save_voie);
                  fin_tnc ();
            }

            svoie[voie]->sta.connect = 0;
            console_off ();
            maj_niv (0, 0, 0);
            aff_nbsta ();
            curseur ();

            if (svoie[voie]->l_yapp)
            {
                  svoie[voie]->finf.lastyap = svoie[voie]->l_yapp;
                  svoie[voie]->l_yapp = 0L;
            }

            if (svoie[voie]->curfwd)
            {
                  svoie[voie]->curfwd->forward = -1;
                  svoie[voie]->curfwd->no_bbs = 0;
                  svoie[voie]->curfwd = NULL;
            }

            majinfo (voie, 2);
#ifdef __FBBDOS__
            clear_insert ();
#endif
            libere_zones_allouees (voie); /* Vide les eventuelles listes */
            aff_forward ();

            del_temp (voie);
            del_copy (voie);
            /* printf("Fin deconnexion console\n"); */
      }

      else if (voie == INEXPORT)
      {
            svoie[voie]->sta.connect = 0;
            aff_event (voie, 2);
            maj_niv (0, 0, 0);
            aff_nbsta ();

            if (svoie[voie]->curfwd)
            {
                  svoie[voie]->curfwd->forward = -1;
                  svoie[voie]->curfwd->no_bbs = 0;
                  svoie[voie]->curfwd = NULL;
            }

            /*      majinfo(voie, 2); */
            /*      clear_insert(); */
            libere_zones_allouees (voie); /* Vide les eventuelles listes */
            aff_forward ();

            del_temp (voie);
            del_copy (voie);
      }

      else
      {
            dec (voie, type);
      }
}


void en_navant_toute (void)
{
}

/*
 * Type = 0 : toutes les voies actives
 *        1 : pas la console
 *        2 : toutes les voies sauf la console
 */
int actif (int type)
{
      int i, nb = 0;
      int val = (type == 2) ? 0 : 1;

      for (i = 1; i < NBVOIES; i++)
      {
            if (svoie[i]->sta.connect > val)
                  nb++;
      }
      if ((type == 0) && (svoie[CONSOLE]->sta.connect))
            nb++;
      return (nb);
}

char *d_disque (char *chaine)
{
      static char s[256];
      char *ptr;

      strcpy (s, DATADIR);
      ptr = s + strlen (s);
      while (*chaine)
      {
            *ptr++ = tolower (*chaine);
            ++chaine;
      }
      *ptr = '\0';
#ifdef __LINUX__
      strcpy(s, back2slash(s));
#endif
      return (sup_ln (s));
}

char *c_disque (char *chaine)
{
      static char s[256];
      char *ptr;

      strcpy (s, CONFDIR);
      ptr = s + strlen (s);
      while (*chaine)
      {
            *ptr++ = tolower (*chaine);
            ++chaine;
      }
      *ptr = '\0';
#ifdef __LINUX__
      strcpy(s, back2slash(s));
#endif
      return (sup_ln (s));
}

void test_disque ()
{
#if defined(__WINDOWS__) || defined(__FBBDOS__)
      char texte[300];
      unsigned long mfree;

      mfree = free_disk (0);
#ifdef ENGLISH
      cprintf ("Disk space available : %ld    \r\n\n", mfree);
#else
      cprintf ("Espace disque disponible : %ld\r\n\n", mfree);
#endif
      if (mfree < 1000L)
      {
#ifdef ENGLISH
            sprintf (texte, "Warning ! Disk space available on disk %c: = %ld bytes.        \r", getdisk () + 'A', mfree * 1024UL);
#else
            sprintf (texte, "Attention ! Stockage disponible sur le disque %c: = %ld octets.\r", getdisk () + 'A', mfree * 1024UL);
#endif
            cprintf (texte);

            if (w_mask & W_DISK)
            {
#ifdef ENGLISH
                  mess_warning (admin, "*** WARNING : DISK ***  ", texte);
#else
                  mess_warning (admin, "*** ATTENTION DISQUE ***", texte);
#endif
            }
      }
#endif
}

int find (char *s)
{
      char *t = s;
      int n = 0;
      int dernier = 0, chiffre = 0, lettre = 0;

      /* Pour valider 50MHz */
      if (isdigit (s[0]) && isdigit (s[1]))
            return (FALSE);

      while (*t)
      {
/*** Test rajoute ***/
            if (!isalnum (*t))
                  return (FALSE);
            *t = toupper (*t);

            dernier = (isdigit (*t));

            if (isdigit (*t))
                  ++chiffre;
            else
                  ++lettre;

            ++t;
            ++n;
      }
      /* *t = '\0' ; */

      if (strcmp ("SYSOP", s) == 0)
            return (TRUE);

      if (strcmp ("WP", s) == 0)
            return (TRUE);

      if (std_header & 4096)
      {
            /*
             * L'indicatif doit avoir entre 3 et 6 caracteres .
             *             doit contenir au moins un chiffre
             *                  doit contenir au moins une lettre
             */
            if ((n < 3) || (n > 6) || (chiffre < 1) || (lettre < 1))
                  return (FALSE);
      }
      else
      {
            /*
             * L'indicatif doit avoir entre 3 et 6 caracteres .
             *             doit contenir 1 ou 2 chiffres
             *             et finir par une lettre.
             */

            if ((n < 3) || (n > 6) || (chiffre < 1) || (chiffre > 2) || dernier)
                  return (FALSE);
      }
      return (TRUE);
}

Generated by  Doxygen 1.6.0   Back to index