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

console.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 de la console
 */

#include <serv.h>

static int dde_cnx = 0;
static int dde_trait = 0;

int connect_console (void)
{
      Svoie *vptr = svoie[CONSOLE];

      if (vptr->sta.connect)
      {
#ifdef ENGLISH
            cprintf ("Can't connect ! Console channel is busy.   \r\n");
#else
            cprintf ("Connexion Impossible. Voie Console occup‚e.\r\n");
#endif
            return (0);
      }
      init_etat ();
      selvoie (CONSOLE);                  /* F2 = Connexion  */

      if (arret)
            vptr->dde_marche = TRUE;
      else
            vptr->dde_marche = FALSE;
      vptr->timout = time_n;
      init_timout (CONSOLE);
      /*  lastaff = -1 ; */
      vptr->aut_linked = 1;
      vptr->private_dir = 0;
      vptr->read_only = 0;
      vptr->vdisk = 2;
      vptr->log = 1;
      vptr->deconnect = FALSE;
      vptr->tstat = vptr->debut = time (NULL);
      maj_niv (0, 0, 0);
      vptr->tmach = 0L;
      vptr->nb_err = vptr->seq = vptr->stop = vptr->sr_mem = 0;
      vptr->maj_ok = 0;
      vptr->rev_param = 0;
      vptr->ch_mon = vptr->cross_connect = -1;
      vptr->msg_held = 0;
      vptr->binary = vptr->conf = 0;
      vptr->mess_recu = vptr->xferok = 1;
      vptr->mbl = 1;
      vptr->entmes.numero = 0L;
      vptr->entmes.theme = 0;
      strn_cpy (6, vptr->sta.indicatif.call, cons_call.call);
      vptr->sta.indicatif.num = cons_call.num;
      vptr->r_tete = NULL;
      vptr->mbl_ext = 1;
      vptr->prot_fwd = FWD_MBL;
      vptr->nb_egal = 0;
      *vptr->passwd = '\0';
      console_on ();
      aff_event (CONSOLE, 1);
      vptr->sta.stat = vptr->sta.connect = 16;
      curseur ();
      clear_inbuf (CONSOLE);
      connexion (voiecur);
      new_om = nouveau (voiecur);
      /*  pvoie->finf.nbl = 16 ; */
      /* vptr->mode = vptr->finf.flags ; */
      vptr->mode = 0;
      vptr->l_mess = 0L;
      vptr->l_yapp = 0L;
      if (fbb_fwd)
      {
            vptr->mode |= F_NFW;
            if (bin_fwd)
                  vptr->mode |= F_BIN;
      }
      /*  mbl[CONSOLE] = TRUE ; */
      /*  cprintf("Connecte\r\n") ;      */
      change_droits (voiecur);
      strcpy (vptr->dos_path, "\\");
      aff_nbsta ();
      fbb_log (CONSOLE, 'C', "@ CONSOL");
      dde_cnx = 1;
      return (TRUE);
}

void console_inbuf (char *data, int len)
{
      in_buf (CONSOLE, data, len);
      dde_trait = 1;
}

void justifie (unsigned char *buffer)
{
      unsigned char ligne[83];
      unsigned char *ptr, *ptri, *ptro;
      int nb_sp = 0;
      int nb_mot = 1;
      int nb_car = 0;
      int k, sp_int, sp_rst, i_sp, j_sp, k_sp, ds_mot, nb_int;

      df ("justifie", 2);

      ptri = buffer;
      ptro = ligne;
      while ((*ptri) && (*ptri == ' '))
      {
            ++nb_car;
            *ptro++ = *ptri++;
      }

      if (*ptri)
      {

            ptr = ptri;
            ds_mot = TRUE;

            while (*ptr)
            {
                  ++nb_car;
                  if (*ptr == ' ')
                  {
                        ++nb_sp;
                        if (ds_mot)
                        {
                              ds_mot = FALSE;
                              nb_mot++;
                        }
                  }
                  else
                        ds_mot = TRUE;
                  ++ptr;
            }

            if (nb_mot > 1)
            {
                  nb_int = nb_mot - 1;
                  /* nb_sp += (80 - nb_car) ; */
                  nb_sp += (78 - nb_car);
                  sp_int = nb_sp / nb_int;
                  sp_rst = nb_sp % nb_int;
                  if (sp_rst > (nb_int / 2))
                  {
                        k_sp = FALSE;
                        sp_rst = nb_int - sp_rst;
                        i_sp = (sp_rst % 2) ? nb_int / (sp_rst + 1) : nb_int / sp_rst;
                  }
                  else
                  {
                        k_sp = TRUE;
                        if (sp_rst)
                              i_sp = (sp_rst % 2) ? nb_int / (sp_rst + 1) : nb_int / sp_rst;
                        else
                              i_sp = 0;
                  }
                  j_sp = 0;

                  while (*ptri)
                  {
                        if (*ptri == '\r')
                              break;
                        if ((just) && (*ptri == ' '))
                        {
                              for (k = 0; k < sp_int; k++)
                                    *ptro++ = ' ';
                              while (*++ptri == ' ')
                                    ;
                              if (k_sp)
                              {
                                    if (sp_rst)
                                    {
                                          if (++j_sp == i_sp)
                                          {
                                                *ptro++ = ' ';
                                                j_sp = 0;
                                                sp_rst--;
                                          }
                                    }
                              }
                              else
                              {
                                    if (sp_rst)
                                    {
                                          if (++j_sp != i_sp)
                                          {
                                                *ptro++ = ' ';
                                          }
                                          else
                                          {
                                                j_sp = 0;
                                                sp_rst--;
                                          }
                                    }
                                    else
                                    {
                                          *ptro++ = ' ';
                                    }
                              }
                        }
                        else
                              *ptro++ = *ptri++;
                  }
                  *ptro = '\0';
                  if (!just)
                  {
                        nb_car = strlen (ligne);
                        while (nb_car++ < 78)
                        {
                        }
                  }
                  /* *ptro++ = '\r'; */
                  *ptro = '\0';
                  ptr = ligne;
                  while ((*buffer++ = *ptr++) != '\0');
            }
      }
      ff ();
}

