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

serveur.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.
    ****************************************************************/

/*
 * Gestion des serveurs de donnees. SERVEUR.H
 */

#include <serv.h>

static int is_redist (char *);

void tst_serveur (bullist * pbul)
{
      serlist *lptr;
      bullist psauve;

      if ((strcmp (pbul->desti, "WP") == 0) &&
            (strcmp (pbul->exped, mycall) != 0) &&
            (is_wpupdate (pbul->titre)))
      {                                         /* WP Update ? */
            wp_read_mess (pbul);    /* Lit le message pour MAJ WP */

            return;
      }

      if ((*pbul->bbsv) || (pbul->type != 'P'))
            return;

      psauve = *pbul;

      if (is_redist (pbul->desti))
      {
            lptr = tete_serv;
            while (lptr)
            {
                  if (strcmp (lptr->nom_serveur, "REDIST") == 0)
                  {
                        appel_serveur (lptr, pbul);
                        break;
                  }
                  lptr = lptr->suiv;
            }
      }
      else
      {
            lptr = tete_serv;
            while (lptr)
            {
                  if (strcmp (lptr->nom_serveur, pbul->desti) == 0)
                  {
                        appel_serveur (lptr, pbul);
                        break;
                  }
                  lptr = lptr->suiv;
            }
      }
      *pbul = psauve;
}


int p_cmd (void)
{
      serlist *lptr;
      char s[200];
      int ok = 1;
      int c = toupper (*indd);

      switch (c)
      {

      case 'G':
            incindd ();
            maj_niv (N_MBL, 17, 0);
            exec_pg ();
            ok = 2;
            break;

      case 'R':
            ok = mbl_print ();
            break;

      case 'S':
            lptr = tete_serv;
            while (lptr)
            {
                  sprintf (s, "%6s: %s", lptr->nom_serveur, lptr->com_serveur);
                  outln (s, strlen (s));
                  lptr = lptr->suiv;
            }
            break;

      default:
            ok = 0;
            break;
      }

      if (ok == 1)
            retour_mbl ();
      return (ok);
}


void libere_serveurs (void)
{
      serlist *lptr;

      while (tete_serv)
      {
            lptr = tete_serv;
            tete_serv = tete_serv->suiv;
            m_libere (lptr, sizeof (serlist));
      }
}

void init_serveur (char *ligne, int nolig)
{
      char nom[80], pg[80], com[80];
      serlist *lptr;

      *com = '\0';
      if (sscanf (ligne, "%s %s %[^\n\r]", nom, pg, com) < 2)
            err_init (nolig);

      strupr (nom);

      /* Cherche si le service existe deja */
      lptr = tete_serv;
      while (lptr)
      {
            if (strcmp (lptr->nom_serveur, nom) == 0)
                  return;
            lptr = lptr->suiv;
      }

      lptr = tete_serv;
      if (lptr)
      {
            while (lptr->suiv)
            {
                  lptr = lptr->suiv;
            }
            lptr->suiv = (serlist *) m_alloue (sizeof (serlist));
            lptr = lptr->suiv;
      }
      else
      {
            tete_serv = lptr = (serlist *) m_alloue (sizeof (serlist));
      }
      lptr->suiv = NULL;
      strn_cpy (6, lptr->nom_serveur, nom);
      strcpy (lptr->nom_pg, pg);
      strcpy (lptr->com_serveur, com);
}

#ifdef __WINDOWS__
#pragma argsused
#endif
void affich_serveurs (int tp)
{
#ifdef __LINUX__
      int tot = 0;
      char text[80];
      serlist *lptr = tete_serv;

      while (lptr)
      {
            ++tot;
            sprintf (text, "%d: %s", tot, lptr->nom_serveur);
            InitText (text);
            lptr = lptr->suiv;
      }
#endif
#ifdef __WINDOWS__
      int tot = 0;
      char text[80];
      serlist *lptr = tete_serv;

      while (lptr)
      {
            ++tot;
            wsprintf (text, "%d: %s %s", tot, lptr->nom_serveur, lptr->com_serveur);
            InitText (text);
            lptr = lptr->suiv;
      }
#endif
#ifdef __FBBDOS__
      fen *fen_ptr;
      serlist *lptr;
      int size, nb_serv = 0;

      lptr = tete_serv;
      while (lptr)
      {
            ++nb_serv;
            lptr = lptr->suiv;
      }

      if (nb_serv == 0)
            return;

      size = (nb_serv > 19) ? 19 : nb_serv;
      lptr = tete_serv;
      deb_io ();

#ifdef ENGLISH
      fen_ptr = open_win (10, 2, 75, 4 + size, INIT, "Servers ");
      while (lptr)
      {
            cprintf ("Server %s: %s \r\n", lptr->nom_serveur, lptr->com_serveur);
            lptr = lptr->suiv;
      }
      attend_caractere (tp);
      close_win (fen_ptr);
#else
      fen_ptr = open_win (10, 2, 75, 4 + size, INIT, "Services");
      while (lptr)
      {
            cprintf ("Service %s: %s\r\n", lptr->nom_serveur, lptr->com_serveur);
            lptr = lptr->suiv;
      }
      attend_caractere (tp);
      close_win (fen_ptr);
#endif

      fin_io ();
#endif /* __WINDOWS__ */
}