int kb_vide (void)
{
      return 1;
}

void curseur (void)
{
}

void connect_fen (void)
{
}

void winputs (int voie, int attr, char *ptr)
{
      int val;
      int header;

      if (attr == -1)
      {
            attr = W_CHNI;
            header = 1;
      }
      else
            header = 0;

      val = (attr & 8) ? 255 : 127;
      window_write (voie, ptr, strlen (ptr), attr, header);
}


void put_nr (unsigned char *texte, int attr, int nbcar)
{
      unsigned char chaine[400];
      unsigned char *ptr = chaine;
      unsigned char *scan = texte;
      unsigned char ch;
      int i, nb, pcode, txt = 0;

      if (nbcar > 256)
            nbcar = 256;

      texte[nbcar] = '\0';
      if ((*scan != 0xff) && (*scan != 0xfe))
      {
            strcpy (ptr, "(NRom: ");
            ptr += 7;
            for (i = 0; i < 6; i++)
                  *ptr++ = (*scan++ >> 1);
            while (*(ptr - 1) == ' ')
                  --ptr;
            *ptr++ = '-';
            ch = (*scan++ >> 1) | 0x30;
            if (ch > '9')
            {
                  *ptr++ = '1';
                  ch -= 10;
            }
            *ptr++ = ch;

            *ptr++ = ' ';

            for (i = 0; i < 6; i++)
                  *ptr++ = (*scan++ >> 1);
            while (*(ptr - 1) == ' ')
                  --ptr;
            *ptr++ = '-';
            ch = (*scan++ >> 1) | 0x30;
            if (ch > '9')
            {
                  *ptr++ = '1';
                  ch -= 10;
            }
            *ptr++ = ch;

            *ptr++ = ' ';

            itoa ((int) (*scan++), ptr, 10);
            while (*ptr)
            {
                  ++ptr;
            }

            *ptr++ = ' ';

            itoa ((int) (*scan++), ptr, 10);
            while (*ptr)
            {
                  ++ptr;
            }

            *ptr++ = ' ';

            itoa ((int) (*scan++), ptr, 10);
            while (*ptr)
            {
                  ++ptr;
            }

            *ptr++ = ' ';

            scan += 2;
            pcode = (int) (*scan++) & 0xf;

            switch (pcode)
            {
            case 0:
                  *ptr++ = 'I';
                  *ptr++ = 'P';
                  txt = 20;
                  break;

            case 1:
                  *ptr++ = 'C';
                  *ptr++ = ' ';
                  ++scan;
                  for (i = 0; i < 6; i++)
                        *ptr++ = (*scan++ >> 1);
                  while (*(ptr - 1) == ' ')
                        --ptr;
                  *ptr++ = '-';
                  ch = (*scan++ >> 1) | 0x30;
                  if (ch > '9')
                  {
                        *ptr++ = '1';
                        ch -= 10;
                  }
                  *ptr++ = ch;
                  *ptr++ = ' ';
                  for (i = 0; i < 6; i++)
                        *ptr++ = (*scan++ >> 1);
                  while (*(ptr - 1) == ' ')
                        --ptr;
                  *ptr++ = '-';
                  ch = (*scan++ >> 1) | 0x30;
                  if (ch > '9')
                  {
                        *ptr++ = '1';
                        ch -= 10;
                  }
                  *ptr++ = ch;
                  txt = 0;
                  break;

            case 2:
                  *ptr++ = 'C';
                  *ptr++ = ' ';
                  *ptr++ = 'A';
                  *ptr++ = 'K';
                  txt = 0;
                  break;

            case 3:
                  *ptr++ = 'D';
                  txt = 0;
                  break;

            case 4:
                  *ptr++ = 'D';
                  *ptr++ = ' ';
                  *ptr++ = 'A';
                  *ptr++ = 'K';
                  txt = 0;
                  break;

            case 5:
                  *ptr++ = 'I';
                  txt = 20;
                  break;

            case 6:
                  *ptr++ = 'I';
                  *ptr++ = ' ';
                  *ptr++ = 'A';
                  *ptr++ = 'K';
                  txt = 0;
                  break;

            default:
                  return;
            }
            *ptr++ = ')';
            *ptr = '\0';
            put_ui (chaine, attr, strlen (chaine));

            if (txt > 0)
            {
                  scan = texte + txt;
                  put_ui (scan, attr, nbcar - txt);
            }
      }
      else
      {
            scan = texte + 7;
            nbcar -= 7;
            nb = 0;
            ptr = chaine;
            while (nbcar > 0)
            {
                  for (i = 0; i < 6; i++)
                        *ptr++ = (*scan++ >> 1);
                  *ptr++ = '-';
                  ch = (*scan++ >> 1) | 0x30;
                  if (ch > '9')
                  {
                        *ptr++ = '1';
                        ch -= 10;
                  }
                  else
                        *ptr++ = ' ';
                  *ptr++ = ch;
                  *ptr++ = ':';
                  for (i = 0; i < 6; i++)
                        *ptr++ = *scan++;
                  *ptr++ = ' ';
                  *ptr++ = '-';
                  *ptr++ = '>';
                  *ptr++ = ' ';
                  for (i = 0; i < 6; i++)
                        *ptr++ = (*scan++ >> 1);
                  *ptr++ = '-';
                  ch = (*scan++ >> 1) | 0x30;
                  if (ch > '9')
                  {
                        *ptr++ = '1';
                        ch -= 10;
                  }
                  else
                        *ptr++ = ' ';
                  *ptr++ = ch;
                  *ptr++ = ' ';
                  sprintf (ptr, "%3d ", (int) (*scan++));
                  /*          itoa((int)(*scan++), ptr, 10) ; */
                  while (*ptr)
                        ++ptr;
                  if (++nb == 2)
                  {
                        *ptr = '\0';
                        put_ui (chaine, attr, strlen (chaine));
                        ptr = chaine;
                        /* *ptr++ = '\r' ; */
                        nb = 0;
                  }
                  else
                  {
                        *ptr++ = ' ';
                        *ptr++ = ' ';
                        *ptr++ = ' ';
                  }
                  nbcar -= 21;
            }
      }
}

int put_ui (unsigned char *texte, int attr, int nb)
{
      unsigned char buf[600];
      unsigned char *ptr = buf;
      unsigned char c;
      int pos = 0;

      deb_io ();

      /* Commence toujours par un cr */
      c = '\r';
      ++nb;

      while (nb--)
      {

            /* Le dernier CR n'est pas pris en compte */
            if ((nb == 0) && (c == '\r'))
                  break;

            if (c == '\r')
            {
                  *ptr++ = c;
                  *ptr = '\0';
                  window_write (MMONITOR, buf, strlen (buf), attr, 0);
                  ptr = buf;
                  pos = 0;
            }
            else
            {
                  if (++pos == 80)
                  {
                        *ptr++ = '\r';
                        *ptr = '\0';
                        window_write (MMONITOR, buf, strlen (buf), attr, 0);
                        ptr = buf;
                        pos = 0;
                  }
                  if (c >= ' ')
                  {
                        *ptr++ = c;
                  }
                  else
                  {
                        *ptr++ = c + '@';
                  }
            }
            c = *texte++;
      }
      *ptr = '\0';
      window_write (MMONITOR, buf, strlen (buf), attr, 0);
      return (1);
}


int attend_caractere (int secondes)
{
      return (0);
}


int forwarding_bbs (int nobbs)
{
      int port;
      Forward *pfwd;

      for (port = 0; port < NBPORT; port++)
      {
            if (p_port[port].pvalid)
            {
                  pfwd = p_port[port].listfwd;
                  while (pfwd)
                  {
                        if (pfwd->no_bbs == nobbs)
                              return (1);
                        pfwd = pfwd->suite;
                  }
            }
      }
      return (0);
}

static int is_nb(char *ptr)
{
      int val = isdigit (*ptr);
      
      while (*ptr)
      {
            if (!ISGRAPH (*ptr))
                  break;
            if (!isdigit(*ptr))
                  val = 0;
            ++ptr;
      }
      
      return val;
}

int val_fwd (char *bbs, int *port_fwd, int reverse)
{
      Forward *pfwd;
      int i, port, noport;
      int nobbs;

      strupr (sup_ln (bbs));
/*    if ((isdigit (*bbs)) && (!ISGRAPH (*(bbs + 1)))) */
      if (is_nb(bbs))
      {
/*          *port_fwd = noport = *bbs - '0'; */
            *port_fwd = noport = atoi(bbs);
            if (noport == 0)
            {                                   /* Lance le forward sur tous les ports */
                  *bbs = '\0';
                  for (port = 0; port < NBPORT; port++)
                  {
                        if (p_port[port].pvalid)
                        {
                              for (i = 0; i < NBMASK; i++)
                                    p_port[port].fwd[i] = '\0';
                              pfwd = p_port[port].listfwd;
                              while (pfwd)
                              {
                                    if ((pfwd->forward == 0) && (ch_voie (port, 0) != -1))
                                    {
                                          *pfwd->fwdbbs = '\0';
                                          pfwd->forward = -1;
                                          pfwd->fwdpos = 0;
                                          pfwd->fin_fwd = pfwd->cptif = pfwd->fwdlig = 0;
                                          pfwd->reverse = reverse;
                                    }
                                    pfwd = pfwd->suite;
                              }
                        }
                  }
            }
            else if (noport > 0)
            {                                   /* Selectionne un port */
                  *bbs = '\0';
                  if (p_port[noport].pvalid)
                  {
                        for (i = 0; i < NBMASK; i++)
                              p_port[noport].fwd[i] = '\0';
                        pfwd = p_port[noport].listfwd;
                        while (pfwd)
                        {
                              if ((pfwd->forward == 0) && (ch_voie (noport, 0) != -1))
                              {
                                    *pfwd->fwdbbs = '\0';
                                    pfwd->forward = -1;
                                    pfwd->fwdpos = 0;
                                    pfwd->fin_fwd = pfwd->cptif = pfwd->fwdlig = 0;
                                    pfwd->reverse = reverse;
                              }
                              pfwd = pfwd->suite;
                        }
                  }
            }
      }
      else
      {
            nobbs = num_bbs (bbs);
            if (nobbs)
            {                                   /* Selectionne une BBS */
                  if ((chercher_voie (bbs) == -1) && !forwarding_bbs (nobbs))
                  {
                        if ((port = what_port (nobbs)) != -1)
                        {
                              *port_fwd = port;
                              pfwd = p_port[port].listfwd;
                              while (pfwd)
                              {
                                    if ((pfwd->forward == 0) && (ch_voie (port, 0) != -1))
                                    {
                                          strn_cpy (6, pfwd->fwdbbs, bbs);
                                          clr_bit_fwd (p_port[port].fwd, nobbs);
                                          pfwd->forward = -1;
                                          pfwd->fwdpos = 0;
                                          pfwd->fin_fwd = pfwd->cptif = pfwd->fwdlig = 0;
                                          pfwd->reverse = reverse;
                                          break;
                                    }
                                    pfwd = pfwd->suite;
                              }
                              if (pfwd == NULL)
                                    noport = -1;
                              else
                                    noport = port;
                        }
                        else
                              noport = -2;
                  }
                  else
                        noport = -4;
            }
            else
                  noport = -3;
      }
      return (noport);
}