static int is_redist (char *server_name)
{
      if (
               (strcmp (server_name, "REDIST") == 0) ||
               (strcmp (server_name, "LOCBBS") == 0) ||
               (strcmp (server_name, "LOCAL") == 0) ||
               (strcmp (server_name, "REGION") == 0) ||
               (strcmp (server_name, "NATION") == 0)
            )
      {
            return (1);
      }
      return (0);
}


int appel_serveur (serlist * lptr, bullist * pbul)
{
      static int num_file = 1;

      ind_noeud *noeud;
      mess_noeud *mptr;

      FILE *fptr;
      FILE *fptm;
      char nom_fichier[80];
      char texte[80];

#ifdef __FBBDOS__
      int disk;
      int duplic;
      char cur_dir[MAXPATH];
      char localdir[61];
#endif

#ifdef __WINDOWS__
      char localdir[61];
#endif

      int retour = 0;
      int supprime = 1;

      /* Affiche le nom du service dans le bandeau */
      sprintf (texte, "%-7s", lptr->nom_serveur);
      aff_chaine (W_STAT, 2, 4, texte);

      /* Cree le fichier copie */
#ifdef __LINUX__
      sprintf (nom_fichier, "%sl_serv%02d.in", DATADIR, num_file);
      if ((fptr = fopen (nom_fichier, "w")) != NULL)
#endif
#ifdef __WINDOWS__
      sprintf (nom_fichier, "%s\\w_serv%02d.IN", getcwd (localdir, 60), num_file);
      if ((fptr = fopen (nom_fichier, "wt")) != NULL)
#endif
#ifdef __FBBDOS__
      sprintf (nom_fichier, "%s\\d_serv%02d.IN", getcwd (localdir, 60), num_file);
      if ((fptr = fopen (nom_fichier, "wt")) != NULL)
#endif
      {
            fprintf (fptr, "SP %s < %s\n", pbul->desti, pbul->exped);
            fprintf (fptr, "%s\n", pbul->titre);
            fflush (fptr);

            /* Fait une copie du message original */

            if ((fptm = ouvre_mess (O_TEXT, pbul->numero, pbul->status)) != NULL)
            {
                  fflush (fptr);
                  fflush (fptm);
                  copy_fic (fileno (fptm), fileno (fptr), NULL);
                  fprintf (fptr, "\n/EX\n");
                  ferme (fptm, 75);
                  ferme (fptr, 76);

                  /* Teste les services "speciaux" */

                  if ((*lptr->nom_pg == '*') && strcmp ("REQCFG", lptr->nom_serveur) == 0)
                  {
                        retour = req_cfg (nom_fichier);
                  }
                  else if ((*lptr->nom_pg == '*') && strcmp ("REDIST", lptr->nom_serveur) == 0)
                  {
                        retour = redist (nom_fichier);
                  }
                  else if ((*lptr->nom_pg == '*') && strcmp ("WP", lptr->nom_serveur) == 0)
                  {

                        if (strcmp (pbul->exped, mycall) == 0)
                        {                       /* Exped = moi ? */

                              if (*pbul->bbsv)
                                    supprime = 0;     /* Ne supprime pas le message */
                              else
                                    retour = wp_service (nom_fichier);
                        }

                        else if (*pbul->bbsv == '\0')
                              retour = wp_service (nom_fichier);  /* Exped = autre */

                        else
                              supprime = 0;

                  }
                  else
                  {
#ifdef __LINUX__
                        char commande[256];

                        sprintf (commande, "cd %s ; ./%s %s", SERVDIR, lptr->nom_pg, back2slash(nom_fichier));
                        printf("Server : {%s}\n", commande);

                        /* Appel serveurs via Linux */
                        retour = system (commande) >> 8;
                        if (retour == 127)
                              retour = -1;
                        if (++num_file == 10)
                              num_file = 1;
#endif
#ifdef __WINDOWS__
                        char commande[256];
                        char *extension;

                        extension = strrchr (lptr->nom_pg, '.');
                        if (extension && (strcmp (extension, ".DLL") == 0))
                        {
                              /* DLL appel immediat... */
                              HINSTANCE hinstFilter;

                              retour = -1;

                              hinstFilter = LoadLibrary (lptr->nom_pg);
                              if (hinstFilter > HINSTANCE_ERROR)
                              {
                                    int (FAR PASCAL * DllProc) (int ac, char FAR ** av);
                                    int ac = 0;
                                    char *av[30];

                                    ac = 0;
                                    av[ac++] = lptr->nom_pg;
                                    av[ac++] = nom_fichier;
                                    av[ac] = NULL;

                                    (FARPROC) DllProc = GetProcAddress (hinstFilter, "svc_main");
                                    if (DllProc)
                                          retour = (*DllProc) (ac, (char FAR **) av);

                                    FreeLibrary (hinstFilter);
                              }
                        }
                        else
                        {
                              sprintf (commande, "%s %s", lptr->nom_pg, nom_fichier);


                              /* Appel serveurs via Windows */
                              retour = (fbb_exec (commande) == 1) ? 0 : -1;
                        }
                        if (++num_file == 10)
                              num_file = 1;
#endif
#ifdef __FBBDOS__
                        deb_io ();        /* Stoppe le multitaches */
                        disk = getdisk ();
                        strcpy (cur_dir, "X:\\");
                        cur_dir[0] = 'A' + disk;
                        getcurdir (0, cur_dir + 3);

                        operationnel = FALSE;   /* Stoppe les stats de taches */
                        duplic = dup (1); /* Ferme le stdout */
                        close (1);
                        break_ok ();      /* Valide le Ctrl C */
                        retour = spawnlp (P_WAIT, lptr->nom_pg, lptr->nom_serveur, nom_fichier, NULL);
                        break_stop ();    /* Devalide le Ctrl C */
                        dup2 (duplic, 1); /* Remet le stdout */
                        close (duplic);
                        operationnel = TRUE;
                        setdisk (disk);
                        chdir (cur_dir);
                        fin_io ();
                        unlink (nom_fichier);
#endif /* __WINDOWS__ */

                  }
                  if ((retour != 0) && (retour != 10))
                  {
                        /* Erreur de lancement : Envoi d'un message SYSOP */
#ifdef ENGLISH
                        cprintf ("Error starting server %s (%s)\r\n", lptr->nom_serveur, lptr->nom_pg);
                        sprintf (texte, "Error starting server %s (%s)\n", lptr->nom_serveur, lptr->nom_pg);
                        if (w_mask & W_SERVER)
                              mess_warning (admin, "*** SERVER ERROR ***  ", texte);
#else
                        cprintf ("Erreur appel serveur %s (%s) \r\n", lptr->nom_serveur, lptr->nom_pg);
                        sprintf (texte, "Erreur appel serveur %s (%s) \n", lptr->nom_serveur, lptr->nom_pg);
                        if (w_mask & W_SERVER)
                              mess_warning (admin, "*** ERREUR SERVEUR ***", texte);
#endif
                  }
                  if (retour == 10)
                        supprime = 0;
            }
            else
                  ferme (fptr, 77);
            timeprec = 0L;
      }


      if (supprime)
      {
            if ((mptr = findmess (pbul->numero)) != NULL)
            {                                   /* Tue le message */
                  ouvre_dir ();
                  pbul->status = 'K';
                  write_dir (mptr->noenr, pbul);
                  ferme_dir ();
                  noeud = cher_noeud (pbul->desti);
                  --(noeud->nbnew);
                  --(noeud->nbmess);
                  chg_mess (0xffff, pbul->numero);    /* Plus de destinataire */
            }
      }

      return (supprime);
}

int ptctrx (int port, char *cmde)
{
      int pp;
      int ok = 0;
      char cmdbuf[80];

      for (pp = 1; pp < NBPORT; pp++)
      {
            if ((HST (pp)) && (p_port[pp].moport & 0x80))
            {
                  sprintf (cmdbuf, "!%s", cmde + 3);
                  tnc_commande (pp, cmdbuf, PORTCMD);
                  ok = 1;
                  break;
            }
      }

      /* Les autres ports attendent deux secondes
         pour etre sur que la commande a ete envoyee */

      if ((ok) && (pp != port))
      {
            p_port[port].stop = 2;
      }

      return (ok);
}

Generated by  Doxygen 1.6.0   Back to index