int traite_console ()
{
      df ("traite_console", 0);

      if (dde_cnx)
      {
            dde_cnx = 0;
            ff ();
            return (1);
      }

      if (dde_trait)
      {
            dde_trait = 0;
            ff ();
            return (1);
      }

      ff ();
      return (0);
}

void free_use (void)
{
      FbbMem (0);
}

int aff_etat (int lettre)
{
      int prec;
      char s[20];

      df ("aff_etat", 1);

      prec = let_prec;
      if (lettre != let_prec)
      {
            let_prec = lettre;
            switch (lettre)
            {
#ifdef ENGLISH
            case 'A':
                  sprintf (s, "Idle   ");
                  break;
            case 'B':
                  sprintf (s, "Beacon ");
                  break;
            case 'C':
                  sprintf (s, "Cron   ");
                  break;
            case 'D':
                  sprintf (s, "Disconn");
                  break;
            case 'E':
                  sprintf (s, "Sending");
                  break;
            case 'F':
                  sprintf (s, "Forward");
                  break;
            case 'G':
                  sprintf (s, "F_send ");
                  break;
            case 'I':
                  sprintf (s, "Import ");
                  break;
            case 'J':
                  sprintf (s, "Export ");
                  break;
            case 'K':
                  sprintf (s, "WaitAck");
                  break;
            case 'L':
                  sprintf (s, "Reading");
                  break;
            case 'M':
                  sprintf (s, "Unproto");
                  break;
            case 'N':
                  sprintf (s, "Inbuf  ");
                  break;
            case 'O':
                  sprintf (s, ">%-6ld", ptmes->numero);
                  let_prec = 'A';
                  break;
            case 'R':
                  sprintf (s, "Receive");
                  break;
            case 'S':
                  sprintf (s, "Saving ");
                  break;
            case 'T':
                  sprintf (s, "Process");
                  break;
            case 'W':
                  sprintf (s, "H-Route");
                  break;
            case 'X':
                  sprintf (s, "WP-Upd ");
                  break;
            case 'Y':
                  sprintf (s, "Kernel ");
                  break;
            case 'Z':
                  sprintf (s, "W-Share");
                  break;
#else
            case 'A':
                  sprintf (s, "Attend ");
                  break;
            case 'B':
                  sprintf (s, "Balise ");
                  break;
            case 'C':
                  sprintf (s, "Cron   ");
                  break;
            case 'D':
                  sprintf (s, "D‚conn.");
                  break;
            case 'E':
                  sprintf (s, "Envoie ");
                  break;
            case 'F':
                  sprintf (s, "Forward");
                  break;
            case 'G':
                  sprintf (s, "F_env  ");
                  break;
            case 'I':
                  sprintf (s, "Import ");
                  break;
            case 'J':
                  sprintf (s, "Export ");
                  break;
            case 'K':
                  sprintf (s, "Att.Ack");
                  break;
            case 'L':
                  sprintf (s, "LitTnc ");
                  break;
            case 'M':
                  sprintf (s, "Monitor");
                  break;
            case 'N':
                  sprintf (s, "Inbuf  ");
                  break;
            case 'O':
                  sprintf (s, ">%-6ld", ptmes->numero);
                  let_prec = 'A';
                  break;
            case 'R':
                  sprintf (s, "Recoit ");
                  break;
            case 'S':
                  sprintf (s, "Sauve  ");
                  break;
            case 'T':
                  sprintf (s, "Traite ");
                  break;
            case 'W':
                  sprintf (s, "H-Route");
                  break;
            case 'X':
                  sprintf (s, "MAJ-WP ");
                  break;
            case 'Y':
                  sprintf (s, "Kernel ");
                  break;
            case 'Z':
                  sprintf (s, "W-Share");
                  break;
#endif
            }
            win_status (s);
      }
      ff ();
      return (prec);
}

void aff_msg_cons ()
{
      unsigned num_indic;
      ind_noeud *noeud;
      int priv = -1;
      int hold = -1;

      noeud = insnoeud (cons_call.call, &num_indic);

      if (noeud->nbnew != msg_cons)
            priv = msg_cons = noeud->nbnew;

      if (nb_hold != hold_cons)
            hold = hold_cons = nb_hold;

      win_msg_cons (priv, hold);
}

enum meminfo_row
{
      meminfo_main = 0,
      meminfo_swap
};

enum meminfo_col
{
      meminfo_total = 0, meminfo_used, meminfo_free,
      meminfo_shared, meminfo_buffers, meminfo_cached
};

/* Code from linuxnode */

#define MEMINFO_FILE "/proc/meminfo"

static char buf[300];

#define MAX_ROW 3                   /* these are a little liberal for flexibility */
#define MAX_COL 7

unsigned **meminfo (void)
{
      static unsigned *row[MAX_ROW + 1];  /* row pointers */
      static unsigned num[MAX_ROW * MAX_COL];         /* number storage */
      char *p;
      int i, j, k, l;

      static int n, fd = -1;

      if (fd == -1 && (fd = open (MEMINFO_FILE, O_RDONLY)) == -1)
      {
            /* node_perror(FILE, errno); */
            close (fd);
            return 0;
      }
      lseek (fd, 0L, SEEK_SET);
      if ((n = read (fd, buf, sizeof buf - 1)) < 0)
      {
            close (fd);
            fd = -1;
            return 0;
      }
      buf[n] = '\0';

      if (!row[0])                        /* init ptrs 1st time through */
            for (i = 0; i < MAX_ROW; i++) /* std column major order: */
                  row[i] = num + MAX_COL * i;
      p = buf;
      for (i = 0; i < MAX_ROW; i++) /* zero unassigned fields */
            for (j = 0; j < MAX_COL; j++)
                  row[i][j] = 0;
      for (i = 0; i < MAX_ROW && *p; i++)
      {                                         /* loop over rows */
            while (*p && !isdigit (*p))
                  p++;                    /* skip chars until a digit */
            for (j = 0; j < MAX_COL && *p; j++)
            {                                   /* scanf column-by-column */
                  l = sscanf (p, "%u%n", row[i] + j, &k);
                  p += k;                       /* step over used buffer */
                  if (*p == '\n' || l < 1)      /* end of line/buffer */
                        break;
            }
      }
      return row;                         /* NULL return ==> error */
}

void free_mem (void)
{
      unsigned **mem;

      if (!(mem = meminfo ()) || mem[meminfo_main][meminfo_total] == 0)
      {
            /* cannot normalize mem usage */
            tot_mem = 0L;
      }
      else
      {
            tot_mem =
                  mem[meminfo_main][meminfo_free] +
                  mem[meminfo_main][meminfo_buffers] +
                  mem[meminfo_total][meminfo_cached] +
                  mem[meminfo_swap][meminfo_free];
      }

      FbbMem (0);
}

void aff_forward (void)
{
      fbb_list (FALSE);
}


int aff_nbsta (void)
{
      return (fbb_list (FALSE));
}


char *stat_voie (int voie)
{
      static char s[15];

      switch (svoie[voie]->sta.stat)
      {
      case 0:
            strcpy (s, "Disconne");
            break;
      case 1:
            strcpy (s, "Link Set");
            break;
      case 2:
            strcpy (s, "Fram Rej");
            break;
      case 3:
            strcpy (s, "Disc Req");
            break;
      case 4:
            strcpy (s, "Transfer");
            break;
      case 5:
            strcpy (s, "FRej Snd");
            break;
      case 6:
            if (p_port[no_port (voie)].typort == TYP_KAM)
                  sprintf (s, "Retry %-2d", svoie[voie]->sta.ret + 1);
            else
                  sprintf (s, "Retry %-2d", svoie[voie]->sta.ret);
            break;
      case 7:
            strcpy (s, "Dev Busy");
            break;
      case 8:
            strcpy (s, "RdevBusy");
            break;
      case 9:
            strcpy (s, "BdevBusy");
            break;
      case 10:
            strcpy (s, "WAck Dbs");
            break;
      case 11:
            strcpy (s, "WAckRbsy");
            break;
      case 12:
            strcpy (s, "WAckBbsy");
            break;
      case 13:
            strcpy (s, "RFrmDbsy");
            break;
      case 14:
            strcpy (s, "RFrmRbsy");
            break;
      case 15:
            strcpy (s, "RFrmBbsy");
            break;
      case 16:
            strcpy (s, "Console ");
            break;
      case 17:
            strcpy (s, "Ch Busy ");
            break;
      default:
            strcpy (s, "Error st");
            break;
      }
      return (s);
}


void status (int voie)
{
      char buf[255];
      char call[80];
      char ret[80];
      Svoie *ptvoie = svoie[voie];

      if (operationnel)
      {
            if ((v_aff < 0) || (voie == v_aff))
            {
                  if (voie > 1)
                  {
                        sprintf (ret, "(%03d)", ptvoie->sta.mem);
                        sprintf (buf, "Buf %03d/%03d %s %02d-%02d-%02d %s",
                                     ptvoie->sta.ack, ptvoie->maxbuf,
                                     ret, ptvoie->niv1, ptvoie->niv2, ptvoie->niv3, stat_voie (voie));

#ifdef ENGLISH
                        sprintf (call, "Ch %02d %s-%d",
                                     virt_canal (voie), ptvoie->sta.indicatif.call, ptvoie->sta.indicatif.num);
#else
                        sprintf (call, "Vo %02d %s-%d",
                                     virt_canal (voie), ptvoie->sta.indicatif.call, ptvoie->sta.indicatif.num);
#endif

                        FbbStatus (call, buf);
                  }
                  free_mem ();
            }
            user_status (voie);
      }
      svoie[voie]->ch_status = 0;
}


int aff_yapp (int voie)
{
      return 1;
}

char *yapp_str (int voie, char *s)
{
#define YAPPLEN 44
#define MAX_AFF 12

      static char stdesc[MAX_AFF][11] =
      {
            "SendInit  ",
            "SendInitRt",
            "SendHeader",
            "SendData  ",
            "SendEof   ",
            "SendEOT   ",
            "RcvWait   ",
            "RcvHeader ",
            "RcvData   ",
            "SndABORT  ",
            "WaitAbtAck",
            "RcdABORT  "
      };
      static char *yapp_name[2] =
      {"Yapp", "YapC"};
      Svoie *pv = svoie[voie];
      int i;
      int ok = 1;
      int retour = 0;
      int niv = pv->niv2;
      long offset = pv->enrcur;

      *s = '\0';

      if (!operationnel)
            return (0);

      if (offset < 0L)
            offset = 0L;

      *s = '\0';
      if (v_aff < 0)
      {
            if ((svoie[voie]->sta.connect) && (svoie[voie]->niv1 == N_YAPP))
            {
                  if ((niv > 0) && (niv < MAX_AFF))
                  {
                        sprintf (s, "%s:%s %s %ld/%ld", yapp_name[pv->type_yapp], stdesc[pv->niv2], pv->appendf,
                                     offset, pv->tailm);
                        retour = 1;
                  }
            }
            if (retour == 0)
            {
                  for (i = 0; i < NBVOIES; i++)
                  {
                        if ((svoie[i]->sta.connect) && (svoie[i]->niv1 == N_YAPP))
                        {
                              if ((niv > 0) && (niv < MAX_AFF))
                              {
                                    pv = svoie[i];
                                    sprintf (s, "%s:%s %s %ld/%ld", yapp_name[pv->type_yapp], stdesc[pv->niv2], pv->appendf,
                                                 offset, pv->tailm);
                                    break;
                              }
                        }
                  }
            }
      }
      else if (voie == v_aff)
      {
            if ((svoie[voie]->sta.connect) && (svoie[voie]->niv1 == N_YAPP))
            {
                  if ((niv > 0) && (niv < MAX_AFF))
                  {
                        sprintf (s, "%s:%s %s %ld/%ld", yapp_name[pv->type_yapp], stdesc[pv->niv2], pv->appendf,
                                     offset, pv->tailm);
                        retour = 1;
                  }
            }
      }
      else
            ok = 0;

      return (s);
}


void aff_ind_console (void)
{
      char s[80];

      sprintf (s, "Console : %6s-%-2d\n", cons_call.call, cons_call.num);
      aff_chaine (DEF, 25, 1, s);
}

void affich_logo (int att)
{
      char chaine[80];

#ifdef ENGLISH
      sprintf (chaine, "MULTICONNECT BBS   F6FBB V%s", version ());
#else
      sprintf (chaine, "SERVEUR MULTIVOIES F6FBB V%s", version ());
#endif
      aff_chaine (att, 55 - strlen (version ()), 1, chaine);
}

void aff_date (void)
{
      char buffer[300];
      char cdate[19];
      long temps;
      struct tm *sdate;

#ifdef ENGLISH
      char jour[] = "SunMonTueWedThuFriSat";

#else
      char jour[] = "DimLunMarMerJeuVenSam";

#endif

      temps = time (NULL);
      sdate = localtime (&temps);
#ifdef ENGLISH
      sprintf (cdate, "    %02d-%02d-%02d %02d:%02d",
                   sdate->tm_year, sdate->tm_mon + 1, sdate->tm_mday,
                   sdate->tm_hour, sdate->tm_min);
#else
      sprintf (cdate, "    %02d/%02d/%02d %02d:%02d",
                   sdate->tm_mday, sdate->tm_mon + 1, sdate->tm_year,
                   sdate->tm_hour, sdate->tm_min);
#endif
      memcpy (cdate, jour + (sdate->tm_wday * 3), 3);
      if (com_error)
            sprintf (buffer, "%s  %02d", cdate, com_error);
      else
            sprintf (buffer, "%s", cdate);
      aff_chaine (DEF, 1, 1, buffer);
}

void maj_options (void)
{
      FILE *fptr;

      if ((fptr = fopen (d_disque ("OPTIONS.SYS"), "wb")) != NULL)
      {
            fwrite (&bip, sizeof (short), 1, fptr);
            fwrite (&ok_tell, sizeof (short), 1, fptr);
            fwrite (&ok_aff, sizeof (short), 1, fptr);
            fwrite (&separe, sizeof (short), 1, fptr);
            fwrite (&doub_fen, sizeof (short), 1, fptr);
            fwrite (&gate, sizeof (short), 1, fptr);
            fwrite (&just, sizeof (short), 1, fptr);
            fwrite (&p_forward, sizeof (short), 1, fptr);
            fwrite (&sed, sizeof (short), 1, fptr);
            fwrite (&aff_inexport, sizeof (short), 1, fptr);
            fwrite (&aff_popsmtp, sizeof (short), 1, fptr);

            fclose (fptr);
      }

      maj_menu_options ();
}

int ind_console (int type, char *chaine)  /* Type : 0 = decimal, 1 = hexa */
{
      int c = 0;
      char *ptr = chaine;

      while (isalnum (*ptr))
            ++ptr;
      if (*ptr)
      {
            *ptr++ = '\0';
            while ((*ptr) && (!isxdigit (*ptr)))
                  ++ptr;
      }

      if (find (chaine))
      {
            strcpy (cons_call.call, chaine);
            if (*ptr)
            {
                  if (type)
                        sscanf (ptr, "%x", &c);
                  else
                        sscanf (ptr, "%d", &c);
                  if ((c < 0) || (c > 15))
                        return (0);
            }
            cons_call.num = c;
            return (1);
      }
      return (0);
}

void house_keeping (void)
{
      long caltemps;

      save_fic = 1;
      set_busy ();
      time (&caltemps);
      stop_min = minute (caltemps);
      type_sortie = 3;
}

#if 0
int read_wp (unsigned record, Wp * wp)
{
      return (0);
}

int write_wp (unsigned record, Wp * wp)
{
      return (0);
}

unsigned search_wp_record (lcall icall, int what, unsigned first_record)
{
      return (0xffff);
}

#endif

void console_off (void)
{
      CloseFbbWindow (0);
}

void console_on (void)
{
}

void FbbRequestUserList (void)
{
      bloc_indic *bptr;
      unsigned offset;
      int nb = 0;
      char buffer[8];

      /* Envoie les indicatifs dans la ListBox */

      bptr = racine;
      offset = 0;

      while (bptr)
      {
            if (*(bptr->st_ind[offset].indic) == '\0')
                  break;
            if (bptr->st_ind[offset].coord != 0xffff)
            {
                  if (bptr->st_ind[offset].val)
                  {
                        n_cpy (6, buffer, bptr->st_ind[offset].indic);
                        AddUserList (buffer);
                  }
            }
            if (++offset == T_BLOC_INFO)
            {
                  offset = 0;
                  bptr = bptr->suiv;
            }
      }

      /* Envoie les langues dans la ListBox */
      for (nb = 0; nb < maxlang; nb++)
      {
            AddUserLang (nomlang + nb * LG_LANG);
      }
}

int GetUserInfos (char *callsign, info * frec)
{
      ind_noeud *noeud;
      FILE *fptr;
      unsigned num_indic;

      noeud = insnoeud (callsign, &num_indic);
      if (noeud->coord == 0xffff)
      {
            return (0);
      }
      fptr = ouvre_nomenc ();
      fseek (fptr, (long) noeud->coord * sizeof (info), 0);
      fread (frec, sizeof (info), 1, fptr);
      ferme (fptr, 39);
      return (1);
}

int SetUserInfos (char *callsign, info * frec)
{
      int voie;
      ind_noeud *noeud;
      FILE *fptr;
      unsigned num_indic;

      /* Met a jour l'utilisateur eventuellement connecte */
      for (voie = 0; voie < NBVOIES; ++voie)
      {
            if (svoie[voie]->sta.connect &&
                  indcmp (svoie[voie]->sta.indicatif.call, callsign))
            {
                  svoie[voie]->finf = *frec;
            }
      }

      /* Met a jour le record de l'utilisateur */
      noeud = insnoeud (callsign, &num_indic);
      if (noeud->coord == 0xffff)
      {
            return (0);
      }
      fptr = ouvre_nomenc ();
      fseek (fptr, (long) noeud->coord * sizeof (info), 0);
      fwrite (frec, sizeof (info), 1, fptr);
      ferme (fptr, 39);
      return (1);
}

void FbbRequestMessageList (void)
{
      char buf[40];
      unsigned offset;
      bloc_mess *bptr = tete_dir;

      ouvre_dir ();
      /* pvoie->typlist = 0; */


      if (bptr)
      {
            /* Goto the end of the list */
            while (bptr->suiv)
                  bptr = bptr->suiv;

            /* Scans the list */
            offset = T_BLOC_MESS;
            while (bptr)
            {
                  --offset;
                  if (bptr->st_mess[offset].noenr)
                        AddMessageList (ltoa (bptr->st_mess[offset].nmess, buf, 10));
                  if (offset == 0)
                  {
                        bptr = prec_dir (bptr);
                        offset = T_BLOC_MESS;
                  }
            }
      }
      ferme_dir ();
}

int GetMsgInfos (bullist * plig, long numero)
{
      mess_noeud *mptr;

      mptr = findmess (numero);
      if (mptr == NULL)
            return 0;

      ouvre_dir ();
      read_dir (mptr->noenr, plig);
      ferme_dir ();
      return (1);
}

int SetMsgInfo (bullist * plig, long numero)
{
      mess_noeud *mptr;

      mptr = findmess (numero);
      if (mptr == NULL)
            return 0;

      ouvre_dir ();
      write_dir (mptr->noenr, plig);
      ferme_dir ();
      return (1);
}

char *MessPath (void)
{
      return (MESSDIR);
}

void fwd_encours (void)
{
      int i, priv, bull, kb;
      atfwd *nbmess;
      char ifwd[NBBBS][7];
      char maxfwd[NBBBS + 1];
      char typfwd[NBBBS + 1];
      char typdat[NBBBS + 1];

      ch_bbs (1, ifwd);

      fwd_value (maxfwd, typfwd, typdat);

      for (i = 0; i < NBBBS; i++)
      {
            nbmess = attend_fwd (i + 1, maxfwd[i + 1], 0, typfwd[i + 1], typdat[i + 1]);
            if (nbmess > 0)
            {
                  priv = nbmess->nbpriv;
                  bull = nbmess->nbbul;
                  kb = nbmess->nbkb;
            }
            else
                  priv = bull = kb = 0;
            AddPendingLine (ifwd[i], priv, bull, kb);
      }
}

void compress_display (int type, long value, long numero)
{
      CompressPosition (type, (int) value, numero);
}


void maintenance (void)
{
      int i;
      int suite;
      int port, voie, flag, strm;
      char txt[80];
      char chaine[300];
      FILE *fpinit;

      df ("maintenance", 0);

      InfoMessage (-1, "Halting communication", "Halt");

      operationnel = FALSE;
      for (port = 1; port < NBPORT; port++)
      {
            if (p_port[port].pvalid)
            {
                  wsprintf (txt, "Halting port %d", port);
                  InfoMessage (-1, txt, NULL);

                  selcanal (port);
                  switch (p_port[port].typort)
                  {
                  case TYP_DED:
                  case TYP_HST:
                        vide (port, 0);   /* Supprime le dernier ACK de sonde */
                        tnc_commande (port, "Y0", PORTCMD);
                        break;
                  case TYP_PK:
                        tnc_commande (port, "UR1", PORTCMD);
                        break;
                  case TYP_MOD:
                        /* modem_stop(port) ; */
                        break;
                  case TYP_KAM:
                        tnc_commande (port, "USERS 0/0", PORTCMD);
                        break;
                  case TYP_BPQ:
                        for (voie = 1; voie < NBVOIES; voie++)
                        {
                              if (svoie[voie]->affport.port == port)
                              {
                                    strm = no_canal (voie);
                                    flag = 6;
                                    cprintf ("Devalidating stream %d\r\n", strm);
                                    sta_drv (voie, SETFLG, (void *) &flag);
                              }
                        }
                        break;
                  }
                  for (voie = 1; voie < NBVOIES; voie++)
                  {
                        if ((svoie[voie]->affport.port == port) && (svoie[voie]->sta.connect))
                        {
                              deconnexion (voie, 1);
#ifdef ENGLISH
                              cprintf ("Disconnecting Port %d Channel %d\r\n", port, virt_canal (voie));
#else
                              cprintf ("Deconnection du Port %d Voie %d \r\n", port, virt_canal (voie));
#endif
                        }
                  }
                  if (!BPQ (port))
                  {
                        sprintf (chaine, "MAINT%d.SYS", port);
                        if ((fpinit = fopen (c_disque (chaine), "r")) != NULL)
                        {
                              while (fgets (chaine, 256, fpinit))
                              {
                                    if (*chaine == '#')
                                          continue;
                                    sup_ln (chaine);
                                    if (*chaine)
                                          tnc_commande (port, chaine, PORTCMD);
                              }
                              fclose (fpinit);
                        }
                        switch (p_port[port].typort)
                        {
                        case TYP_DED:
                        case TYP_HST:
                              suite = 0;
                              if (DRSI (port))
                              {
                                    for (i = port + 1; i < NBPORT; i++)
                                    {
                                          if (DRSI (i))
                                                suite = 1;
                                    }
                              }
                              if (suite == 0)
                              {
                                    cls_drv (port);
                              }
                              break;
                        case TYP_PK:
                              tnc_commande (port, "HON", PORTCMD);
                              break;
                        case TYP_KAM:
                              break;
                        }
                  }
            }
      }
      closecom ();
      InfoMessage (-1, NULL, NULL);
      port_log (0, 0, 'S', "Q *** BBS Quit");
      ferme_log ();
      ff ();
}

void set_busy (void)
{
      int port, voie, flag, strm;

      InfoMessage (-1, "Stopping connections", "Halt");

      for (port = 1; port < NBPORT; port++)
      {
            if (p_port[port].pvalid)
            {
                  selcanal (port);

                  switch (p_port[port].typort)
                  {
                  case TYP_DED:
                  case TYP_HST:
                        tnc_commande (port, "Y0", PORTCMD);
                        break;
                  case TYP_PK:
                        tnc_commande (port, "UR1", PORTCMD);
                        break;
                  case TYP_MOD:
                        for (voie = 0; voie < NBVOIES; voie++)
                        {
                              if ((no_port (voie) == port) && (!svoie[voie]->sta.connect))
                              {
                                    tnc_commande (port, "ATH0=0", PORTCMD);
                              }
                        }
                        break;
                  case TYP_KAM:
                        tnc_commande (port, "USERS 0/0", PORTCMD);
                        break;
                  case TYP_BPQ:
                        for (voie = 1; voie < NBVOIES; voie++)
                        {
                              if (no_port (voie) == port)
                              {
                                    flag = 0;
                                    strm = no_canal (voie);
                                    cprintf ("Devalidating stream %d (%02x)\r\n", strm, flag);
                                    sta_drv (voie, SETFLG, (void *) &flag);
                              }
                        }
                        break;
                  case TYP_SCK:
                  case TYP_TCP:
                  case TYP_ETH:
                        for (voie = 1; voie < NBVOIES; voie++)
                        {
                              if (no_port (voie) == port)
                              {
                                    sta_drv (voie, SETBUSY, NULL);
                              }
                        }
                        break;
                  }
            }
      }
      InfoMessage (-1, "Connections stopped", NULL);
      InfoMessage (-1, NULL, NULL);
}

Generated by  Doxygen 1.6.0   Back to index